正規表示式語法¶

一個正規表示式（或 RE）會指定一組匹配它的字串；這個模組的函式讓你可以檢查一個特定的字串是否匹配給定的正規表示式（或是給定的正規表示式是否匹配特定的字串，說到底是一樣的）。

正規表示式可以被連接 (concatenated) 成新的正規表示式；如果A 和B 都是正規表示式，則AB 也是一個正規表示式。一般來說，如果一個字串p 與A 匹配，並且另一個字串q 與B 匹配，則字串pq 會匹配 AB。或：這在以下情況下不成立：A*或 *B 包含低優先順序的運算子；或A 和B 之間的邊界條件 (boundary conditions)；或是有編號群組 (numbered group) 的參照。因此，複雜的正規表示式可以輕鬆地從此處提到的簡單原始正規表示式建立。關於正規表示式的理論和實作，請參考 Friedl 書[Frie09]，或任何有關建構編譯器的書籍。

一個簡短的正規表示式格式解釋如下。如需更多資訊或以較平易的方式了解，請參閱如何使用正規表示式。

正規表示式可以包含特殊和一般字元。大多數一般字元，如'A'、'a' 或'0' 是最簡單的正規表示式；它們只匹配它們自己。你可以連接一般字元，讓last 匹配字串'last'。（在本節的其餘部分，我們會用通常沒有引號的這種特殊樣式 來書寫正規表示式，而被匹配的字串會'在單引號中'。）

某些字元是特殊的，像'|' 或'('。特殊字元會代表一般字元的類別，或是會影響它們周圍正規表示式的解讀方法。

重複運算子或量詞 (quantifiers)（*,+,?,{m,n} 等）不能直接嵌套使用。這樣避免了和非貪婪修飾符號後綴? 和其他實作中的修飾符號的模糊性。要在一個重複正規表示式內添加第二個重複，可以使用括號。例如：正規表示式(?:a{6})* 會匹配任何六的倍數個a 字元。

特殊字元包含：

.

（點） 在預設模式下，這會匹配除換行符號外的任何字元。如果指定了DOTALL 旗標，這會匹配包含換行符號的任何字元。無論旗標為何，(?s:.) 都會匹配任何字元。

^

（插入符號） 會匹配字串的開頭，並且在MULTILINE 模式下，也會立即匹配緊接在每個換行符號之後的位置。

$

匹配字串的結尾或是字串結尾的換行符號之前，並且在MULTILINE 模式下會匹配換行符號之前的位置。foo 會匹配 'foo' 和 'foobar'，而正規表示式foo$ 只會匹配 'foo'。更有趣的是，在'foo1\nfoo2\n' 中搜尋foo.$，正常情況下會匹配 'foo2'，但是在MULTILINE 模式下會匹配 'foo1'；在'foo\n' 中搜尋單一個$ 會找到兩個（空的）匹配：一個在換行符號之前，一個在字串結尾。

*

使得到的正規表示式匹配前面正規表示式的 0 或多次的重複，盡可能多次的重複。ab* 會匹配 'a'、'ab'，或後面跟著任何數量個 'b' 的 'a'。

+

使得到的正規表示式匹配前面正規表示式的 1 或多次的重複。ab+ 會匹配後面跟著任何非零數量個 'b' 的 'a'；它不會匹配 'a'。

?

使得到的正規表示式匹配前面正規表示式的 0 或 1 次的重複。ab? 會匹配 'a' 或 'ab'。

*?,+?,??

量詞 (quantifier)'*'、'+' 和'?' 都是greedy（貪婪的）；它們會盡可能地匹配更多文字。有時候這種行為不是預期的；如果正規表示式<.*> 被用來匹配'<a>b<c>'，它會匹配整個字串，而不只是'<a>'。在量詞後添加? 會讓他以non-greedy（非貪婪的）或minimal（最小的）方式進行匹配；盡可能匹配更少的字元。使用正規表示式<.*?> 只會匹配到'<a>'。

*+,++,?+

類似於量詞'*'、'+' 和'?'，添加了'+' 的量詞也會盡可能多次的匹配。然而，不同於真正的貪婪量詞，這些量詞在接續的正規表示式匹配失敗時不允許回溯 (back-tracking)。這些量詞被稱為possessive （佔有的）量詞。例如，a*a 會匹配'aaaa'，因為a* 會匹配全部 4 個'a'，但是在遇到最後的'a' 時，此正規表示式會回溯，以讓a* 最終可以總共匹配 3 個'a'，而第四個'a' 會被最後的'a' 匹配。然而，當a*+a 被用來匹配'aaaa' 時，a*+ 會匹配全部 4 個'a'，但是當最終的'a' 在尋找更多字元匹配失敗時，此正規表示式不能回溯並會因此匹配失敗。x*+、x++ 和x?+ 分別等同於(?>x*)、(?>x+) 和(?>x?)。

在 3.11 版被加入.

{m}

指定應該恰好匹配m 個前面的正規表示式；太少的匹配會造成整個正規表示式匹配失敗。例如，a{6} 會匹配恰好六個'a' 字元，但不匹配五個。

{m,n}

使得到的正規表示式重複匹配前面的正規表示式m 到n 次，並嘗試盡可能多次的匹配。例如，a{3,5} 會匹配 3 到 5 個'a' 字元。忽略m 會指定下限為零，且忽略n 會指定無限大的上限。舉例來說，a{4,}b 會匹配'aaaab' 或一千個'a' 字元加上一個'b'，但是不匹配'aaab'。不可以忽略逗號，否則量詞會與前述的形式混淆。

{m,n}?

使得到的正規表示式重複匹配前面的正規表示式m 到n 次，嘗試盡可能更少次的匹配。這是上一個量詞的非貪婪版本。例如，對六個字元的字串'aaaaaa'，a{3,5} 會匹配 5 個'a' 字元，而a{3,5}? 只會匹配 3 個字元。

{m,n}+

使得到的正規表示式重複匹配前面的正規表示式m 到n 次，並嘗試盡可能更多次的匹配而不建立任何回溯點。這是上述量詞的佔有版本。例如，對六個字元的字串'aaaaaa'，a{3,5}+aa 嘗試匹配 5 個'a' 字元，然後需要再 2 個'a'，會需要比可用的字元更多所以失敗，而a{3,5}aa 會捕捉到 5 個'a'，然後回溯成 4 個'a'，接著最後兩個'a' 會被模式中最後的aa 匹配。x{m,n}+ 等同於(?>x{m,n})。

在 3.11 版被加入.

\

用來跳脫特殊字元（允許你匹配如'*'、'?' 等字元），或是表示一個特殊序列；特殊序列將在下方討論。

如果你沒有使用原始字串來表示正規表示式，請記得 Python 也會使用反斜線作為字串文本的跳脫序列；如果 Python 的剖析器辨認不出該跳脫序列，反斜線和接續的字元將會被包含在得到的字串中。然而，如果 Python 能辨認出該序列，反斜線應該要被重複兩次。這很複雜並且難以理解，所以強烈建議，除了最簡單的正規表示式，都應該使用原始字串。

[]

用來表示一個字元集合。在一個集合中：

• 字元可以獨立列出，例如：[amk] 會匹配'a'、'm' 或'k'。

• 可以透過給定兩個字元並且使用'-' 分隔它們來表示一個範圍的字元，例如[a-z] 會匹配任何 ASCII 小寫字母，[0-5][0-9] 會匹配所有從00 到59 的兩位數字，而[0-9A-Fa-f] 會匹配任何十六進位數字。如果- 被跳脫了（如：[a\-z]） 或是放在第一或最後一個位置（如：[-a] 或[a-]），它將會匹配字面的'-'。

• 除反斜線外的特殊字元會在集合內失去它們的特殊意義。例如，[(+*)] 會匹配任何字面字元'('、'+'、'*'，或')'。

• 反斜線可能用於跳脫集合內具有特殊意義的字元，像是'-'、']'、'^' 和'\\' 本身，或是表示一個代表單一字元的特殊序列，像是\xa0 或\n 或一個字元類別，如\w 或\S（定義如下）。請注意，\b 代表單一個 "backspace" 字元，而不是在集合外代表的字元邊界，且像是\1 的數值跳脫總是代表八進位數字的跳脫，而不是群組的參照。不匹配單一字元的特殊序列是不被允許的，像是\A 和\Z。

• 不在範圍內的字元可以透過取集合的補集 (complement) <complementing> 匹配。如果集合中的第一個字元是'^'，所有不在集合內的字元都會被匹配。例如，[^5] 會匹配任何除了'5' 的字元，而[^^] 會匹配任何除了'^' 的字元。如果^ 不是集合中的第一個字元的話，沒有特殊意義。

• 要在集合中匹配字面的']'，在前面加上一個反斜線，或是將它放在集合中的最前面。例如，[()[\]{}] 和[]()[{}] 都會匹配右方括號、左方括號、花括號和括號。

• 未來可能會支援Unicode Technical Standard #18 中的嵌套集合與集合操作。這會改變語法，所以為了促進這個改變，暫時會在模糊的情況下引發FutureWarning。包含了以字面'[' 開頭，或是包含字面的字元序列'--'、'&&'、'~~' 和'||' 的集合。為了避免警告，請用反斜線跳脫它們。

在 3.7 版的變更:如果一個字元集合包含了其語義未來會被改變的結構，FutureWarning 會被引發。

|

A|B，其中A 和B 可以為任何正規表示式，會創造出一個匹配A 或是B 的正規表示式。任何數量的正規表示式可以像這樣用'|' 分隔。這也可以用在群組（見下文）中。當目標字串被掃描時，被'|' 分隔的正規表示式會被從左到右嘗試。當一個模式完全匹配時，那條分支就被接受了。這代表一旦A 匹配了，B 就不會被進一步測試，就算它會讓整個匹配更長。換句話說，'|' 永遠不是貪婪的。要匹配字面的'|'，使用\|，或是將它包圍在一個字元類別中，就像[|]。

(...)

匹配括號中的任何正規表示式，並且表示一個群組的開始和結束；群組的內容可以在執行匹配後取得，並且在後續的字串可以使用\number 特殊序列來匹配，如下所述。要匹配字面的'(' 或')'，用\( 或\)，或是將它們包圍在一個字元類別中：[(、[)]。

(?...)

這是一個擴充表示法（否則一個'?' 接著一個'(' 是沒有意義的）。'?' 後面的第一個字元決定了這個結構的意義和進一步的語法。擴充通常不會創造新的群組；(?P<name>...) 是這個規則的唯一例外。以下是目前支援的擴充。

(?aiLmsux)

（集合'a'、'i'、'L'、'm'、's'、'u'、'x' 中的一或多個字母。）該群組會匹配空字串；這些字母會為整個正規表示式設定對應的旗標。

• re.A（僅限 ASCII 字元匹配）

• re.I（忽略大小寫）

• re.L（依賴區域設定）

• re.M（多行）

• re.S（點會匹配所有字元）

• re.U（匹配 Unicode）

• re.X（詳盡模式）

（這些旗標在模組內容 中說明。）如果你想將旗標當作正規表示式的一部分，而不是傳遞一個flag 引數給re.compile() 函式的話，這會有幫助。旗標應該首先在正規表示式字串中使用。

在 3.11 版的變更:此結構只能用於正規表示式的開頭。

(?:...)

一個非捕捉版本的普通括號。匹配括號內的任何正規表示式，但是被群組匹配到的子字串不能在執行匹配後被取得，或是在之後的模式中被參照。

(?aiLmsux-imsx:...)

（集合'a'、'i'、'L'、'm'、's'、'u'、'x' 中的零或多個字母，選擇性地接著'-'，並接著一或多個'i'、'm'、's'、'x' 中的字母。）該字母集合會為那一部分的正規表示式設定或是移除對應的旗標。

• re.A（僅限 ASCII 字元匹配）

• re.I（忽略大小寫）

• re.L（依賴區域設定）

• re.M（多行）

• re.S（點會匹配所有字元）

• re.U（匹配 Unicode）

• re.X（詳盡模式）

（這些旗標在模組內容 中說明。）

字母'a'、'L' 和'u' 在被當作嵌入旗標時是互斥的，所以它們不能被組合使用或是接在'-' 後面。相反地，當它們其中一個出現在嵌入群組時，它會覆蓋括號中群組的匹配模式。在 Unicode 模式中，(?a:...) 會切換到僅匹配 ASCII 模式，且(?u:...) 會切換到 Unicode 匹配模式（預設）。在位元組模式，(?L:...) 會切換到依賴區域設定 (locale) 的匹配，且(?a:...) 會切換到僅匹配 ASCII 模式（預設）。這個覆蓋只會在嵌入群組中作用，而原本的匹配模式會在群組外恢復。

在 3.6 版被加入.

在 3.7 版的變更:字母'a'、'L' 和'u' 也可以被用在群組中。

(?>...)

嘗試將... 視為獨立的正規表示式進行匹配，且若成功則會繼續匹配後續的模式。如果後續模式匹配失敗，則回溯堆疊 (stack) 只能還原 (unwound) 到(?>...)之前，因為一旦退出了，這個也叫做原子群組 (atomic group) 的正規表示式，已經丟棄了它自己的所有回溯點 (stack point)。因此，(?>.*). 永遠不會匹配任何內容，因為.* 會先盡可能匹配所有的字元，接著沒有任何剩餘內容可以匹配，導致最終的. 匹配失敗。因為原子群組中沒有儲存回溯點，而且群組之前也沒有回溯點，整個正規表示式都會匹配失敗。

在 3.11 版被加入.

(?P<name>...)

類似於一般的括號，但是這個群組匹配的子字串可以透過符號群組名稱name 存取。群組名稱必須是有效的 Python 識別字 (identifier)，並且在bytes 模式中，它們只能包含 ASCII 範圍中的位元組。每個群組名稱在正規表示式中只能定義一次。一個符號群組同時也是一個編號群組，只是等同於該群組沒有名稱。

命名群組 (named groups) 可以在三種情境下被參照。如果該模式是(?P<quote>['"]).*?(?P=quote)（也就是匹配一個用單引號或雙引號包圍的字串）：

對 "quote" 群組參照的情境	參照方式
在同一個模式中	(?P=quote)（如上例所示） \1
在處理匹配物件m 時	m.group('quote') m.end('quote')（等）
在被當成re.sub() 的repl 引數傳入的字串中	\g<quote> \g<1> \1

在 3.12 版的變更:在bytes 模式中，群組的名稱只能包含 ASCII 範圍中的位元組（b'\x00'-b'\x7f'）。

(?P=name)

對於命名群組的反向參照；它會匹配任何之前被命名為name 的群組所匹配到的文字。

(?#...)

一個註解；括號中的內容會被忽略。

(?=...)

如果字串接下來可以匹配... 才會成功匹配，但是並不會消耗任何字串。這被稱作lookahead assertion。例如，Isaac(?=Asimov) 只在後面跟著'Asimov' 時才會匹配'Isaac'。

(?!...)

如果字串接下來不匹配...，才會成功匹配。這是一個負向預查斷言 (negative lookahead assertion) <negative lookahead assertion>。例如，Isaac(?!Asimov) 只在後面不跟著'Asimov' 時才會匹配'Isaac'。

(?<=...)

如果目前位置前方的字串能夠匹配...，可以成功匹配。這叫做正向回查斷言 (positive lookbehind assertion) <positive lookbehind assertion>。(?<=abc)def 會在'abcdef' 中找到一個匹配，因為回查會向後 3 個字元，並檢查是否能匹配包含的模式。這個包含的模式只能匹配固定長度的字串，代表abc 或a|b 是被允許的，但是a* 和a{3,4} 不被允許。請注意，使用正向回查斷言開頭的模式不會匹配被搜尋字串的開頭；你更可能想要使用search() 函式而不是match() 函式：

>>>importre>>>m=re.search('(?<=abc)def','abcdef')>>>m.group(0)'def'

這個範例在尋找連字號後的單字：

>>>m=re.search(r'(?<=-)\w+','spam-egg')>>>m.group(0)'egg'

在 3.5 版的變更:新增固定長度群組參照的支援。

(?<!...)

如果目前位置前方的字串不能夠匹配...，可以成功匹配。這叫做負向回查斷言 (negative lookbehind assertion) <negative lookbehind assertion>。類似於正向回查斷言，包含的模式只能匹配固定長度的字串。使用負向回查斷言開頭的模式可以匹配被搜尋字串的開頭。

(?(id/name)yes-pattern|no-pattern)

如果給定id 或name 的群組存在，會嘗試匹配yes-pattern，否則會匹配no-pattern。no-pattern 是可選的並且可以省略。例如，(<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) 是一個不好的電子郵件匹配模式，它會匹配'<user@host.com>' 和'user@host.com'，但不會匹配'<user@host.com' 以及'user@host.com>'。

在 3.12 版的變更:群組id 只能包含 ASCII 數字。在bytes 模式中，群組name 只能包含 ASCII 範圍中的位元組 (b'\x00'-b'\x7f')。

特殊序列由'\' 和下列清單的一個字元組成。如果序列中的一般字元不是一個 ASCII 數字或是一個 ASCII 字母，那麼產生的的正規表示式會匹配第二個字元。例如，\$ 會匹配字元'$'。

\number

匹配相同數字群組中的內容。群組會從 1 開始編號。例如，(.+)\1 會匹配'thethe' 或'5555'，但不會匹配'thethe'（注意群組後的空格）。這個特殊序列只能用來匹配前 99 個群組之一。如果number 的第一位數是 0，或是number 有 3 個八進位位數，它就不會被解讀成匹配群組，而是解讀成八進位數值number 的字元。在一個字元類別中的'[' 和']'，所有數值的跳脫字元都會被當作字元。

\A

只在字串的開頭匹配。

\b

匹配空字串，但是只在一個單字的開頭或結尾。一個單字被定義為一個單字字元的序列。請注意在正式情況下，\b 被定義為\w 和一個\W 字元的邊界（或是反之亦然），或是在\w 和字串的開頭或結尾之間。這表示r'\bat\b' 會匹配'at'、'at.'、'(at)'，以及'asatay'，但是不匹配'attempt' 或'atlas'。

預設的單字字元在 Unicode（字串）模式中，是 Unicode 字母數字 (alphanumerics) 和底線，但是這可以透過使用ASCII 旗標來改變。如果使用了LOCALE 旗標，單字的邊界會由目前的區域設定決定。

備註

在字元範圍中，為了與 Python 的字串文本的相容性，\b 表示 backspace 字元。

\B

匹配空字串，但是只有在空字串不在單字的開頭或結尾時匹配。這表示r'at\B' 會匹配'athens'、'atom'、'attorney'，但是不匹配'at'、'at.' 或'at!'。\B 是\b 的相反，所以 Unicode（字串）模式中的單字字元是 Unicode 字母、數字或底線，不過這可以透過使用ASCII 旗標來改變。如果使用了LOCALE 旗標，單字的邊界會由目前的區域設定決定。

在 3.14 版的變更:\B 現在會匹配空的輸入字串。

\d

對於 Unicode（字串）模式：

匹配任何 Unicode 十進位數字（也就是 Unicode 字元類別中的任何字元[Nd]）。這包含了[0-9]，以及許多許多其他的數字字元。

如果使用了ASCII 旗標，匹配[0-9]。

對於 8 位元（位元組）模式：

匹配任何 ASCII 字元集合中的十進位數字；這等同於[0-9]。

\D

匹配任何不是十進位數字的字元。這是\d 的相反。

如果使用了ASCII 旗標，會匹配[^0-9]。

\s

對於 Unicode（字串）模式：

匹配 Unicode 空格字元（在str.isspace() 中定義）。包含[\t\n\r\f\v]，還有許多其他的字元，例如許多語言的排版規則中要求的不換行空格。

如果使用了ASCII 旗標，匹配[\t\n\r\f\v]。

對於 8 位元（位元組）模式：

匹配 ASCII 字元集合中認定的空格；這等同於[\t\n\r\f\v]。

\S

匹配任何不是空格字元的字元。這是\s 的相反。

如果使用了ASCII 旗標，匹配[^\t\n\r\f\v]。

\w

對於 Unicode（字串）模式：

匹配 Unicode 單字字元；這包含全部 Unicode 的字母數字字元（在str.isalnum() 中定義），以及底線 (_)。

如果使用了ASCII 旗標，匹配[a-zA-Z0-9_]。

對於 8 位元（位元組）模式：

匹配在 ASCII 字元集合中被認定為字母或數字的字元；這等同於[a-zA-Z0-9_]。如果使用了LOCALE 旗標，會匹配目前區域設定中被認定為字母或數字的字元，以及底線。

\W

匹配任何不是單字字元的字元。這是\w 的相反。預設情況下，會匹配任何不是底線 (_)，並且str.isalnum() 會回傳False 的字元。

如果使用了ASCII 旗標，會匹配[^a-zA-Z0-9_]。

如果使用了LOCALE 旗標，會匹配目前區域中不是字母數字，也不是底線的字元。

\z

只在字串的結尾匹配。

在 3.14 版被加入.

\Z

和\z 相同。為了與舊版的 Python 相容而保留。

大多數 Python 的字串文本支援的跳脫序列也能被正規表示式剖析器接受：

\a      \b      \f      \n\N      \r      \t      \u\U      \v      \x      \\

（請注意\b 被用來表示單字邊界，並且只在字元類別內表示 "backspace"。）

'\u'、'\U'，和'\N' 跳脫序列只會在 Unicode（字串）模式中可辨認。在位元組模式中，它們是錯誤。未知的跳脫 ASCII 字母被保留於未來使用，並且會被當成錯誤。

八進位數的跳脫被有限地包含在內。如果第一個數字是一個 0，或是如果有三個八進位數字，它就會被當作是一個八進位跳脫。否則，它是一個群組參照。至於字串文本，八進位跳脫最多只能包含三個數字。

模組內容¶

The module defines several functions, constants, and an exception. Some of thefunctions are simplified versions of the full featured methods for compiledregular expressions. Most non-trivial applications always use the compiledform.

正規表示式物件¶

classre.Pattern¶

由re.compile() 回傳的已編譯正規表示式物件。

在 3.9 版的變更:re.Pattern 支援[] 以表示 Unicode（字串）或位元組模式。請參閱泛型別名型別。

Pattern.search(string[,pos[,endpos]])¶

掃描string 以尋找此正規表示式產生匹配的第一個位置，並回傳對應的Match。如果字串中沒有與模式匹配的位置則回傳None；請注意，這與在字串中的某個點查找零長度匹配不同。

可選的第二個參數pos 提供字串中的索引，表示要從哪裡開始搜尋；預設值為0。這並不完全等同於對字串進行切片；'^' 模式字元會在字串的實際開頭和換行之後的位置匹配，但不一定是在要開始搜尋的索引處。

可選的參數endpos 限制了字串將被搜尋的範圍；就好像字串的長度為endpos 個字元一樣，因此只有從pos 到endpos-1 的字元會被搜尋以尋找匹配項。如果endpos 小於pos，則不會找到匹配項；否則，如果rx 是已編譯的正規表示式物件，則rx.search(string,0,50) 等價於rx.search(string[:50],0)。

>>>pattern=re.compile("d")>>>pattern.search("dog")# 在索引 0 處匹配<re.Match object; span=(0, 1), match='d'>>>>pattern.search("dog",1)# 無匹配；搜尋不包含 "d"

Pattern.match(string[,pos[,endpos]])¶

如果在string 的開頭處有零個或多個字元與此正規表示式匹配，則回傳對應的Match。如果字串與模式不匹配，則回傳None；請注意，這與零長度匹配不同。

可選的pos 和endpos 參數與search() 方法中的參數具有相同的意義。

>>>pattern=re.compile("o")>>>pattern.match("dog")# 無匹配，因為 "o" 不在 "dog" 的開頭。>>>pattern.match("dog",1)# 匹配，因為 "o" 是 "dog" 的第二個字元。<re.Match object; span=(1, 2), match='o'>

如果你想在string 中的任何位置找到匹配，請改用search()（另請參閱search() vs. match()）。

Pattern.fullmatch(string[,pos[,endpos]])¶

如果整個string 與此正規表示式匹配，則回傳對應的Match。如果字串與模式不匹配，則回傳None；請注意，這與零長度匹配不同。

可選的pos 和endpos 參數與search() 方法中的參數具有相同的意義。

>>>pattern=re.compile("o[gh]")>>>pattern.fullmatch("dog")# 無匹配，因為 "o" 不在 "dog" 的開頭。>>>pattern.fullmatch("ogre")# 無匹配，因為整個字串不匹配。>>>pattern.fullmatch("doggie",1,3)# 在給定限制內匹配。<re.Match object; span=(1, 3), match='og'>

在 3.4 版被加入.

Pattern.split(string,maxsplit=0)¶

和split() 函式相同，使用已編譯的模式。

Pattern.findall(string[,pos[,endpos]])¶

類似於findall() 函式，使用已編譯的模式，但也接受可選的pos 和endpos 參數，這些參數會像search() 一樣限制搜尋區域。

Pattern.finditer(string[,pos[,endpos]])¶

類似於finditer() 函式，使用已編譯的模式，但也接受可選的pos 和endpos 參數，這些參數會像search() 一樣限制搜尋區域。

Pattern.sub(repl,string,count=0)¶

和sub() 函式相同，使用已編譯的模式。

Pattern.subn(repl,string,count=0)¶

和subn() 函式相同，使用已編譯的模式。

Pattern.flags¶

正規表示式匹配旗標。這是傳遞給compile() 的旗標、模式中的任何(?...) 內嵌旗標以及隱含旗標（例如如果模式是 Unicode 字串則為UNICODE）的組合。

Pattern.groups¶

模式中捕獲群組的數量。

Pattern.groupindex¶

一個字典，將任何由(?P<id>) 定義的符號群組名稱對映到群組編號。如果模式中未使用符號群組，則字典為空。

Pattern.pattern¶

從中編譯出模式物件的模式字串。

Match Objects¶

Match objects always have a boolean value ofTrue.Sincematch() andsearch() returnNonewhen there is no match, you can test whether there was a match with a simpleif statement:

match=re.search(pattern,string)ifmatch:process(match)

classre.Match¶

Match object returned by successfulmatches andsearches.

在 3.9 版的變更:re.Match supports[] to indicate a Unicode (str) or bytes match.See泛型別名型別.

Match.expand(template)¶

Return the string obtained by doing backslash substitution on the templatestringtemplate, as done by thesub() method.Escapes such as\n are converted to the appropriate characters,and numeric backreferences (\1,\2) and named backreferences(\g<1>,\g<name>) are replaced by the contents of thecorresponding group. The backreference\g<0> will bereplaced by the entire match.

在 3.5 版的變更:不匹配的群組將被替換為空字串。

Match.group([group1,...])¶

Returns one or more subgroups of the match. If there is a single argument, theresult is a single string; if there are multiple arguments, the result is atuple with one item per argument. Without arguments,group1 defaults to zero(the whole match is returned). If agroupN argument is zero, the correspondingreturn value is the entire matching string; if it is in the inclusive range[1..99], it is the string matching the corresponding parenthesized group. If agroup number is negative or larger than the number of groups defined in thepattern, anIndexError exception is raised. If a group is contained in apart of the pattern that did not match, the corresponding result isNone.If a group is contained in a part of the pattern that matched multiple times,the last match is returned.

>>>m=re.match(r"(\w+) (\w+)","Isaac Newton, physicist")>>>m.group(0)# The entire match'Isaac Newton'>>>m.group(1)# The first parenthesized subgroup.'Isaac'>>>m.group(2)# The second parenthesized subgroup.'Newton'>>>m.group(1,2)# Multiple arguments give us a tuple.('Isaac', 'Newton')

If the regular expression uses the(?P<name>...) syntax, thegroupNarguments may also be strings identifying groups by their group name. If astring argument is not used as a group name in the pattern, anIndexErrorexception is raised.

A moderately complicated example:

>>>m=re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)","Malcolm Reynolds")>>>m.group('first_name')'Malcolm'>>>m.group('last_name')'Reynolds'

Named groups can also be referred to by their index:

>>>m.group(1)'Malcolm'>>>m.group(2)'Reynolds'

If a group matches multiple times, only the last match is accessible:

>>>m=re.match(r"(..)+","a1b2c3")# Matches 3 times.>>>m.group(1)# Returns only the last match.'c3'

Match.__getitem__(g)¶

This is identical tom.group(g). This allows easier access toan individual group from a match:

>>>m=re.match(r"(\w+) (\w+)","Isaac Newton, physicist")>>>m[0]# The entire match'Isaac Newton'>>>m[1]# The first parenthesized subgroup.'Isaac'>>>m[2]# The second parenthesized subgroup.'Newton'

Named groups are supported as well:

>>>m=re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)","Isaac Newton")>>>m['first_name']'Isaac'>>>m['last_name']'Newton'

在 3.6 版被加入.

Match.groups(default=None)¶

Return a tuple containing all the subgroups of the match, from 1 up to howevermany groups are in the pattern. Thedefault argument is used for groups thatdid not participate in the match; it defaults toNone.

舉例來說：

>>>m=re.match(r"(\d+)\.(\d+)","24.1632")>>>m.groups()('24', '1632')

If we make the decimal place and everything after it optional, not all groupsmight participate in the match. These groups will default toNone unlessthedefault argument is given:

>>>m=re.match(r"(\d+)\.?(\d+)?","24")>>>m.groups()# Second group defaults to None.('24', None)>>>m.groups('0')# Now, the second group defaults to '0'.('24', '0')

Match.groupdict(default=None)¶

Return a dictionary containing all thenamed subgroups of the match, keyed bythe subgroup name. Thedefault argument is used for groups that did notparticipate in the match; it defaults toNone. For example:

>>>m=re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)","Malcolm Reynolds")>>>m.groupdict(){'first_name': 'Malcolm', 'last_name': 'Reynolds'}

Match.start([group])¶

Match.end([group])¶

Return the indices of the start and end of the substring matched bygroup;group defaults to zero (meaning the whole matched substring). Return-1 ifgroup exists but did not contribute to the match. For a match objectm, anda groupg that did contribute to the match, the substring matched by groupg(equivalent tom.group(g)) is

m.string[m.start(g):m.end(g)]

Note thatm.start(group) will equalm.end(group) ifgroup matched anull string. For example, afterm=re.search('b(c?)','cba'),m.start(0) is 1,m.end(0) is 2,m.start(1) andm.end(1) are both2, andm.start(2) raises anIndexError exception.

An example that will removeremove_this from email addresses:

>>>email="tony@tiremove_thisger.net">>>m=re.search("remove_this",email)>>>email[:m.start()]+email[m.end():]'tony@tiger.net'

Match.span([group])¶

For a matchm, return the 2-tuple(m.start(group),m.end(group)). Notethat ifgroup did not contribute to the match, this is(-1,-1).group defaults to zero, the entire match.

Match.pos¶

The value ofpos which was passed to thesearch() ormatch() method of aregex object. This isthe index into the string at which the RE engine started looking for a match.

Match.endpos¶

The value ofendpos which was passed to thesearch() ormatch() method of aregex object. This isthe index into the string beyond which the RE engine will not go.

Match.lastindex¶

The integer index of the last matched capturing group, orNone if no groupwas matched at all. For example, the expressions(a)b,((a)(b)), and((ab)) will havelastindex==1 if applied to the string'ab', whilethe expression(a)(b) will havelastindex==2, if applied to the samestring.

Match.lastgroup¶

The name of the last matched capturing group, orNone if the group didn'thave a name, or if no group was matched at all.

Match.re¶

Theregular expression object whosematch() orsearch() method produced this match instance.

Match.string¶

The string passed tomatch() orsearch().

Regular Expression Examples¶

defdisplaymatch(match):ifmatchisNone:returnNonereturn'<Match:%r, groups=%r>'%(match.group(),match.groups())

>>>valid=re.compile(r"^[a2-9tjqk]{5}$")>>>displaymatch(valid.match("akt5q"))# Valid."<Match: 'akt5q', groups=()>">>>displaymatch(valid.match("akt5e"))# Invalid.>>>displaymatch(valid.match("akt"))# Invalid.>>>displaymatch(valid.match("727ak"))# Valid."<Match: '727ak', groups=()>"

>>>pair=re.compile(r".*(.).*\1")>>>displaymatch(pair.match("717ak"))# Pair of 7s."<Match: '717', groups=('7',)>">>>displaymatch(pair.match("718ak"))# No pairs.>>>displaymatch(pair.match("354aa"))# Pair of aces."<Match: '354aa', groups=('a',)>"

>>>pair=re.compile(r".*(.).*\1")>>>pair.match("717ak").group(1)'7'# Error because re.match() returns None, which doesn't have a group() method:>>>pair.match("718ak").group(1)Traceback (most recent call last):  File"<pyshell#23>", line1, in<module>re.match(r".*(.).*\1","718ak").group(1)AttributeError:'NoneType' object has no attribute 'group'>>>pair.match("354aa").group(1)'a'

/usr/sbin/sendmail-0errors,4warnings

%s-%derrors,%dwarnings

(\S+)-(\d+)errors,(\d+)warnings

>>>re.match("c","abcdef")# No match>>>re.search("c","abcdef")# Match<re.Match object; span=(2, 3), match='c'>>>>re.fullmatch("p.*n","python")# Match<re.Match object; span=(0, 6), match='python'>>>>re.fullmatch("r.*n","python")# No match

>>>re.match("c","abcdef")# No match>>>re.search("^c","abcdef")# No match>>>re.search("^a","abcdef")# Match<re.Match object; span=(0, 1), match='a'>

>>>re.match("X","A\nB\nX",re.MULTILINE)# No match>>>re.search("^X","A\nB\nX",re.MULTILINE)# Match<re.Match object; span=(4, 5), match='X'>

>>>text="""Ross McFluff: 834.345.1254 155 Elm Street......Ronald Heathmore: 892.345.3428 436 Finley Avenue...Frank Burger: 925.541.7625 662 South Dogwood Way.........Heather Albrecht: 548.326.4584 919 Park Place"""

>>>entries=re.split("\n+",text)>>>entries['Ross McFluff: 834.345.1254 155 Elm Street','Ronald Heathmore: 892.345.3428 436 Finley Avenue','Frank Burger: 925.541.7625 662 South Dogwood Way','Heather Albrecht: 548.326.4584 919 Park Place']

>>>[re.split(":? ",entry,maxsplit=3)forentryinentries][['Ross', 'McFluff', '834.345.1254', '155 Elm Street'],['Ronald', 'Heathmore', '892.345.3428', '436 Finley Avenue'],['Frank', 'Burger', '925.541.7625', '662 South Dogwood Way'],['Heather', 'Albrecht', '548.326.4584', '919 Park Place']]

>>>[re.split(":? ",entry,maxsplit=4)forentryinentries][['Ross', 'McFluff', '834.345.1254', '155', 'Elm Street'],['Ronald', 'Heathmore', '892.345.3428', '436', 'Finley Avenue'],['Frank', 'Burger', '925.541.7625', '662', 'South Dogwood Way'],['Heather', 'Albrecht', '548.326.4584', '919', 'Park Place']]

>>>defrepl(m):...inner_word=list(m.group(2))...random.shuffle(inner_word)...returnm.group(1)+"".join(inner_word)+m.group(3)...>>>text="Professor Abdolmalek, please report your absences promptly.">>>re.sub(r"(\w)(\w+)(\w)",repl,text)'Poefsrosr Aealmlobdk, pslaee reorpt your abnseces plmrptoy.'>>>re.sub(r"(\w)(\w+)(\w)",repl,text)'Pofsroser Aodlambelk, plasee reoprt yuor asnebces potlmrpy.'

>>>text="He was carefully disguised but captured quickly by police.">>>re.findall(r"\w+ly\b",text)['carefully', 'quickly']

>>>text="He was carefully disguised but captured quickly by police.">>>forminre.finditer(r"\w+ly\b",text):...print('%02d-%02d:%s'%(m.start(),m.end(),m.group(0)))07-16: carefully40-47: quickly

>>>re.match(r"\W(.)\1\W"," ff ")<re.Match object; span=(0, 4), match=' ff '>>>>re.match("\\W(.)\\1\\W"," ff ")<re.Match object; span=(0, 4), match=' ff '>

>>>re.match(r"\\",r"\\")<re.Match object; span=(0, 1), match='\\'>>>>re.match("\\\\",r"\\")<re.Match object; span=(0, 1), match='\\'>

fromtypingimportNamedTupleimportreclassToken(NamedTuple):type:strvalue:strline:intcolumn:intdeftokenize(code):keywords={'IF','THEN','ENDIF','FOR','NEXT','GOSUB','RETURN'}token_specification=[('NUMBER',r'\d+(\.\d*)?'),# Integer or decimal number('ASSIGN',r':='),# Assignment operator('END',r';'),# Statement terminator('ID',r'[A-Za-z]+'),# Identifiers('OP',r'[+\-*/]'),# Arithmetic operators('NEWLINE',r'\n'),# Line endings('SKIP',r'[ \t]+'),# Skip over spaces and tabs('MISMATCH',r'.'),# Any other character]tok_regex='|'.join('(?P<%s>%s)'%pairforpairintoken_specification)line_num=1line_start=0formoinre.finditer(tok_regex,code):kind=mo.lastgroupvalue=mo.group()column=mo.start()-line_startifkind=='NUMBER':value=float(value)if'.'invalueelseint(value)elifkind=='ID'andvalueinkeywords:kind=valueelifkind=='NEWLINE':line_start=mo.end()line_num+=1continueelifkind=='SKIP':continueelifkind=='MISMATCH':raiseRuntimeError(f'{value!r} unexpected on line{line_num}')yieldToken(kind,value,line_num,column)statements='''    IF quantity THEN        total := total + price * quantity;        tax := price * 0.05;    ENDIF;'''fortokenintokenize(statements):print(token)

Token(type='IF',value='IF',line=2,column=4)Token(type='ID',value='quantity',line=2,column=7)Token(type='THEN',value='THEN',line=2,column=16)Token(type='ID',value='total',line=3,column=8)Token(type='ASSIGN',value=':=',line=3,column=14)Token(type='ID',value='total',line=3,column=17)Token(type='OP',value='+',line=3,column=23)Token(type='ID',value='price',line=3,column=25)Token(type='OP',value='*',line=3,column=31)Token(type='ID',value='quantity',line=3,column=33)Token(type='END',value=';',line=3,column=41)Token(type='ID',value='tax',line=4,column=8)Token(type='ASSIGN',value=':=',line=4,column=12)Token(type='ID',value='price',line=4,column=15)Token(type='OP',value='*',line=4,column=21)Token(type='NUMBER',value=0.05,line=4,column=23)Token(type='END',value=';',line=4,column=27)Token(type='ENDIF',value='ENDIF',line=5,column=4)Token(type='END',value=';',line=5,column=9)