Python（爬虫）正则表达式

正则表达式是文本匹配模式，也就是按照固定模式匹配文本

一、导入

re模块是Python环境的内置模块，所以无需手动安装。直接在文件中导入即可：

import re

---

二、正则表达式基础知识

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

^ 匹配字符串的开始

$ 匹配字符串的结尾

* 匹配前面的子表达式零次或多次

+ 匹配前面的子表达式一次或多次

? 匹配前面的子表达式零次或一次

{n} n 是一个非负整数。匹配确定的 n 次

{n,} n 是一个非负整数。至少匹配n 次

{n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次

[xyz] 字符集合。匹配所包含的任意一个字符 [^xyz] 负值字符集合。匹配未包含的任意字符

\d 匹配一个数字字符。等价于 [0-9]

\D 匹配一个非数字字符。等价于 [^0-9]

\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [\f\n\r\t\v]

\S 匹配任何非空白字符。等价于 [^\f\n\r\t\v]

\w 匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'

\W 匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'

---

例如：

有一个字符串：python pytttthon

正则表达式格式为：pyt{4}hon

那么只有"pytttthon"匹配到

如果正则表达式为：pyt{1,4}hon

那么匹配到的字符串就是python和pytttthon

三、compile

compile()函数用于编译一个字符串形式的正则表达式，将其转换为一个模式对象（Pattern object）。这个模式对象具有匹配（match()）、搜索（search()）、查找所有（findall()）、查找迭代（finditer()）以及分割（split()）等方法，用于对字符串进行各种基于正则表达式的操作。

案例：

import re
pattern=re.compile(r'\d+')
print(pattern)

上述代码编译了一个字符串：‘\d+’为正则表达式，字符串前的r:代表是原始字符，通常与转义字符联用，当不加r时使用转义字符需要使用两个\，并返回一个对象给pattern。这个正则表达式的意义为：找到一个数字或多个数字的字符串。输出pattern：

re.compile('\\d+')

四、compile中的方法使用

1、match方法

match方法是用来按顺序从头匹配字符串的。不会全部匹配，而是找到第一个符合正则格式的字符串就返回。

案例1：

import re
pattern=re.compile(r'\d+')
m1=pattern.match('one123two457three89')
#因为o不是数字，所以无匹配数据
print(m1)

.match中是要匹配格式的字符串，通过上文，我们可知，这个代码是要找一个带有数字的字符串，且match是从头开始匹配，所以在匹配第一个字符时发现不是数字，所以直接返回。

导致输出结果为：None

案例2，按索引查询：

import re
pattern=re.compile(r'\d+')
m1=pattern.match('one123two457three89',3,6)
print(m1.group())#通过group查看匹配的数据

match函数的参数：（要匹配的字符串，开始索引，结束索引），开始和结束索引是前闭后开集合，也就是包括开始索引字符，不包括结束索引字符。上述代码实现了从索引值为3的字符开始，到6结束，不包括6。.group是查看匹配的数据

输出：123

如果不写.group输出：<re.Match object; span=(3, 6), match='123'>

2、search方法

search方法也是搜索匹配字符串，但是与match不同，他是整体的字符串匹配，但只返回第一个匹配的字符串。

import re
pattern=re.compile(r'\d+')
s1=pattern.search('one123two457three89')
print(s1)

输出：123。因为search不是从头开始严格匹配，所以就会匹配到123。

3、findall方法

findall也是用来检索匹配字符串的，而且他会返回所有符合条件的字符串。并且返回一个列表。

案例：

import re
pattern=re.compile(r'\d+')
f1=pattern.findall('one123two457three89')
print(f1)

上述代码是要匹配所有是数字的字符串，但返回的是一个列表，所以输出形式为：

['123', '457', '89']

4、split方法

split方法是分隔字符串的，并且返回一个列表。这个方法不归属于正则表达式。

比如我们要按逗号分隔一个字符串：

import re
str='a,b,c'
print(str.split(','))

那么我们就可以得到一个列表：['a', 'b', 'c']

但是如果分隔符是多种的，我们就需要用到正则表达式了

案例：

import re
str='a,b;;c d'
pattern=re.compile(r'[\s\,\;]+')
print(pattern.split(str))

如果我们要将str中的abcd作为单独元素分隔，但他们之间的分隔符不一样，那么我们就可以将分隔符写到正则表达式中。上述代码将空格逗号分号作为分隔符写入正则表达式。那么我们将返回的pattern对象打点调用split就可以按照pattern格式分隔，split（）括号中填入要分割的字符串。因为字符串中可能两个或多个分隔符连着使用，所以后边加上一个加号用来匹配一次或多次。

输出：['a', 'b', 'c', 'd']

5、sub方法

sub方法是用来替换字符串的，sub方法中有三个参数：参数一：替换后的值，参数二：原值,参数三：替换几个。参数一既可以传值也可以穿函数

案例1：

string='<h1 class="test">1 helloworld</h1>'
pattern=re.compile(r'\d')
print(pattern.sub('2',string))
print(pattern.sub('2',string,1))

上述代码的第一个sub方法是要将string字符串中的所有数字都换成2，第二个sub方法是将string字符串中的第一个数字替换成2。

输出：<h2 class="test">2 helloworld</h2>
           <h2 class="test">1 helloworld</h1>

五、分组

.group方法是将检索出来的字符串按组取出

在写正则表达式时我们可以将字符串进行分组

案例：

string='<h1 class="test">1 helloworld</h1>'
pattern=re.compile(r'<(.\d)\sclass="(.*?)">.*?</(.1)>')#p给组起名字:classname,可以通过名字调用该组
print(pattern.search(string).group(1))

上述代码的结果：test。在写正则表达式时我们可以用括号对字符串进行分组，数字代表第几组，上述代码是要第一组，也就是class后面括号内的内容，在匹配时，匹配到class后边的组括号。

我们也可以给组起名，用分组名：

pattern=re.compile(r'<(.\d)\sclass="(?P<classname>.*?)">.*?</(.1)>')
print(pattern.search(string).group('classname'))

上述代码跟上一个案例的结果一样

sub方法补充（参数一传函数时）：

sub方法中 参数1函数名，是对字符串的替换规则。参数2是要操作的字符串，将sub(str)的结果传入到第一个参数中，返回第一个参数的结果。将匹配的结果传入func方法中，对传入的数据操作，这个方法的内容就是替换规则。替换后的语句就是func的返回值。

import re
string='<h1 class="test">1 helloworld</h1>'
pattern=re.compile(r'<(.\d)\sclass="(?P<classname>.*?)">.*?</(.1)>')
def func(m):#m是要匹配的格式return "after sub:"+m.group('classname')
#sub方法中传入函数
#参数一：函数名，参数二：原字符串
print(pattern.sub(func,string))

上述代码输出：after sub:test

六、防止贪婪模式：？

import re
string='<h1 class="test">1 helloworld</h1>'
pattern=re.compile(r'<.\d\sclass=.*>')
print(pattern.search(string).group())
#'?'防止贪婪匹配
pattern=re.compile(r'<.\d\sclass=.*?>')
print(pattern.search(string).group())

上述代码第一个输出语句为string完整字符串，而第二个输出语句为：<h1 class="test">。因为第一个是贪婪模式，当出现重复的结尾字符时，他会匹配到最后一个>符号，而加上问号，他会匹配到离他最近的那个。