21、正則表達式
正則表達式時用來干嘛的？主要是用來匹配字符串的。由于字符串提供的匹配方法是完全匹配。而在實際情況中，我們可能只需要一串字符串中的某一部分，這時，正則表達式就非常有用了，可以實現(xiàn)模糊匹配。
（1）、元字符：. ^ $ * + ? {} | () \
<1> 元字符： . (通配符)

<2> 元字符：^ （從被匹配字符串的開頭開始進行匹配）

import re# ret = re.findall('^h...o','hkslhelloadfas') #從被匹配字符串的開頭開始進行匹配# print(ret)#[]
1
2
3

<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,+∞]）

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

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

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

總結：*等價于{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

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

<9> 元字符 ： \
注意：
反斜杠后邊跟元字符去除其特殊功能
反斜杠后邊跟普通字符實現(xiàn)特殊功能
例如：
\d: 匹配任何十進制數(shù)，它相當于類[0-9]
\D: 匹配任何非數(shù)字字符，相當于類[^0-9]
\s：匹配任何空白字符，相當于類[\t\n\r\f\v]
\S：匹配任何非空白字符，相當于類[^\t\n\r\f\v]
\w：匹配任何字母數(shù)字字符，相當于類[a-zA-Z0-9]
\W：匹配任何非字母數(shù)字字符，相當于類[^a-zA-Z0-9]
\b: 匹配一個特殊字符邊界。
示例：

import re''' 反斜杠后邊跟元字符去除其特殊功能 '''ret = re.findall('a\.','a.gjfdsa%fd')print(ret)#['a.']'''反斜杠后邊跟普通字符實現(xiàn)特殊功能'''print(re.findall('\d{11}','afddsafdsaf123045678954fsfda'))#匹配任何十進制數(shù) ['12304567895']print(re.findall('\sasd','fasdd asd'))#[' asd']保證有asd字符串，并且在該字符串的前面有空白字符（空格），輸出時，（空格）一并輸出print(re.findall('\w{2}a','afd9affsasd'))#['d9a', 'fsa']只要有字符a并且在字符a前面保證有兩個任何字母數(shù)字字符print(re.findall(r'I\b','Hello, I Im a LI%T'))#['I', 'I'] 匹配出單個字符I，并且要求I后面有一個特殊字符，前面的r表示用正則表達式里的語法規(guī)則，前面的一個 r 表示字符串為非轉義的原始字符串，讓編譯器忽略反斜杠，也就是忽略換行字符
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意：由于下面連個原因，在正則表達式中使用反斜杠就會產生一個雙重轉換的問題。
·Python自身處理字符串是，反斜杠是用于轉義字符
·正則表達式也使用反斜杠來表示轉義字符

為什么在匹配規(guī)則中會出現(xiàn)兩種情況呢？這是因為，第一種，是在正則表達式的語法規(guī)則下進行匹配的；而第二種，是通過Python解釋器向正則表達式語法規(guī)則轉換導致的結果。轉換的原則見下圖

示例解析：

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)#匹配規(guī)則是一個換行符('123xaffdxdsa', 2)# ret1_4 = re.subn('\\\\n','x',s)# print(ret1_4)#匹配規(guī)則是一個反斜杠接n ，未能進行匹配('123\nabc', 0)
1
2
3
4
5
6
7
8
9
10

解析：
由于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解釋器之間的轉換關系決定的。如要實現(xiàn)替換，該如何呢?見下面的代碼

<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）、正則表達式的處理函數(shù)
<1>findall(匹配的正則表達式 , 要匹配的字符串)把匹配到的所有結果返回到一個列表中
<2>search(匹配的正則表達式 , 要匹配的字符串)返回一個對象（object），對象可以調用group()返回結果,返回匹配到的第一個對象。
示例：

<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(匹配的正則表達式 , 要匹配的字符串):以匹配的正則表達式為界限，把要匹配的字符串分割，并且不把正則表達式輸出
示例：

<5>sub( )替換 subn( )也是替換，但會顯示替換的次數(shù)
示例：

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( )編譯
示例：

（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