㈠ python其實很簡單 第十一章 正則表達式
正則表達式是一個特殊的字元序列，它用來檢查一個字元串是否與某種模式匹配。正則表達式在編譯程序中至關重要，但並不是每個人都需要特別深入的學習和掌握。在此，只介紹一些最基本的應用。
1、元字元
元字元是構成正則表達式的一些特殊字元。在正則表達式中，元字元被賦予了新的含義。
下面介紹一些常用的元字元及其含義：
. 匹配除換行符以外的任意字元。
w 匹配字母、數字、下劃線或漢字。
W 匹配w所匹配的字元以外的字元。
s 匹配單個空白符（包括Tab鍵和換行符）。
S 匹配除s匹配的字元以外的字元。
d 匹配數字。
b 匹配單詞的分界符，如：空格、標點符號或換行符。
^ 匹配字元串的開始
$ 匹配字元串的結束
2、限定符
限定符是在正則表達式中用來指定數量的字元。常用的限定符有：
? 匹配前面的字元0或1次。如：zo?m可以匹配zom和zm，但不能匹配 zoom
+ 匹配前面的字元1或n次。如：zo?m可以匹配zom和zoom，但不能匹配zm
* 匹配前面的字元0或n次。如：zo?m可以匹配zom、zoom和zm
{n} 匹配前面的字元n次。如：zo{2}m可以匹配zoom，但不能匹配zom和zm
{n,} 匹配前面的字元至少n次。如：zo{1,}m可以匹配zom和zoom，但不能匹配zm
{n,m} 匹配前面的字元至少n次，最多m次。如：zo{1,2}m可以匹配zom和zoom，但不能匹配zm
3、方括弧」[ ]」的用途
方括弧「[ ]」里可以列出某個字元范圍。如：[aeiou]表示匹配任意一個母音字母，[zqsl]表示匹配姓氏「趙錢孫李」的拼音第一個字母。
4、排除字元
方括弧」[ ]」中的「^」字元表示排除的意思，如：[^aeiou]表示匹配任意一個非母音字母的字元。
5、選擇字元
字元「|」相當於「或」。如：(^d{3}[-]d{8})|(^d{4}[-]d{7})$可以匹配形如」 - 」或「 - 」的電話號碼格式。
6、轉義字元
對於已經用於定義元字元和限定符的字元，需要加轉義符「」來表示。
如：為了匹配形如「192.168.0.1」的IPv4地址（1~255.0~255.0~255.0~255），可以用這樣的正則表達式：^(25[0-5]|2[0-4][0-9]|[0,1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]).(25[0-5]|2[0-4][0-9]|[0,1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0).(25[0-5]|2[0-4][0-9]|[0,1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0).(25[0-5]|2[0-4][0-9]|[0,1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9])$
這里解釋一下第一段IP地址的規則，取值范圍為1~255，可分解為以下情況：
250~255：25[0-5]；
200~249：2[0-4][0-9]；
100~199：[01]{1}[0-9]{2}；
0~99: [0-9]{1}[1-9]
再加上」.」： .
其他三段地址和第一段相似。
7、「( )」可以用於分組
在正則表達式中，用「( )」括起來的部分是一個整體。
8、r（或R）的意義
在正則表達式中，為了保證模式字元串為原生字元串（沒有經過加工處理的字元串），可以在模式字元串前加上一個字元『r』或『R』。例如：
# 這里用到對的re.match()方法接下來介紹
>>> import re # 導入re模塊
>>> re.match('bPy[a-z]+','Python') # 表達式'bPy[a-z]+'不能匹配』Python』
>>> re.match('bPy[a-z]+','Python') # 表達式'bPy[a-z]+'可以匹配』Python』
在上述代碼中，原本要用作匹配單詞開始或結束的元字元』b』在表達式中字元串中會被視為轉義一個字元『b』，為了轉義』b』就不得不再加一個』』符號。
也可以採用下面的方法：
>>> re.match(r'bPy[a-z]+','Python') #加字元』r』，可以保證原生字元串
9、match()方法
Match()方法 嘗試從字元串的起始位置匹配一個模式，如果不是起始位置匹配成功的話，match() 就返回 none。
語法格式：
re.match(pattern, string, [flags])
其中，pattern表示匹配的正則表達式；string是要匹配的字元串；flags表示標志位，用於控制正則表達式的匹配方式，如：re.I表示不區分大小寫。
例：
import re #導入re模塊
print(re.match('www', 'www.python.org/').span()) #span()函數可以獲取匹配的位置
print(re.match('org', 'www.python.org'))
輸出結果為：
(0, 3) #在位置0到3（不包括3）匹配成功
None #從起始位置未能匹配成功
10、search()方法
search()方法用於在整個字元串中搜索第一個匹配的值，如果匹配成功，則返回Match對象，否則返回None。
語法格式：
re.search(pattern, string, [flags])
其中，pattern表示匹配的正則表達式；string是要匹配的字元串；flags表示標志位，用於控制正則表達式的匹配方式，如：re.I表示不區分大小寫。
例如：
>>> re.search(r'Pyw+','It's easy to use Python, but it's not easy to learn Python.')
可以看出，目標字元串「It's easy to use Python, but it's not easy to learn Python.」中一共有兩個『Python』，search()方法可以從字元串的起始位置開始查找到『Python』，當找到第一個匹配值後就停止查找，返回位置信息。
match()和search()的比較
match()要求目標字元串的起始位置就能匹配，search()對目標字元串全段進行逐次匹配，只要首次匹配成功就停止匹配。
請看下例:
>>> import re
>>> print(re.match(r'Pyw+','It's easy to use Python, but it's not easy to learn Python.'))
輸出結果：None
11、findall()方法
findall()方法用於在整個字元串中搜索所有匹配的值，如果匹配成功，則返回以匹配值為元素的列表，否則返回空列表。
語法格式：
re.findall(pattern, string[, flags])
其中，pattern表示匹配的正則表達式；string是要匹配的字元串；flags表示標志位，用於控制正則表達式的匹配方式，如：re.I表示不區分大小寫。
例：
>>> import re
>>>print(re.findall(r'Pyw+','It's easy to use Python, but it's not easy to learn Python.'))
輸出結果：['Python', 'Python']
可以看出，findall()的結果沒有指出匹配的具體位置。
12、正則表達式的應用
字元串替換
這里要用到sub()方法。它的語法格式如下：
re.sub(pattern, repl, string [,count] [,flgs])
其中，pattern是模式字元串；repl是用於替換的字元串；string是原字元串；可選參數count為模式匹配後替換的最大次數，省缺表示替換所有的匹配；可選參數flags的意義與前面的方法的該參數一致。
例：
>>> import re
>>> str1='x=36.567 y=123.234'
>>> str2=re.sub('.d+','',str1) #用空格代替小數點及其後的數字
>>> print(str2)
輸出結果：x=36 y=123
分隔字元串
這里要用到split()方法。它的返回值為一個列表，它的語法格式如下：
re.split(pattern, string [,maxsplit] [,flgs])
其中，pattern是模式字元串；string是原字元串；可選參數maxsplit為最大拆分次數，省缺表示拆分所有的匹配；可選參數flags的意義與前面的方法的該參數一致。
例：
>>> import re
>>> str='白日依山盡，黃河入海流。欲窮千里目，更上一層樓！'
>>> re.split(r'，|。|！',str) #按照「，」、「。」、「！」分隔字元串。
['白日依山盡', '黃河入海流', '欲窮千里目', '更上一層樓', '']
注意，返回值列表中多出了一個空字元。
㈡ 學Python正則表達式，這一篇就夠了
正則表達式是一個特殊的字元序列，可以幫助您使用模式中保留的專門語法來匹配或查找其他字元串或字元串集。 正則表達式在UNIX世界中被廣泛使用。
註：很多開發人員覺得正則表達式比較難以理解，主要原因是缺少使用或不願意在這上面花時間。
re模塊在Python中提供對Perl類正則表達式的完全支持。如果在編譯或使用正則表達式時發生錯誤，則re模塊會引發異常re.error。
在這篇文章中，將介紹兩個重要的功能，用來處理正則表達式。 然而，首先是一件小事：有各種各樣的字元，這些字元在正則表達式中使用時會有特殊的意義。 為了在處理正則表達式時避免混淆，我們將使用：r'expression'原始字元串。
匹配單個字元的基本模式
編譯標志可以修改正則表達式的某些方面。標志在re模塊中有兩個名稱：一個很長的名稱，如IGNORECASE，和一個簡短的單字母形式，如。
1.match函數
此函數嘗試將RE模式與可選標志的字元串進行匹配。
下面是函數的語法 ：
這里是參數的描述 ：
pattern ： 這是要匹配的正則表達式。
string ： 這是字元串，它將被搜索用於匹配字元串開頭的模式。 |
flags ： 可以使用按位OR(|)指定不同的標志。 這些是修飾符，如下表所列。
re.match函數在成功時返回匹配對象，失敗時返回None。使用match(num)或groups()函數匹配對象來獲取匹配的表達式。
示例
當執行上述代碼時，會產生以下結果 ：
2.search函數
此函數嘗試將RE模式與可選標志的字元串進行匹配。
下面是這個函數的語法 ：
這里是參數的描述 ：
pattern ： 這是要匹配的正則表達式。
string ： 這是字元串，它將被搜索用於匹配字元串開頭的模式。 |
flags ： 可以使用按位OR(|)指定不同的標志。 這些是修飾符，如下表所列。
re.search函數在成功時返回匹配對象，否則返回None。使用match對象的group(num)或groups()函數來獲取匹配的表達式。
示例
當執行上述代碼時，會產生以下結果 ：
3.匹配與搜索
Python提供基於正則表達式的兩種不同的原始操作：match檢查僅匹配字元串的開頭，而search檢查字元串中任何位置的匹配(這是Perl默認情況下的匹配)。
示例
當執行上述代碼時，會產生以下結果 ：
4.搜索和替換
使用正則表達式re模塊中的最重要的之一是sub。
模塊
此方法使用repl替換所有出現在RE模式的字元串，替換所有出現，除非提供max。此方法返回修改的字元串。
示例
當執行上述代碼時，會產生以下結果 ：
5.正則表達式修飾符：選項標志
正則表達式文字可能包含一個可選修飾符，用於控制匹配的各個方面。 修飾符被指定為可選標志。可以使用異或(|)提供多個修飾符，如前所示，可以由以下之一表示 ：
6.正則表達模式
除了控制字元(+ ? . * ^ $ ( ) [ ] { } | )，所有字元都與其自身匹配。 可以通過使用反斜杠將其轉換為控制字元。
7.正則表達式示例
字元常量
字元類
特殊字元類
重復匹配
非貪婪重復
這匹配最小的重復次數 ：
用圓括弧分組
反向引用
這與以前匹配的組再次匹配 ：
備擇方案
python|perl ： 匹配「python」或「perl」
rub(y|le) ： 匹配 「ruby」 或 「ruble」
Python(!+|?) ： 「Python」後跟一個或多個! 還是一個?
錨點
這需要指定匹配位置。
帶括弧的特殊語法
開課吧廣場-人才學習交流平台-開課吧
㈢ Python re模塊 正則表達式之compile函數
為了重復利用同一個正則對象，需要多次使用這個正則表達式的話，使用re.compile()保存這個正則對象以便復用，可以讓程序更加高效。
1）re.compile
參數：
re.I 忽略大小寫
re.L 表示特殊字元集 w, W, b, B, s, S 依賴於當前環境
re.M 多行模式
re.S 即為' . '並且包括換行符在內的任意字元（' . '不包括換行符）
re.U 表示特殊字元集 w, W, b, B, d, D, s, S 依賴於 Unicode 字元屬性資料庫
re.X 為了增加可讀性，忽略空格和' # '後面的注釋
案例：
在上面，當匹配成功時返回一個 Match 對象，其中：
2）re.findall
在字元串中找到正則表達式所匹配的所有子串，並返回一個列表，如果有多個匹配模式，則返回元組列表，如果沒有找到匹配的，則返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。
參數：
案例：
3）re.finditer
和 findall 類似，在字元串中找到正則表達式所匹配的所有子串，並把它們作為一個迭代器返回。
案例：
4）re.split
split 方法按照能夠匹配的子串將字元串分割後返回列表。
案例：
從上篇Python re模塊 正則表達式到這篇，我們已經把常用的正則匹配的方法學會了。
關注我，堅持每日積累一個技巧， 長期堅持 ，我們將會不斷進步。
#python# #程序員# #請回答，你的年度知識點# #教育聽我說# #計算機#
㈣ Python正則表達式（二）
上節我們說到 Python 正則表達式的基本字元，以及這些字元的用法
今天，我們繼續講講 Python 中一些擴展標記法，以及一些特殊序列
(?...) : 這種擴展標記法以括弧內 ? 開頭，其後第一個字元決定了採用什麼樣的語法。
在 ? 後面添加( 'a', 'i', 'L', 'm', 's', 'u', 'x' 中的一個或多個)，然後加上匹配規則。
這些字元對正則表達式設置以下標記，免去設置 flag 參數
注意 ： 'a', 'L', 'u' 作為內聯標記是相互排斥的，它們不能結合在一起
括弧分組的非捕獲版本，該分組所匹配的子字元串 不能 在執行匹配後被獲取或是在之後的模式中被引用
可以配合 | 和 {m} 使用
為分組再指定一個組合名
每個組合名只能用一個正則表達式定義，只能定義一次
反向引用一個命名組合
匹配前面那個名字叫 name 的命名組中匹配到的字元串
注釋信息，裡面的內容會被忽略。
哈哈，是不是沒看懂，沒事，舉個栗子
看看，是不是一下子就明了了。
哈哈，這個又看不懂？
思考一下，既然有根據後面字元斷言的，那麼根據前面字元來斷言，也是很合理的，
如果給定的 id 或 name 存在，將會嘗試匹配 yes-pattern ，否則就嘗試匹配 no-pattern ， no-pattern 可選，也可以被忽略。
是不是有點像 if else 三目運算，其中 id 和 name 是分組 id 、和指定的分組名 name
照舊，舉個栗子吧
看了栗子是不是有點糊塗呢，我們來解析一下這個正則表達式
其結果匹配的就是 <[email protected]> 和 [email protected] 。
而不會匹配 <[email protected] ' 和 <[email protected]
但是上面的第三個結果為啥不一樣呢？
因為 findall 允許返回空匹配的，在有 ? 的情況下，所以它會分兩種情況去匹配
今天講了一些擴展標記法，其實沒那麼難，多看看例子，多練習練習。
下節將介紹 re 模塊各函數的用法，敬請期待......
㈤ 一文秒懂python正則表達式常用函數
01 Re概覽
Re模塊是python的內置模塊，提供了正則表達式在python中的所有用法，默認安裝位置在python根目錄下的Lib文件夾（如 ..\Python\Python37\Lib）。主要提供了3大類字元串操作方法：
字元查找/匹配
字元替換
字元分割
由於是面向字元串類型的模塊，就不得不提到字元串編碼類型。re模塊中，模式串和搜索串既可以是 Unicode 字元串 (常用str類型) ，也可以是8位位元組串 (bytes，2位16進制數字，例如\xe5) ， 但要求二者必須是同類型字元串。
02 字元串查找/匹配
預編譯：compile
在介紹查找和匹配函數前，首先需要知道re的compile函數，該函數可以將一個模式串編譯成正則表達式類型，以便後續快速匹配和復用
import re pattern = re.compile(r'[a-z]{2,5}') type(pattern) #re.Pattern
此例創建了一個正則表達式式對象 (re.pattern) ，命名為pattern，用於匹配2-5位小寫字母的模式串。後續在使用其他正則表達式函數時，即可使用pattern進行方法調用。
匹配：match
match函數用於從文本串的起始位置開始匹配，若匹配成功，則返回相應的匹配對象，此時可調用group()方法返回匹配結果，也可用span()方法返回匹配起止下標區間；否則返回None
import re pattern = re.compile(r'[a-z]{2,5}') text1 = 'this is a re test' res = pattern.match(text1) print(res) # if res: print(res.group()) #this print(res.span()) #(0, 4) text2 = '是的, this is a re test' print(pattern.match(text2))#None
match函數還有一個變形函數fullmatch，當且僅當模式串與文本串剛好全部匹配時，返回一個匹配對象，否則返回None
搜索：search
match只提供了從文本串起始位置匹配的結果，如果想從任意位置匹配，則可調用search方法，與match方法類似，當任意位置匹配成功，則立即返回一個匹配對象，也可調用span()方法獲取起止區間、調用group方法獲得匹配文本串
import re pattern = re.compile(r'\s[a-z]{2}') text1 = 'this is a re test' res = pattern.search(text1) print(res) # if res: print(res.group()) #is print(res.span()) #(4, 7) pattern2 = re.compile(r'\s[a-z]{5}') text2 = '是的,this is a re test' print(pattern2.search(text2))#None
match和search均用於匹配單個結果，唯一區別在於前者是從起始位置開始匹配，而後者從任意位置匹配，匹配成功則返回一個match對象。
全搜索：findall/finditer
幾乎是最常用的正則表達式函數，用於尋找所有匹配的結果，例如在爬蟲信息提取中，可非常方便地提取所有匹配欄位
import re pattern = re.compile(r'\s[a-z]{2,5}') text1 = 'this is a re test' res = pattern.findall(text1) print(res) #[' is', ' re', ' test']
findall返回的是一個列表對象類型，當無匹配對象時，返回一個空列表。為了避免因同時返回大量匹配結果佔用過多內存，可以調用finditer函數返回一個迭代器類型，其中每個迭代元素是一個match對象，可繼續調用group和span方法獲取相應結果
import re pattern = re.compile(r'\s[a-z]{2,5}') text1 = 'this is a re test' res = pattern.finditer(text1) for r in res: print(r.group()) """ is re test """
當匹配模式串較為簡單或者僅需單詞調用時，上述所有方法也可直接調用re類函數，而無需事先編譯。此時各方法的第一個參數為模式串。
import re pattern = re.compile(r'\d{2,5}') text = 'this is re test' re.findall('[a-z]+', text) #['this', 'is', 're', 'test'] 03 字元串替換/分割
替換:sub/subn
當需要對文本串進行條件替換時，可調用re.sub實現 (當然也可先編譯後再用調用實例方法) ，相應參數分別為模式串、替換格式、文本串，還可以通過增加預設參數限定替換次數和匹配模式。通過在模式串進行分組，可實現字元串的格式化替換（類似字元串的format方法），以實現特定任務。
import re text = 'today is 2020-03-05' print(re.sub('-', '', text)) #'today is 20200305' print(re.sub('-', '', text, 1)) #'today is 202003-05' print(re.sub('(\d{4})-(\d{2})-(\d{2})', r'\2/\3/\1', text)) #'today is 03/05/2020'
re.sub的一個變形方法是re.subn，區別是返回一個2元素的元組，其中第一個元素為替換結果，第二個為替換次數
import re text = 'today is 2020-03-05' print(re.subn('-', '', text)) #('today is 20200305', 2)
分割：split
還可以調用正則表達式實現字元串的特定分割，相當於.split()方法的一個加強版，實現特定模式的分割，返回一個切割後的結果列表
import re text = 'today is a re test, what do you mind?' print(re.split(',', text)) #['today is a re test', ' what do you mind?'] 04 總結
python中的re模塊提供了正則表達式的常用方法，每種方法都包括類方法調用(如re.match)或模式串的實例調用(pattern.match)2種形式
常用的匹配函數：match/fullmatch
常用的搜索函數：search/findall/finditer
常用的替換函數：sub/subn
常用的切割函數：split
還有其他很多方法，但不是很常用，具體可參考官方文檔
另外，python還有第三方正則表達式庫regex可供選擇
到此這篇關於一文秒懂python正則表達式常用函數的文章就介紹到這了，希望大家以後多多支持！
㈥ Python re正則表達式模塊及其用法
1.第一個參數是正則表達式,這里為"(\w+)\s",如果匹配成功,則返回一個Match,否則返回一個None;
2.第二個參數表示要匹配的字元串;
3.第三個參數是標致位,用於控制正則表達式的匹配方式,如:是否區分大小寫,多行匹配等等。 re.search函數會在字元串內查找模式匹配,只到找到第一個匹配然後返回,如果...
4.第四個參數指替換個數。默認為0,表示每個匹配項都替換。 re.sub還允許使用函數對匹配...
㈦ Python 標准庫模塊 - re
正則表達式引擎對正則表達式文本進行編譯生成正則表達式對象，再由正則表達式對象對目標文本進行匹配，後返回匹配結果。
正則表達式中一共包含 2 中字元： 普通字元 、 元字元
匹配單個字元的元字元及其含義：
匹配重復性的元字元及其含義：
匹配位置的元字元及其含義：
分組匹配的元字元及其含義：
表示或運算的元字元：
轉義元字元：
在 Python 中使用正則表達式，我們需要藉助 re 模塊提供的強大 API，下面我們就來學習幾個 re 模塊常用的介面吧~
參數說明： findall("正則表達式", "要匹配的字元串", flags=標志1|標志2|...)
返回值：以列表形式返回匹配到的字元串。
下面，我們用 findall 返回 Python 之禪中首尾用到的反義詞：
運行結果：
當正則表達式中含有一個以上分組時， findall 返回的列表由元組構成，元組中包含每個分組匹配到的內容。如果只有一個分組，則返回由該分組匹配到的內容組所構成的列表：
match 函數返回的結果是一個 SRE_Match 對象：
SRE_Match 具有很多的屬性，比如 .string 屬性可以方便我們我獲取在匹配時輸入的字元串：
屬性 .re 可以獲取匹配時使用的編譯後的正則表達式模式：
由於默認使用了 re.UNICODE ，所以我們這里的 w 可以匹配中文字元。
屬性 .regs 則以列表的形式返回正則表達式匹配到的內容以及各個分組陪陪到的內容，不過請注意，返回的都是索引的形式：
可以使用序列切片來看一下我們的正則表達式及其中的兩個分組所匹配到的內容：
SRE_Match 對象也提供了非常多好用的方法，比如 groups 可以獲取各個分組匹配到的內容：
group 則可以靈活地獲取正則表達式或對應分組匹配到的內容：
如果使用的正則表達式定義了分組的名稱， group 還可以通過名稱獲取相應分組匹配的內容：
在定義了分組的名稱之後，還可以方便地使用 groupdict 以字典的形式返回所有分組匹配的結果：
最後需要注意的是， match 從字元串的開頭開始匹配，如果開頭不符合要求，則直接返回 None 。
與 match 匹配開頭不同， search 匹配第一個符合規則的字元串，未成功則返回 None 。參數： re.search(pattern, string, flags=0) ；返回值同 match 。
在介紹 match 的使用時，最後一個例子，由於我們在字元串前面添加了 'PYTHON' 導致 match 使用原來的正則表達式無法匹配，返回 None 。此時，使用 search 就可以迎刃而解啦：
運行結果：
小結：
參數： re.split(pattern, string, maxsplit=0, flags=0) ， split 功能非常強大，以正則表達式匹配到的標志來分隔字元串，比如下面這樣一個混亂的字元串，我們要提取其中所有的數字：
下面，我們就來詳細介紹一下 split 的用法。
首先，是以單字元切割：
以分號切割時，共產生了 4 個子字元串，放在列表中返回。
下面，還是以單字元切割，但可以使用正則表達式中的 [] 來指定多種字元：
由於字元串 line 中有連續的 2 個分號，逗號或者空格，因此可以使用 [;s,]+ 來切割：
最後，上面的字元串在切割時，分隔符都沒有被保留下來，使用括弧捕獲分組，即可保留分隔符：
re.sub 提供比字元串的 replace 方法更加強大的功能：對於輸入的字元串 string ,利用正則表達式 pattern 強大的字元串處理功能，實現復雜的字元串替換處理為 repl ，返回被替換後的字元串。
下面的例子中，我們將句子中多餘的空格和數字去掉：
如果想要知道替換過程中，共發生了多少次替換，可以使用 subn ：
小結：
上述的案例中，我們每次都需要傳入正則表達式，相應的函數每次在調用時，都需要編譯一次正則表達式。如果上述過程需要多次重復，那麼每次都去耗費時間編譯正則表達式是很不劃算的。
re 模塊為我們提供了 compile 函數，用來編譯正則表達式模式，返回編譯好模式。因此，可以把那些常用的正則表達式編譯成正則表達式對象，以提高效率。
格式： re.compile(pattern, flags=0) ，其中 pattern 為編譯時用的表達式字元串， flags 為編譯標志位，用於修改正則表達式的匹配方式，如：是否區分大小寫，多行匹配等。常用的 flags 有：
註：使用按位或 | 連接多個 flags 。
我們上述介紹的 re 模塊的匹配、分割、替換函數， compile 函數的返回值類提供了相應的方法，使用方式類似，只是不需要傳入正則表達式字元串而已。
由於用法幾乎一致，這里就不一一舉例啦~
貪婪模式 ： * + ? {m,n} ，正則表達式的重復默認總是盡可能多得向後匹配內容。
非貪婪模式 ： *? +? ?? {m,n}? ，盡可能少的匹配內容。