沭阳学爬虫08 正则表达式

08 正则表达式

我们用Requests来获取网页的源代码，得到HTML代码

但我们如何从HTML代码中获取真正想要的数据呢？

正则表达式是处理字符串的强大工具，它有自己特定的语法结构，可以实现字符串的检索、替换、匹配验证

对于爬虫，有了它，要从HTML里提取想要的信息就非常方便了

简单实例

开源中国的正则表达式测试工具http://tool.oschina.net/regex/

输入待匹配的文本，然后选择常用的正则表达式，就可以得出相应的匹配结果了

Hello, my phone number is 010-86432100 and email is cqc@cuiqingcai.com, and my website is https://cuiqingcai.com.

这段字符串中包含了一个电话号码和一个电子邮件

这里使用了正则表达式的匹配功能，用一定规则将特定的文本提取出来

• 电子邮件的组成格式: 一段字符串 + @符号 + 某个域名
• URL的组成格式:协议类型 + 冒号加双斜线 + 域名和路径

[a-zA-z]+://[^\s]*

用上面的正则表达式去匹配一个字符串，如果这个字符串中包含类似URL的文本，那就会被提取出来

• a-z 匹配任意的小写字母
• \s 匹配任意的空白字符
• *匹配前面任意多个字符

如果想找出网页源代码里有多少URL，用URL的正则表达式去匹配即可

---

常用的匹配规则

模　　式	描　　述
\w	匹配字母、数字及下划线
\W	匹配不是字母、数字及下划线的字符
\s	匹配任意空白字符，等价于 [\t\n\r\f]
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0~9]
\D	匹配任意非数字的字符
\A	匹配字符串开头
\Z	匹配字符串结尾，如果存在换行，只匹配到换行前的结束字符串
\z	匹配字符串结尾，如果存在换行，同时还会匹配换行符
\G	匹配最后匹配完成的位置
\n	匹配一个换行符
\t	匹配一个制表符
^	匹配一行字符串的开头
$	匹配一行字符串的结尾
.	匹配任意字符，除了换行符，当 re.DOTALL 标记被指定时，则可以匹配包括换行符的任意字符
[…]	用来表示一组字符，单独列出，比如 [amk] 匹配 a、m 或 k
[^…]	不在 [] 中的字符，比如 匹配除了 a、b、c 之外的字符
*	匹配 0 个或多个表达式
+	匹配 1 个或多个表达式
?	匹配 0 个或 1 个前面的正则表达式定义的片段，非贪婪方式
{n}	精确匹配 n 个前面的表达式
{n, m}	匹配 n 到 m 次由前面正则表达式定义的片段，贪婪方式
a|b	匹配 a 或 b
()	匹配括号内的表达式，也表示一个组

正则表达式不是Python独有的，它也可以用在其他编程语言中

但是Python的re库提供了整个正则表达式的实现

match

一个常用的匹配方法——match，向它传入要匹配的字符串，以及正则表达式，就可以检测这个正则表达式是否匹配字符串

match方法会尝试从字符串的起始位置匹配正则表达式

如果匹配，就返回匹配成功的结果，如果不匹配，就返回None

import re

content = 'Hello 123 4567 World_This is a Regex Demo'
print(len(content))

result = re.match('^Hello\s\d\d\d\s\d{4}\s\w{10}',content)
print(result)
print(result.group())
print(result.span())

首先声明一个字符串，其中包括英文字母、空白字符、数字

然后写一个正则表达式 ^Hello\s\d\d\d\s\d{4}\s\w{10}

• 开头的^匹配字符串的开头，也就是以Hello开头

• \s匹配空白字符，用来匹配目标字符串的空格

• \d匹配数字，3个\d匹配123

• 4567，依然能用4个\d匹配，但是这么写比较烦琐，所以后面可以跟{4}代表匹配前面的规则4次，也就是匹配4个数字

• \w{10}匹配10个字母及下划线

这里并没有把目标字符串匹配完，不过依然可以进行匹配，只不过匹配结果短一点而已

---

在match方法中，第一个参数传入正则表达式，第二个参数传入要匹配的字符串

打印输出结果，可以看到结果是Match对象，证明成功匹配

该对象有两个方法

• group方法，可以输出匹配的内容,正则表达式规则所匹配的内容
• span方法，可以输出匹配的范围，结果(0,25),这就是匹配到的结果字符串在原字符串中的位置范围

匹配目标

我们用match方法得到了匹配到的字符串内容，但当我想从字符串中提取一部分内容，该怎么办？

要从一段文本中提取出邮件或电话号码等内容，我们可以使用 ()括号将想提取的子字符串括起来

() 实际上标记了一个子表达式的开始和结束位置，被标记的每个子表达式会依次对应每一个分组，调用group方法传入分组的索引即可获取提取的结果

import re
content = 'Hello 1234567 World_This is a Regex Demo'
result = re.match('^Hello\s(\d+)\sWorld',content)
print(result)
print(result.group())
print(result.group(1))
print(result.span())

这里我们想把字符串中的1234567提取出来，此时可以将数字部分的正则表达式用()括起来，然后调用了group(1)获取匹配结果

group(1)与group()有所不同，后者会输出完整的匹配结果，而前者会输出第一个被()包围的匹配结果

假如正则表达式后面还有()包括的内容，那么可以依次用group(2)、group(3)来获取

通用匹配

刚才正则表达比较复杂，出现空白字符就写\s匹配，出现数字就用\d匹配，这样的工作量非常大

可以用一个万能匹配来减少这些工作，那就是—— .*

• . 可以匹配任意字符(除换行符)

• * 代表匹配前面的字符无限次

它们组合在一起就可以匹配任意字符了

有了它，我们就不用挨个字符的匹配了

import re

content = 'Hello 123 4567 World_This is a Regex Demo'

result = re.match('^Hello.*Demo$',content)
print(result)
print(result.group())
print(result.span())

我们将中间部分直接省略，全部用.*来代替，最后加一个结尾字符$

group方法输出了匹配的全部字符串，也就是说我们写的正则表达式匹配到了目标字符串的全部内容

span方法输出(0,41),这是整个字符串的长度

因此，我们可以使用.*简化正则表达式的书写

贪婪与非贪婪

使用.*匹配时，有时候匹配到的并不是我们想要的结果

import re
content = 'Hello 1234567 World_This is a Regex Demo'
result = re.match('^He.*(\d+).*Demo$',content)
print(result)
print(result.group(1))

我们想获取中间的数字，中间依然写的是(\d+)

由于数字两侧的内容比较杂乱，所以略写成 .*

我们只得到了7，这是为什么？

这就涉及一个贪婪匹配与非贪婪匹配的问题了

*在贪婪匹配下，.会匹配尽可能多的字符

• 正则表达式中. *后面是\d+,也就是至少一个数字，并没有指定具体多少个数字
• 因此，. *就会尽可能匹配多的字符，这里就把123456都匹配了，给\d+留下一个可满足条件的数字7，最后得到的内容就只有数字7了

这会给我们带来很大的不便。匹配的结果会莫名其妙少了一部分内容。这里只需要用非贪婪匹配就好——.*?

import re

content = 'Hello 1234567 World_This is a Regex Demo'
result = re.match('^He.*?(\d+).*Demo$', content)
print(result)
print(result.group(1))

此时就可以成功获取1234567

贪婪匹配是尽可能匹配多的字符，非贪婪匹配就是尽可能匹配少的字符

• 当. *?匹配到Hello后面的空白字符时，再往后的字符就是数字了
• 而\d+恰好可以匹配，那么 . *?就不再进行匹配，交给\d+去匹配后面的数字
• 这样.*?匹配了尽可能少的字符，\d+的结果就是1234567

因此，在做匹配的时候，字符串中间尽量使用非贪婪匹配

**用. ? 来代替 . ,以免出现匹配结果缺失的情况

但需要注意的是，如果匹配的结果在字符串结尾，.*?就有可能匹配不到任何内容了，因为它会匹配尽可能少的字符

import re

content = 'http://weibo.com/comment/kEraCN'
result1 = re.match('http.*?comment/(.*?)',content)
result2 = re.match('http.*?comment/(.*)',content)
print('result1',result1.group(1))
print('result2',result2.group(1))

修饰符

正则表达式可以包含一些可选标志修饰符来控制匹配的模式

修饰符被指定为一个可选的标志

import re

content = '''Hello 1234567 World_This
is a Regex Demo
'''
result = re.match('^He.*?(\d+).*?Demo$',content)
print(result.group(1))

运行报错，也就是说正则表达式没有匹配到这个字符串，返回结果为None

而我们又调用了group方法导致AttributeError

为什么加了一个换行符，就匹配不到了？

这是因为我们匹配的是除换行符之外的任意字符，当遇到换行符时，.*?就不能匹配了，导致匹配失败

这里只需加一个修饰符re.S即可纠正错误

result = re.match('^He.*?(\d+).*?Demo$',content,re.S)

这个修饰符的作用是匹配包括换行符在内的所有字符

这个re.S在网页匹配中经常用到

因为HTML节点经常会有换行，加上它，就可以匹配节点与节点之间的换行了

还有一些修饰符，在必要的情况下也可以使用

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别(local-aware)匹配
re.M	多行匹配，影响^和$
re.S	使匹配包括换行内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响\w \W \b \B
re.X	该标志通过给予更灵活的格式以便你将正则表达式写得更易于理解

在网页匹配中，较为常用的修饰符有re.s和re.I

转义匹配

正则表达式定义了许多匹配模式，如匹配除换行符以外的任意字符，但如果目标字符串里面就包括. 那怎么办呢？

这就要用到转义匹配了

import re

content = '(百度)www.baidu.com'

result =  re.match('\(百度\)www\.baidu\.com',content)

print(result)

当遇到用于正则匹配模式的特殊字符时，在前面加反斜线转义一下即可 例如 .就可以用 \ .来匹配

成功匹配了原字符串

search

match方法是从字符串的开头开始匹配的，一旦开头不匹配，那么整个匹配就失败了

import re

content = 'Extra strings  1234567 World_This is a Regex Demo Extra stings'
result = re.match('Hello.*?(\d+).*?Demo',content)
print(result)

这里的字符串以Extra开头，但正则表达式以Hello开头

整个正则表达式是字符串的一部分，但是这样匹配是失败的

因为match方法在使用时需要考虑到开头的内容，这在做匹配时并不方便。它更适合用来检测某个字符串是否符合某个正则表达式的规则

这里有另外一个search方法，它在匹配时会扫描整个字符串，然后返回第一个成功匹配的结果。

• 也就是说，正则表达式可以是字符串的一部分
• 在匹配时，search方法会依次扫描字符串
• 直到找到第一个符合规则的字符串，然后返回匹配内容
• 如果搜索完了还没有找到，就返回None

把match方法修改为search,就得到了匹配结果

import re

content = 'Extra strings Hello 1234567 World_This is a Regex Demo Extra stings'
result = re.search('Hello.*?(\d+).*?Demo',content)
print(result)

因此，为了匹配方便，我们可以尽量使用search方法

---

HTML文本提取练习

一段待匹配的HTML文本，接下来我们写几个正则表达式来实现相应信息的提取

html = '''<div id="songs-list">
<h2 class="title">经典老歌</h2>
<p class="introduction">
经典老歌列表
</p>
<ul id="list" class="list-group">
<li data-view="2">一路上有你</li>
<li data-view="7">
<a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
</li>
<li data-view="4" class="active">
<a href="/3.mp3" singer="齐秦">往事随风</a>
</li>
<li data-view="6"><a href="/4.mp3" singer="beyond">光辉岁月</a></li>
<li data-view="5"><a href="/5.mp3" singer="陈慧琳">记事本</a></li>
<li data-view="5">
<a href="/6.mp3" singer="邓丽君">但愿人长久</a>
</li>
</ul>
</div>'''

• ul节点里有很多li节点
• 其中li节点中有的包含a节点，有的不包含，
• a节点还有一些相应的属性——超链接和歌手名

首先，我们尝试提取class为active的li节点内部超链接包含的歌手名和歌名

此时需要提取第三个li节点下a节点的singer属性和文本

• 正则表达式可以用li开头，然后寻找一个标志符active，中间的部分可以用 . *?来匹配
• 接下来，要提取singer这个属性值，所以需要写入singer="(.*?)",这里需要提取的部分用小括号括起来
• 然后需要匹配a节点的文本，其中它的左边界是>,右边界是< /a> 目标内容依然用(.*?)来匹配

**正则表达式: <li. *?active. *?singer="(. ?)">(. ?)< /a>

在调用search方法，它会搜索整个HTML文本，找到符合正则表达式的第一个内容返回。另外，由于代码有换行，所以这里第三个参数需要传入re.S

result = re.search('<li.*?active.*?singer="(.*?)">(.*?)</a>',html,re.S)
if result:
    print(result.group(1),result.group(2))

这正是class为active的li节点 内部的超链接 包含的歌手名和歌名

---

如果正则表达式不加active（匹配不带class为active的节点内容）

result = re.search('<li.*?singer="(.*?)">(.*?)</a>',html,re.S)
if result:
    print(result.group(1),result.group(2))

把active标签去掉后，从字符串开头开始搜索，此时符合条件的节点就变成了第二个li节点，后面的不再匹配

---

re.S使得.*?可以匹配换行，所以含有换行的li节点被匹配到了，如果我们将其去掉，会怎样?

result = re.search('<li.*?singer="(.*?)">(.*?)</a>', html)
if result:
    print(result.group(1), result.group(2))

可以看到，结果变成了第四个li节点的内容。

• 这是因为第二个和第三个li节点都包含了换行符，

• 去掉re.S之后，.*?已经不能匹配换行符，

• 所以正则表达式不会匹配到第二个和第三个li节点，

• 而第四个li节点中不包含换行符，所以成功匹配

• 由于绝大部分的HTML文本都包含了换行符，所以尽量都需要加上re.S修饰符，以免出现匹配不到的问题

findall

search方法，可以返回匹配正则表达式的第一个内容

但如果想要匹配正则表达式的所有内容，就需要借助findall方法了

findall会搜索整个字符串，然后返回匹配正则表达式的所有内容

如果想获取所有a节点的超链接、歌手、和歌名，就可以将search方法换成findall方法

如果有返回结果的话，就是列表类型，所以需要遍历一下来一次获取每组内容

results = re.findall('<li.*?href="(.*?)".*?singer="(.*?)">(.*?)</a>', html,re.S)
print(results)
print(type(results))
for result in results:
    print(result)
    print(result[0],result[1],result[2])

返回的列表中的每个元素都是元组类型，我们用对应的索引依次取出即可

如果只是获取第一个内容，可以用search方法

当需要提取多个内容时，可以用findall方法

sub

除了使用正则表达式提取信息外，有时候还需要借助它来修改文本

例如想要把一串文本的所有数字都去掉，如果只用字符串的replace方法，就太烦琐了，可以借助sub方法

import re 

content = '54aK54yr5oiR54ix5L2g'
content = re.sub('\d+', '',content)
print(content)

• 我们只需要给第一个参数传入\d+来匹配所有的数字

• 第二参数传入替换成的字符串(如果去掉该参数的话，可以赋值为空)

• 第三个参数是原字符串

上面的例子中，如果想获取所有li节点的歌名，直接用正则表达式来提取可能比较烦琐，我可以写成这样

results = re.findall('<li.*?>\s*?(<a.*?>)?(\w+)(</a>)?\s*?</li>',html,re.S)
for result in results:
    print(result)
    print(result[1])

此时借助sub方法就比较简单了。可以先用sub方法将a节点去掉，只留下文本，然后再利用findall提取就好了

html = re.sub('<a.*?>|</a>','',html)
print(html)
results = re.findall('<li.*?>(.*?)</li>',html,re.S)
for result in results:
    print(result)
    print(result.strip())

在适当的时候，借助sub方法可以起到事半功倍的效果

compile

可以将正则字符串编译成正则表达式对象，以便在后面的匹配中复用

import re

content1 = '2019-12-15 12:00'
content2 = '2019-12-17 12:55'
content3 = '2019-12-22 13:21'

pattern = re.compile('\d{2}:\d{2}')

result1 = re.sub(pattern, '', content1)
result2 = re.sub(pattern, '', content2)
result3 = re.sub(pattern, '', content3)
print(result1,result2,result3)

这里有3个日期，我们想分别将3个日期中的时间去掉

可以借助sub方法，该方法的第一个参数是正则表达式，但我们没有必要重复写3个同样的正则表达式。

可以借助compile方法将正则表达式编译成一个正则表达式对象，以便复用

compile还可以传入修饰符，例如re.S修饰符，这样在search、findall等方法中就不需要额外传了

可以将正则字符串编译成正则表达式对象，以便在后面的匹配中复用

import re

content1 = '2019-12-15 12:00'
content2 = '2019-12-17 12:55'
content3 = '2019-12-22 13:21'

pattern = re.compile('\d{2}:\d{2}')

result1 = re.sub(pattern, '', content1)
result2 = re.sub(pattern, '', content2)
result3 = re.sub(pattern, '', content3)
print(result1,result2,result3)

这里有3个日期，我们想分别将3个日期中的时间去掉

可以借助sub方法，该方法的第一个参数是正则表达式，但我们没有必要重复写3个同样的正则表达式。

可以借助compile方法将正则表达式编译成一个正则表达式对象，以便复用

compile还可以传入修饰符，例如re.S修饰符，这样在search、findall等方法中就不需要额外传了

因此，findall方法可以说是给正则表达式做了一层封装，以便我们更好的复用