正則表達式（Python3）
（Python3中常用的正則表達式處理函數）
1. re.match函數
功能
- 嘗試從字符串的起始位置匹配一個模式，如果不是起始位置匹配成功的話，match()返回none
函數語法
re.match(pattern, string, flags=0)
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串 |
| flags | 標誌位：用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等 |
匹配成功返回一個匹配的對象，否則返回None。
可以使用group(num)或groups()匹配對象函數來獲取匹配表達式。
| 匹配對象方法 | 描述 |
|---|---|
| group(num=0) | 匹配的整個表達式的字符串，group()可以一次輸入多個組號，在這種情況下它將返回一個包含那些組所對應值的元組。 |
| group() | 返回一個包含所有小組字符串的元組，從1到所含的小組號 |
實例：
#!/usr/bin/python
import re
print(re.match('www', 'www.runoob.com').span()) #在起始位置匹配,span()匹配範圍
print(re.match('com', 'www.runoob.com')) #不在起始位置匹配
運行結果：
(0, 3)
None
實例：
#!/usr/bin/python3
import re
line = "Cats are smarter than dogs"
# .* 表示任意匹配除換行符（\n、\r）之外的任何單個或多個字符,**注意空格符**
matchObj = re.match(r'(.*) are (.*?) (.*)', line, re.M|re.I)#正則表達式中()表示要匹配的地方，此時爲三處
matchObj2 = re.match(r'(.*) are (.*?) .*', line, re.M|re.I)#正則表達式中()表示要匹配的地方，此時爲兩處
if matchObj:
print("matchObj:", matchObj)
print("matchObj.group():", matchObj.group())
print("matchObj.group(1):", matchObj.group(1))
print("matchObj.group(2):", matchObj.group(2))
print("matchObj.group(3):", matchObj.group(3))
else:
print("No match!")
if matchObj2:
print("matchObj2:", matchObj2)
print("matchObj2.group():", matchObj2.group())
print("matchObj2.group(1):", matchObj2.group(1))
print("matchObj2.group(2):", matchObj2.group(2))
else:
print("No match!")
運行結果：
matchObj: <re.Match object; span=(0, 26), match='Cats are smarter than dogs'>
matchObj.group(): Cats are smarter than dogs
matchObj.group(1): Cats
matchObj.group(2): smarter
matchObj.group(3): than dogs
matchObj2: <re.Match object; span=(0, 26), match='Cats are smarter than dogs'>
matchObj2.group(): Cats are smarter than dogs
matchObj2.group(1): Cats
matchObj2.group(2): smarter
2. re.search函數
功能
- 掃描整個字符串並返回第一個成功的匹配。
函數語法
re.search(pattern, string, flags=0)
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串 |
| flags | 標誌位：用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等 |
匹配成功返回一個匹配的對象，否則返回None。
可以使用group(num)或groups()匹配對象函數來獲取匹配表達式。
| 匹配對象方法 | 描述 |
|---|---|
| group(num=0) | 匹配的整個表達式的字符串，group()可以一次輸入多個組號，在這種情況下它將返回一個包含那些組所對應值的元組。 |
| group() | 返回一個包含所有小組字符串的元組，從1到所含的小組號 |
實例：
#!/usr/bin/python
import re
print(re.search('www', 'www.runoob.com').span()) #在起始位置匹配,span()匹配範圍
print(re.search('com', 'www.runoob.com').span()) #不在起始位置匹配
運行結果：
(0, 3)
(11, 14)
實例：
#!/usr/bin/python3
import re
line = "Cats are smarter than dogs"
# .* 表示任意匹配除換行符（\n、\r）之外的任何單個或多個字符,注意空格符
searchObj = re.search(r'(.*) are (.*?) .*', line, re.M|re.I) # 正則表達式中()表示要匹配的地方，此時爲三處
if searchObj:
print("searchObj:", searchObj)
print("searchObj.group():", searchObj.group())
print("searchObj.group(1):", searchObj.group(1))
print("searchObj.group(2):", searchObj.group(2))
else:
print("Nothing found!")
運行結果：
searchObj: <re.Match object; span=(0, 26), match='Cats are smarter than dogs'>
searchObj.group(): Cats are smarter than dogs
searchObj.group(1): Cats
searchObj.group(2): smarter
re.match與re.search的區別
- re.match只匹配字符串的開始，如果字符串開始不符合正則表達式，則匹配失敗，函數返回None；而re.search匹配整個字符串，直到找到一個匹配。
實例：
#!/usr/bin/python3
import re
line = "Cats are smarter than dogs"
matchObj = re.match(r'dogs', line, re.M|re.I)
if matchObj:
print("match --> matchObj.group():", matchObj.group())
else:
print("No match!")
matchObj = re.search(r'dogs', line, re.M|re.I)
if matchObj:
print("serch --> matchObj.group():", matchObj.group())
else:
print("No match!")
運行結果：
No match!
serch --> matchObj.group(): dogs
3. 替換與檢索
功能
- re.sub用於替換字符串中的匹配項。
函數語法
re.sub(pattern, repl, string,count=0, flags=0)
| 參數 | 描述 |
|---|---|
| pattern | 正則中的模式字符串 |
| repl | 替換的字符串，也可爲一個函數 |
| string | 要被查找替換的原始字符串 |
| count | 模式匹配後替換的最大次數，默認0表示替換所有的匹配 |
實例：
#!/usr/bin/python
#-*-coding: UTF-8 -*-
import re
phone = "2004-959-559 # 這是一個國外電話號碼"
#刪除字符串中的Python註釋
num = re.sub(r'#.*$', "", phone)# $ 匹配字符串的末尾
print ("電話號碼是：", num)
#刪除非數字（-）的字符串
num = re.sub(r'\D', "",phone)#\D 匹配任意非數字
print ("電話號碼是：", num)
運行結果：
電話號碼是： 2004-959-559
電話號碼是： 2004959559
repl 參數是一個函數
實例：
#!/usr/bin/python
#-*-coding: UTF-8 -*-
import re
#將匹配的數字乘以2
def double(matched):
value = int(matched.group('value'))
return str(value *2)
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))#將匹配結果依次賦值給double函數，函數返回結果替換匹配字符串
matched = re.search('(?P<value>\d+)', s)
print(matched)
print(matched.group('value'))
print(double(matched))
運行結果：
A46G8HFD1134
<re.Match object; span=(1, 3), match='23'>
23
46
4. re.complie函數
功能
- 用於編譯正則表達式，生成一個正則表達式（Pattren）對象，供match()和search()這兩個函數使用。
函數語法
re.complie(pattern, flags)
| 參數 | 描述 |
|---|---|
| pattern | 一個字符串形式的正則表達式 |
| flags | 可選，表示匹配模式，比如忽略大小寫，多行模式等 |
實例：
#!/usr/bin/python
#-*-coding: UTF-8 -*-
import re
pattern = re.compile(r'\d+')#用於匹配至少一個數字
m = pattern.match('one12twothree34four')#查找頭部，沒有匹配
print (m)
m2 = pattern.match('one12twothree34four', 2, 10)#從‘e’的位置開始匹配，沒有匹配
print (m2)
m3 = pattern.match('one12twothree34four', 3, 10)#從‘1’的位置開始匹配，正好匹配，返回一個match對象
print (m3)
print('m3.group:', m3.group(0))#m3.group()也可，下同
print('m3.start:', m3.start(0))#start 子串第一個字符的索引
print('m3.end:', m3.end(0))#end 子串最後一個字符的索引+1
print('m3.span:', m3.span(0))
運行結果：
None
None
<re.Match object; span=(3, 5), match='12'>
m3.group: 12
m3.start: 3
m3.end: 5
m3.span: (3, 5)
5. findall函數
功能
- 在字符串中找到正則表達式所有子串，並返回一個列表，如果沒有找到匹配的，則返回空列表。
- match和search是匹配一次，findall匹配所有
函數語法
findall(string, pos, endpos)
| 參數 | 描述 |
|---|---|
| pos | 可選參數，指定字符串的起始位置，默認爲0 |
| endpos | 可選參數，指定字符串的結束位置，默認爲字符串的長度 |
實例：
# -*- coding:UTF8 -*-
import re
pattern = re.compile(r'\d+') # 查找數字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)
print(result1)
print(result2)
運行結果：
['123', '456']
['88', '12']
6. re.finditer函數
功能
- 和findall類似，在字符串中找到正則表達式所有子串，並把它們作爲一個迭代器返回。
函數語法
re.finditer(pattern, string, flag=0)
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串 |
| flags | 標誌位：用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等 |
實例：
# -*- coding: UTF-8 -*-
import re
it = re.finditer(r"\d+","12a32bc43jf3")
for match in it:
print (match.group() )
運行結果：
12
32
43
3
7. re.split函數
功能
- 按照能夠匹配的字符串分割後返回列表。
函數語法
re.split(pattern, string, maxsplit=0, flag=0)
| 參數 | 描述 |
|---|---|
| pattern | 匹配的正則表達式 |
| string | 要匹配的字符串 |
| maxsplit | 分割次數，maxsplit=1分割一次，默認爲0，不限制次數 |
| flags | 標誌位：用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等 |
實例：
>>>import re
>>> re.split('\W+', 'runoob, runoob, runoob.')
['runoob', 'runoob', 'runoob', '']
>>> re.split('(\W+)', ' runoob, runoob, runoob.')
['', ' ', 'runoob', ', ', 'runoob', ', ', 'runoob', '.', '']
>>> re.split('\W+', ' runoob, runoob, runoob.', 1)
['', 'runoob, runoob, runoob.']
>>> re.split('a*', 'hello world') # 對於一個找不到匹配的字符串而言，split 不會對其作出分割。 **但是實際運行時則全部分割了，不解。**
['', 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '']
8. 正則表達式對象
re.RegexObject
- re.complie() 返回RegexObject對象。
re.MatchObject
- group() 返回被RE匹配的字符串。
9. 正則表達式修飾符 - 可選標誌
- 正則表達式可以包含一些可選標誌修飾符來控制匹配的模式。修飾符被指定爲一個可選的標誌。多個標誌可以通過按位 OR(|) 它們來指定。如 re.I | re.M 被設置成 I 和 M 標誌：
| 修飾符 | 描述 |
|---|---|
| re.I | 使匹配對大小寫不敏感 |
| re.L | 做本地化識別（locale-aware）匹配 |
| re.M | 多行匹配，影響 ^ 和 $ |
| re.S | 使 . 匹配包括換行在內的所有字符 |
| re.U | 根據Unicode字符集解析字符。這個標誌影響 \w, \W, \b, \B. |
| re.X | 該標誌通過給予你更靈活的格式以便你將正則表達式寫得更易於理解。 |
10. 正則表達式模式
- 模式字符串使用特殊的語法來表示一個正則表達式：
字母和數字表示他們自身。一個正則表達式模式中的字母和數字匹配同樣的字符串。
多數字母和數字前加一個反斜槓時會擁有不同的含義。
標點符號只有被轉義時才匹配自身，否則它們表示特殊的含義。
反斜槓本身需要使用反斜槓轉義。
由於正則表達式通常都包含反斜槓，所以最好使用原始字符串來表示它們。模式元素(如 r’\t’，等價於 ‘\\t’)匹配相應的特殊字符。
下表列出了正則表達式模式語法中的特殊元素。如果使用模式的同時提供了可選的標誌參數，某些模式元素的含義會改變。
| 模式 | 描述 |
|---|---|
| ^ | 匹配字符串的開頭 |
| $ | 匹配字符串的末尾。 |
| . | 匹配任意字符，除了換行符，當re.DOTALL標記被指定時，則可以匹配包括換行符的任意字符。 |
| […] | 用來表示一組字符,單獨列出：[amk] 匹配 ‘a’，‘m’或’k’ |
| [^…] | 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。 |
| re* | 匹配0個或多個的表達式。 |
| re+ | 匹配1個或多個的表達式。 |
| re? | 匹配0個或1個由前面的正則表達式定義的片段，非貪婪方式 |
| re{ n} | 精確匹配 n 個前面表達式。例如， o{2} 不能匹配 “Bob” 中的 “o”，但是能匹配 “food” 中的兩個 o。 |
| re{ n,} | 匹配 n 個前面表達式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。“o{1,}” 等價於 “o+”。“o{0,}” 則等價於 “o*”。 |
| re{n,m} | 匹配 n 到 m 次由前面的正則表達式定義的片段，貪婪方式 |
| ‘a’b | 匹配a或b |
| (re) | 對正則表達式分組並記住匹配的文本 |
| (?imx) | 正則表達式包含三種可選標誌：i, m, 或 x 。隻影響括號中的區域。 |
| (?-imx) | 正則表達式關閉 i, m, 或 x 可選標誌。隻影響括號中的區域。 |
| (?: re) | 類似 (…), 但是不表示一個組 |
| (?imx: re) | 在括號中使用i, m, 或 x 可選標誌 |
| (?-imx: re) | 在括號中不使用i, m, 或 x 可選標誌 |
| (?#…) | 註釋. |
| (?= re) | 前向肯定界定符。如果所含正則表達式，以 … 表示，在當前位置成功匹配時成功，否則失敗。但一旦所含表達式已經嘗試，匹配引擎根本沒有提高；模式的剩餘部分還要嘗試界定符的右邊。 |
| (?! re) | 前向否定界定符。與肯定界定符相反；當所含表達式不能在字符串當前位置匹配時成功 |
| (?> re) | 匹配的獨立模式，省去回溯。 |
| \w | 匹配字母數字及下劃線 |
| \W | 匹配非字母數字及下劃線 |
| \s | 匹配任意空白字符，等價於 [\t\n\r\f]. |
| \S | 匹配任意非空字符 |
| \d | 匹配任意數字，等價於 [0-9]. |
| \D | 匹配任意非數字 |
| \A | 匹配字符串開始 |
| \Z | 匹配字符串結束，如果是存在換行，只匹配到換行前的結束字符串。 |
| \z | 匹配字符串結束 |
| \G | 匹配最後匹配完成的位置。 |
| \b | 匹配一個單詞邊界，也就是指單詞和空格間的位置。例如， ‘er\b’ 可以匹配"never" 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。 |
| \B | 匹配非單詞邊界。‘er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。 |
| \n, \t, 等. | 匹配一個換行符，匹配一個製表符等。 |
| \1…\9 | 匹配第n個分組的內容。 |
| \10 | 匹配第n個分組的內容，如果它經匹配。否則指的是八進制字符碼的表達式。 |
11. 正則表達式實例
字符類
| 實例 | 描述 |
|---|---|
| python | 匹配 “python”. |
| [Pp]ython | 匹配 “Python” 或 “python” |
| rub[ye] | 匹配 “ruby” 或 “rube” |
| [aeiou] | 匹配中括號內的任意一個字母 |
| [0-9] | 匹配任何數字。類似於 [0123456789] |
| [a-z] | 匹配任何小寫字母 |
| [A-Z] | 匹配任何大寫字母 |
| [a-zA-Z0-9] | 匹配任何字母及數字 |
| [^aeiou] | 除了aeiou字母以外的所有字符 |
| [^0-9] | 匹配除了數字外的字符 |
特殊字符類
| 實例 | 描述 |
|---|---|
| . | 匹配除 “\n” 之外的任何單個字符。要匹配包括 ‘\n’ 在內的任何字符，請使用象 ‘[.\n]’ 的模式。 |
| \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_]’。 |
其他
r'(.*) are (.*?) .*'
#前面的一個 r 表示字符串爲非轉義的原始字符串，讓編譯器忽略反斜槓，也就是忽略轉義字符。但是這個字符串裏沒有反斜槓，所以這個 r 可有可無。
#(.*) 第一個匹配分組，.* 代表匹配除換行符之外的所有字符。
#(.*?) 第二個匹配分組，.*? 後面多個問號，代表非貪婪模式，也就是說只匹配符合條件的最少字符
#後面的一個 .* 沒有括號包圍，所以不是分組，匹配效果和第一個相同，但是不計入匹配結果中。
#'(?P...)' ：分組匹配
import re
s = '1102231990xxxxxxxx'
res = re.search('(?P<province>\d{3})(?P<city>\d{3})(?P<born_year>\d{4})',s)
print(res.groupdict())
#運行結果：
{'province': '110', 'city': '223', 'born_year': '1990'}
#直接將匹配結果直接轉爲字典模式，方便使用。