第三十節，正則表達式re模塊
正則表達式python
正則表達式自己是一種小型的、高度專業化的編程語言，而在python中，經過內嵌集成re模塊，程序員們能夠直接調用來實現正則匹配。正則表達式模式被編譯成一系列的字節碼，而後由用C編寫的匹配引擎執行。程序員
正則表達式是用來匹配處理字符串的 python 中使用正則表達式須要引入re模塊正則表達式
如：編程
import re #第一步，要引入re模塊編程語言
a = re.findall("匹配規則", "要匹配的字符串") #第二步，調用模塊函數函數
以列表形式返回匹配到的字符串post
如：spa
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("匹配規則", "這個字符串是否有匹配規則的字符") #第二步，調用模塊函數 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹配規則']
字符匹配（普通字符，元字符）3d
普通字符：是沒有包含特殊意義的字符，大多以數字字母和中文漢字的，以自身匹配code
也就是查找字符串裏是否有包含匹配規則的字符串，必須徹底包含才匹配
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("匹配規則", "這個字符串是否有匹配規則的字符") #第二步，調用模塊函數 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹配規則']
元字符：是包含特殊意義的字符，通常都是和普通字符搭配使用的
.元字符
須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的.元字符）能夠是任何一個字符
匹配任意除換行符"\n"外的字符(在DOTALL模式中也能匹配換行符)
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("匹配規.則", "這個字符串是否有匹配規a則的字符") #須要徹底符合匹配規則，（.元字符）能夠是任何一個字符 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹配規則']
^元字符
字符串開始位置與匹配規則符合就匹配，不然不匹配
匹配字符串開頭。在多行模式中匹配每一行的開頭
^元字符若是寫到[]字符集裏就是反取
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("^匹配規則", "匹配規則這個字符串是否匹配") #字符串開始位置與匹配規則符合就匹配，不然不匹配 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹配規則']
[^a-z]反取，匹配出除字母外的字符，^元字符若是寫到字符集裏就是反取
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("[^a-z]", "匹配s規則這s個字符串是否s匹配f規則則re則則則") #反取，匹配出除字母外的字符 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹', '配', '規', '則', '這', '個', '字', '符', '串', '是', '否', '匹', '配', '規', '則', '則', '則', '則', '則']
$元字符
字符串結束位置與匹配規則符合就匹配，不然不匹配
匹配字符串末尾，在多行模式中匹配每一行的末尾
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("匹配規則$", "這個字符串是否匹配規則") #字符串結束位置與匹配規則符合就匹配，不然不匹配 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹配規則']
*元字符
須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的*元字符）前面的一個字符能夠是0個或多個本來字符
匹配前一個字符0或屢次，貪婪匹配前導字符有多少個就匹配多少個很貪婪
若是規則裏只有一個分組，儘可能避免用*不然會有可能匹配出空字符串
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("匹配規則*", "這個字符串是否匹配規則則則則則") #須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的*元字符）前面的一個字符能夠是0或多個本來字符 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹配規則則則則則']
+元字符
須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的+元字符）前面的一個字符能夠是1個或多個本來字符
匹配前一個字符1次或無限次，貪婪匹配前導字符有多少個就匹配多少個很貪婪
#!/usr/bin/env python # -*- coding:gbk -*- import re #第一步，要引入re模塊 a = re.findall("匹配+", "匹配配配配配規則這個字符串是否匹配規則則則則則") #須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的+元字符）前面的一個字符能夠是1個或多個本來字符 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹配配配配配', '匹配']
?元字符，和防止貪婪匹配
須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的?元字符）前面的一個字符能夠是0個或1個本來字符
匹配一個字符0次或1次
還有一個功能是能夠防止貪婪匹配，詳情見防貪婪匹配
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("匹配規則?", "匹配規這個字符串是否匹配規則則則則則") #須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的?元字符）前面的一個字符能夠是0個或1個本來字符 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹配規', '匹配規則']
{}元字符,範圍
須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的 {} 元字符）前面的一個字符，是自定義字符數，位數的本來字符
{m}匹配前一個字符m次，{m,n}匹配前一個字符m至n次，若省略n，則匹配m至無限次
{0,}匹配前一個字符0或屢次,等同於*元字符
{+,}匹配前一個字符1次或無限次,等同於+元字符
{0,1}匹配前一個字符0次或1次,等同於?元字符
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("匹配規則{3}", "匹配規這個字符串是否匹配規則則則則則") #{m}匹配前一個字符m次，{m,n}匹配前一個字符m至n次，若省略n，則匹配m至無限次 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹配規則則則']
[]元字符,字符集
須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的 [] 元字符）對應位置是[]裏的任意一個字符就匹配
字符集。對應的位置能夠是字符集中任意字符。字符集中的字符能夠逐個列出，也能夠給出範圍，如[abc]或[a-c]。[^abc]表示取反，即非abc。
全部特殊字符在字符集中都失去其原有的特殊含義。用\反斜槓轉義恢復特殊字符的特殊含義。
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("匹配[a,b,c]規則", "匹配a規則這個字符串是否匹配規則則則則則") #須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的 [] 元字符）對應位置是[]裏的任意一個字符就匹配 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹配a規則']
[^]非，反取，匹配出除[^]裏面的字符，^元字符若是寫到字符集裏就是反取
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("[^a-z]", "匹配s規則這s個字符串是否s匹配f規則則re則則則") #反取，匹配出除字母外的字符 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹', '配', '規', '則', '這', '個', '字', '符', '串', '是', '否', '匹', '配', '規', '則', '則', '則', '則', '則']
\元字符
1.反斜槓後邊跟元字符去除特殊功能；（即將特殊字符轉義成普通字符）
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("匹配\.規則", "匹配.規則這個字符串是否匹配規則則則則則") #反斜槓後邊跟元字符去除特殊功能；（即將特殊字符轉義成普通字符） print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹配.規則']
2.反斜槓後邊跟普通字符實現特殊功能；（即預約義字符）
預約義字符是在字符集和組裏都是有用的
\d匹配任何十進制數，它至關於類[0-9]
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("\d", "匹配規則這2個字符串3是否匹配規則5則則則7則") #\d匹配任何十進制數，它至關於類[0-9] print(a) #以列表形式返回匹配到的字符串 #打印出 ['2', '3', '5', '7']
\d+若是須要匹配一位或者多位數的數字時用
#!/usr/bin/env python # -*- coding:gbk -*- import re #第一步，要引入re模塊 a = re.findall("\d+", "匹配規則這2個字符串134444是否匹配規則5則則則7則") #\d+若是須要匹配一位或者多位數的數字時用 print(a) #以列表形式返回匹配到的字符串 #打印出 ['2', '134444', '5', '7']
\D匹配任何非數字字符，它至關於類[^0-9]
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("\D", "匹配規則這2個字符串3是否匹配規則5則則則7則") #\D匹配任何非數字字符，它至關於類[^0-9] print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹', '配', '規', '則', '這', '個', '字', '符', '串', '是', '否', '匹', '配', '規', '則', '則', '則', '則', '則']
\s匹配任何空白字符，它至關於類[\t\n\r\f\v]
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("\s", "匹配規則 這2個字符串3是否匹配規則5則則則7則") #\s匹配任何空白字符，它至關於類[\t\n\r\f\v] print(a) #以列表形式返回匹配到的字符串 #打印出 [' ', ' ', ' ']
\S匹配任何非空白字符，它至關於類[^\t\n\r\f\v]
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("\S", "匹配規則 這2個字符串3是否匹配規則5則則則7則") #\S匹配任何非空白字符，它至關於類[^\t\n\r\f\v] print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹', '配', '規', '則', '這', '2', '個', '字', '符', '串', '3', '是', '否', '匹', '配', '規', '則', '5', '則', '則', '則', '7', '則']
\w匹配包括下劃線在內任何字母數字字符，它至關於類[a-zA-Z0-9_]
#!/usr/bin/env python # -*- coding:utf8 -*- import re #第一步，要引入re模塊 a = re.findall('\w',"http://www.cnb_logs.com/") #\w匹配包括下劃線在內任何字母數字字符，它至關於類[a-zA-Z0-9_] print(a) #以列表形式返回匹配到的字符串 #打印出 ['h', 't', 't', 'p', 'w', 'w', 'w', 'c', 'n', 'b', '_', 'l', 'o', 'g', 's', 'c', 'o', 'm']
\W匹配非任何字母數字字符包括下劃線在內，它至關於類[^a-zA-Z0-9_]
#!/usr/bin/env python # -*- coding:utf8 -*- import re #第一步，要引入re模塊 a = re.findall('\W',"http://www.cnb_logs.com/") #\W匹配非任何字母數字字符包括下劃線在內，它至關於類[^a-zA-Z0-9_] print(a) #以列表形式返回匹配到的字符串 #打印出 [':', '/', '/', '.', '.', '/']
\b匹配一個單詞邊界，也就是指單詞和空格間的位置
#!/usr/bin/env python # -*- coding:utf8 -*- import re #第一步，要引入re模塊 #也就是分組匹配，()裏面的爲一個組也能夠理解成一個總體 a = re.findall(r"\babc\b", "a4a4a4a abc 4a4dggdg4g654gb") #\b匹配一個單詞邊界，也就是指單詞和空格間的位置 print(a) #打印出 ['abc']
3.\2引用序號對應的字組所匹配的字符串。
#!/usr/bin/env python # -*- coding:utf8 -*- import re #第一步，要引入re模塊 #也就是分組匹配，()裏面的爲一個組也能夠理解成一個總體 a = re.search(r"(a4)(dg)g\2", "a4a4a4a4a4dggdg4g654gb") #引用序號對應的字組所匹配的字符串,\2就是引用第2個組(dg) b = a.group() print(b) #打印出 a4dggdg
()元字符，分組
也就是分組匹配，()裏面的爲一個組也能夠理解成一個總體
若是()後面跟的是特殊元字符如 (adc)* 那麼*控制的前導字符就是()裏的總體內容，再也不是前導一個字符
列1
#!/usr/bin/env python # -*- coding:utf8 -*- import re #第一步，要引入re模塊 #也就是分組匹配，()裏面的爲一個組也能夠理解成一個總體 a = re.search("(a4)+", "a4a4a4a4a4dg4g654gb") #匹配一個或多個a4 b = a.group() print(b) #打印出 a4a4a4a4a4
列2
#!/usr/bin/env python # -*- coding:utf8 -*- import re #第一步，要引入re模塊 #也就是分組匹配，()裏面的爲一個組也能夠理解成一個總體 a = re.search("a(\d+)", "a466666664a4a4a4dg4g654gb") #匹配 (a) (\d0-9的數字) (+能夠是1個到多個0-9的數字) b = a.group() print(b) #打印出 a466666664
|元字符，或
|或，或就是先後其中一個符合就匹配
#!/usr/bin/env python # -*- coding:utf8 -*- import re #第一步，要引入re模塊 a = re.findall(r"你|好", "a4a4a你4aabc4a4dgg好dg4g654g") #|或，或就是先後其中一個符合就匹配 print(a) #打印出 ['你', '好']
r原生字符
將在python裏有特殊意義的字符如\b，轉換成原生字符（就是去除它在python的特殊意義），否則會給正則表達式有衝突，爲了不這種衝突能夠在規則前加原始字符r
#!/usr/bin/env python # -*- coding:utf8 -*- import re #第一步，要引入re模塊 a = re.findall(r"\b", "a4 a4a你4aabc4 a4dgg好 dg4g654g") #將在python裏有特殊意義的字符如\b，轉換成原生字符（就是去除它在python的特殊意義） print(a) #打印出 ['', '', '', '', '', '', '', ''] 若是不加r就匹配不到空格
re模塊中經常使用功能函數
正則表達式有兩種書寫方式，一種是直接在函數裏書寫規則，
#!/usr/bin/env python # -*- coding:utf-8 -*- import re #第一步，要引入re模塊 a = re.findall("匹配規則", "這個字符串是否有匹配規則的字符") #第二步，調用模塊函數 print(a) #以列表形式返回匹配到的字符串 #打印出 ['匹配規則']
一種是用compile()函數將規則編譯成對象在用功能函數調用編譯對象
compile()，參數（"正則規則"，標示）
編譯正則表達式模式，返回一個對象的模式。（能夠把那些經常使用的正則表達式編譯成正則表達式對象，這樣能夠提升一點效率。）
格式：
#!/usr/bin/env python # -*- coding:utf8 -*- import re tt = "Tina is a good girl, she is cool, clever, and so on..." rr = re.compile(r'\w*oo\w*') a = rr.findall(tt) #查找全部包含'oo'的單詞 print(a) #執行結果以下： ['good', 'cool']
re.compile(pattern,flags=0)
pattern正則模式：編譯時用的表達式字符串
flags標示：編譯標誌位，用於修改正則表達式的匹配方式，如：是否區分大小寫，多行匹配等。經常使用的有
默認爲標示爲flags=0，也就是取所有匹配到的，
flags標示，匹配模式
| 標誌 |
含義 |
| re.S(DOTALL) |
使.匹配包括換行在內的全部字符 |
| re.I（IGNORECASE） |
使匹配對大小寫不敏感 |
| re.L（LOCALE） |
作本地化識別（locale-aware)匹配，法語等 |
| re.M(MULTILINE) |
多行匹配，影響^和$ |
| re.X(VERBOSE) |
該標誌經過給予更靈活的格式以便將正則表達式寫得更易於理解 |
| re.U |
根據Unicode字符集解析字符，這個標誌影響\w,\W,\b,\B |
#!/usr/bin/env python # -*- coding:gbk -*- import re #無分組 origin = "hello alex bcd alex lge alex acd 19" r = re.match("H\w+", origin,re.I) #re.I使匹配對大小寫不敏感 print(r.group()) # 獲取匹配到的全部結果，無論有沒有分組將匹配到的所有拿出來 print(r.groups()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果 print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果 #輸出結果 # hello 匹配到的所有拿出來，加了re.I標示因此字符串裏的小寫h也匹配的 # () 沒有分組因此爲空 # {} 沒分組部分定義了key的組因此爲空
match()函數（之後經常使用）
match，從頭匹配一個符合規則的字符串，從起始位置開始匹配，匹配成功返回一個對象，未匹配成功返回None
match(pattern, string, flags=0)
# pattern： 正則模型
# string ： 要匹配的字符串
# falgs ： 匹配模式
注意：match()函數 與 search()函數基本是同樣的功能，不同的就是match()匹配字符串開始位置的一個符合規則的字符串，search()是在字符串全局匹配第一個合規則的字符串
#!/usr/bin/env python # -*- coding:utf8 -*- import re #無分組 origin = "hello alex bcd alex lge alex acd 19" r = re.match("h\w+", origin) #match，從起始位置開始匹配，匹配成功返回一個對象，未匹配成功返回None print(r.group()) # 獲取匹配到的全部結果，無論有沒有分組將匹配到的所有拿出來 print(r.groups()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果 print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果 #輸出結果 # hello 匹配到的所有拿出來 # () 沒有分組因此爲空 # {} 沒分組部分定義了key的組因此爲空 # 有分組 # 爲什麼要有分組？提取匹配成功的指定內容（先匹配成功所有正則，再匹配成功的局部內容提取出來） r = re.match("h(\w+)", origin) #match，從起始位置開始匹配，匹配成功返回一個對象，未匹配成功返回None print(r.group()) # 獲取匹配到的全部結果，無論有沒有分組將匹配到的所有拿出來 print(r.groups()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果 print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果 #輸出結果 # hello 匹配到的所有拿出來 # ('ello',) 有分組，在匹配到的字符串中拿出分組的部分 # {} 沒分組部分定義了key的組因此爲空 # 有兩個分組定義了key # 爲什麼要有分組？提取匹配成功的指定內容（先匹配成功所有正則，再匹配成功的局部內容提取出來） r = re.match("(?P<n1>h)(?P<n2>\w+)", origin) #?P<>定義組裏匹配內容的key(鍵)，<>裏面寫key名稱，值就是匹配到的內容 print(r.group()) # 獲取匹配到的全部結果，無論有沒有分組將匹配到的所有拿出來 print(r.groups()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果 print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果 #輸出結果 # hello 匹配到的所有拿出來 # ('h', 'ello') 有分組，在匹配到的字符串中拿出分組的部分 # {'n1': 'h', 'n2': 'ello'} 有定義了key的組因此，將定義了key的組裏的內容以字典形式拿出來
?P<n1> #?P<>定義組裏匹配內容的key(鍵)，<>裏面寫key名稱，值就是匹配到的內容（只對正則函數返回對象的有用）
取出匹配對象方法
只對正則函數返回對象的有用
group() # 獲取匹配到的全部結果，無論有沒有分組將匹配到的所有拿出來，有參取匹配到的第幾個如2
groups() # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
groupdict() # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
search()函數
search,瀏覽所有字符串，匹配第一符合規則的字符串，瀏覽整個字符串去匹配第一個，未匹配成功返回None
search(pattern, string, flags=0)
# pattern： 正則模型
# string ： 要匹配的字符串
# falgs ： 匹配模式
注意：match()函數 與 search()函數基本是同樣的功能，不同的就是match()匹配字符串開始位置的一個符合規則的字符串，search()是在字符串全局匹配第一個合規則的字符串
#!/usr/bin/env python # -*- coding:utf8 -*- import re #無分組 origin = "hello alex bcd alex lge alex acd 19" r = re.search("a\w+", origin) #search瀏覽所有字符串，匹配第一符合規則的字符串，瀏覽整個字符串去匹配第一個，未匹配成功返回None print(r.group()) # 獲取匹配到的全部結果，無論有沒有分組將匹配到的所有拿出來 print(r.groups()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果 print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果 #輸出結果 # alex 匹配到的所有拿出來 # () 沒有分組因此爲空 # {} 沒分組部分定義了key的組因此爲空 # 有分組 # 爲什麼要有分組？提取匹配成功的指定內容（先匹配成功所有正則，再匹配成功的局部內容提取出來） r = re.search("a(\w+).*(\d)", origin) print(r.group()) # 獲取匹配到的全部結果，無論有沒有分組將匹配到的所有拿出來 print(r.groups()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果 print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果 #輸出結果 # alex bcd alex lge alex acd 19 匹配到的所有拿出來 # ('lex', '9') 有分組，在匹配到的字符串中拿出分組的部分 # {} 沒分組部分定義了key的組因此爲空 # 有兩個分組定義了key # 爲什麼要有分組？提取匹配成功的指定內容（先匹配成功所有正則，再匹配成功的局部內容提取出來） r = re.search("a(?P<n1>\w+).*(?P<n2>\d)", origin) #?P<>定義組裏匹配內容的key(鍵)，<>裏面寫key名稱，值就是匹配到的內容 print(r.group()) # 獲取匹配到的全部結果，無論有沒有分組將匹配到的所有拿出來 print(r.groups()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果 print(r.groupdict()) # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果 #輸出結果 # alex bcd alex lge alex acd 19 匹配到的所有拿出來 # ('lex', '9') 有分組，在匹配到的字符串中拿出分組的部分 # {'n1': 'lex', 'n2': '9'} 有定義了key的組因此，將定義了key的組裏的內容以字典形式拿出來
findall()函數（之後經常使用）
findall(pattern, string, flags=0)
# pattern： 正則模型
# string ： 要匹配的字符串
# falgs ： 匹配模式
瀏覽所有字符串，匹配全部合規則的字符串，匹配到的字符串放到一個列表中，未匹配成功返回空列表
注意：一旦匹配成，再次匹配，是從前一次匹配成功的，後面一位開始的，也能夠理解爲匹配成功的字符串，不在參與下次匹配
#!/usr/bin/env python # -*- coding:utf8 -*- import re #無分組 r = re.findall("\d+\w\d+", "a2b3c4d5") #瀏覽所有字符串，匹配全部合規則的字符串，匹配到的字符串放到一個列表中 print(r) #輸出結果 #['2b3', '4d5'] #注意：匹配成功的字符串，不在參與下次匹配,因此3c4也符合規則可是沒匹配到
注意：若是沒寫匹配規則，也就是空規則，返回的是一個比原始字符串多一位的，空字符串列表
#!/usr/bin/env python # -*- coding:utf8 -*- import re #無分組 r = re.findall("", "a2b3c4d5") #瀏覽所有字符串，匹配全部合規則的字符串，匹配到的字符串放到一個列表中 print(r) #輸出結果 #['', '', '', '', '', '', '', '', ''] #注意：若是沒寫匹配規則，也就是空規則，返回的是一個比原始字符串多一位的，空字符串列表
注意：正則匹配到空字符的狀況，若是規則裏只有一個組，而組後面是*就表示組裏的內容能夠是0個或者多過，這樣組裏就有了兩個意思，一個意思是匹配組裏的內容，二個意思是匹配組裏0內容（便是空白）因此儘可能避免用*不然會有可能匹配出空字符串
注意：正則只拿組裏最後一位，若是規則裏只有一個組，匹配到的字符串裏在拿組內容是，拿的是匹配到的內容最後一位
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "hello alex bcd alex lge alex acd 19" r = re.findall("(a)*", origin) print(r) #輸出結果 ['', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', '', '', '', '', 'a', '', '', '', '', 'a', '', '', '', '', '', '']
無分組：匹配全部合規則的字符串，匹配到的字符串放到一個列表中
#!/usr/bin/env python # -*- coding:utf8 -*- import re #無分組 origin = "hello alex bcd alex lge alex acd 19" r = re.findall("a\w+", origin) #瀏覽所有字符串，匹配全部合規則的字符串，匹配到的字符串放到一個列表中 print(r) #輸出結果 #['alex', 'alex', 'alex', 'acd'] #匹配全部合規則的字符串，匹配到的字符串放到一個列表中
有分組：只將匹配到的字符串裏，組的部分放到列表裏返回，至關於groups()方法
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "hello alex bcd alex lge alex acd 19" r = re.findall("a(\w+)", origin) #有分組：只將匹配到的字符串裏，組的部分放到列表裏返回 print(r) #輸出結果 #['lex', 'lex', 'lex', 'cd']
多個分組：只將匹配到的字符串裏，組的部分放到一個元組中，最後將全部元組放到一個列表裏返
至關於在group()結果裏再將組的部分，分別，拿出來放入一個元組，最後將全部元組放入一個列表返回
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "hello alex bcd alex lge alex acd 19" r = re.findall("(a)(\w+)", origin) #多個分組：只將匹配到的字符串裏，組的部分放到一個元組中，最後將全部元組放到一個列表裏返回 print(r) #輸出結果 #[('a', 'lex'), ('a', 'lex'), ('a', 'lex'), ('a', 'cd')]
分組中有分組：只將匹配到的字符串裏，組的部分放到一個元組中，先將包含有組的組，看做一個總體也就是一個組，把這個總體組放入一個元組裏，而後在把組裏的組放入一個元組，最後將全部組放入一個列表返回
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "hello alex bcd alex lge alex acd 19" r = re.findall("(a)(\w+(e))", origin) #分組中有分組：只將匹配到的字符串裏，組的部分放到一個元組中，先將包含有組的組，看做一個總體也就是一個組，把這個總體組放入一個元組裏，而後在把組裏的組放入一個元組，最後將全部組放入一個列表返回 print(r) #輸出結果 #[('a', 'le', 'e'), ('a', 'le', 'e'), ('a', 'le', 'e')]
?:在有分組的狀況下findall()函數，不僅拿分組裏的字符串，拿全部匹配到的字符串，注意?:只用於不是返回正則對象的函數如findall()
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "hello alex bcd alex lge alex acd 19" b = re.findall("a(?:\w+)",origin) #?:在有分組的狀況下，不僅拿分組裏的字符串，拿全部匹配到的字符串，注意?:只用於不是返回正則對象的函數如findall() print(b) #輸出 # ['alex', 'alex', 'alex', 'acd']
finditer()函數
finditer(pattern, string, flags=0)
# pattern： 正則模型
# string ： 要匹配的字符串
# falgs ： 匹配模式
（須要for循環）瀏覽所有字符串，匹配全部合規則的字符串，返回一個須要for循環的對象，匹配成功for循環後返回對應個數的正則對象，未匹配成功返回空
finditer()和findall()函數基本同樣的，finditer()不同的是須要for循環後返回匹配到的對應個數對象
由於返回的是正則對象，因此須要用到對象方法
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "hello alex bcd alex lge alex acd 19" r = re.finditer("a\w*(?P<n1>\w)", origin) #瀏覽所有字符串，匹配全部合規則的字符串，返回一個須要for循環的對象，匹配成功for循環後返回對應個數的正則對象，未匹配成功返回空 for i in r: print(i.group()) print(i.groupdict()) #輸出結果 # alex # {'n1': 'x'} # alex # {'n1': 'x'} # alex # {'n1': 'x'} # acd # {'n1': 'd'} #由於返回的是正則對象，因此須要用到對象方法
split()函數
根據正則匹配分割字符串，返回分割後的一個列表
split(pattern, string, maxsplit=0, flags=0)
# pattern： 正則模型
# string ： 要匹配的字符串
# maxsplit：指定分割個數
# flags ： 匹配模式
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "hello alex bcd alex lge alex acd 19" r = re.split("a", origin) #根據正則匹配分割字符串 print(r) #輸出結果 ['hello ', 'lex bcd ', 'lex lge ', 'lex ', 'cd 19'] #根據a進行分組
將匹配到的字符串做爲分割標準進行分割
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "hello alex bcd alex lge alex 2acd 19" r = re.split("a\w+", origin) #根據正則匹配分割字符串 print(r) #輸出結果 ['hello ', ' bcd ', ' lge ', ' 2', ' 19'] #將匹配到的字符串做爲分割標準進行分割
設置分割參數，若是設置了分割次數，分割次數達到後，後面匹配的也不分割了
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "hello alex bcd alex lge alex 2acd 19" r = re.split("a\w+", origin,2) #設置分割參數，若是設置了分割次數，分割次數達到後，後面匹配的也不分割了 print(r) #輸出結果 ['hello ', ' bcd ', ' lge ', ' 2', ' 19'] #設置分割參數，若是設置了分割次數，分割次數達到後，後面匹配的也不分割了
有分組分割，無分組分割，匹配到做爲分割標準的字符串，是不被輸出的，若是想一樣輸出做爲分割標準的字符串能夠用組來分割，能夠理解爲組部分，分割後一樣被拿出
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "hello alex bcd alex lge alex 2acd 19" r = re.split("(a\w+)", origin) #有分組分割，無分組分割，匹配到做爲分割標準的字符串，是不被輸出的，若是想一樣輸出做爲分割標準的字符串能夠用組來分割 print(r) #輸出結果 ['hello ', 'alex', ' bcd ', 'alex', ' lge ', 'alex', ' 2', 'acd', ' 19'] #有分組分割，無分組分割，匹配到做爲分割標準的字符串，是不被輸出的，若是想一樣輸出做爲分割標準的字符串能夠用組來分割
用split()作一個多括號，字符串提取功能，也就是去除字符串裏的全部括號
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "1 - 2 * ( (60-30 +(-4/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )" while True: r = re.split("\(([^()]+)\)", origin,1)#匹配以\(開頭,以\)結尾，中間沒有[^()]的,+中間除括號外能夠是1位或者多位字符，而後經過分組拿到匹配到的（）號裏的字符串 if len(r) == 3: #每一次正則表達式匹配分割後，應該返回的是一個有3個元素的列表，匹配列表元素是不是3個 a = r[0] #索引列表拿出列表元素 b = r[1] #索引列表拿出列表元素 c = r[2] #索引列表拿出列表元素 xin = a + b + c #將列表索引出來的字符串重組 origin = xin #將列表索引出來的字符串重組後，從新賦值給origin變量進行下次正則匹配 print(origin) else: break #當列表元素不是3個時，說明正則已經處理完括號了，就退出循環 #輸出結果 # 1 - 2 * ( (60-30 +-4/5 * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) ) # 1 - 2 * ( (60-30 +-4/5 * 9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 ) - (-4*3)/ (16-3*2) ) # 1 - 2 * ( 60-30 +-4/5 * 9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 - (-4*3)/ (16-3*2) ) # 1 - 2 * ( 60-30 +-4/5 * 9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 - -4*3/ (16-3*2) ) # 1 - 2 * ( 60-30 +-4/5 * 9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 - -4*3/ 16-3*2 ) # 1 - 2 * 60-30 +-4/5 * 9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 - -4*3/ 16-3*2
sub()函數
替換匹配成功的指定位置字符串
sub(pattern, repl, string, count=0, flags=0)
# pattern： 正則模型
# repl ： 要替換的字符串
# string ： 要匹配的字符串
# count ： 指定匹配個數
# flags ： 匹配模式
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "hello alex bcd alex lge alex acd 19" r = re.sub("a","替換",origin) #替換匹配成功的指定位置字符串 print(r) #輸出 # hello 替換lex bcd 替換lex lge 替換lex 替換cd 19
subn()函數
替換匹配成功的指定位置字符串,而且返回替換次數，能夠用兩個變量分別接受
subn(pattern, repl, string, count=0, flags=0)
# pattern： 正則模型
# repl ： 要替換的字符串
# string ： 要匹配的字符串
# count ： 指定匹配個數
# flags ： 匹配模式
#!/usr/bin/env python # -*- coding:utf8 -*- import re origin = "hello alex bcd alex lge alex acd 19" a,b = re.subn("a","替換",origin) #替換匹配成功的指定位置字符串,而且返回替換次數，能夠用兩個變量分別接受 print(a) print(b) #輸出 # hello 替換lex bcd 替換lex lge 替換lex 替換cd 19 # 4
元字符表
| . |
須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的.元字符）能夠是任何一個字符，匹配任意除換行符"\n"外的字符(在DOTALL模式中也能匹配換行符) |
a.c |
abc |
| \ |
1.反斜槓後邊跟元字符去除特殊功能；（即將特殊字符轉義成普通字符），2.反斜槓後邊跟普通字符實現特殊功能；（即預約義字符），3.\2引用序號對應的字組 |
a\.c;a\\c |
a.c;a\c |
| * |
須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的*元字符）前面的一個字符能夠是0個或多個本來字符，匹配前一個字符0或屢次，貪婪匹配前導字符有多少個就匹配多少個很貪婪，若是規則裏只有一個分組，儘可能避免用*不然會有可能匹配出空字符串 |
abc* |
ab;abccc |
| + |
須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的+元字符）前面的一個字符能夠是1個或多個本來字符，匹配前一個字符1次或無限次，貪婪匹配前導字符有多少個就匹配多少個很貪婪 |
abc+ |
abc;abccc |
| ? |
須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的?元字符）前面的一個字符能夠是0個或1個本來字符，匹配一個字符0次或1次，還有一個功能是能夠防止貪婪匹配，詳情見防貪婪匹配 |
abc? |
ab;abc |
| ^ |
字符串開始位置與匹配規則符合就匹配，不然不匹配，匹配字符串開頭。在多行模式中匹配每一行的開頭，^元字符若是寫到[]字符集裏就是反取 |
^abc |
abc |
| $ |
字符串結束位置與匹配規則符合就匹配，不然不匹配，匹配字符串末尾，在多行模式中匹配每一行的末尾 |
abc$ |
abc |
| | |
|或，或就是先後其中一個符合就匹配 |
abc|def |
abc def |
| {} |
須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的 {} 元字符）前面的一個字符，是自定義字符數，位數的本來字符，{m}匹配前一個字符m次，{m,n}匹配前一個字符m至n次，若省略n，則匹配m至無限次，{0,}匹配前一個字符0或屢次,等同於*元字符，{+,}匹配前一個字符1次或無限次,等同於+元字符，{0,1}匹配前一個字符0次或1次,等同於?元字符 |
ab{1,2}c |
abc abbc |
| [] |
須要字符串裏徹底符合，匹配規則，就匹配，（規則裏的 [] 元字符）對應位置是[]裏的任意一個字符就匹配，字符集。對應的位置能夠是字符集中任意字符。字符集中的字符能夠逐個列出，也能夠給出範圍，如[abc]或[a-c]。[^abc]表示取反，即非abc。全部特殊字符在字符集中都失去其原有的特殊含義。用\反斜槓轉義恢復特殊字符的特殊含義。 |
a[bcd]e |
abe ace ade
|
| () |
也就是分組匹配，()裏面的爲一個組也能夠理解成一個總體，若是()後面跟的是特殊元字符如 (adc)* 那麼*控制的前導字符就是()裏的總體內容，再也不是前導一個字符 |
(abc){2} |
abcabc a456c |
預約義字符集表，能夠寫在字符集[...]中
| \d |
\d匹配任何十進制數，它至關於類[0-9]，\d+若是須要匹配一位或者多位數的數字時用 |
a\bc |
a1c |
| \D |
\D匹配任何非數字字符，它至關於類[^0-9] |
a\Dc |
abc |
| \s |
\s匹配任何空白字符，它至關於類[\t\n\r\f\v] |
a\sc |
a c |
| \S |
\S匹配任何非空白字符，它至關於類[^\t\n\r\f\v] |
a\Sc |
abc |
| \w |
\w匹配包括下劃線在內任何字母數字字符，它至關於類[a-zA-Z0-9_] |
a\wc |
abc |
| \W |
\W匹配非任何字母數字字符包括下劃線在內，它至關於類[^a-zA-Z0-9_] |
a\Wc |
a c |
| \A |
僅匹配字符串開頭,同^ |
\Aabc |
abc |
| \Z |
僅匹配字符串結尾，同$ |
abc\Z |
abc |
| \b |
b匹配一個單詞邊界，也就是指單詞和空格間的位置 |
\babc\b |
空格abc空格 |
| \B |
[^\b] |
a\Bbc |
abc |
特殊分組用法表：只對正則函數返回對象的有用
| (?P<name>) |
?P<>定義組裏匹配內容的key(鍵)，<>裏面寫key名稱，值就是匹配到的內容，在用groupdict()方法打印字符串 |
(?P<id>abc){2} |
abcabc |
| (?P=name) |
引用別名爲<name>的分組匹配到字符串 |
(?P<id>\d)abc(?P=id) |
1abc1 5abc5 |
| \<number> |
引用編號爲<number>的分組匹配到字符串 |
(\d)abc\1 |
1abc1 5abc5 |
正則匹配模式表
| 標誌 |
含義 |
| re.S(DOTALL) |
使.匹配包括換行在內的全部字符 |
| re.I（IGNORECASE） |
使匹配對大小寫不敏感 |
| re.L（LOCALE） |
作本地化識別（locale-aware)匹配，法語等 |
| re.M(MULTILINE) |
多行匹配，影響^和$ |
| re.X(VERBOSE) |
該標誌經過給予更靈活的格式以便將正則表達式寫得更易於理解 |
| re.U |
根據Unicode字符集解析字符，這個標誌影響\w,\W,\b,\B |
正則小示例
一、匹配電話號碼
p = re.compile(r'\d{3}-\d{6}')
print(p.findall('010-628888'))
二、匹配IP
re.search(r"(([01]?\d?\d|2[0-4]\d|25[0-5])\.){3}([01]?\d?\d|2[0-4]\d|25[0-5]\.)","192.168.1.1")
IP： ^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$ 手機號： ^1[3|4|5|8][0-9]\d{8}$ 郵箱： [a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+
正則表達式重點
1、
r原生字符
將在python裏有特殊意義的字符如\b，轉換成原生字符（就是去除它在python的特殊意義），否則會給正則表達式有衝突，爲了不這種衝突能夠在規則前加原始字符r
2、
正則表達式，返回類型爲表達式對象的
如：<_sre.SRE_Match object; span=(6, 7), match='a'>
返回對象的，須要用正則方法取字符串，
方法有
group() # 獲取匹配到的全部結果，無論有沒有分組將匹配到的所有拿出來，有參取匹配到的第幾個如2
groups() # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分的結果
groupdict() # 獲取模型中匹配到的分組結果，只拿出匹配到的字符串中分組部分定義了key的組結果
3、
匹配到的字符串裏出現空字符
注意：正則匹配到空字符的狀況，若是規則裏只有一個組，而組後面是*就表示組裏的內容能夠是0個或者多過，這樣組裏就有了兩個意思，一個意思是匹配組裏的內容，二個意思是匹配組裏0內容（便是空白）因此儘可能避免用*不然會有可能匹配出空字符串
4、
()分組
注意：分組的意義，就是在匹配成功的字符串中，在提取()裏，組裏面的字符串
5、
?:在有分組的狀況下findall()函數，不僅拿分組裏的字符串，拿全部匹配到的字符串，注意?:只用於不是返回正則對象的函數如findall()
- 1. python正則表達式-re模塊
- 2. Python之正則表達式（re模塊）
- 3. re模塊 正則表達式 python
- 4. 爬蟲 re 模塊 (正則表達式)
- 5. 正則表達式/re模塊
- 6. re模塊正則表達式
- 7. Day 15 正則表達式 re模塊
- 8. re-正則表達式模塊
- 9. py12 正則表達式 re模塊
- 10. [ python ] 正則表達式及re模塊
- 更多相關文章...
- • Scala 正則表達式 - Scala教程
- • PHP 正則表達式(PCRE) - PHP參考手冊
- • 委託模式
- • RxJava操作符（十）自定義操作符
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 升級Gradle後報錯Gradle‘s dependency cache may be corrupt (this sometimes occurs
- 2. Smarter, Not Harder
- 3. mac-2019-react-native 本地環境搭建(xcode-11.1和android studio3.5.2中Genymotion2.12.1 和VirtualBox-5.2.34 )
- 4. 查看文件中關鍵字前後幾行的內容
- 5. XXE萌新進階全攻略
- 6. Installation failed due to: ‘Connection refused: connect‘安卓studio端口占用
- 7. zabbix5.0通過agent監控winserve12
- 8. IT行業UI前景、潛力如何？
- 9. Mac Swig 3.0.12 安裝
- 10. Windows上FreeRDP-WebConnect是一個開源HTML5代理，它提供對使用RDP的任何Windows服務器和工作站的Web訪問
- 1. python正則表達式-re模塊
- 2. Python之正則表達式（re模塊）
- 3. re模塊 正則表達式 python
- 4. 爬蟲 re 模塊 (正則表達式)
- 5. 正則表達式/re模塊
- 6. re模塊正則表達式
- 7. Day 15 正則表達式 re模塊
- 8. re-正則表達式模塊
- 9. py12 正則表達式 re模塊
- 10. [ python ] 正則表達式及re模塊