一、什麼是正規表示式？
- 正規表示式，又稱規則表示式，通常被用來檢索、替換那些符合某個模式(規則)的文字。
- 正規表示式是對字串操作的一種邏輯公式，就是用事先定義好的一些特定字元、及這些特定字元的組合，組成一個“規則字串”，這個“規則字串”用來表達對字串的一種過濾邏輯。
二、正規表示式的匹配規則
1.表示字元
- ·：匹配任意除換行符'\n'外的字元，但是在DOTALL模式中也可以匹配換行符'\n'
- \：轉義字元，使後一個字元改變原來的意思，如果字串中想匹配*，可以使用\*，也可以使用字符集[*]
- [...]：字符集，匹配字符集中列出的任意字元。字元可以逐個列出，也可以給出範圍，比如[a-z]，[0-9]，第一個字元是^表示取反。所有特殊字元在字符集中都失去其原有的特殊含義。如果想使用']','-'或者'^'，可以在前面加上\，或者將]或者-放在首位，將^放在非首位
2.預定義字符集（可寫在字符集[]中）
- \d：數字[0-9]
- \D：非數字[^0-9]
- \s：空白字元[<空格>，\t,\n,\r,\f,\v]
- \S：非空白字元[^\s]
- \w：單詞字元[a-zA-Z0-9_]
- \W：非單詞字元[^\w]
3.表示數量
- *：匹配前一個字元0次或無限次，即可有可無
- +：匹配前一個字元出現1次或者無限次，即至少有1次
- {m}：匹配前一個字元出現m次
- {m,}：匹配前一個字元至少出現m次
- {,n}：匹配前一個字元至多出現n次
- {m,n}：匹配前一個字元出現從m到n次
4.表示邊界
- ^：匹配字串開頭。在多行模式中匹配每一行的開頭
- $：匹配字串結尾。在多行模式中匹配每一行的結尾
- \A：僅匹配字串開頭
- \Z：僅匹配字串結尾
- \b：匹配單詞邊界，\w和\W之間
- \B：匹配非單詞邊界，[^\b]
5.匹配分組
- |：匹配左右任意一個表示式
- (...)：被括起來的表示式作為一個分組，從表示式左邊開始，每遇到一個'('，編號+1。分組表示式作為一個整體，後面可接數量詞。表示式中的|僅在該分組中有效
- (?P<name>)：分組，除了原有的編號以外，再給分組取一個別名
- (?P=<name>)：引用別名為<name>的分組匹配到的字串
- \<number>：引用編號為<number>的分組匹配到的字串
6.特殊構造(不作為分組)
- (?:...)：(...)的不分組版本，用於使用'|'或後面接上數量詞，比如(?:[1-9]?\d|100)表示匹配數字0-100，(?:abc){2}表示匹配abcabc
- 剩下的一些不常見，略
三、re模組
在 Python中，我們可以使用內建的 re 模組來使用正規表示式。與大多數程式語言相同，正規表示式裡使用'\'作為轉義字元，這就可能造成反斜槓困擾。Python裡的原生字串很好地解決了這個問題，只需要在字串前面加上'r'字首。
re模組的一般使用步驟：
-
使用
compile()函式將正規表示式的字串形式編譯為一個Pattern物件 -
通過
Pattern物件提供的一系列方法對文字進行匹配查詢
1.compile函式
- compile 函式用於編譯正規表示式，生成一個 Pattern 物件。必須傳入的第一個引數是'規則字串'，另外可以通過第二個引數(flags)來指定匹配模式。
- 常見的匹配模式：
- re.I(re.IGNORECASE): 忽略大小寫
- re.M(MULTILINE): 多行模式，改變’^’和’$’的行為
- re.S(DOTALL): 點任意匹配模式，改變’.’的行為，可以匹配'\n'
import re # 將正規表示式編譯成 Pattern物件，並指定匹配模式為點任意匹配模式 pattern = re.compile(r'\d+',re.S)
2.Pattern 物件的一些常用方法
-
match方法
- match 方法用於查詢字串的頭部（也可以指定起始位置），它是一次匹配，只要找到了一個匹配的結果就返回，而不是查詢所有匹配的結果。
- 它的一般使用形式如下：
match(string[, pos[, endpos]])
其中，string 是待匹配的字串，pos 和 endpos 是可選引數，指定字串的起始和終點位置，預設值分別是 0 和 len (字串長度)。因此，當你不指定 pos 和 endpos 時，match 方法預設匹配字串的頭部。
- 當匹配成功時，返回一個 Match 物件，如果沒有匹配上，則返回 None。
- Match物件常用的方法:
- group(([group1, …])：用於獲得一個或多個分組匹配的字串，如果傳入多個分組編號，則返回的結果為元組形式。當要獲得整個匹配的子串時，可直接使用 group() 或 group(0)；
- groups()：獲得所有分組匹配到的字串所構成的元組
- start([group]) 方法用於獲取分組匹配的子串在整個字串中的起始位置（子串第一個字元的索引），引數預設值為 0；
- end([group]) 方法用於獲取分組匹配的子串在整個字串中的結束位置（子串最後一個字元的索引+1），引數預設值為 0；
- span([group]) 方法返回 (start(group), end(group))，獲取分組匹配的子串在整個字串中的起始和結束位置構成的元組。
- 通過一些例子來熟悉一下：
In [1]: import re In [2]: pattern = re.compile(r"(\w+) (\d+)") In [3]: m = pattern.match('hello 123') In [4]: m.group(1) Out[4]: 'hello' In [5]: m.group(1,2) Out[5]: ('hello', '123') In [6]: m.group() Out[6]: 'hello 123' In [7]: m.groups() Out[7]: ('hello', '123') In [8]: m.start(1) Out[8]: 0 In [9]: m.start(2) Out[9]: 6 In [10]: m.end(1) Out[10]: 5 In [11]: m.span(1) Out[11]: (0, 5) In [12]: m.span(2) Out[12]: (6, 9)
-
search方法
- search 方法用於查詢字串的任何位置，它也是一次匹配，只要找到了一個匹配的結果就返回，而不是查詢所有匹配的結果
- 它的一般使用形式如下：
search(string[, pos[, endpos]])
其中，string 是待匹配的字串，pos 和 endpos 是可選引數，指定字串的起始和終點位置，預設值分別是 0 和 len (字串長度)。
- 看看例子
>>> import re >>> pattern = re.compile('\d+') >>> m = pattern.search('one12twothree34four') # 這裡如果使用 match 方法則不匹配 >>> m <_sre.SRE_Match object at 0x10cc03ac0> >>> m.group() '12' >>> m = pattern.search('one12twothree34four', 10, 30) # 指定字串區間 >>> m <_sre.SRE_Match object at 0x10cc03b28> >>> m.group() '34' >>> m.span() (13, 15)
-
findall方法
- 上面的 match 和 search 方法都是一次匹配，只要找到了一個匹配的結果就返回。然而，在大多數時候，我們需要搜尋整個字串，獲得所有匹配的結果。
- findall 方法的使用形式如下：
findall(string[, pos[, endpos]])
其中，string 是待匹配的字串，pos 和 endpos 是可選引數，指定字串的起始和終點位置，預設值分別是 0 和 len (字串長度)。
- findall 以列表形式返回全部能匹配的子串，如果沒有匹配，則返回一個空列表。
- 看個例子：
import re #re模組提供一個方法叫compile函式，提供我們輸入一個匹配的規則 #然後返回一個pattern例項，我們根據這個規則去匹配字串 pattern = re.compile(r'\d+\.\d*') #通過partten.findall()方法就能夠全部匹配到我們得到的字串 result = pattern.findall("123.141593, 'bigcat', 232312, 3.15") #findall 以 列表形式 返回全部能匹配的子串給result for item in result: print(item)
執行結果:
123.141593 3.15
-
finditer方法
- finditer 方法的行為跟 findall 的行為類似，也是搜尋整個字串，獲得所有匹配的結果。但它返回一個順序訪問每一個匹配結果（Match 物件）的迭代器。
- 舉例：
In [1]: import re In [2]: pattern = re.compile(r"\d+") In [3]: iter = pattern.finditer('hello123world456 haha789') In [4]: iter Out[4]: <callable_iterator at 0x7fb824fe2a90> In [5]: for m in iter: ...: print(m.group()) ...: 123 456 789
-
split方法
- split 方法按照能夠匹配的子串將字串分割後返回列表
- 它的使用形式如下:
split(string[, maxsplit])
其中，maxsplit 用於指定最大分割次數，不指定將全部分割。
- 舉個例子:
In [1]: import re In [2]: pattern = re.compile(r"[\d\s]") In [3]: pattern.split('hello1word2aaa bbb') Out[3]: ['hello', 'word', 'aaa', 'bbb'] In [4]: pattern.split('hello1word2aaa bbb',2) Out[4]: ['hello', 'word', 'aaa bbb']
-
sub方法
- sub 方法用於替換。
- 它的使用形式如下：
sub(repl, string[, count])
其中，repl 可以是字串也可以是一個函式：
- 如果 repl 是字串，則會使用 repl 去替換字串每一個匹配的子串，並返回替換後的字串，另外，repl 還可以使用 id 的形式來引用分組，但不能使用編號 0，注意repl應是帶字首'r'的原生字串；
- 如果 repl 是函式，這個方法應當只接受一個引數（Match 物件），並返回一個字串用於替換（返回的字串中不能再引用分組）。
- count 用於指定最多替換次數，不指定時全部替換。
In [1]: import re In [2]: pattern = re.compile(r'\d+') In [3]: pattern.sub('100','hello20 world30')#將所有匹配到的資料替換成100 Out[3]: 'hello100 world100' In [4]: pattern.sub('100','hello20 world30',1)#只替換第一個資料為100 Out[4]: 'hello100 world30' In [5]: def add(temp): ...: '''將匹配到的資料加1''' ...: strNum = temp.group() ...: num = int(strNum)+1 ...: return str(num) In [6]: pattern.sub(add,'hello20 world30')#將所有匹配到的資料加1 Out[6]: 'hello21 world31' In [7]: pattern.sub(add,'hello20 world30',1)#只將匹配到的第一個資料加1 Out[7]: 'hello21 world30' In [8]: pattern = re.compile('(\d+) (\w+)') In [9]: pattern.sub(r'\2哈哈\1','123 abc 456 def')#使用原生字串，成功引用分組匹配到的字串 Out[9]: 'abc哈哈123 def哈哈456' In [10]: pattern.sub('\2哈哈\1','123 abc 456 def')#不使用原生字串，未成功引用分組匹配到的字串 Out[10]: '\x02哈哈\x01 \x02哈哈\x01'
四、貪婪模式與非貪婪模式
- 貪婪模式：在整個表示式匹配成功的前提下，儘可能多的匹配
- 非貪婪模式：在整個表示式匹配成功的前提下，儘可能少的匹配
- 在表示數量的"*","?","+","{m,n}"後面加上？，使貪婪模式變成非貪婪模式
In [1]: import re In [2]: pattern = re.compile(r'\d+') In [3]: pattern.match('123456789').group() Out[3]: '123456789' In [4]: pattern = re.compile(r'\d+?')#關閉貪婪模式 In [5]: pattern.match('123456789').group()#非貪婪模式下，+只匹配一個字元 Out[5]: '1' In [6]: pattern = re.compile(r'<div>.*</div>') In [7]: pattern.match('<div>test1</div>bb<div>test2</div>').group() Out[7]: '<div>test1</div>bb<div>test2</div>' In [8]: pattern = re.compile(r'<div>.*?</div>')#關閉貪婪模式 In [9]: pattern.match('<div>test1</div>bb<div>test2</div>').group() Out[9]: '<div>test1</div>'