爬虫解析库（7. 正则表达式）

正则表达式

Tips:本章内容量很多，因为正则表达式的功能十分强大，笔者曾经在一本《自制编译器》中看到作者使用正则表达式进行语法分析，学好了正则表达式，绝对是一把趁手的尖刀利器。

一、正则表达式的简介

正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。
正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。
正则表达式的功能非常强大。

二、内容介绍

编写爬虫的步骤
第1步，抓取Web资源
第2步，对Web资源进行分析
    1、正则表达式
    2、用match方法匹配字符串
    3、用search方法搜索满足条件的字符串
    4、用findall方法和finditor方法查找字符串
    5、用sub方法和subn方法搜索和替换
    6、split方法分割字符串
    7、常用的正则表达式表示法
    8、实战案例，分别使用urllib，urllib3和requests抓取不同的Web资源

三、干货

7.1 match_group

1. 正则表达式中的match方法有两个参数，第一个参数表示文本模式，第二个参数表示待匹配的字符串。
2. 如果匹配成功，match方法返回SRE_Match方法，然后可以调用该对象中的group方法获取匹配成功的字符串，
3. 如果文本模式就是一个普通的字符串，那么group方法按返回的就是文本模式字符串本身

import re                       # 导入re模块
m = re.match('hello','hello')   # 进行文本匹配，匹配成功
if m is not None:
    print(m.group())            # 运行结果：hellow
print(m.__class__.__name__)     # 输出m的类名，运行结果：SRE_Match

m = re.match('hellow','world')
if m is not None:
    print(m.group())            # 运行结果：None
print(m.__class__.__name__)

m = re.match('hello','hello, world.')
if m is not None:
    print(m.group())            # 运行结果：hello
# 
print(m)

7.2 match和select方法

使用match方法和search方法对文本模式进行匹配和搜索，并对这两个方法做一个对比

import re
# 进行文本模式匹配，匹配失败，match方法返回None
m = re.match('python','I love python')
if m is not None:
    print(m.group())
# 匹配失败，要完全相等或者在开头
print(m)

# 进行文本模式搜索，搜索成功
m = re.search('python','I love python')
if m is not None:
    print(m.group())    # 匹配成功
# 
print(m)

# .*代表匹配任意字符，后面会讲到正则表达式的规则
m = re.search('.*','/177913/37117198/')
if m is not None:
    print(m.group())    # 匹配成功

7.3 SelectOne择一匹配符号"|"

使用带择一匹配符号的文本模式字符串，并通过match方法和search方法分别匹配和搜索指定字符串

import re
s = 'Bill|Mike|John'                    
# 指定使用择一匹配符号的文本模式字符串
# 满足其中之一则匹配成功

m = re.match(s, 'Bill')                 # 匹配成功
if m is not None:
    print(m.group())                    # 运行结果Bill

m = re.match(s, "Bill is my friend")    # 匹配成功
if m is not None:
    print(m.group())

m = re.match(s, "John is my friend")
if m is not None:
    print(m.group())
# 
print(m)

7.4 MatchAny

正则表达式匹配规则：
	.字符，可以匹配1个任意字符
 	\.转义字符，可以匹配到真正的.字符

例子主要针对match、select、.字符和.\字符的使用

import re

s = '.ind'  				# 使用了点（.）符号的文本模式字符串
m = re.match(s, 'bind')		# 匹配成功
if m is not None:
    print(m.group())		# 运行结果：bind
m = re.match(s,'binding')
# 运行结果：<<_sre.SRE_Match object; span=(0, 4), match='bind'>
print("<" + str(m))
m = re.match(s,'bin')		# 匹配失败
print(m)					# 运行结果：None

m = re.search(s,'')	# 搜索成功
print(m.group())			# 运行结果：bind
# 运行结果：<_sre.SRE_Match object; span=(1, 5), match='bind'>
print(m)

s1 = '3.14'				# 使用了点（.）符号的文本模式字符串
s2 = '3\.14'				# 使用了转义符将点(.)变成真正的点字符
m = re.match(s1, '3.14')	# 匹配成功，因为点字符同样也是一个字符
# 运行结果：<_sre.SRE_Match object; span=(0, 4), match='3.14'>
print(m)
m = re.match(s1, '3314')	# 匹配成功，3和14之间可以是任意字符
# 运行结果：<_sre.SRE_Match object; span=(0, 4), match='3314'>
print(m)

m = re.match(s2, '3.14')	# 匹配成功
# 运行结果：<_sre.SRE_Match object; span=(0, 4), match='3.14'>
print(m)
m = re.match(s2, '3314')	# 匹配失败，因为中间的3并不是点（.）字符
print(m)					# 运行结果：None

7.5 CharSet字符集

一个字符集【】内只能匹配一个字符，等同于多个 | (择一匹配符)

import re
# 使用字符集，匹配成功
m = re.match('[ab][cd][ef][gh]','adfh')
# 运行结果：adfh
print(m.group())
# 使用字符集，匹配成功
m = re.match('[ab][cd][ef][gh]','bceg')
# 运行结果：bceg
print(m.group())
# 使用字符集，匹配不成功，因为a和b是或的关系
m = re.match('[ab][cd][ef][gh]','abceg')
# 运行结果：None
print(m)
# 字符集和普通文本模式字符串混合使用，匹配成功，ab相当于前缀
m = re.match('ab[cd][ef][gh]','abceh')
# 运行结果：abceh
print(m.group())
# 
print(m)
# 使用择一匹配符，匹配成功，abcd和efgh是或的关系，只要满足一个即可
m = re.match('abcd|efgh','efgh')
# 运行结果：efgh
print(m.group())
# 
print(m)

7.6 SpecificSymbol特殊匹配

通过模式字符串中使用* + ？符号以及特殊字符\w \d
        *：0-n个字符
        +：1-n个字符
        ？：前缀或者后缀
        \w：一个字母或者一个数字
        \d：任意一个数字

import re
# 匹配'a''b''c'三字母按顺序从左到右排列，而且这3个字母都必须至少有一个
# abc aabc abbbcc都可以匹配成功
s = 'a+b+c+'
strList = ['abc','aabc','bbabc','aabbbcccxyz']
# 只有'bbabc'无法匹配成功，因为开头没有'a'
for value in strList:
    m = re.match(s, value)
    if m is not None:
        print(m.group())
    else:
        print('{}不匹配{}'.format(value, s))
print('''---------------------''')

# 匹配任意3个数字-任意3个小写字母
# 123-abc   433-xyz都可以成功
# 下面采用了两种设置模式字符串的方式
# [a-z]是设置字母之间或关系的简化形式，表示a到z的26个字母可以选择任意一个，相当于“a|b|c|…|z”
# s = '\d\d\d-[a-z][a-z][a-z]'
# {3}表示让前面修饰的特殊字符“\d”重复3次，相当于“\d\d\d”
s = '\d{3}-[a-z]{3}'
strList = ['123-abc','432-xyz','1234-xyz','1-xyzabc','543-xyz^%ab']
# '1234-xyz'和'1-xyzabc'匹配失败
for value in strList:
    m = re.match(s, value)
    if m is not None:
        print(m.group())
    else:
        print('{}不匹配{}'.format(value, s))
print('''---------------------''')

# 匹配以a到z的26个字母中的任意一个作为前缀（也可以没有这个前缀），后面是至少1个数字
s = '[a-z]?\d+'
strList = ['1234','a123','ab432','b234abc']
# 'ab432'匹配失败，因为前缀是两个字母
for value in strList:
    m = re.match(s, value)
    if m is not None:
        print(m.group())
    else:
        print('{}不匹配{}'.format(value,s))
print('''---------------------''')

# 匹配一个email
email = '\w+@(\w+\.)*\w+\.com'
emailList =['[email protected]','[email protected]','[email protected]','[email protected]']
# '[email protected]'匹配失败，因为“test”和“abc”之间有连字符（-）
for value in emailList:
    m = re.match(email,value)
    if m is not None:
        print(m.group())
    else:
        print('{}不匹配{}'.format(value,email))

strValue = '我的email是[email protected]，请发邮件到这个邮箱'
# 搜索文本中的email，由于“\w”对中文也匹配，所以下面对email模式字符串进行改进
m = re.search(email, strValue)
print(m)
# 规定“@”前面的部分必须是至少1个字母（大写或小写）和数字，不能是其他字符
email = '[a-zA-Z0-9]+@(\w+\.)*\w+\.com'
m = re.search(email, strValue)
print(m)

7.7 group分组匹配

用括号()表示一组匹配，案例如下：

import re
# 分成3组:(\d{3})(\d{4})([a-z]{2})
m = re.match('(\d{3})-(\d{4})-([a-z]){2}','123-4567-xy')

if m is not None:
    print(m.group())    # 123-4567-xy
    print(m.group(1))   # 123
    print(m.group(2))   # 4567
    print(m.group(3))   # y
    print(m.group())    # 123-4567-xy
print('---------------------------')
# 分成2组：(\d{3}-\d{4})和([a-z]{2})
m = re.match('(\d{3}-\d{4})-([a-z]{2})', '123-4567-xy')
if m is not None:
    print(m.group())		# 运行结果：123-4567-xy
    print(m.group(1))		# 获取第1组的值，运行结果：123-4567
    print(m.group(2))		# 获取第2组的值，运行结果：xy
    print(m.groups())         # 获取每组的值组成的元组，运行结果：('123-4567', 'xy')
print('-----------------')
# 分了1组：([a-z]{2})
m = re.match('\d{3}-\d{4}-([a-z]{2})', '123-4567-xy')
if m is not None:
    print(m.group())		# 运行结果：123-4567-xy
    print(m.group(1))		# 获取第1组的值，运行结果：xy
print(m.groups())		# 获取每组的值组成的元组，运行结果：('xy',)
print('-----------------')
# 未分组，因为模式字符串中没有圆括号括起来的部分
m = re.match('\d{3}-\d{4}-[a-z]{2}', '123-4567-xy')
if m is not None:
    print(m.group())		# 运行结果：123-4567-xy
    print(m.groups())		# 获取每组的值组成的元组，运行结果：()

7.8 start和end-匹配单词的开始和结束

	规则：
		^用于表示匹配字符串的开始
        $用于表示匹配字符串的结束
        \b用于表示单词的边界
        ```
  

```python
import re
# 匹配成功
m = re.search('^The','The end.')
print(m)
if m is not None:
    print(m.group())

# The在匹配字符串的最后，不匹配
m = re.search('^The','end. The')
print(m)
if m is not None:
    print(m.group())
m = re.search('The$','The end.')
print(m)
if m is not None:
    print(m.group())

# this的左侧必须有边界，成功匹配，this左侧是空格
m = re.search(r'\bthis',"What's this?")
print(m)
if m is not None:
    print(m.group())

# 不匹配，因为this左侧是“s”，没有边界
# 字符串前面的r表示该字符中的特殊字符（如“\b”)不进行转义
m = re.search(r'\bthis',"What'sthis？")
print(m)
if m is not None:
    print(m.group())

# this的左右要求都有边界，匹配成功，因为this左侧是空格，右侧是符号？
m = re.search(r'\bthis\b',"What's this?")
print(m)
if m is not None:
    print(m.group())


# 不匹配，因为this右侧是a，a也是单词，不是边界
m = re.search(r'\bthis\b',"What's thisa")
print(m)
if m is not None:
    print(m.group())

7.9 findall函数

findall函数用于查询字符串中某个正则表达式模式全部的非重复出现
        finditem与findall类似，前者更灵活，后者更节省内存资源
        共同的第三个参数re.I: 大小写不敏感
        
        .*：贪婪匹配，尽可能长，在findall里可能只获得一个
        .*?：非贪婪，尽可能短，findall里可以获得多组数据

小案例如下：

import re
# 待匹配的字符串
s = '12.数据库存储-a-abc54-a-xyz---78-A-ytr'
# 匹配以2个数字开头，结尾是3个小写字母，中间用“-a”分隔的字符串，对大小写敏感
# 下面的代码都使用了同样的模式字符串
result = re.findall(r'\d\d-a-[a-z]{3}',s)
# ['12.数据库存储-a-abc', '54-a-xyz']
print(result)

# 将模式字符串加了两个分组（用圆括号括起来的部分），findall方法也会以分组形势返回
result = re.findall(r'(\d\d-a-[a-z]{3})',s)
# ['12.数据库存储-a-abc', '54-a-xyz']
print(result)
# 忽略大小写（最后一个参数值，re.I）
result = re.findall(r'\d\d-a-[a-z]{3}',s,re.I)
# ['12.数据库存储-a-abc', '54-a-xyz', '78-A-ytr']
print(result)

# 忽略大小写，并且加了2个分组
result = re.findall(r'(\d\d-a-[a-z]{3})',s,re.I)
# ['12.数据库存储-a-abc', '54-a-xyz', '78-A-ytr']
print(result)

# 使用finditer函数匹配模式字符串，并返回匹配迭代器
# finditer返回字符串中匹配成功的迭代器，对于每一个匹配，这个迭代器都返回一个Match Object
it = re.finditer(r'(\d\d)-a-([a-z]{3})',s,re.I)
for each in it:
    print(each.group(),end='< ')
    # 获取每一个迭代结果中组的所有的值
    groups = each.groups()
    # 对分组进行迭代
    for i in groups:
        print(i,end=' ')
    print('>')

7.10 sub函数和subn函数的替换和搜索

sub函数与subn函数用于实现搜索和替换功能，将某个字符串中所有匹配正则表达式的部分替换成其他字符串
sub返回替换后的结果，subn函数返回一个元组：元组的第一个元素替换后的结果，第二个元素是替换的总数

案例：sub和subn配合正则表达式进行搜索和替换

import re
# sub函数第1个参数是模式字符串，第2个参数是要替换的字符串，第3个参数是被替换的字符串
# 匹配'Bill is my son'中的'Bill'，并用'Mike'替换'Bill'
result = re.sub('Bill', 'Mike', 'Bill is my son')
# 运行结果：Mike is my son
print(result)
# 返回替换结果和替换总数
result = re.subn('Bill', 'Mike', 'Bill is my son，I like Bill')
# 运行结果：('Mike is my son，I like Mike', 2)
print(result)
# 运行结果：Mike is my son，I like Mike
print(result[0])
# 运行结果：替换总数 = 2
print('替换总数','=',result[1])

# 使用“\N”的形式引用匹配字符串中的分组
result = re.sub('([0-9])([a-z]+)',r'产品编码(\1-\2)','01-1abc,02-2xyz,03-9hgf')
# 01-产品编码(1-abc),02-产品编码(2-xyz),03-产品编码(9-hgf)
print(result)
# 该函数返回要替换的字符串
def fun():
    return r'产品编码(\1-\2)'
result = re.subn('([0-9])([a-z]+)',fun(),'01-1abc,02-2xyz,03-9hgf')
# ('01-产品编码(1-abc),02-产品编码(2-xyz),03-产品编码(9-hgf)', 3)
print(result)
# 01-产品编码(1-abc),02-产品编码(2-xyz),03-产品编码(9-hgf)
print(result[0])
# 替换总数 = 3
print('替换总数','=',result[1])

7.11 split分割

split函数根据正则表达式分割字符串
第一个参数式模式字符串，第二个参数式待分隔的字符串
案例：split配合正则表达式分割字符串

import re
result = re.split(';','Bill;Mike;John')
# 运行结果：['Bill', 'Mike', 'John']
print(result)
# 用至少1个逗号（,），分号（;），点（.）和空白符（\s）分隔字符串
result = re.split('[,;.\s]+','a,b,,d,d;x    c;d.  e')
# 运行结果：['a', 'b', 'd', 'd', 'x', 'c', 'd', 'e']
print(result)
# 用以3个小写字母开头，紧接着一个连字符（-），并以2个数字结尾的字符串作为分隔符对字符串进行分隔
result = re.split('[a-z]{3}-[0-9]{2}','testabc-4312productxyz-49abill')
# 运行结果：['test', '12product', 'abill']
print(result)
# 使用maxsplit参数限定分隔的次数，这里限定为1，也就是只分隔一次
result = re.split('[a-z]{3}-[0-9]{2}','testabc-4312productxyz-43abill',maxsplit=1)
# 运行结果：['test', '12productxyz-43abill']
print(result)

7.12 三种常用的匹配格式

电子邮箱 	1、Email:'[0-9a-zA-Z]+@[0-9a-zA-Z]+\.[a-zA-Z]{2,3}'
IP地址 	2、IP(IPV4):'\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}'
网址匹配 	3、Web address: 'https?:/{2}\w.+'

import re
# 匹配Email的正在表达式
email = '[0-9a-zA-Z]+@[0-9a-zA-Z]+\.[a-zA-Z]{2,3}'
result = re.findall(email, '[email protected]')
# 运行结果：['[email protected]']
print(result)
result = re.findall(email, 'abcdefg@aa')
# “@”后面不是域名形式，匹配失败。运行结果：[]
print(result)
result = re.findall(email, '我的email是[email protected]，不是[email protected]，请确认输入的Email是否正确')
# 运行结果：['[email protected]', '[email protected]']
print(result)


# 匹配IPV4的正则表达式
# 此处应该有限制，0-255.0-255.0-255.0-255
ipv4 = '\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}'
result = re.findall(ipv4, '这是我的IP地址：33.12.数据库存储.54.34，你的IP地址是100.32.53.13吗')
# 运行结果：['33.12.数据库存储.54.34', '100.32.53.13']
print(result)

# 匹配Url的正则表达式
url = 'https?:/{2}\w.+'
url1 = 'https://geekori.com'
url2 = 'ftp://geekori.com' # ftp文件传输协议
# 运行结果：<_sre.SRE_Match object; span=(0, 19), match='https://geekori.com'>
print(re.match(url,url1))
# 运行结果：None
print(re.match(url,url2))

最终案例：糗事网笑话合集抓取

本来是由三个案例，但由于篇幅问题，只能放一个，学习足矣。

import requests
import re

headers = {
    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) '
                  'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.119 Safari/537.36'
}

jokeLists = []
# 判断性别
def verifySex(class_name):
    if class_name =='womenIcon':
        return '女'
    else:
        return '男'

def getJoke(url):
    # 获取页面的HTML代码
    res = requests.get(url)
    # 获取用户ID
    ids = re.findall('
(.*?)
', res.text, re.S)
    # re.S = '如果不使用re.S参数，则只在每一行内进行匹配，如果一行没有，就换下一行重新开始。' \
    #        '而使用re.S参数以后，正则表达式会将这个字符串作为一个整体，在整体中进行匹配。'
    # 获取用户级别
    levels = re.findall('
(.*?)
', res.text, re.S)
    # 获取性别
    sexs = re.findall('
', res.text, re.S)
    # 获取段子内容
    contents = re.findall('
.*?(.*?)',res.text,re.S)
    # 获取好笑数
    laughs = re.findall('(.*?)',res.text,re.S)
    # 获取评论数
    comments = re.findall('(\d+)',res.text,re.S)
    # 使用zip函数将上述获得的数据的对应索引元素放到一起
    # 如将[1,2]、['a','b']编程[(1,'a'),(2,'b')]，便于对元素迭代
    for id,level,sex,content,laugh,comment in zip(ids,levels,sexs,contents,laughs,comments):
        # 获得每一个段子相关的数据
        info = {
            'id':id,
            'level':level,
            'sex':verifySex(sex),
            'content':content,
            'laugh':laugh,
            'comment':comment
        }
        print(info)
        jokeLists.append(info)

# 产生1-30页的URL
urls = ['http://www.qiushibaike.com/text/page/{}/'.format(str(i)) for i in range(1,31)]
# 对这30个URl进行迭代，获取这30页的段子
for url in urls:
    getJoke(url)
# 将抓取结果保存到jokes.txt文件中
for joke in jokeLists:
    f = open('jokes.txt','a+')
    try:
        f.write(joke['id']+'\n')
        f.write(joke['level'] + '\n')
        f.write(joke['sex'] + '\n')
        f.write(joke['content'] + '\n')
        f.write(joke['laugh'] + '\n')
        f.write(joke['comment'] + '\n')
        f.close()
    except UnicodeEncodeError:
        pass

抓取的joke.txt内容