Python爬虫中使用正则表达式的方法和注意事项

说明

爬虫一共就四个主要步骤&＃xff1a; 

• 明确目标 (要知道你准备在哪个范围或者网站去搜索) 

• 爬 (将所有的网站的内容全部爬下来) 

• 取 (去掉对我们没用处的数据) 

• 处理数据(按照我们想要的方式存储和使用) 

对于爬取的网页数据实际中往往和复杂&＃xff0c;很多数据都是无用的数据&＃xff0c;这时候就需要过滤掉这些无用的数据&＃xff0c;将需要的数据匹配处理&＃xff0c;最强大的就是正则表达式&＃xff0c;是Python爬虫世界里必不可少的神兵利器。

正则表达式&＃xff0c;又称规则表达式&＃xff0c;通常被用来检索、替换那些符合某个模式(规则)的文本。正则表达式是对字符串操作的一种逻辑公式&＃xff0c;就是用事先定义好的一些特定字符、及这些特定字符的组合&＃xff0c;组成一个“规则字符串”&＃xff0c;这个“规则字符串”用来表达对字符串的一种过滤逻辑。

给定一个正则表达式和另一个字符串&＃xff0c;我们可以达到如下的目的&＃xff1a;

• 给定的字符串是否符合正则表达式的过滤逻辑(“匹配”)&＃xff1b;

• 通过正则表达式&＃xff0c;从文本字符串中获取我们想要的特定部分(“过滤”)。

正则表达式匹配规则

re 模块

re模块是python的内置模块来使用正则表达式。 

注意&＃xff1a;正则表达式使用 对特殊字符进行转义&＃xff0c;在使用原始字符串&＃xff0c;只需加一个 r 前缀&＃xff0c;示例&＃xff1a;

r&＃39;chuayjgiboke\t\.\tpython&＃39;

re 模块的一般使用步骤&＃xff1a; 

首先&＃xff0c;使用 compile() 函数将正则表达式的字符串形式编译为一个 Pattern 对象 

其次&＃xff0c;通过 Pattern 对象提供的一系列方法对文本进行匹配查找&＃xff0c;获得匹配结果&＃xff0c;一个 Match 对象。 

最后&＃xff0c;使用 Match 对象提供的属性和方法获得信息&＃xff0c;根据需要进行其他的操作

compile 函数

compile 函数用于编译正则表达式&＃xff0c;生成一个 Pattern 对象&＃xff0c;一般使用形式如下&＃xff1a;

import re
# 将正则表达式编译成 Pattern 对象
pattern &＃61; re.compile(r&＃39;\d&＃43;&＃39;)

在上面&＃xff0c;已将一个正则表达式编译成 Pattern 对象&＃xff0c;接下来&＃xff0c;就可以利用 pattern 的一系列方法对文本进行匹配查找了。 

Pattern 对象的常用方法如下

match 方法&＃xff1a;从起始位置开始查找&＃xff0c;一次匹配 

search 方法&＃xff1a;从任何位置开始查找&＃xff0c;一次匹配  

findall 方法&＃xff1a;全部匹配&＃xff0c;返回列表  

finditer 方法&＃xff1a;全部匹配&＃xff0c;返回迭代器  

split 方法&＃xff1a;分割字符串&＃xff0c;返回列表  

sub 方法&＃xff1a;替换

match 方法

match 方法用于查找字符串的头部(也可以指定起始位置)&＃xff0c;它是一次匹配&＃xff0c;只要找到了一个匹配的结果就返回&＃xff0c;而不是查找所有匹配的结果。

一般使用形式如下&＃xff1a;

match(string[, pos[, endpos]])

其中&＃xff0c;string 是待匹配的字符串&＃xff0c;pos 和 endpos 是可选参数&＃xff0c;指定字符串的起始和终点位置&＃xff0c;默认值分别是 0 和 len (字符串长度)。

因此&＃xff0c;当你不指定 pos 和 endpos 时&＃xff0c;match 方法默认匹配字符串的头部。当匹配成功时&＃xff0c;返回一个 Match 对象&＃xff0c;如果没有匹配上&＃xff0c;则返回 None。

# coding&＃61;utf-8import re
pattern &＃61; re.compile(r&＃39;\d&＃43;&＃39;) # 用于匹配至少一个数字m &＃61; pattern.match(&＃39;one12twothree34four&＃39;) # 查找头部&＃xff0c;没有匹配print m
m &＃61; pattern.match(&＃39;one12twothree34four&＃39;, 2, 10) # 从&＃39;e&＃39;的位置开始匹配&＃xff0c;没有匹配print m
m &＃61; pattern.match(&＃39;one12twothree34four&＃39;, 3, 10) # 从&＃39;1&＃39;的位置开始匹配&＃xff0c;正好匹配print m # 返回一个 Match 对象print m.group(0)# 可省略 0print m.start(0)# 可省略 0print m.end(0)# 可省略 0print m.span(0)# 可省略 0

运行&＃xff1a;

None
None
<_sre>.SRE_Match object at 0x0000000002A491D0>
12
3
5
(3, 5)

在上面&＃xff0c;当匹配成功时返回一个 Match 对象&＃xff0c;其中&＃xff1a; 

• group([group1, …]) 方法用于获得一个或多个分组匹配的字符串&＃xff0c;当要获得整个匹配的子串时&＃xff0c;可直接使用 group() 或 

• group(0)&＃xff1b;start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置(子串第一个字符的索引)&＃xff0c;参数默认值为 0&＃xff1b; 

• end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置(子串最后一个字符的索引&＃43;1)&＃xff0c;参数默认值为 0&＃xff1b; 

• span([group]) 方法返回 (start(group), end(group))。

再如&＃xff1a;

# coding&＃61;utf-8import re
pattern &＃61; re.compile(r&＃39;([a-z]&＃43;) ([a-z]&＃43;)&＃39;, re.I) # re.I 表示忽略大小写m &＃61; pattern.match(&＃39;Hello World Wide Web&＃39;)print m # 匹配成功&＃xff0c;返回一个 Match 对象print m.group(0) # 返回匹配成功的整个子串print m.span(0) # 返回匹配成功的整个子串的索引print m.group(1) # 返回第一个分组匹配成功的子串print m.span(1) # 返回第一个分组匹配成功的子串的索引print m.group(2) # 返回第二个分组匹配成功的子串print m.span(2) # 返回第二个分组匹配成功的子串print m.groups() # 等价于 (m.group(1), m.group(2), ...)# print m.group(3) # 不存在第三个分组

运行&＃xff1a;

<_sre.sre_match>object at 0x0000000002B4F470>Hello World
(0, 11)Hello
(0, 5)World
(6, 11)
(&＃39;Hello&＃39;, &＃39;World&＃39;)

search 方法

search 方法用于查找字符串的任何位置&＃xff0c;它也是一次匹配&＃xff0c;只要找到了一个匹配的结果就返回&＃xff0c;而不是查找所有匹配的结果

一般使用形式如下&＃xff1a; 

search(string[, pos[, endpos]])

其中&＃xff0c;string 是待匹配的字符串&＃xff0c;pos 和 endpos 是可选参数&＃xff0c;指定字符串的起始和终点位置&＃xff0c;默认值分别是 0 和 len (字符串长度)。 

当匹配成功时&＃xff0c;返回一个 Match 对象&＃xff0c;如果没有匹配上&＃xff0c;则返回 None。

如&＃xff1a;

# coding&＃61;utf-8import re
pattern &＃61; re.compile(&＃39;\d&＃43;&＃39;)
m &＃61; pattern.search(&＃39;loaderman122twothree343four&＃39;) # 这里如果使用 match 方法则不匹配print mprint m.group()print pattern.search(&＃39;loaderman122twothree343four&＃39;, 10, 30) # 指定字符串区间print m.group()print m.span()

运行&＃xff1a;

<_sre.sre_match>object at 0x00000000037891D0>122<_sre.sre_match>object at 0x0000000003789238>122
(9, 12)

再如&＃xff1a;

# -*- coding: utf-8 -*-import re# 将正则表达式编译成 Pattern 对象pattern &＃61; re.compile(r&＃39;\d&＃43;&＃39;)# 使用 search() 查找匹配的子串&＃xff0c;不存在匹配的子串时将返回 None# 这里使用 match() 无法成功匹配m &＃61; pattern.search(&＃39;loaderman 64123341 864&＃39;)if m:# 使用 Match 获得分组信息 print &＃39;matching string:&＃39;,m.group()# 起始位置和结束位置 print &＃39;position:&＃39;,m.span()

执行&＃xff1a;

matching string: 64123341
position: (10, 18)

findall 方法

match 和 search 方法都是一次匹配&＃xff0c;只要找到了一个匹配的结果就返回。然而&＃xff0c;在大多数时候&＃xff0c;需要搜索整个字符串&＃xff0c;获得所有匹配的结果。 

使用形式如下&＃xff1a; 

findall(string[, pos[, endpos]])

其中&＃xff0c;string 是待匹配的字符串&＃xff0c;pos 和 endpos 是可选参数&＃xff0c;指定字符串的起始和终点位置&＃xff0c;默认值分别是 0 和 len (字符串长度)。findall 以列表形式返回全部能匹配的子串&＃xff0c;如果没有匹配&＃xff0c;则返回一个空列表。 

示例&＃xff1a;

import re
pattern &＃61; re.compile(r&＃39;\d&＃43;&＃39;) # 查找数字

result1 &＃61; pattern.findall(&＃39;hello 123456 789&＃39;)
result2 &＃61; pattern.findall(&＃39;one1two2three3four4&＃39;, 0, 10)

print result1
print result2

运行结果&＃xff1a;

[&＃39;123456&＃39;, &＃39;789&＃39;]
[&＃39;1&＃39;, &＃39;2&＃39;]

再如&＃xff1a;

# re_test.py

import re

#re模块提供一个方法叫compile模块&＃xff0c;提供我们输入一个匹配的规则
#然后返回一个pattern实例&＃xff0c;我们根据这个规则去匹配字符串
pattern &＃61; re.compile(r&＃39;\d&＃43;\.\d*&＃39;)

#通过partten.findall()方法就能够全部匹配到我们得到的字符串
result &＃61; pattern.findall("123.141593, &＃39;bigcat&＃39;, 232312, 3.15")

#findall 以 列表形式 返回全部能匹配的子串给result
for item in result:
    print item

运行结果&＃xff1a;

123.141593
3.15

finditer 方法

finditer 方法的行为跟 findall 的行为类似&＃xff0c;也是搜索整个字符串&＃xff0c;获得所有匹配的结果。但它返回一个顺序访问每一个匹配结果(Match 对象)的迭代器。 

如&＃xff1a;

# -*- coding: utf-8 -*-import re
pattern &＃61; re.compile(r&＃39;\d&＃43;&＃39;)
result1 &＃61; pattern.finditer(&＃39;loaderman 6844321 123&＃39;)
result2 &＃61; pattern.finditer(&＃39;hello1two2three3four4&＃39;, 0, 10)print type(result1)print type(result2)print &＃39;返回1...&＃39;for m1 in result1: # m1 是 Match 对象 print &＃39;匹配 字符串: {}, 索引值: {}&＃39;.format(m1.group(), m1.span())print &＃39;返回2...&＃39;for m2 in result2:print &＃39;匹配 字符串: {}, 索引值: {}&＃39;.format(m2.group(), m2.span())


执行结果&＃xff1a;





返回1...

匹配 字符串: 6844321, 索引值: (10, 17)

匹配 字符串: 123, 索引值: (18, 21)

返回2...

匹配 字符串: 1, 索引值: (5, 6)

匹配 字符串: 2, 索引值: (9, 10)

split 方法

split 方法按照能够匹配的子串将字符串分割后返回列表

形式如下&＃xff1a; 

split(string[, maxsplit])

其中&＃xff0c;maxsplit 用于指定最大分割次数&＃xff0c;不指定将全部分割。

如&＃xff1a;

import re
p &＃61; re.compile(r&＃39;[\s\,\;]&＃43;&＃39;)
print p.split(&＃39;a,b;; c d&＃39;)

执行结果&＃xff1a;

[&＃39;a&＃39;, &＃39;b&＃39;, &＃39;c&＃39;, &＃39;d&＃39;]

sub 方法

sub方法用于替换&＃xff0c;使用形式如下&＃xff1a; 

sub(repl, string[, count])

其中&＃xff0c;repl 可以是字符串也可以是一个函数&＃xff1a; 

• 如果 repl 是字符串&＃xff0c;则会使用 repl 去替换字符串每一个匹配的子串&＃xff0c;并返回替换后的字符串&＃xff0c;另外&＃xff0c;repl 还可以使用 id 的形式来引用分组&＃xff0c;但不能使用编号 0&＃xff1b; 

• 如果 repl 是函数&＃xff0c;这个方法应当只接受一个参数(Match 对象)&＃xff0c;并返回一个字符串用于替换(返回的字符串中不能再引用分组)。 

• count 用于指定最多替换次数&＃xff0c;不指定时全部替换。

如&＃xff1a;

import re
p &＃61; re.compile(r&＃39;(\w&＃43;) (\w&＃43;)&＃39;) # \w &＃61; [A-Za-z0-9]
s &＃61; &＃39;hi 123, hi 456&＃39;

print p.sub(r&＃39;hi world&＃39;, s) # 使用 &＃39;hi world&＃39; 替换 &＃39;hi 123&＃39; 和 &＃39;hello 456&＃39;
print p.sub(r&＃39;\2 \1&＃39;, s) # 引用分组

def func(m):
    return &＃39;hei&＃39; &＃43; &＃39; &＃39; &＃43; m.group(2)

print p.sub(func, s)
print p.sub(func, s, 1) # 最多替换一次

执行结果&＃xff1a;

hi world, hi world
123 hi, 456 hi
hei 123, hei 456
hei 123, hello 456

匹配中文

在某些情况下&＃xff0c;我们想匹配文本中的汉字&＃xff0c;有一点需要注意的是&＃xff0c;中文的 unicode 编码范围 主要在 [u4e00-u9fa5]&＃xff0c;这里说主要是因为这个范围并不完整&＃xff0c;比如没有包括全角(中文)标点&＃xff0c;不过&＃xff0c;在大部分情况下&＃xff0c;应该是够用的。

假设现在想把字符串 title &＃61; u&＃39;你好&＃xff0c;hello&＃xff0c;世界&＃39; 中的中文提取出来&＃xff0c;可以这么做&＃xff1a;

import re

title &＃61; u&＃39;你好&＃xff0c;hello&＃xff0c;世界&＃39;
pattern &＃61; re.compile(ur&＃39;[\u4e00-\u9fa5]&＃43;&＃39;)
result &＃61; pattern.findall(title)

print result

注意到&＃xff0c;我们在正则表达式前面加上了两个前缀 ur&＃xff0c;其中 r 表示使用原始字符串&＃xff0c;u 表示是 unicode 字符串。执行结果:

[u&＃39;\u4f60\u597d&＃39;, u&＃39;\u4e16\u754c&＃39;]

贪婪模式与非贪婪模式

贪婪模式&＃xff1a;在整个表达式匹配成功的前提下&＃xff0c;尽可能多的匹配 ( * )&＃xff1b; 

非贪婪模式&＃xff1a;在整个表达式匹配成功的前提下&＃xff0c;尽可能少的匹配 ( ? )&＃xff1b; 

Python里数量词默认是贪婪的。

示例一 &＃xff1a;源字符串&＃xff1a;dqqqe 

• 使用贪婪的数量词的正则表达式 dq* &＃xff0c;匹配结果&＃xff1a; dqqq。 

        * 决定了尽可能多匹配 q&＃xff0c;所以a后面所有的 q 都出现了。 

• 使用非贪婪的数量词的正则表达式dq*?&＃xff0c;匹配结果&＃xff1a; d。 

        * 即使前面有 *&＃xff0c;但是 ? 决定了尽可能少匹配 q&＃xff0c;所以没有 q。

示例二 &＃xff1a;源字符串&＃xff1a;dd

• 使用贪婪的数量词的正则表达式&＃xff1a;

  .*
   

• 匹配结果&＃xff1a;

  demo1
  ee
  demo2

  这里采用的是贪婪模式。在匹配到第一个“