爬虫学习（03）: 数据解析_re篇

一、re模块简介

1.1 re正则

Regular Expression, 正则表达式, 一种使用表达式的方式对字符串进行匹配的语法规则.
我们在网页上抓取的页面源代码，在本质上就是一个超长的字符串，想要从里面提取内容，使用正则再适合不过。

正则的优点：

速度快， 效率高， 准确性高

正则的语法：

使用元字符进行排列组合用来 匹配字符串。

在线测试正则表达式：https://tool.oschina.net/regex/
元字符：具有固定含义的特殊符号

常用元字符

 .     √匹配除换行符以外的任意字符,  未来在python的re模块中是一个坑. 
 \w    √匹配字母或数字或下划线.
 \s    匹配任意的空白符
 \d    √匹配数字
 \n    匹配一个换行符
 \t    匹配一个制表符
 
 ^     匹配字符串的开始
 $     匹配字符串的结尾
 
 \W    匹配非字母或数字或下划线
 \D    匹配非数字
 \S    匹配非空白符
 a|b   匹配字符a或字符b
 ()    √匹配括号内的表达式，也表示一个组
 [...]    √匹配字符组中的字符
 [^...]    匹配除了字符组中字符的所有字符

量词: 控制前面的元字符出现的次数

 *    重复零次或更多次
 +    重复一次或更多次
 ?    重复零次或一次
 {n}    重复n次 
 {n,}    重复n次或更多次 
 {n,m}    重复n到m次

贪婪匹配和惰性匹配(重点)

 .*     贪婪匹配,  尽可能多的去匹配结果
 .*?    惰性匹配,  尽可能少的去匹配结果 -> 回溯

通用flags（修正符

值	说明
`re.I`	是匹配对大小写不敏感
`re.M`	多行匹配，影响到^和$
`re.S`	使.匹配包括换行符在内的所有字符

1.2 re模块

re模块中我们只需要记住下面这几个功能就够我们使用了.

1.2.1 findall()函数（返回列表）

扫描整个字符串string，并返回所有匹配的pattern模式结果的字符串列表（findall 查找所有. 返回list）
参数

参数	说明
`pattern`	匹配的正则表达式(一种字符串的模式)
`string`	要匹配的字符串
`flags`	标识位，用于控制正则表达式的匹配方式

import re
lst = re.findall("m", "mai le fo len, mai ni mei!") 
print(lst)    # ['m', 'm', 'm'] 
lst = re.findall(r"\d+", "5点之前. 你要给我5000万")
print(lst)   # ['5', '5000']

1.2.2 search()函数

search 会进行匹配. 但是如果匹配到了第一个结果. 就会返回这个结果. 如果匹配不上，search返回的则是None

import re
ret = re.search(r'\d', '5点之前. 你要给我5000万').group()
print(ret)  # 5

1.2.3 match()函数

match 只能从字符串的开头进行匹配

ret = re.match('a', 'abc').group()  
print(ret)     # a

1.2.4 finditer()函数

finditer 和findall差不多. 只不过这返回的是迭代器(重点)

it = re.finditer("m", "mai le fo len, mai ni mei!")
for el in it:
    print(el.group()) # 依然需要分组

运行结果
在这里插入图片描述

1.2.5 compile()函数

compile() 可以将一个长长的正则进行预加载. 方便后面的使用

obj = re.compile(r'\d{3}')  # 将正则表达式编译成为一个 正则表达式对象, 规则要匹配的是3个数字
ret = obj.search('abc123eeee') # 正则表达式对象调用search, 参数为待匹配的字符串
print(ret.group())  # 结果: 123

1.2.6 正则内容单独提取

单独获取到正则中的具体内容可以给分组起名字(?P<name>xxx)

s = """
<div class='西游记'><span id='10010'>中国联通</span></div>
"""
obj = re.compile(r"<span id='(?P<id>\d+)'>(?P<name>\w+)</span>", re.S)

result = obj.search(s)
print(result.group())  # 结果: <span id='10010'>中国联通</span>
print(result.group("id"))  # 结果: 10010 # 获取id组的内容
print(result.group("name"))  # 结果: 中国联通 # 获取name组的内容

这里可以看到我们可以通过使用分组. 来对正则匹配到的内容进一步的进行筛选.

1.2.7 字符串替换

正则表达式本身是用来提取字符串中的内容的. 也可以用作字符串的替换

import re
r = re.split(r"\d+", "我今年19岁了, 你知道么, 19岁就已经很大了. 周杰伦20岁就得奖了")
print(r)  # ['我今年', '岁了, 你知道么, ', '岁就已经很大了. 周杰伦', '岁就得奖了']
# 替换
r = re.sub(r"\d+", "18", "我今年19岁了, 你知道么, 19岁就已经很大了. 周杰伦20岁就得奖了")
print(r)  # 我今年18岁了, 你知道么, 18岁就已经很大了. 周杰伦18岁就得奖了

哦了. 正则. 这些东西够用了.

二、re实操

2.1 贪婪非贪婪的区分

我们能发现这样一个规律: .*? 表示尽可能少的匹配, .*表示尽可能多的匹配, 暂时先记住这个规律. 后面写爬虫会用到

str: 玩儿吃鸡游戏, 晚上一起上游戏, 干嘛呢? 打游戏啊
 reg: 玩儿.*?游戏
 
 此时匹配的是: 玩儿吃鸡游戏
 
 reg: 玩儿.*游戏   
 此时匹配的是: 玩儿吃鸡游戏, 晚上一起上游戏, 干嘛呢? 打游戏    
     
                 
 str: <div>胡辣汤</div>
 reg: <.*>
 结果: <div>胡辣汤</div>
 
 
 str: <div>胡辣汤</div>
 reg: <.*?>
 结果: 
     <div>
     </div>
 
 str: <div class="abc"><div>胡辣汤</div><div>饭团</div></div>
 reg: <div>.*?</div>
 结果:
     <div>胡辣汤</div>
	 <div>饭团</div>

2.2 元字符的练习

[] 原子表
[a]  # 匹配a
[ab]  # 匹配a或者b
[abc]  # 匹配a或者b或者c
[123]  # 匹配1或者2或者3
[0-9]  # 匹配任意一位数字
[a-z]  # 匹配任意一位小写字母
[A-Z]  # 匹配任意一位大写字母
[a-zA-Z]  # 匹配任意大小写字母

[][]
[abc][0-9]  匹配a或者b或者c和任意一个数字->a1,b2,c3...

匹配手机号码
1[3-9][0-9]{
    
    9}  # {9} 代表前面的[0-9]9位 共11位

 ^ 限制开头 $ 限制结尾 一般用于组合
^1[3-9][0-9]{
    
    9}$  # 完全匹配 匹配的字符串中，必须完全符合才算匹配成功
13134534681  # 符合
131345346812 # 不符合 因为多了一位

{
    
    } 代表前面正则匹配的n词
[a-z]{
    
    2}  # 匹配两位小写字母
[a-z][a-z] # 等同于上方

{
    
    m,n} m-n之间的
[a-z]{
    
    2,5} # 匹配2-5个小写字母

 {
    
    m,} #至少匹配m个
[a-z]{
    
    2,} # 至少匹配2个小写字母

？可有可无
-?[1-9] # 匹配正负1-9

 . 匹配换行符以外的任意字符(不单独使用)
a   b   c  # 都能匹配

* 代表前面的0次或多次(不单独使用)

.*?组合 非贪婪匹配 (重要!!!) #匹配换行符以外的任意字符任意次

.*组合 贪婪匹配 #匹配换行符以外的任意字符任意次

 + 匹配一次到多次{
    
    1,}

.+? 非贪婪匹配 #匹配换行符以外的任意字符至少1次

｜ 代表或
[a-z]|[0-9] # 匹配字母或数字、

() #1. 作为一个单元  2. 作为子存储

2.3 re修正符练习

import re
#  re.I 是匹配队大小写不敏感
#  re.M 多行匹配，影响到^和$
#  re.S 使.匹配包括换行符在内的所有字符
mystr = """
<a href="http://www.baidu.com">百度</a>
<A href="http://www.baidu.com">百度</A>
<a href='http://www.sogou.com'>搜狗</a>
<a href="http://www.tengxun.com">腾
讯</a>
"""

# 首先匹配所有的正常a链接->小写
# print(re.findall("<a href=\"http://www.baidu.com\">百度</a>")) #内部用转义
print(re.findall('<a href="(.*?)">(.*?)</a>', mystr))  # 外部用单引号
# 可以发现，只能匹配出一个结果来
# >>>[('http://www.baidu.com', '百度')]

# re.I 不区分大小写
print(re.findall('<a href="(.*?)">(.*?)</a>', mystr, re.I))
# 可以发现，匹配出两个结果来了
# >>>[('http://www.baidu.com', '百度'), ('http://www.baidu.com', '百度')]

#  匹配大小写 多行匹配 可以匹配换行符 中间用|隔开
print(re.findall('<a href="(.*?)">(.*?)</a>', mystr, re.I | re.M | re.S))
# >>> [('http://www.baidu.com', '百度'), ('http://www.baidu.com', '百度'), ('http://www.tengxun.com', '腾\n讯')]
# 可以发现匹配出来了三个结果，但唯独少一个搜狗，因为搜狗是用单引号扩起来的

# 在上面的案例基础上匹配单双引号 [] 表示或，表示双引号或者单引号
print(re.findall('<a href=[\'"](.*?)[\'"]>(.*?)</a>', mystr, re.I | re.M | re.S))
# >>> 匹配出来了全部结果
print('*'*20)
myStr = """asadasdd1\nbsadasdd2\ncsadasdd3"""
print(re.findall('^[a-z]',myStr))  # 匹配以字母开头
# >>> ['a']
print(re.findall('\A[a-z]',myStr))  # 匹配以字母开头 (整段)
# >>> ['a']
print(re.findall('\d$',myStr))  # 匹配以数字结尾
# >>> ['3']
print(re.findall('\d\Z',myStr))  # 匹配以数字结尾 (整段)
# >>> ['3']

# re.M
print(re.findall('^[a-z]',myStr, flags=re.M))
# >>> ['a', 'b', 'c']
print(re.findall('\A[a-z]',myStr, flags=re.M))
# >>> ['a']
print(re.findall('\d$',myStr, flags=re.M))
# >>> ['1', '2', '3']
print(re.findall('\d\Z',myStr, flags=re.M))
# >>> ['3']

2.4 match_search_findall练习

import re

# r"" 专业写正则，没有转义的烦恼

# search re.search(正则，字符串) 会进行匹配. 但是如果匹配到了第一个结果. 就会返回这个结果. 如果匹配不上search返回的则是None
print('search')
print()
print(re.search(r'a', '123456'))  # None
# group() 若匹配成功则返回匹配数值
print(re.search(r'[a-z]','123c423').group())  # c
print(re.search(r'[a-z][a-z]', '12321a21'))  # None
print(re.search(r'1[3-9][0-9]{9}','1345643256543').group())  # 13456432565
print(re.search(r'1[3-9][0-9]{9}','b1345643256543b').group())  # 13456432565
print(re.search(r'^1[3-9][0-9]{9}','x1345643256543'))  # None

print('-'*30)
print('match')
print()
# match 只匹配一次，必须从第一位开始，类似于search('^')
print(re.match(r'a','a213131').group())  # a
print(re.match(r'a','213131'))  # None
print(re.match(r'[a-z]','123x456'))  # None
print(re.match(r'1[1-3][0-9]{9}','b1345643256543b'))  # None
print(re.match(r'1[1-3][0-9]{9}','1345643256543b').group())  # 1345643256543

print('-'*30)
print('findall')
# 查找所有 结果返回列表
print(re.findall(r"\d+","我有1000万，不给你话，给你1块钱拿去"))  # ['1000', '1']

三、关于re总结

.*? -> 惰性匹配 / * -> 贪婪匹配
searce()函数：扫描整个字符串string，并返回第一个pattern模式成功的匹配，匹配失败返回 None
findall()函数 扫描整个字符串string，并返回所有匹配的pattern模式结果的字符串列表
match()函数 匹配成功返回匹配的对象
匹配失败返回 None
re 最常用的地方 -> 在html中获取到js的一部分代码(字符串中)