python爬虫（五）正则表达式

正则表达式的简介

动态网页的难点在于找数据接口，Network里找，大部分用了Ajax技术，selenium可以爬取静态和动态的网站。

正则表达式的概述

正则表达式是由.*?() 等一些特殊符号组合在一起的字符串，对预知的字符串进行验证，好比抓取的网页源码是一大段字符串，我们需要在里面提取某些内容。正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
比如我们写好的模板，去模板里匹配某些内容，可以帮我们提取一些我们需要东西，也有可能过滤一些我们不需要的某些内容。

之前爬取网页获取源代码，在网页源码中由很多很多的数据，学习正则是用来从网页源码中提取数据。比如我们想获得网页内的图片，我们在源码中找到图片的链接，向链接发送请求，把图片保存到本地，拿到网页源代码不是最终的目的，是要从代码中提取某些数据，为了获取数据要对网页源码进行数据解析，留下想要的，去掉多余的数据，就可以用正则。

正则表达式的应用场景比较广泛

• 表单验证(例如 : 手机号、邮箱、身份证… )，在业务层进行逻辑判断，用if，else通过正则表达式来完成表单的验证。
• 爬虫

正则表达式对Python的支持，内置re模块

普通字符

字母、数字、汉字、下划线、以及没有特殊定义的符号，都是"普通字符"。正则表达式中的普通字符，在匹配的时候,只匹配与自身相同的一个字符。
例如：表达式c，在匹配字符串abcde时，匹配结果是：成功；匹配到的内容是c；匹配到的位置开始于2，结束于3。（注：下标从0开始还是从1开始，因当前编程语言的不同而可能不同）
match()函数
match(pattern, string, flags=0)，匹配到了返回match对象，匹配不到返回空值。
第一个参数是正则表达式，也就是匹配模型，区分大小写。如果匹配成功，则返回一个match对象，否则返回一个None
第二个参数表示要匹配的字符串，待匹配的数据，也就是网页源码。
第三个参数是标志位用于控制正则表达式的匹配方式 （是否区分大小写，是否用于多行匹配），默认是0，可传可不传。如: 是否区分大小写,多行匹配等等
普通字符

import re
str1 = 'python and java'
spt = 'python'  # --> 如果改为python2，就会匹配失败，因为str里没有python2
resu = re.match(spt, str1)
if resu:
    # print(resu) # -- <_sre.SRE_Match object; span=(0, 6), match='python'>，返回是<>包括的对象，可以用对象的方法提取出想要的内容
    print(resu.group())  #普通字符python
else:
    print('匹配失败')

元字符

正则表达式中使⽤了很多元字符，⽤来表示⼀些特殊的含义或功能。可以用jupyter来演示运行的结果，jupyter比较多的用在数据分析上。爬虫多的是用pycham。
安装：cmd --> pip install jupyter --> jupyter notebook（启动），注意运行期间，cmd窗口不要关闭。jupyter默认路径在C:\Users\Administrator
“r"也就是rawstring，原生字符串 ,字符串前面加上"r”，表示后面的内容只是单纯的表示原生含义，避免多次转义造成的" \ “，python中会有两次转义，python解释器的一次转义，正则的一次转义。
跟 Python 的字符串规则一样，如果在反斜杠” \ “后边紧跟着一个元字符，那么元字符的“特殊功能”不会被触发。例如你需要匹配符号[或\，你可以在它们前面加上一个反斜杠，以消除它们的特殊功能：” \ ["，" \\ “。
一个元字符是”."，如果设置了 re.DOTALL 标志，它匹配除了换行符以外的任何字符。加了" \ “之后，” \ ."就变成小数点的意思。

print('\\')  # --> \
print(r'\\')  # --> \\

表达式	匹配
.	小数点可以匹配除了换行符"\n"以外的任意一个字符
|	逻辑"或"操作符
[]	匹配字符集中的任意一个字符
[^]	对字符集取反，上面的反操作，^在[]里的最前面
-	定义[]里的一个字符区间，例如[a-z]
\	对紧跟其后的一个字符进行转义，称为普通的字符
()	对表达式进行分组，将()内的内容当作一个整体，并获得匹配的值

in[15]，a|b，用来匹配a或者b
in[16]，match会从头开始匹配，成功的话返回第一个匹配的结果；一旦匹配失败就直接结束了。
在match(‘a|b’，ab)，得到的结果是a，match匹配的特性是把正则表达式去待匹配的字符里从头开始匹配，返回第一个匹配到的结果。
search**不会从头开始匹配，只要符合就能匹配到，**返回的也是第一个匹配到的结果。

in[24]，把[abc]2改为[abc]3 就可以匹配到a3了。re.match(’[abc]3’,‘a3’).group() # --> a3
match方法中只要字符串的开头符合正则表达式中的字符都能匹配到，返回第一个匹配到的结果，匹配第一个字符。

表达式	匹配
\r,\n	匹配回车和换行符
\t	匹配制表符
\	匹配斜杠\
^	匹配^符号
$	匹配$符号
.	匹配小数点.

" \ "转义之后成为普通的字符，就没有他所代表的意义了。表达式前面都会加"r “，打开文件的路径前面也会加上“r”。
比如’\type’ # --> ype，r’\type’ # --> \type，’\\type’’ # --> \type
一些无法书写或者具有特殊功能的字符，采用在前面加斜杠” \ "进行转义的方法。

尚未列出的还有问号？、星号*和括号等其他的符号。所有正则表达式中具有特殊含义的字符在匹配自身的时候，都要使用斜杠进行转义。这些转义字符的匹配用法与普通字符类似，也是匹配与之相同的一个字符

预定义匹配字符集

事先定义好的匹配字符的集合。正则表达式中的一些表示方法，可以同时匹配某个预定义字符集中的任意一个字符。比如，表达式\d可以匹配任意一个数字。虽然可以匹配其中任意字符，但是只能是一个，不是多个

表达式	匹配
\d	任意一个数字，0-9中的任意一个
\w	任意一个字母，数字或下划线，A-Z,a-z,0-9,_中的任意一个
\s	空格" “、制表符”\t"、换页符"\f"，换行符"\n"等空白字符的其中任意一个
\D	\d的反集，也就是非数字的任意一个字符，等同于[^\d]
\W	\w的反集，也就是[^\w]
\S	\s的反集，也就是[^\s]

重复匹配

前面的表达式，无论是只能匹配一种字符的表达式，还是可以匹配多种字符其中任意一个的表达式，都只能匹配一次。但是有时候我们需要对某个字段进行重复匹配，例如手机号码13666666666，一般的新手可能会写成\d\d\d\d\d\d\d\d\d\d\d（注意，这不是一个恰当的表达式），不但写着费劲，看着也累，还不⼀定准确恰当。
这种情况可以使用表达式再加上修饰匹配次数的特殊符号{}，不但重复书写表达式就可以重复匹配。例如[abcd][abcd]可以写成[abcd]{2}

表达式	匹配（匹配的是符号前面的表达式）
{n}	表达式重复n次，比如\d{2}相当于\d\d，a{3}相当于aaa，比如{4}，待匹配的字符串有3个会报错，有5个则只能匹配出前4个
{m,n}	表达式至少重复m次，表达式至多重复n次，比如ab{1,3}可以匹配ab、abb或者abbb，包括m，n；如果字符串超过了n，则只匹配到n。注意m，n前后均无空格
{m,}	表达式至少重复m次，没有上限，比如\w\d{2}可以匹配a11，A1234，_45625等等
?	匹配表达式0次或1次，相当于{0,1}，比如a[cd]?可以匹配a,ac,ad
+	表达式至少出现1次，相当于{1,}，比如\a+b可以匹配ab,aab,aaab等等
*	表达式出现0到任意次，相当于{0,}，比如^*b可以匹配b,^^^b等

{m,n}，m和n前后均无空格，否则会匹配不到结果。待匹配的数据不得超出n，否则会报错。

in[57]，若想成功匹配用search。re.search(r’\d{3,4}-\d{6,7}’, ‘123456-123456789’).group()，返回的结果是：3456-1234567，search会返回第一个满足条件的值，正则表达式要求数字之后必须跟的是"-"，匹配"-“前面的第一个满足条件的，和”-"后面第一个满足条件的。

位置匹配

有时候，我们对匹配出现的位置有要求，比如开头、结尾、单词之间等等。

表达式	匹配
^	在字符串开始的地方匹配，符号本身不匹配任何字符
$	在字符串结束的地方匹配，符号本身不匹配任何字符
\b	匹配一个单词边界，也就是单词和空格之间的位置，符号本身不匹配任何字符
\B	匹配非单词边界，即左右两边都是\w范围或者左右两边都不是\w范围时的字符缝隙

可以用help查看使用方法

re.match(r'^1[2-9]\d{9}','123456789121').group() #--> 12345678912，多余9位，只匹配出9位数字
re.match(r'^1[2-9]\d{9}$','123456789121').group() #--> 报错，加上结束符后，就限定了后面匹配的必须是9位，否则就报错

贪婪与非贪婪模式

在重复匹配时，正则表达式默认总是尽可能多的匹配，这被称为贪婪模式。例如，针对文本dxxxdxxxd，表达式"d\w+d"中的"\w+“将匹配第一个"d"和最后一个"d"之间的所有字符"xxxdxxx”。可见，"\w+"在匹配的时候，总是尽可能多的匹配符合它规则的字符。同理，带有?、*和{m,n}的重复匹配表达式都是尽可能地多匹配。

• 贪婪：一直匹配，能匹配多少匹配多少，返回最长的匹配结果
• 非贪婪：匹配尽可能少的字符，一旦满足条件，立即输出，结束匹配结果。

之前进行网页爬取的时候都是把源代码给爬取下来，并没有对里面的数据做解析，有时候只想获取里面的某些数据，比如只要div这个里面的内容。

需求：<div>abc</div>
import re
# s表示带匹配的数据
s = '<div>abc</div><div>def</div>'
# . 用来匹配任意不换行的一个字符   * 匹配0到任意次
ptn = r'<div>.*</div>'
result = re.match(ptn, s)
print(result.group())  # -->'<div>abc</div><div>def</div>'
# 本意是取出一部分，却得到了全部的结果，这就是贪婪 一直匹配，返回最长的匹配结果
# 非贪婪，匹配尽可能少的字符，非贪婪后加"？"，如.*？  .+？   {m,n}?
ptn = r'<div>.*?</div>'
result = re.match(ptn, s)
print(result.group())  # -->'<div>abc</div>'

正则小练习

单个字符的匹配

import re
def fn(ptn, lst):
    for i in lst:
        result = re.match(ptn, i)
        if result:
            print('匹配成功！匹配结果为：', result.group())
        else:
            print('匹配失败！')

# . 用来匹配除换行符以外的任意字符

lst = ['abc', 'abbb', 'other', 'add', 'aba', '123']
ptn = r'ab.'
fn(ptn, lst) 
# 匹配成功！匹配结果为： abc
# 匹配成功！匹配结果为： abb
# 匹配失败！
# 匹配失败！
# 匹配成功！匹配结果为： aba
# 匹配失败！
# abbb 匹配出是abb，只要满足条件就能匹配出来；
#如果改为ptn = r'ab.$'，则abbb匹配不了，$限制了匹配的只能是3位。

# [] 匹配[]列举的字符
lst = ['man', 'mbn', 'mdn', 'mun', 'mfna1', 'nba']
ptn = r'm[abcf]n'
fn(ptn, lst)
# 匹配成功！匹配结果为： man
# 匹配成功！匹配结果为： mbn
# 匹配失败！
# 匹配失败！
# 匹配成功！匹配结果为： mfn
# 匹配失败！

# ^ 取反，加在中括号第一个字符的前面
lst = ['man', 'mbn', 'mdn', 'mun','mfna1', 'nba']
ptn = r'm[^abcf]n'
fn(ptn, lst)
# 匹配失败！
# 匹配失败！
# 匹配成功！匹配结果为： mdn
# 匹配成功！匹配结果为： mun
# 匹配失败！
# 匹配失败！
# nba 不符合条件，要匹配的是以m开头的字符

# \d 用来匹配一个数字  [0-9]
lst = ['8.1', '569', '4.5', '555']
ptn = r'\d.\d'
fn(ptn, lst)  # --> 8.1  569  4.5  555

lst = ['8.1', '569', '4.5', '555']
ptn = r'\d\.\d'
fn(ptn, lst)  # --> 8.1  4.5 

lst = ['py1', 'py2', 'pyxxx', 'other']
ptn = r'py\d'
fn(ptn, lst)    # --> py1 py2

# \D 取了反集，匹配非数字的
lst = ['py1', 'py2', 'pyxxx', 'other']
ptn = r'py\D'
fn(ptn, lst)   # --> pyx

# \s 匹配空白，空格" "、制表符"\t"、换页符"\f"，换行符"\n"等
lst = ['hello world', 'helloxxxx', 'hello,world', 'hello\fworld', 'hello\tworld', 'hello\nworld']
ptn = r'hello\sworld'
fn(ptn, lst)    # --> hello world , helloworld , hello	 world , hello换行world

# \S 取反集，非空白字符的
lst = ['hello world', 'helloxxxx', 'hello,world', 'helloxworld']
ptn = r'hello\Sworld'
fn(ptn, lst)  # --> hello,world ,  helloxworld

# \w 匹配字母数字下划线
lst = ['1-age', 'a-age', '&-age', '_-age']
ptn = r'\w-age'
fn(ptn, lst)  # --> 1-age ， a-age ，_-age
# \W
lst = ['1-age', 'a-age', '&-age', '_-age']
ptn = r'\W-age'
fn(ptn, lst)  # -->  &-age

重复匹配

import re
def fn(ptn, lst):
    for i in lst:
        result = re.match(ptn, i)
        if result:
            print('匹配成功！匹配结果为：', result.group())
        else:
            print('匹配失败！')
            
# * 出现0到任意次
lst = ['hello', 'java', 'python', 'h', 'xxx']
ptn = r'[hp][a-z]*'
fn(ptn, lst)  # --> hello ，python ，h

# + 至少出现一次
lst = ['hello', 'java', 'python', 'h', 'xxx']
ptn = r'[hp][a-z]+'
fn(ptn, lst)   # --> hello ，python

# {n} 重复匹配n次，可以超过，超过后只输出符合条件的几个；不能不够
lst = ['hello', 'java', 'python', 'h', 'xxxxxxxx']
ptn = r'\w{6}'
fn(ptn, lst)   # --> python ，xxxxxx

# {m,n} 大于等于m次 小于等于n次
# 在python中 默认是贪婪的，会取区间的右边界
lst = ['hello', 'jav', 'python', 'h', 'xxxxxxxx']
ptn = r'\w{3,4}'
fn(ptn, lst)  # --> hell ，jav ，pyth ，xxxx

位置匹配

lst = ['123@qq.com', 'abc@yy.com', 'xxx@qq.com.cn']
ptn = r'\w+@qq.com'
fn(ptn, lst)  # --> 123@qq.com ，xxx@qq.com

lst = ['123@qq.com', 'abc@yy.com', 'xxx@qq.com.cn']
ptn = r'\w+@qq.com$'
fn(ptn, lst)  # --> 123@qq.com

校验数字的相关表达式：

功能	表达式
数字	^[0-9]*$
n位的数字	^\d{n}$
至少n位的数字	^\d{n,}$
零和非零开头的数字	^(0|[1-9][0-9]*)$
有两位小数的正实数	^[0-9]+(.[0-9]{2})?$
非零的负整数	^-[1-9]\d*$
非负浮点数	^\d+(\.\d+)?$
浮点数	^(-?\d+)(\.\d+)?$

特殊场景的表达式:

re模块常用方法

方法	描述	返回值
compile(pattern[,flags])	根据包含正则表达式的字符串创建模式对象	re对象
search(pattern,string[,flags])	在字符串中查找	第一个匹配到的对象或者None
match(pattern,string[,flags])	在字符串的开始处匹配模式	在字符串的开头匹配到的对象或者None
split(pattern,string[,maxsplit = 0,flags])	根据模式的匹配项来分割字符串	分割后的字符串列表
findall(pattern,string,flags)	列出字符串中模式的所有匹配项	所有匹配到的字符串列表
sub(pat,repl,string[,count=0,flags])	将字符串中所有的pat的匹配项用repl替换	完成替换后的新字符串

compile(pattern, flags=0)
返回值是正则表达式的对象，更加安全更加灵活，有些时候确实需要传递正则的对象。如高阶函数以函数对象作为返回值，以函数对象作为参数传递。好比是闭包，嵌套循环for，内部函数引用外部函数的变量，最后以函数对象返回，可以使数据更加安全。刚才的小练习是往里传的正则表达式和列表，如果传递函数对象的话，可以以传参的形式往里传很多的代码，以前传递数据是单一的数据或者单一的逻辑，如果能传递对象的话就能传递很多很多逻辑。
这个⽅法是re模块的工厂法，⽤于将字符串形式的正则表达式编译为Pattern模式对象，可以实现更加效率的匹配。第二个参数flag是匹配模式 使用compile()完成一次转换后，再次使用该匹配模式的时候就不能进行转换了。经过compile()转换的正则表达式对象也能使用普通的re⽅法。

相当于在compile 里传入了正则表达式，返回的是正则表达式对象，传入的参数为待匹配的数据就可以了，用对象里的match方法。返回的是match对象，用group()方法去取出匹配的内容，用表达式.match方法取值的时候里面只用放字符串就可以了。

flag匹配模式

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

search(pattern, string, flags=0)
在文本内查找，返回第一个匹配到的字符串。它的返回值类型和使用方法与match()是一样的，唯一的区别就是查找的位置不用固定在文本的开头。


match相当于自带"^"，必须从开始匹配；search 只要待匹配的字符串里有满足条件的数据就能匹配成功，返回的是第一个匹配成功的结果

findall(pattern, string, flags=0)
作为re模块的三大搜索函数之一，findall()和match()、search()的不同之处在于，前两者都是单值匹配，找到一个就忽略后面，直接返回不再查找了。而findall是全文查找，它的返回值是一个匹配到的字符串的列表。这个列表没有group()方法，没有start、end、span，更不是一个匹配对象，仅仅是个列表！如果一项都没有匹配到那么返回一个空列表。

findall 后面不需要加group方法，返回的是列表，通过遍历或列表的下标索引取出，匹配失败返回空列表；match，search返回的都是对象，需要用group方法提取数据。

split(pattern, string, maxsplit=0, flags=0)
re模块的split()方法和字符串的split()方法很相似，都是利用特定的字符去分割字符串。但是re模块的split()可以使用正则表达式，因此更灵活，更强大。

split有个参数maxsplit，用于指定分割的次数，，从左致右，依次切割。例题中maxsplit=2，相当于从左边开始，"+"，"-"分别切割一次后，后面的内容整体作为第三部分，maxsplit大于等于最大切割数之后，跟0的效果一样的，全部切割。
sub(pattern, repl, string, count=0, flags=0)
sub()方法类似字符串的replace()方法，用指定的内容替换匹配到的字符，可以指定替换次数

注意：内外引号不要混淆。要替换的值（正则表达式）放到第一个参数里，要替换成的值放到第二个参数里，第三个参数是原数据；在s里面找到符合正则表达式（i）的内容，把符合正则表达式的内容替换为第二个参数（I）。
正则表达式做操作或者筛选的功能，从网上爬取数据，从互联网上众多的数据中提取需要的数据，需要用到数据解析，正则是方法之一。match，search用于单值匹配的，findall可以把符合正则表达式的所有内容一次性的提取出来，后面不加group；compile返回的是re对象，可以用对象来调用match，search，调用的时候就不再传入正则表达式，只需传递需要匹配的数据；标志位用的比较多是re.I和re.S，不区分大小写和换行匹配。

分组功能

Python的re模块有一个分组功能。所谓的分组就是去已经匹配到的内容再筛选出需要的内容，相当于二次过滤。实现分组靠圆括号()，而获取分组的内容靠的是group()、groups()，其实前面我们已经展示过。re模块里的几个重要方法在分组上，有不同的表现形式，需要区别对待。
group()里没有参数和0的时候，返回的是符合正则表达式的所有内容，传参数的时候返回的是括号内对内容进行再次过滤得到的，result.groups() 传不传数据打印的是以元组形式，返回所有分组的内容，可以用元组的下标取值。

# 需求，获取$22,$32
import re
# s是待匹配的数据
s = 'apple price is $22, banana price is $32'
result = re.search(r'.*\$\d+.*\$\d+', s)  # 注意，$是有特殊意义的字符，要用"\"转义

# .*代表不换行的字符匹配任意次
print(result.group())  # apple price is $22, banana price is $32

# 分组就是从匹配到的数据里再次进行筛选，相当于二次过滤
import re
# group()里没有参数和0的时候，返回的是符合正则表达式的所有内容，传参数的时候返回的是括号内对内容进行再次过滤得到的
s = 'apple price is $22, banana price is $32'
result = re.search(r'.*(\$\d+).*(\$\d+)', s)
print(result.group())  # apple price is $22, banana price is $32
print(result.group(0))   #  apple price is $22, banana price is $32
print(result.group(1))   #  $22
print(result.group(2))   #  $32
print(result.groups())   #  ('$22', '$32')，传不传数据打印的是以元组形式，返回所有分组的内容。
print(result.groups()[0])  # 可以用元组的下标取值

"""result.group()/result.group(0) 匹配整个分组
result.group(1) $22 匹配第一个分组，第一个（）内的数据
result.group(2) $33 匹配第二个分组，第二个（）内的数据
result.groups()/result.groups(0) ('$22', '$33') 获取所有的分组"""