您现在的位置是：首页 > 学无止境 > Python 网站首页学无止境

正则表达式是处理字符串的强大工具，我们可以通过正则表达式来实现字符串的检索、替换和匹配。因此对于爬虫而言，通过正则表达式就可以从html页面里面提取到对我们有利的信息。

---

一、匹配规则

下面是常用的一些正则表达式匹配规则：

字符	描述
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“n”匹配字符“n”。“\n”匹配一个换行符。串行“\\”匹配“\”而“\(”则匹配“(”。
^	匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性，^也匹配“\n”或“\r”之后的位置。
$	匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性，$也匹配“\n”或“\r”之前的位置。
*	匹配前面的子表达式零次或多次。例如，zo*能匹配“z”以及“zoo”。*等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，“zo+”能匹配“zo”以及“zoo”，但不能匹配“z”。+等价于{1,}。
?	匹配前面的子表达式零次或一次。例如，“do(es)?”可以匹配“does”或“does”中的“do”。?等价于{0,1}。
{n}	n是一个非负整数。匹配确定的n次。例如，“o{2}”不能匹配“Bob”中的“o”，但是能匹配“food”中的两个o。
{n,}	n是一个非负整数。至少匹配n次。例如，“o{2,}”不能匹配“Bob”中的“o”，但能匹配“foooood”中的所有o。“o{1,}”等价于“o+”。“o{0,}”则等价于“o*”。
{n,m}	m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}”将匹配“fooooood”中的前三个o。“o{0,1}”等价于“o?”。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符（*,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串“oooo”，“o+?”将匹配单个“o”，而“o+”将匹配所有“o”。
.	匹配除“\n”之外的任何单个字符。要匹配包括“\n”在内的任何字符，请使用像“(.|\n)”的模式。
x|y	匹配x或y。例如，“z|food”能匹配“z”或“food”。“(z|f)ood”则匹配“zood”或“food”。
[xyz]	字符集合。匹配所包含的任意一个字符。例如，“[abc]”可以匹配“plain”中的“a”。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如，“[^abc]”可以匹配“plain”中的“p”。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，“[a-z]”可以匹配“a”到“z”范围内的任意小写字母字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]”可以匹配任何不在“a”到“z”范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”。
\B	匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”。
\cx	匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“c”字符。
\d	匹配一个数字字符。等价于[0-9]。
\D	匹配一个非数字字符。等价于[^0-9]。
\f	匹配一个换页符。等价于\x0c和\cL。
\n	匹配一个换行符。等价于\x0a和\cJ。
\r	匹配一个回车符。等价于\x0d和\cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于[^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于\x09和\cI。
\v	匹配一个垂直制表符。等价于\x0b和\cK。
\w	匹配包括下划线的任何单词字符。等价于“[A-Za-z0-9_]”。
\W	匹配任何非单词字符。等价于“[^A-Za-z0-9_]”。

 

二、匹配方法

Python的re库提供了在Python中对正则表达式的实现，如果想要在Python中很好的使用正则表达式，我们就需要了解一些re库的常用方法。

1.match()

match()方法会尝试从字符串的起始位置开始匹配正则表达式，如果匹配成功了，则返回成功的结果；若失败，则返回None。match()由于是从字符串的开头位置匹配，因此更多的用于检测某个字符串是否符合某个正则表达式的规则。

import re

content = "Hello, 416 5874188, How are you?"
result = re.match('^Hello,\s\d\d\d\s\d{7}\W', content)
print(result)
print(result.group())
print(result.span())


# 结果如下
<_sre.SRE_Match object; span=(0, 19), match='Hello, 416 5874188,'>  # 表明结果是SRE_Match对象，匹配成功
Hello, 416 5874188,     # 匹配到的内容
(0, 19)    # 匹配到的内容在字符串中的位置

2.search()

与match()方法从字符串开头开始匹配不同，search()方法在匹配的时候会扫描整个字符串，然后返回第一个成功匹配的结果；如果搜索完整个字符串也没成功匹配，则返回None。也就是说，返回的结果是整个字符串的一部分，因此为了匹配方便我们一般都用search()而不是match()。通过一些实例来看search()的用法。

html = '''
    <li>
    <a href="/song/2pgtbd9.html" title="Christine Welch - 一百万个可能" >Christine Welch - 一百万个可能</a>
    </li>
    <li class="top" title="火箭少女101 - 卡路里" data-index="1">
    <a href="/song/o35k304.html" title="火箭少女101 - 卡路里">火箭少女101 - 卡路里</a>
    </li>
    <a href="/song/mlcina9.html" title="王大毛 - 去年夏天">王大毛 - 去年夏天</a>
    <li><a href="/song/ootaieb.html" title="黑龙 - 38度6">黑龙 - 38度6</a></li>'''

# 提取class为top的li节点的歌曲名，歌曲链接。以top作为标识符，中间无用的部分可以用.*?来匹配
# 最终表达式为<li.*?top.*?href="(.*?)".*?>(.*?)</a>
result = re.search('<li.*?top.*?href="(.*?)".*?>(.*?)</a>', html, re.S)
if result:
    print(result.group(1), result.group(2))

# 运行结果
/song/o35k304.html 火箭少女101 - 卡路里


# 如果我们将top去掉，
result = re.search('<li.*?href="(.*?)".*?>(.*?)</a>', html, re.S)
if result:
    print(result.group(1), result.group(2))

# 运行结果
/song/2pgtbd9.html Christine Welch - 一百万个可能  # 因为search()返回第一个成功匹配的结果

3.findall()

上面search()返回的是第一个成功匹配的结果，那么如果我们想要一个页面中所有与表达式匹配的结果怎么办？这时就可以使用findall()方法了。它与search()一样，会搜索整个字符串，但是与search()不同的是，findall()返回的是所有成功匹配的结果。

html = '''
    <li>
    <a href="/song/2pgtbd9.html" title="Christine Welch - 一百万个可能" >Christine Welch - 一百万个可能</a>
    </li>
    <li class="top" title="火箭少女101 - 卡路里" data-index="1">
    <a href="/song/o35k304.html" title="火箭少女101 - 卡路里">火箭少女101 - 卡路里</a>
    </li>
    <a href="/song/mlcina9.html" title="王大毛 - 去年夏天">王大毛 - 去年夏天</a>
    <li><a href="/song/ootaieb.html" title="黑龙 - 38度6">黑龙 - 38度6</a></li>'''

# 获取所有a节点的歌曲名，歌曲链接。
result = re.findall('<a.*?href="(.*?)".*?>(.*?)</a>', html, re.S)
print(result)
print(type(result))
for i in result:
    print(i)
    print(i[0], i[1])


# 运行结果
[('/song/2pgtbd9.html', 'Christine Welch - 一百万个可能'), ('/song/o35k304.html', '火箭少女101 - 卡路里'), ('/song/mlcina9.html', '王大毛 - 去年夏天'), ('/song/ootaieb.html', '黑龙 - 38度6')]

<class 'list'>
('/song/2pgtbd9.html', 'Christine Welch - 一百万个可能')
/song/2pgtbd9.html Christine Welch - 一百万个可能
('/song/o35k304.html', '火箭少女101 - 卡路里')
/song/o35k304.html 火箭少女101 - 卡路里
('/song/mlcina9.html', '王大毛 - 去年夏天')
/song/mlcina9.html 王大毛 - 去年夏天
('/song/ootaieb.html', '黑龙 - 38度6')
/song/ootaieb.html 黑龙 - 38度6

# 可以看到，返回的列表中的每个元素都是元素类型，我们只要根据索引就可以取出

4.sub()

除了使用正则表达式来获取内容，我们也可以通过它来修改文本。比如把一个文本中的数字全部去掉，如果只用replace()方法的话，那就显得比较繁琐，这时就可以使用re库的sub()方法。

import re

content = '19wrg1r8g19wefw51we155'
content = re.sub('\d+', '', content)
print(content)

# 运行结果
wrgrgwefwwe

5.compile()

最后介绍一种compile()方法，这种方法是用来将正则表达式字符串编译成正则表达式对象，以便在之后的匹配中复用。

import re

time1 = '2018-09-17 12:00'
time2 = '2018-09-18 12:24'
time3 = '2018-09-19 12:37'
pattern = re.compile('\d{2}:\d{2}')
result1 = re.sub(pattern, '', time1)
result2 = re.sub(pattern, '', time2)
result3 = re.sub(pattern, '', time3)
print(result1)
print(result2)
print(result3)


# 结果
2018-09-17
2018-09-18
2018-09-19

三、其他说明

1.匹配目标

我们想要从字符串中提取某一部分对我们有利的内容，这一部分内容就可以称为我们需要匹配的目标。一般我们使用()括号将想要匹配的内容的正则表达式包括起来，被包括的每个子表达式会依次对应一个分组，调用group()方法传入分组的索引即可获取提取的内容。

import re

content = 'Hello 123445 World_134523_This is a demo'
result = re.match('^Hello\s(\d+)\sWorld_(\d+)', content)
print(result)
print(result.group())
print(result.group(1))
print(result.group(2))


# 结果
<_sre.SRE_Match object; span=(0, 25), match='Hello 123445 World_134523'>
Hello 123445 World_134523
123445
134523

# group()会输出完整的匹配结果，而group(1)则是输入第一个被()包围的结果，同理group(2)输出的是第二个被()包围的结果，其他同理。

2.通用匹配

一般，如果对于一些没有用的信息，我们可以用万能匹配 .* 来代替。其中 .(点)代表匹配任意字符，*代表匹配前面的字符无数次。因此我们使用.*来简化正则表达式的书写。

import re

content = 'Hello 123445 World_134523_This is a demo'
result = re.match('^Hello.*demo', content)
print(result)
print(result.group())


# 结果
<_sre.SRE_Match object; span=(0, 40), match='Hello 123445 World_134523_This is a demo'>
Hello 123445 World_134523_This is a demo

3.贪婪与非贪婪

使用通用匹配式.*是，可能有时候匹配到的不是我们想要的结果。

import re

content = 'Hello 123445 World_134523_This is a demo'
result = re.match('^Hello.*(\d+).*demo', content)
print(result)
print(result.group(1))


# 结果
<_sre.SRE_Match object; span=(0, 40), match='Hello 123445 World_134523_This is a demo'>
3

# 可以看到 我们只得到了3这个数字。这是因为在贪婪模式下，.*会匹配尽可能多的字符，而后面的\d+为只少匹配一个数字，因此.*就把Hello 123445 World_13452都匹配了

# 解决这个问题，我们只要加上一个?，匹配模式就有贪婪变成了非贪婪。我们将上面例子的.*改为.*?看看

content = 'Hello 123445 World_134523_This is a demo'
result = re.match('^Hello.*?(\d+).*?demo', content)
print(result)
print(result.group(1))

# 结果
<_sre.SRE_Match object; span=(0, 40), match='Hello 123445 World_134523_This is a demo'>
123445

# 由此可见，贪婪匹配是尽可能的匹配多的字符，而非贪婪匹配则是尽可能的匹配少的字符

4.修饰符

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

在网页匹配中使用的比较多的有re.S和re.I

5.转义匹配

加入我们的目标字符串中包含了(  )  .  ,  ' 等一些特殊字符，那么我们就需要用到转义匹配的，即在前面加一个\

如用 \. 来匹配 .

import re

content = "www.baidu.com"
result = re.match("www\.baidu\.com", content)
print(result)

# 结果
<_sre.SRE_Match object; span=(0, 13), match='www.baidu.com'>

# 可以看出，成功匹配到原字符串

---

版权声明：本文为博主原创文章，转载时请注明来源。https://blog.thinker.ink/passage/10/