re模块
1.爬虫为什么要学习正则表达式
爬虫爬取数据时大概可以分为4步：
（1） 明确要爬取的目标（知道要去爬取哪个网站）
（2）将目标网站的的内容全部爬下来
（3）将我们需要的数据解析出来
（4）数据的存储和使用
2. 什么是正则表达式
正则表达式，通常是用来检索、替换那些符合某个规则的文本。所以通过正则表达式我们可以：
- 给定的字符串是否符合匹配正则表达式
- 通过正则表达式，获取我们在字符串中想要的特定部分
3.正则表达式的匹配规则
4. Python 的 re 模块
在 Python 中，我们可以使用内置的 re 模块来使用正则表达式。有一点需要特别注意的是，正则表达式使用 对特殊字符进行转义，所以如果我们要使用原始字符串，只需加一个 r 前缀，示例：
r' D:\MongoDB\db'
4.1 re 模块的一般使用步骤如下：
- 使用 compile() 函数将正则表达式的字符串形式编译为一个 Pattern 对象
- 通过 Pattern 对象提供的一系列方法对文本进行匹配查找，获得匹配结果，一个 Match 对象。
- 最后使用 Match 对象提供的属性和方法获得信息，根据需要进行其他的操作
4.2 compile 函数
compile 函数用于编译正则表达式，生成一个 Pattern 对象，它的一般使用形式如下：
import re # 将正则表达式编译成 Pattern 对象 pattern = re.compile(r'\d+')
在上面，我们已将一个正则表达式编译成 Pattern 对象，接下来，我们就可以利用 pattern 的一系列方法对文本进行匹配查找了。
Pattern 对象的一些常用方法主要有：
- match 方法：从起始位置开始查找，一次匹配
- search 方法：从任何位置开始查找，一次匹配
- findall 方法：全部匹配，返回列表
- finditer 方法：全部匹配，返回迭代器
- split 方法：分割字符串，返回列表
- sub 方法：替换
4.3 match 方法
match 方法用于查找字符串的头部（也可以指定起始位置），它是一次匹配，只要找到了一个匹配的结果就返回，而不是查找所有匹配的结果。它的一般使用形式如下：
match(pattern,string,flag=0) 尝试使用带有可选标记的正则表达式的模式来匹配字符串，当匹配成功时，返回一个 Match 对象，如果没有匹配上，则返回 None。
import re pattern = re.compile(r'\d+') # 用于匹配至少一个数字 m = pattern.match('one12twothree34four') # 查找头部，没有匹配 print(m)
# 结果:None
m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配 print(m) # 结果：None
m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配 print(m) # 返回一个 Match 对象 #结果：<_sre.SRE_Match object; span=(3, 5), match='12'>
#group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
m.group(0) # 可省略 0
# 结果：'12'
#start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
m.start(0) # 可省略 0 # 结果：3
# end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
m.end(0) # 可省略 0
# 结果：5
#span([group]) 方法返回 (start(group), end(group))。
m.span(0) # 可省略 0
# 结果：(3, 5)
4.3 search 方法
search 方法用于查找字符串的任何位置，它也是一次匹配，只要找到了一个匹配的结果就返回，而不是查找所有匹配的结果，它的一般使用形式如下：
search(pattern,string,flag=0) 尝试使用带有可选标记的正则表达式的模式来匹配字符串，当匹配成功时，返回一个 Match 对象，如果没有匹配上，则返回 None。
例子：
import re pattern = re.compile('\d+') m = pattern.search('one12twothree34four') print(m) # 结果：<_sre.SRE_Match object; span=(3, 5), match='12'> print(m.group()) # 结果：'12' m = pattern.search('one12twothree34four', 10, 30) # 指定字符串区间 print(m) # 结果：<_sre.SRE_Match object; span=(13, 15), match='34'> print(m.group()) #结果'34' print(m.span()) # 结果：(13, 15)
4.4 findall 方法
上面的 match 和 search 方法都是一次匹配，只要找到了一个匹配的结果就返回。然而，在大多数时候，我们需要搜索整个字符串，获得所有匹配的结果。
findall 方法的使用形式如下：
findall(pattern,string,flag=0) findall 以列表形式返回全部能匹配的子串，如果没有匹配，则返回一个空列表。
看看例子：
import re pattern = re.compile(r'\d+') # 查找数字 result1 = pattern.findall('hello 123456 789') result2 = pattern.findall('one1two2three3four4', 0, 10) print(result1) #['123456', '789'] print(result2) #['1', '2']
4.5 finditer 方法
finditer 方法的行为跟 findall 的行为类似，也是搜索整个字符串，获得所有匹配的结果。但它返回一个顺序访问每一个匹配结果（Match 对象）的迭代器。
看看例子：
import re pattern = re.compile(r'\d+') res1 = pattern.finditer('hello 123456 789') res2 = pattern.finditer('one1two2three3four4', 0, 10) print(type(res1)) # <class 'callable_iterator'> print((res2)) # <callable_iterator object at 0x0000000002908F98> for m1 in res1: # m1 是 Match 对象 print('matching string: {}, position: {}'.format(m1.group(), m1.span())) for m2 in res2: print('matching string: {}, position: {}'.format(m2.group(), m2.span()))
4.6 split 方法
split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
split(pattern,string,max=0)
其中，max 用于指定最大分割次数，不指定将全部分割。
例子：
import re p = re.compile(r'[\s\,\;]+') print(p.split('a,b;; c d')) 执行结果： ['a', 'b', 'c', 'd']
4.7 sub 方法
sub 方法用于替换。它的使用形式如下：
sub(pattern, repl, string,count = 0)
使用repl替换正则表达式pattern表达的模式在字符串中出现的位置，除非count=0，否则就替换所有的位置。
其中，repl 可以是字符串也可以是一个函数：
- 如果 repl 是字符串，则会使用 repl 去替换字符串每一个匹配的子串，并返回替换后的字符串，另外，repl 还可以使用 id 的形式来引用分组，但不能使用编号 0；
- 如果 repl 是函数，这个方法应当只接受一个参数（Match 对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
- count 用于指定最多替换次数，不指定时全部替换。
例子：
import re p = re.compile(r'(\w+) (\w+)') # \w = [A-Za-z0-9] s = 'hello 123, hello 456' print(p.sub(r'hello world', s)) # hello world, hello world print(p.sub(r'\2 \1', s)) # 123 hello, 456 hello def func(m): return 'hi' + ' ' + m.group(2) print(p.sub(func, s)) # hi 123, hi 456 print(p.sub(func, s, 1)) # hi 123, hello 456
4.8 匹配中文
在某些情况下，我们想匹配文本中的汉字，有一点需要注意的是，中文的 unicode 编码范围 主要在 [u4e00-u9fa5]，这里说主要是因为这个范围并不完整，比如没有包括全角（中文）标点，不过，在大部分情况下，应该是够用的。
假设现在想把字符串 title = u'你好，hello，世界' 中的中文提取出来，可以这么做：
import re title = u'你好，hello，世界' pattern = re.compile('[\u4e00-\u9fa5]+') result = pattern.findall(title) print(result) # ['你好', '世界']
4.9贪婪模式与非贪婪模式
- 贪婪模式：在整个表达式匹配成功的前提下，尽可能多的匹配 ( * )；
- 非贪婪模式：在整个表达式匹配成功的前提下，尽可能少的匹配 ( ? )；
- Python里数量词默认是贪婪的。
示例一 ： 源字符串：abbbc
- 使用贪婪的数量词的正则表达式 ab* ，匹配结果： abbb。
* 决定了尽可能多匹配 b，所以a后面所有的 b 都出现了。
- 使用非贪婪的数量词的正则表达式ab*?，匹配结果： a。
即使前面有 *，但是 ? 决定了尽可能少匹配 b，所以没有 b。
示例二 ： 源字符串：aa<div>test1</div>bb<div>test2</div>cc
- 使用贪婪的数量词的正则表达式：<div>.*</div>
- 匹配结果：<div>test1</div>bb<div>test2</div>
这里采用的是贪婪模式。在匹配到第一个“</div>”时已经可以使整个表达式匹配成功，但是由于采用的是贪婪模式，所以仍然要向右尝试匹配，查看是否还有更长的可以成功匹配的子串。匹配到第二个“</div>”后，向右再没有可以成功匹配的子串，匹配结束，匹配结果为“<div>test1</div>bb<div>test2</div>”
- 使用非贪婪的数量词的正则表达式：<div>.*?</div>
- 匹配结果：<div>test1</div>
正则表达式二采用的是非贪婪模式，在匹配到第一个“</div>”时使整个表达式匹配成功，由于采用的是非贪婪模式，所以结束匹配，不再向右尝试，匹配结果为“<div>test1</div>”。
5. 正则表达式爬虫实例
import requests from lxml import etree page = 1 url = 'http://www.qiushibaike.com/8hr/page/' + str(page) headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36', 'Accept-Language': 'zh-CN,zh;q=0.8'} try: response = requests.get(url, headers=headers) resHtml = response.text #print(resHtml) html = etree.HTML(resHtml) result = html.xpath('//div[contains(@id,"qiushi_tag")]') for site in result: item = {} imgUrl = site.xpath('./div/a/img/@src')[0] username = site.xpath('./div/a/@title')[0] #username = site.xpath('.//h2')[0].text content = site.xpath('.//div[@class="content"]/span')[0].text.strip() # 投票次数 vote = site.xpath('.//i')[0].text #print site.xpath('.//*[@class="number"]')[0].text # 评论信息 comments = site.xpath('.//i')[1].text print(imgUrl, username, content, vote, comments) except Exception as e: print(e)
