Python进阶之路 — 十一

21、正则表达式
正则表达式时用来干嘛的？主要是用来匹配字符串的。由于字符串提供的匹配方法是完全匹配。而在实际情况中，我们可能只需要一串字符串中的某一部分，这时，正则表达式就非常有用了，可以实现模糊匹配。
（1）、元字符：. ^ $ * + ? {} | () \
<1> 元字符： . (通配符)

import re# ret = re.findall('w..l','Hello world')#.只能代替任意一个字符# print(ret)#['worl']# ret = re.findall('w.l','Hello w\nld')#.不能代替 \n# print(ret)#[] 未能匹配成功

• 1
• 2
• 3
• 4
• 5

<2> 元字符：^ （从被匹配字符串的开头开始进行匹配）

import re# ret = re.findall('^h...o','hkslhelloadfas') #从被匹配字符串的开头开始进行匹配# print(ret)#[]
1
2
3

<3> 元字符：$ （从被匹配字符串的末尾开始进行匹配）

import re# ret = re.findall('a..x$','sdfalex')#从被匹配字符串的末尾开始进行匹配# print(ret)#['alex']

• 1
• 2
• 3

<4> 元字符：* （重复匹配：[0,+∞]）

import re# ret = re.findall('a.*li','adfdalexasli')# print(ret)#['adfdalexasli']# ret = re.findall('ba*','afdafbadafbaaaaa')# print(ret)#['ba', 'baaaaa']
1
2
3
4
5

<5> 元字符：+（重复匹配：[1,+∞]）

import re# ret = re.findall('ab+','afdafdsa')#a后面至少有一个b才能进行匹配# print(ret)#[]

• 1
• 2
• 3

<6> 元字符：? （重复匹配：[0,1]）

import re# ret = re.findall('a?b','aaaabhgabdfabfb')#b前面没有a或者一个a才能进行匹配# print(ret)#['ab', 'ab', 'ab', 'b']
1
2
3

<7> 元字符：{} :（可加匹配范围）

import re# ret = re.findall('a{5}b','abfdsaaaaabdsa')# print(ret)#['aaaaab']# ret = re.findall('a{1,3}b','abfdsaaaaabdsaab')#贪婪匹配 {1，}代表着{1，+∞}# print(ret)#['ab', 'aaab', 'aab']

• 1
• 2
• 3
• 4
• 5

总结：*等价于{0，+∞}，+等价于{1，+∞} ，?等价于{0,1}
<8>元字符 ：[ ]（字符集）

impot re#ret = re.findall('a[c,d,e]x','acx')#可匹配出acx或adx或aex# ret = re.findall('[a-z]','acx')#可匹配出a-z中的所有字母# print(ret)#acx
1
2
3
4

[ ]:还可以取消元字符的特殊功能，但是这三个元字符：\ ^ - 例外

import re# ret = re.findall('[w,*]','awds*')# 把*在正则中的特殊功能抹去了，只是一个普通字符*# print(ret)# ret = re.findall('[0-9,a-z,A-Z]','12tyAs')# - 依旧保持了原来的功能，表示范围# print(ret)#['1', '2', 't', 'y', 'A', 's']# ret = re.findall('[^t]','fdsaetdaed')#此时的^,表示取反，即除去t以外的字符全部取出# print(ret)#['f', 'd', 's', 'a', 'e', 'd', 'a', 'e', 'd']# ret = re.findall('[^t,a]','fdsae45tdaed')#此时的^,表示取反，即除去t和a以外的字符全部取出# print(ret)#['f', 'd', 's', 'e', '4', '5', 'd', 'e', 'd']

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

<9> 元字符 ： \
注意：
反斜杠后边跟元字符去除其特殊功能
反斜杠后边跟普通字符实现特殊功能
例如：
\d: 匹配任何十进制数，它相当于类[0-9]
\D: 匹配任何非数字字符，相当于类[^0-9]
\s：匹配任何空白字符，相当于类[\t\n\r\f\v]
\S：匹配任何非空白字符，相当于类[^\t\n\r\f\v]
\w：匹配任何字母数字字符，相当于类[a-zA-Z0-9]
\W：匹配任何非字母数字字符，相当于类[^a-zA-Z0-9]
\b: 匹配一个特殊字符边界。
示例：

import re''' 反斜杠后边跟元字符去除其特殊功能 '''ret = re.findall('a\.','a.gjfdsa%fd')print(ret)#['a.']'''反斜杠后边跟普通字符实现特殊功能'''print(re.findall('\d{11}','afddsafdsaf123045678954fsfda'))#匹配任何十进制数 ['12304567895']print(re.findall('\sasd','fasdd asd'))#[' asd']保证有asd字符串，并且在该字符串的前面有空白字符（空格），输出时，（空格）一并输出print(re.findall('\w{2}a','afd9affsasd'))#['d9a', 'fsa']只要有字符a并且在字符a前面保证有两个任何字母数字字符print(re.findall(r'I\b','Hello, I Im a LI%T'))#['I', 'I'] 匹配出单个字符I，并且要求I后面有一个特殊字符，前面的r表示用正则表达式里的语法规则，前面的一个 r 表示字符串为非转义的原始字符串，让编译器忽略反斜杠，也就是忽略换行字符
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：由于下面连个原因，在正则表达式中使用反斜杠就会产生一个双重转换的问题。
·Python自身处理字符串是，反斜杠是用于转义字符
·正则表达式也使用反斜杠来表示转义字符

import reret = re.findall(r'\\','f\j\gfdd')print(ret)#['\\', '\\']'''或者'''ret = re.findall('\\\\','f\j\gfdd')print(ret)#['\\', '\\']

• 1
• 2
• 3
• 4
• 5
• 6

为什么在匹配规则中会出现两种情况呢？这是因为，第一种，是在正则表达式的语法规则下进行匹配的；而第二种，是通过Python解释器向正则表达式语法规则转换导致的结果。转换的原则见下图

示例解析：

import res = '123\nabc'#表示：123接一个换行符再接abc# print(s)#123（换行）abc# print(len(s))#7# ret1_1 = re.subn('\n','x','123\naffd\ndsa')# print(ret1_1)#('123xaffdxdsa', 2)# ret1_2 = re.subn('\\n','x','123\naffd\ndsa')# print(ret1_2)#匹配规则是一个换行符('123xaffdxdsa', 2)# ret1_4 = re.subn('\\\\n','x',s)# print(ret1_4)#匹配规则是一个反斜杠接n ，未能进行匹配('123\nabc', 0)
1
2
3
4
5
6
7
8
9
10

import rem = r'123\nabc' #表示：123接 一个反斜杠 再接 nabcprint(m)#123\nabcprint(len(m))#8m1= r'123\\nabc'print(m1)#123\\nabcprint(len(m1))#9ret2_1 = re.subn('\n','x',m)print(ret2_1)#('123\\nabc', 0)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

解析：
由于m = r’123\nabc’，其是表示在正则表达式中的字符串，经过转换，在Python解释器中,实际的字符串应该是’123\nabc’。而，在此行代码re.subn(‘\n’,’x’,m)中，要匹配的是个换行符’\n’，并不能进行匹配，所以最终结果是(‘123\nabc’, 0)

import reret2_1_1 = re.subn('\\n','x',m)print(ret2_1_1)#('123\\nabc', 0)
1
2
3

解析：
re.subn(‘\n’,’x’,m)这行代码中，要匹配的是’\n’,所以也无法匹配。
至于为什么’\n’—>’\n’,是因为re模块和Python解释器之间的转换关系决定的。如要实现替换，该如何呢?见下面的代码

import reret2_1_2 = re.subn('\\\\n','x',m)print(ret2_1_2)#('123xabc', 1)ret2_2 = re.subn(r'\\n','x',m)print(ret2_2)#('123xabc', 1)

• 1
• 2
• 3
• 4
• 5

<10>元字符：( )（分组） |（或）

import re# print(re.search('(ad)+','dfadads').group())#adad# print(re.search('(ad)|3','dfad3s').group())#adprint(re.search('(ad)|3','dfas3s').group())#3# ret = re.search('(?P<id>\d{3})/(?P<name>\w{3})','www333/ddd')# print(ret.group())# print(ret.group('id'))# print(ret.group('name'))
1
2
3
4
5
6
7
8

（2）、正则表达式的处理函数
<1>findall(匹配的正则表达式 , 要匹配的字符串)把匹配到的所有结果返回到一个列表中
<2>search(匹配的正则表达式 , 要匹配的字符串)返回一个对象（object），对象可以调用group()返回结果,返回匹配到的第一个对象。
示例：

import re# ret = re.search('sb','dsasbdsba')# print(ret)#<_sre.SRE_Match object; span=(3, 5), match='sb'># print(ret.group())#sb

• 1
• 2
• 3
• 4

<3>match(匹配的正则表达式 , 要匹配的字符串):只在字符串开始匹配,也返回一个对象（object），对象可以调用group()返回结果,返回匹配到的第一个对象。
示例：

import re#print(re.match('asd','hgdkasd'))#None# ret = re.match('asd','asdhhafeasd')# print(ret)#<_sre.SRE_Match object; span=(0, 3), match='asd'># print(ret.group())#asd
1
2
3
4
5

<4>split(匹配的正则表达式 , 要匹配的字符串):以匹配的正则表达式为界限，把要匹配的字符串分割，并且不把正则表达式输出
示例：

# ret = re.split('k','djksal')# print(ret)#['dj', 'sal']# ret = re.split('[k,s]','djkasl')# print(ret)#['dj', 'a', 'l']#k，s都没有了

• 1
• 2
• 3
• 4

<5>sub( )替换 subn( )也是替换，但会显示替换的次数
示例：

import re print(re.sub('D.*n','hyq','hfalkdDamondfsakfds'))#hfalkdhyqdfsakfds# print(re.subn('D.{3}n','hyq','hfalkdDamondfsaDamonfdsa'))#('hfalkdhyqdfsahyqfdsa', 2)其中2是指，替换了2次
1
2

<6>compile( )编译
示例：

# obj = re.compile('\.com')# ret = obj.findall('dfjksdjfisd.com')# print(ret)#['.com']

• 1
• 2
• 3

（3）Demo

# import re# line = 'Cats are smarter than dogs'# matchObj = re.match(r'(.*) are (.*?) .*',line, re.M |re.I)# if matchObj:#     print('matchObj.group():',matchObj.group())#     print('matchObj.group(1):',matchObj.group(1))#     print('matchObj.group(2):',matchObj.group(2))# else:#     print('No match!')# '''# 解析：# 首先，这是一个字符串，前面的一个 r 表示字符串为非转义的原始字符串，让编译器忽略反斜杠，也就是忽略转义字符。但是这个字符串里没有反斜杠，所以这个 r 可有可无。#  (.*) 第一个匹配分组，.* 代表匹配除换行符之外的所有字符。#  (.*?) 第二个匹配分组，.*? 后面多个问号，代表非贪婪模式，也就是说只匹配符合条件的最少字符#  后面的一个 .* 没有括号包围，所以不是分组，匹配效果和第一个一样，但是不计入匹配结果中。# matchObj.group() 等同于 matchObj.group(0)，表示匹配到的完整文本字符# matchObj.group(1) 得到第一组匹配结果，也就是(.*)匹配到的# matchObj.group(2) 得到第二组匹配结果，也就是(.*?)匹配到的'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19