簡(jiǎn)介

Python 自1.5版本起增加了re 模塊，它提供 Perl 風(fēng)格的正則表達(dá)式模式。Python 1.5之前版本則是通過(guò) regex 模塊提供 Emacs 風(fēng)格的模式。Emacs 風(fēng)格模式可讀性稍差些，而且功能也不強(qiáng)，因此編寫(xiě)新代碼時(shí)盡量不要再使用 regex 模塊，當(dāng)然偶爾你還是可能在老代碼里發(fā)現(xiàn)其蹤影。

就其本質(zhì)而言，正則表達(dá)式（或 RE）是一種小型的、高度專業(yè)化的編程語(yǔ)言，（在Python中）它內(nèi)嵌在Python中，并通過(guò) re 模塊實(shí)現(xiàn)。使用這個(gè)小型語(yǔ)言，你可以為想要匹配的相應(yīng)字符串集指定規(guī)則；該字符串集可能包含英文語(yǔ)句、e-mail地址、TeX命令或任何你想搞定的東 西。然后你可以問(wèn)諸如“這個(gè)字符串匹配該模式嗎？”或“在這個(gè)字符串中是否有部分匹配該模式呢？”。你也可以使用 RE 以各種方式來(lái)修改或分割字符串。

正則表達(dá)式模式被編譯成一系列的字節(jié)碼，然后由用 C 編寫(xiě)的匹配引擎執(zhí)行。在高級(jí)用法中，也許還要仔細(xì)留意引擎是如何執(zhí)行給定 RE ，如何以特定方式編寫(xiě) RE 以令生產(chǎn)的字節(jié)碼運(yùn)行速度更快。本文并不涉及優(yōu)化，因?yàn)槟且竽阋殉浞终莆樟似ヅ湟娴膬?nèi)部機(jī)制。

正則表達(dá)式語(yǔ)言相對(duì)小型和受限（功能有限），因此并非所有字符串處理都能用正則表達(dá)式完成。當(dāng)然也有些任務(wù)可以用正則表達(dá)式完成， 不過(guò)最終表達(dá)式會(huì)變得異常復(fù)雜。碰到這些情形時(shí)，編寫(xiě) Python 代碼進(jìn)行處理可能反而更好；盡管 Python 代碼比一個(gè)精巧的正則表達(dá)式要慢些，但它更易理解。

簡(jiǎn)單模式

我們將從最簡(jiǎn)單的正則表達(dá)式學(xué)習(xí)開(kāi)始。由于正則表達(dá)式常用于字符串操作，那我們就從最常見(jiàn)的任務(wù)：字符匹配 下手。

有關(guān)正則表達(dá)式底層的計(jì)算機(jī)科學(xué)上的詳細(xì)解釋（確定性和非確定性有限自動(dòng)機(jī)），你可以查閱編寫(xiě)編譯器相關(guān)的任何教科書(shū)。

字符匹配

大多數(shù)字母和字符一般都會(huì)和自身匹配。例如，正則表達(dá)式 test 會(huì)和字符串“test”完全匹配。（你也可以使用大小寫(xiě)不敏感模式，它還能讓這個(gè) RE 匹配“Test”或“TEST”；稍后會(huì)有更多解釋。）

這個(gè)規(guī)則當(dāng)然會(huì)有例外；有些字符比較特殊，它們和自身并不匹配，而是會(huì)表明應(yīng)和一些特殊的東西匹配，或者它們會(huì)影響到 RE 其它部分的重復(fù)次數(shù)。本文很大篇幅專門(mén)討論了各種元字符及其作用。

這里有一個(gè)元字符的完整列表；其含義會(huì)在本指南馀下部分進(jìn)行討論。

. ^ $ * + ? { [ ] \ | ( )

我們首先考察的元字符是"[" 和 "]"。它們常用來(lái)指定一個(gè)字符類別，所謂字符類別就是你想匹配的一個(gè)字符集。字符可以單個(gè)列出，也可以用“-”號(hào)分隔的兩個(gè)給定字符來(lái)表示一個(gè)字符區(qū) 間。例如，[abc] 將匹配"a", "b", 或 "c"中的任意一個(gè)字符；也可以用區(qū)間[a-c]來(lái)表示同一字符集，和前者效果一致。如果你只想匹配小寫(xiě)字母，那么 RE 應(yīng)寫(xiě)成 [a-z].

元字符在類別里并不起作用。例如，[akm$]將匹配字符"a", "k", "m", 或 "$" 中的任意一個(gè)；"$"通常用作元字符，但在字符類別里，其特性被除去，恢復(fù)成普通字符。

你可以用補(bǔ)集來(lái)匹配不在區(qū)間范圍內(nèi)的字符。其做法是把"^"作為類別的首個(gè)字符；其它地方的"^"只會(huì)簡(jiǎn)單匹配 "^"字符本身。例如，[^5] 將匹配除 "5" 之外的任意字符。

也許最重要的元字符是反斜杠"\"。 做為 Python 中的字符串字母，反斜杠后面可以加不同的字符以表示不同特殊意義。它也可以用于取消所有的元字符，這樣你就可以在模式中匹配它們了。舉個(gè)例子，如果你需要 匹配字符 "[" 或 "\"，你可以在它們之前用反斜杠來(lái)取消它們的特殊意義： \[ 或 \\。

一些用 "\" 開(kāi)始的特殊字符所表示的預(yù)定義字符集通常是很有用的，象數(shù)字集，字母集，或其它非空字符集。下列是可用的預(yù)設(shè)特殊字符：

\d  匹配任何十進(jìn)制數(shù)；它相當(dāng)于類 [0-9]。
\D  匹配任何非數(shù)字字符；它相當(dāng)于類 [^0-9]。
\s  匹配任何空白字符；它相當(dāng)于類  [ \t\n\r\f\v]。
\S  匹配任何非空白字符；它相當(dāng)于類 [^ \t\n\r\f\v]。
\w  匹配任何字母數(shù)字字符；它相當(dāng)于類 [a-zA-Z0-9_]。
\W  匹配任何非字母數(shù)字字符；它相當(dāng)于類 [^a-zA-Z0-9_]。

這樣特殊字符都可以包含在一個(gè)字符類中。如，[\s,.]字符類將匹配任何空白字符或","或"."。

本節(jié)最后一個(gè)元字符是 . 。它匹配除了換行字符外的任何字符，在 alternate 模式（re.DOTALL）下它甚至可以匹配換行。"." 通常被用于你想匹配“任何字符”的地方。

  重復(fù)

正則表達(dá)式第一件能做的事是能夠匹配不定長(zhǎng)的字符集，而這是其它能作用在字符串上的方法所不能做到的。 不過(guò)，如果那是正則表達(dá)式唯一的附加功能的話，那么它們也就不那么優(yōu)秀了。它們的另一個(gè)功能就是你可以指定正則表達(dá)式的一部分的重復(fù)次數(shù)。

我們討論的第一個(gè)重復(fù)功能的元字符是 *。* 并不匹配字母字符 "*"；相反，它指定前一個(gè)字符可以被匹配零次或更多次，而不是只有一次。

舉個(gè)例子，ca*t 將匹配 "ct" (0 個(gè) "a" 字符), "cat" (1 個(gè) "a"), "caaat" (3 個(gè) "a" 字符)等等。RE 引擎有各種來(lái)自 C 的整數(shù)類型大小的內(nèi)部限制，以防止它匹配超過(guò)2億個(gè) "a" 字符；你也許沒(méi)有足夠的內(nèi)存去建造那么大的字符串，所以將不會(huì)累計(jì)到那個(gè)限制。

象 * 這樣地重復(fù)是“貪婪的”；當(dāng)重復(fù)一個(gè) RE 時(shí)，匹配引擎會(huì)試著重復(fù)盡可能多的次數(shù)。如果模式的后面部分沒(méi)有被匹配，匹配引擎將退回并再次嘗試更小的重復(fù)。

一步步的示例可以使它更加清晰。讓我們考慮表達(dá)式 a[bcd]*b。它匹配字母 "a"，零個(gè)或更多個(gè)來(lái)自類 [bcd]中的字母，最后以 "b" 結(jié)尾?，F(xiàn)在想一想該 RE 對(duì)字符串 "abcbd" 的匹配。

RE 的結(jié)尾部分現(xiàn)在可以到達(dá)了，它匹配 "abcb"。這證明了匹配引擎一開(kāi)始會(huì)盡其所能進(jìn)行匹配，如果沒(méi)有匹配然后就逐步退回并反復(fù)嘗試 RE 剩下來(lái)的部分。直到它退回嘗試匹配 [bcd] 到零次為止，如果隨后還是失敗，那么引擎就會(huì)認(rèn)為該字符串根本無(wú)法匹配 RE 。

另一個(gè)重復(fù)元字符是 +，表示匹配一或更多次。請(qǐng)注意 * 和 + 之間的不同；＊ 匹配零或更多次，所以根本就可以不出現(xiàn)，而 + 則要求至少出現(xiàn)一次。用同一個(gè)例子，ca+t 就可以匹配 "cat" (1 個(gè) "a")， "caaat" (3 個(gè) "a")， 但不能匹配 "ct"。

還有更多的限定符。問(wèn)號(hào) ? 匹配一次或零次；你可以認(rèn)為它用于標(biāo)識(shí)某事物是可選的。例如：home-?brew 匹配 "homebrew" 或 "home-brew"。

最復(fù)雜的重復(fù)限定符是 {m,n}，其中 m 和 n 是十進(jìn)制整數(shù)。該限定符的意思是至少有 m 個(gè)重復(fù)，至多到 n 個(gè)重復(fù)。舉個(gè)例子，a/{1,3}b 將匹配 "a/b"，"a//b" 和 "a///b"。它不能匹配 "ab" 因?yàn)闆](méi)有斜杠，也不能匹配 "a////b" ，因?yàn)橛兴膫€(gè)。

你可以忽略 m 或 n；因?yàn)闀?huì)為缺失的值假設(shè)一個(gè)合理的值。忽略 m 會(huì)認(rèn)為下邊界是 0，而忽略 n 的結(jié)果將是上邊界為無(wú)窮大 -- 實(shí)際上是先前我們提到的 2 兆，但這也許同無(wú)窮大一樣。

細(xì)心的讀者也許注意到其他三個(gè)限定符都可以用這樣方式來(lái)表示。 {0,} 等同于 *，{1,} 等同于 +，而{0,1}則與 ? 相同。如果可以的話，最好使用 *，+，或?。很簡(jiǎn)單因?yàn)樗鼈兏桃苍偃菀锥?/p>

使用正則表達(dá)式

現(xiàn)在我們已經(jīng)看了一些簡(jiǎn)單的正則表達(dá)式，那么我們實(shí)際在 Python 中是如何使用它們的呢？ re 模塊提供了一個(gè)正則表達(dá)式引擎的接口，可以讓你將 REs 編譯成對(duì)象并用它們來(lái)進(jìn)行匹配。

編譯正則表達(dá)式

正則表達(dá)式被編譯成 `RegexObject` 實(shí)例，可以為不同的操作提供方法，如模式匹配搜索或字符串替換。

#!python
>>> import re
>>> p = re.compile('ab*')
>>> print p
<re.RegexObject instance at 80b4150>

re.compile() 也接受可選的標(biāo)志參數(shù)，常用來(lái)實(shí)現(xiàn)不同的特殊功能和語(yǔ)法變更。我們稍后將查看所有可用的設(shè)置，但現(xiàn)在只舉一個(gè)例子：

#!python
>>> p = re.compile('ab*', re.IGNORECASE)

RE 被做為一個(gè)字符串發(fā)送給 re.compile()。REs 被處理成字符串是因?yàn)檎齽t表達(dá)式不是 Python 語(yǔ)言的核心部分，也沒(méi)有為它創(chuàng)建特定的語(yǔ)法。（應(yīng)用程序根本就不需要 REs，因此沒(méi)必要包含它們?nèi)ナ拐Z(yǔ)言說(shuō)明變得臃腫不堪。）而 re 模塊則只是以一個(gè) C 擴(kuò)展模塊的形式來(lái)被 Python 包含，就象 socket 或 zlib 模塊一樣

將 REs 作為字符串以保證 Python 語(yǔ)言的簡(jiǎn)潔，但這樣帶來(lái)的一個(gè)麻煩就是象下節(jié)標(biāo)題所講的。

  反斜杠的麻煩

在早期規(guī)定中，正則表達(dá)式用反斜杠字符 ("\") 來(lái)表示特殊格式或允許使用特殊字符而不調(diào)用它的特殊用法。這就與 Python 在字符串中的那些起相同作用的相同字符產(chǎn)生了沖突。

讓我們舉例說(shuō)明，你想寫(xiě)一個(gè) RE 以匹配字符串 "\section"，可能是在一個(gè) LATEX 文件查找。為了要在程序代碼中判斷，首先要寫(xiě)出想要匹配的字符串。接下來(lái)你需要在所有反斜杠和元字符前加反斜杠來(lái)取消其特殊意義。

簡(jiǎn)單地說(shuō)，為了匹配一個(gè)反斜杠，不得不在 RE 字符串中寫(xiě) '\\\\'，因?yàn)檎齽t表達(dá)式中必須是 "\\"，而每個(gè)反斜杠按 Python 字符串字母表示的常規(guī)必須表示成 "\\"。在 REs 中反斜杠的這個(gè)重復(fù)特性會(huì)導(dǎo)致大量重復(fù)的反斜杠，而且所生成的字符串也很難懂。

解決的辦法就是為正則表達(dá)式使用 Python 的 raw 字符串表示；在字符串前加個(gè) "r" 反斜杠就不會(huì)被任何特殊方式處理，所以 r"\n" 就是包含"\" 和 "n" 的兩個(gè)字符，而 "\n" 則是一個(gè)字符，表示一個(gè)換行。正則表達(dá)式通常在 Python 代碼中都是用這種 raw 字符串表示。

執(zhí)行匹配

一旦你有了已經(jīng)編譯了的正則表達(dá)式的對(duì)象，你要用它做什么呢？`RegexObject` 實(shí)例有一些方法和屬性。這里只顯示了最重要的幾個(gè)，如果要看完整的列表請(qǐng)查閱 Python Library Reference

如果沒(méi)有匹配到的話，match() 和 search() 將返回 None。如果成功的話，就會(huì)返回一個(gè) `MatchObject` 實(shí)例，其中有這次匹配的信息：它是從哪里開(kāi)始和結(jié)束，它所匹配的子串等等。

你可以用采用人機(jī)對(duì)話并用 re 模塊實(shí)驗(yàn)的方式來(lái)學(xué)習(xí)它。如果你有 Tkinter 的話，你也許可以考慮參考一下 Tools/scripts/redemo.py，一個(gè)包含在 Python 發(fā)行版里的示范程序。

首先，運(yùn)行 Python 解釋器，導(dǎo)入 re 模塊并編譯一個(gè) RE：

#!python
Python 2.2.2 (#1, Feb 10 2003, 12:57:01)
>>> import re
>>> p = re.compile('[a-z]+')
>>> p
<_sre.SRE_Pattern object at 80c3c28>

現(xiàn)在，你可以試著用 RE 的 [a-z]+ 去匹配不同的字符串。一個(gè)空字符串將根本不能匹配，因?yàn)?+ 的意思是 “一個(gè)或更多的重復(fù)次數(shù)”。 在這種情況下 match() 將返回 None，因?yàn)樗菇忉屍鳑](méi)有輸出。你可以明確地打印出 match() 的結(jié)果來(lái)弄清這一點(diǎn)。

#!python
>>> p.match("")
>>> print p.match("")
None

現(xiàn)在，讓我們?cè)囍盟鼇?lái)匹配一個(gè)字符串，如 "tempo"。這時(shí)，match() 將返回一個(gè) MatchObject。因此你可以將結(jié)果保存在變量里以便後面使用。

#!python
>>> m = p.match( 'tempo')
>>> print m
<_sre.SRE_Match object at 80c4f68>

現(xiàn)在你可以查詢 `MatchObject` 關(guān)于匹配字符串的相關(guān)信息了。MatchObject 實(shí)例也有幾個(gè)方法和屬性；最重要的那些如下所示：

試試這些方法不久就會(huì)清楚它們的作用了：

#!python
>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)

group() 返回 RE 匹配的子串。start() 和 end() 返回匹配開(kāi)始和結(jié)束時(shí)的索引。span() 則用單個(gè)元組把開(kāi)始和結(jié)束時(shí)的索引一起返回。因?yàn)槠ヅ浞椒z查到如果 RE 在字符串開(kāi)始處開(kāi)始匹配，那幺 start() 將總是為零。然而， `RegexObject` 實(shí)例的 search 方法掃描下面的字符串的話，在這種情況下，匹配開(kāi)始的位置就也許不是零了。

#!python
>>> print p.match('::: message')
None
>>> m = p.search('::: message') ; print m
<re.MatchObject instance at 80c9650>
>>> m.group()
'message'
>>> m.span()
(4, 11)

在實(shí)際程序中，最常見(jiàn)的作法是將 `MatchObject` 保存在一個(gè)變量里，然後檢查它是否為 None，通常如下所示：

#!python
p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
print 'Match found: ', m.group()
else:
print 'No match'

兩個(gè) `RegexObject` 方法返回所有匹配模式的子串。findall()返回一個(gè)匹配字符串行表：

#!python
>>> p = re.compile('\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']

findall() 在它返回結(jié)果時(shí)不得不創(chuàng)建一個(gè)列表。在 Python 2.2中，也可以用 finditer() 方法。

#!python
>>> iterator = p.finditer('12 drummers drumming, 11 ... 10 ...')
>>> iterator
<callable-iterator object at 0x401833ac>
>>> for match in iterator:
...     print match.span()
...
(0, 2)
(22, 24)
(29, 31)

模塊級(jí)函數(shù)

你不一定要產(chǎn)生一個(gè) `RegexObject` 對(duì)象然后再調(diào)用它的方法；re 模塊也提供了頂級(jí)函數(shù)調(diào)用如 match()、search()、sub() 等等。這些函數(shù)使用 RE 字符串作為第一個(gè)參數(shù)，而后面的參數(shù)則與相應(yīng) `RegexObject` 的方法參數(shù)相同，返回則要么是 None 要么就是一個(gè) `MatchObject` 的實(shí)例。

#!python
>>> print re.match(r'From\s+', 'Fromage amk')
None
>>> re.match(r'From\s+', 'From amk Thu May 14 19:12:10 1998')
<re.MatchObject instance at 80c5978>

Under the hood, 這些函數(shù)簡(jiǎn)單地產(chǎn)生一個(gè) RegexOject 并在其上調(diào)用相應(yīng)的方法。它們也在緩存里保存編譯后的對(duì)象，因此在將來(lái)調(diào)用用到相同 RE 時(shí)就會(huì)更快。

你將使用這些模塊級(jí)函數(shù)，還是先得到一個(gè) `RegexObject` 再調(diào)用它的方法呢？如何選擇依賴于怎樣用 RE 更有效率以及你個(gè)人編碼風(fēng)格。如果一個(gè) RE 在代碼中只做用一次的話，那么模塊級(jí)函數(shù)也許更方便。如果程序包含很多的正則表達(dá)式，或在多處復(fù)用同一個(gè)的話，那么將全部定義放在一起，在一段代碼中提前 編譯所有的 REs 更有用。從標(biāo)準(zhǔn)庫(kù)中看一個(gè)例子，這是從 xmllib.py 文件中提取出來(lái)的：

#!python
ref = re.compile( ... )
entityref = re.compile( ... )
charref = re.compile( ... )
starttagopen = re.compile( ... )

我通常更喜歡使用編譯對(duì)象，甚至它只用一次，but few people will be as much of a purist about this as I am。

  編譯標(biāo)志

編譯標(biāo)志讓你可以修改正則表達(dá)式的一些運(yùn)行方式。在 re 模塊中標(biāo)志可以使用兩個(gè)名字，一個(gè)是全名如 IGNORECASE，一個(gè)是縮寫(xiě)，一字母形式如 I。（如果你熟悉 Perl 的模式修改，一字母形式使用同樣的字母；例如 re.VERBOSE的縮寫(xiě)形式是 re.X。）多個(gè)標(biāo)志可以通過(guò)按位 OR-ing 它們來(lái)指定。如 re.I | re.M 被設(shè)置成 I 和 M 標(biāo)志：

這有個(gè)可用標(biāo)志表，對(duì)每個(gè)標(biāo)志后面都有詳細(xì)的說(shuō)明。

I
IGNORECASE

使匹配對(duì)大小寫(xiě)不敏感；字符類和字符串匹配字母時(shí)忽略大小寫(xiě)。舉個(gè)例子，[A-Z]也可以匹配小寫(xiě)字母，Spam 可以匹配 "Spam", "spam", 或 "spAM"。這個(gè)小寫(xiě)字母并不考慮當(dāng)前位置。

L
LOCALE

影響 \w, \W, \b, 和 \B，這取決于當(dāng)前的本地化設(shè)置。

locales 是 C 語(yǔ)言庫(kù)中的一項(xiàng)功能，是用來(lái)為需要考慮不同語(yǔ)言的編程提供幫助的。舉個(gè)例子，如果你正在處理法文文本，你想用 \w+ 來(lái)匹配文字，但 \w 只匹配字符類 [A-Za-z]；它并不能匹配 "é" 或 "ç"。如果你的系統(tǒng)配置適當(dāng)且本地化設(shè)置為法語(yǔ)，那么內(nèi)部的 C 函數(shù)將告訴程序 "é" 也應(yīng)該被認(rèn)為是一個(gè)字母。當(dāng)在編譯正則表達(dá)式時(shí)使用 LOCALE 標(biāo)志會(huì)得到用這些 C 函數(shù)來(lái)處理 \w 后的編譯對(duì)象；這會(huì)更慢，但也會(huì)象你希望的那樣可以用 \w+ 來(lái)匹配法文文本。

M
MULTILINE

(此時(shí) ^ 和 $ 不會(huì)被解釋; 它們將在 4.1 節(jié)被介紹.)

使用 "^" 只匹配字符串的開(kāi)始，而 $ 則只匹配字符串的結(jié)尾和直接在換行前（如果有的話）的字符串結(jié)尾。當(dāng)本標(biāo)志指定后， "^" 匹配字符串的開(kāi)始和字符串中每行的開(kāi)始。同樣的， $ 元字符匹配字符串結(jié)尾和字符串中每行的結(jié)尾（直接在每個(gè)換行之前）。

S
DOTALL

使 "." 特殊字符完全匹配任何字符，包括換行；沒(méi)有這個(gè)標(biāo)志， "." 匹配除了換行外的任何字符。

X
VERBOSE

該標(biāo)志通過(guò)給予你更靈活的格式以便你將正則表達(dá)式寫(xiě)得更易于理解。當(dāng)該標(biāo)志被指定時(shí)，在 RE 字符串中的空白符被忽略，除非該空白符在字符類中或在反斜杠之后；這可以讓你更清晰地組織和縮進(jìn) RE。它也可以允許你將注釋寫(xiě)入 RE，這些注釋會(huì)被引擎忽略；注釋用 "#"號(hào) 來(lái)標(biāo)識(shí)，不過(guò)該符號(hào)不能在字符串或反斜杠之后。

舉個(gè)例子，這里有一個(gè)使用 re.VERBOSE 的 RE；看看讀它輕松了多少？

#!python
charref = re.compile(r"""
&[[]]		     # Start of a numeric entity reference
(
[0-9]+[^0-9]      # Decimal form
| 0[0-7]+[^0-7]   # Octal form
| x[0-9a-fA-F]+[^0-9a-fA-F] # Hexadecimal form
)
""", re.VERBOSE)

沒(méi)有 verbose 設(shè)置， RE 會(huì)看起來(lái)象這樣：

#!python
charref = re.compile("&#([0-9]+[^0-9]"
"|0[0-7]+[^0-7]"
"|x[0-9a-fA-F]+[^0-9a-fA-F])")

在上面的例子里，Python 的字符串自動(dòng)連接可以用來(lái)將 RE 分成更小的部分，但它比用 re.VERBOSE 標(biāo)志時(shí)更難懂

  更多模式功能

到目前為止，我們只展示了正則表達(dá)式的一部分功能。在本節(jié)，我們將展示一些新的元字符和如何使用組來(lái)檢索被匹配的文本部分。

 更多的元字符

還有一些我們還沒(méi)展示的元字符，其中的大部分將在本節(jié)展示。

剩下來(lái)要討論的一部分元字符是零寬界定符（zero-width assertions）。它們并不會(huì)使引擎在處理字符串時(shí)更快;相反，它們根本就沒(méi)有對(duì)應(yīng)任何字符，只是簡(jiǎn)單的成功或失敗。舉個(gè)例子， \b 是一個(gè)在單詞邊界定位當(dāng)前位置的界定符（assertions），這個(gè)位置根本就不會(huì)被 \b 改變。這意味著零寬界定符（zero-width assertions）將永遠(yuǎn)不會(huì)被重復(fù)，因?yàn)槿绻鼈冊(cè)诮o定位置匹配一次，那么它們很明顯可以被匹配無(wú)數(shù)次。

|

可選項(xiàng)，或者 "or" 操作符。如果 A 和 B 是正則表達(dá)式，A|B 將匹配任何匹配了 "A" 或 "B" 的字符串。| 的優(yōu)先級(jí)非常低，是為了當(dāng)你有多字符串要選擇時(shí)能適當(dāng)?shù)剡\(yùn)行。Crow|Servo 將匹配"Crow" 或 "Servo", 而不是 "Cro", 一個(gè) "w" 或 一個(gè) "S", 和 "ervo"。

為了匹配字母 "|"，可以用 \|，或?qū)⑵浒谧址愔?，如[|]。

^

匹配行首。除非設(shè)置 MULTILINE 標(biāo)志，它只是匹配字符串的開(kāi)始。在 MULTILINE 模式里，它也可以直接匹配字符串中的每個(gè)換行。

例如，如果你只希望匹配在行首單詞 "From"，那么 RE 將用 ^From。

#!python
>>> print re.search('^From', 'From Here to Eternity')
<re.MatchObject instance at 80c1520>
>>> print re.search('^From', 'Reciting From Memory')
None

$

匹配行尾，行尾被定義為要么是字符串尾，要么是一個(gè)換行字符后面的任何位置。

#!python
>>> print re.search('}$', '{block}')
<re.MatchObject instance at 80adfa8>
>>> print re.search('}$', '{block} ')
None
>>> print re.search('}$', '{block}\n')
<re.MatchObject instance at 80adfa8>

匹配一個(gè) "$"，使用 \$ 或?qū)⑵浒谧址愔校鏪$]。

\A

只匹配字符串首。當(dāng)不在 MULTILINE 模式，\A 和 ^ 實(shí)際上是一樣的。然而，在 MULTILINE 模式里它們是不同的；\A 只是匹配字符串首，而 ^ 還可以匹配在換行符之后字符串的任何位置。

\Z

Matches only at the end of the string.
只匹配字符串尾。

\b

單詞邊界。這是個(gè)零寬界定符（zero-width assertions）只用以匹配單詞的詞首和詞尾。單詞被定義為一個(gè)字母數(shù)字序列，因此詞尾就是用空白符或非字母數(shù)字符來(lái)標(biāo)示的。

下面的例子只匹配 "class" 整個(gè)單詞；而當(dāng)它被包含在其他單詞中時(shí)不匹配。

#!python
>>> p = re.compile(r'\bclass\b')
>>> print p.search('no class at all')
<re.MatchObject instance at 80c8f28>
>>> print p.search('the declassified algorithm')
None
>>> print p.search('one subclass is')
None

當(dāng)用這個(gè)特殊序列時(shí)你應(yīng)該記住這里有兩個(gè)微妙之處。第一個(gè)是 Python 字符串和正則表達(dá)式之間最糟的沖突。在 Python 字符串里，"\b" 是反斜杠字符，ASCII值是8。如果你沒(méi)有使用 raw 字符串時(shí)，那么 Python 將會(huì)把 "\b" 轉(zhuǎn)換成一個(gè)回退符，你的 RE 將無(wú)法象你希望的那樣匹配它了。下面的例子看起來(lái)和我們前面的 RE 一樣，但在 RE 字符串前少了一個(gè) "r" 。

#!python
>>> p = re.compile('\bclass\b')
>>> print p.search('no class at all')
None
>>> print p.search('\b' + 'class' + '\b')
<re.MatchObject instance at 80c3ee0>

第二個(gè)在字符類中，這個(gè)限定符（assertion）不起作用，\b 表示回退符，以便與 Python 字符串兼容。

\B

另一個(gè)零寬界定符（zero-width assertions），它正好同 \b 相反，只在當(dāng)前位置不在單詞邊界時(shí)匹配。

分組

你經(jīng)常需要得到比 RE 是否匹配還要多的信息。正則表達(dá)式常常用來(lái)分析字符串，編寫(xiě)一個(gè) RE 匹配感興趣的部分并將其分成幾個(gè)小組。舉個(gè)例子，一個(gè) RFC-822 的頭部用 ":" 隔成一個(gè)頭部名和一個(gè)值，這就可以通過(guò)編寫(xiě)一個(gè)正則表達(dá)式匹配整個(gè)頭部，用一組匹配頭部名，另一組匹配頭部值的方式來(lái)處理。

組是通過(guò) "(" 和 ")" 元字符來(lái)標(biāo)識(shí)的。 "(" 和 ")" 有很多在數(shù)學(xué)表達(dá)式中相同的意思；它們一起把在它們里面的表達(dá)式組成一組。舉個(gè)例子，你可以用重復(fù)限制符，象 *, +, ?, 和 {m,n}，來(lái)重復(fù)組里的內(nèi)容，比如說(shuō)(ab)* 將匹配零或更多個(gè)重復(fù)的 "ab"。

#!python
>>> p = re.compile('(ab)*')
>>> print p.match('ababababab').span()
(0, 10)

組用 "(" 和 ")" 來(lái)指定，并且得到它們匹配文本的開(kāi)始和結(jié)尾索引；這就可以通過(guò)一個(gè)參數(shù)用 group()、start()、end() 和 span() 來(lái)進(jìn)行檢索。組是從 0 開(kāi)始計(jì)數(shù)的。組 0 總是存在；它就是整個(gè) RE，所以 `MatchObject` 的方法都把組 0 作為它們?nèi)笔〉膮?shù)。稍后我們將看到怎樣表達(dá)不能得到它們所匹配文本的 span。

#!python
>>> p = re.compile('(a)b')
>>> m = p.match('ab')
>>> m.group()
'ab'
>>> m.group(0)
'ab'

小組是從左向右計(jì)數(shù)的，從1開(kāi)始。組可以被嵌套。計(jì)數(shù)的數(shù)值可以能過(guò)從左到右計(jì)算打開(kāi)的括號(hào)數(shù)來(lái)確定。

#!python
>>> p = re.compile('(a(b)c)d')
>>> m = p.match('abcd')
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'

group() 可以一次輸入多個(gè)組號(hào)，在這種情況下它將返回一個(gè)包含那些組所對(duì)應(yīng)值的元組。

#!python
>>> m.group(2,1,2)
('b', 'abc', 'b')

The groups() 方法返回一個(gè)包含所有小組字符串的元組，從 1 到 所含的小組號(hào)。

#!python
>>> m.groups()
('abc', 'b')

模式中的逆向引用允許你指定先前捕獲組的內(nèi)容，該組也必須在字符串當(dāng)前位置被找到。舉個(gè)例子，如果組 1 的內(nèi)容能夠在當(dāng)前位置找到的話，\1 就成功否則失敗。記住 Python 字符串也是用反斜杠加數(shù)據(jù)來(lái)允許字符串中包含任意字符的，所以當(dāng)在 RE 中使用逆向引用時(shí)確保使用 raw 字符串。

例如，下面的 RE 在一個(gè)字符串中找到成雙的詞。

#!python
>>> p = re.compile(r'(\b\w+)\s+\1')
>>> p.search('Paris in the the spring').group()
'the the'

象這樣只是搜索一個(gè)字符串的逆向引用并不常見(jiàn) -- 用這種方式重復(fù)數(shù)據(jù)的文本格式并不多見(jiàn) -- 但你不久就可以發(fā)現(xiàn)它們用在字符串替換上非常有用。

無(wú)捕獲組和命名組

精心設(shè)計(jì)的 REs 也許會(huì)用很多組，既可以捕獲感興趣的子串，又可以分組和結(jié)構(gòu)化 RE 本身。在復(fù)雜的 REs 里，追蹤組號(hào)變得困難。有兩個(gè)功能可以對(duì)這個(gè)問(wèn)題有所幫助。它們也都使用正則表達(dá)式擴(kuò)展的通用語(yǔ)法，因此我們來(lái)看看第一個(gè)。

Perl 5 對(duì)標(biāo)準(zhǔn)正則表達(dá)式增加了幾個(gè)附加功能，Python 的 re 模塊也支持其中的大部分。選擇一個(gè)新的單按鍵元字符或一個(gè)以 "\" 開(kāi)始的特殊序列來(lái)表示新的功能，而又不會(huì)使 Perl 正則表達(dá)式與標(biāo)準(zhǔn)正則表達(dá)式產(chǎn)生混亂是有難度的。如果你選擇 "&" 做為新的元字符，舉個(gè)例子，老的表達(dá)式認(rèn)為 "&" 是一個(gè)正常的字符，而不會(huì)在使用 \& 或 [&] 時(shí)也不會(huì)轉(zhuǎn)義。

Perl 開(kāi)發(fā)人員的解決方法是使用 (?...) 來(lái)做為擴(kuò)展語(yǔ)法。"?" 在括號(hào)后面會(huì)直接導(dǎo)致一個(gè)語(yǔ)法錯(cuò)誤，因?yàn)?"?" 沒(méi)有任何字符可以重復(fù)，因此它不會(huì)產(chǎn)生任何兼容問(wèn)題。緊隨 "?" 之后的字符指出擴(kuò)展的用途，因此 (?=foo)

Python 新增了一個(gè)擴(kuò)展語(yǔ)法到 Perl 擴(kuò)展語(yǔ)法中。如果在問(wèn)號(hào)后的第一個(gè)字符是 "P"，你就可以知道它是針對(duì) Python 的擴(kuò)展。目前有兩個(gè)這樣的擴(kuò)展: (?P<name>...) 定義一個(gè)命名組，(?P=name) 則是對(duì)命名組的逆向引用。如果 Perl 5 的未來(lái)版本使用不同的語(yǔ)法增加了相同的功能，那么 re 模塊也將改變以支持新的語(yǔ)法，這是為了兼容性的目的而保持的 Python 專用語(yǔ)法。

現(xiàn)在我們看一下普通的擴(kuò)展語(yǔ)法，我們回過(guò)頭來(lái)簡(jiǎn)化在復(fù)雜 REs 中使用組運(yùn)行的特性。因?yàn)榻M是從左到右編號(hào)的，而且一個(gè)復(fù)雜的表達(dá)式也許會(huì)使用許多組，它可以使跟蹤當(dāng)前組號(hào)變得困難，而修改如此復(fù)雜的 RE 是十分麻煩的。在開(kāi)始時(shí)插入一個(gè)新組，你可以改變它之后的每個(gè)組號(hào)。

首先，有時(shí)你想用一個(gè)組去收集正則表達(dá)式的一部分，但又對(duì)組的內(nèi)容不感興趣。你可以用一個(gè)無(wú)捕獲組: (?:...) 來(lái)實(shí)現(xiàn)這項(xiàng)功能，這樣你可以在括號(hào)中發(fā)送任何其他正則表達(dá)式。

#!python
>>> m = re.match("([abc])+", "abc")
>>> m.groups()
('c',)
>>> m = re.match("(?:[abc])+", "abc")
>>> m.groups()
()

除了捕獲匹配組的內(nèi)容之外，無(wú)捕獲組與捕獲組表現(xiàn)完全一樣；你可以在其中放置任何字符，可以用重復(fù)元字符如 "*" 來(lái)重復(fù)它，可以在其他組（無(wú)捕獲組與捕獲組）中嵌套它。(?:...) 對(duì)于修改已有組尤其有用，因?yàn)槟憧梢圆挥酶淖兯衅渌M號(hào)的情況下添加一個(gè)新組。捕獲組和無(wú)捕獲組在搜索效率方面也沒(méi)什么不同，沒(méi)有哪一個(gè)比另一個(gè)更快。

其次，更重要和強(qiáng)大的是命名組；與用數(shù)字指定組不同的是，它可以用名字來(lái)指定。

命令組的語(yǔ)法是 Python 專用擴(kuò)展之一： (?P<name>...)。名字很明顯是組的名字。除了該組有個(gè)名字之外，命名組也同捕獲組是相同的。`MatchObject` 的方法處理捕獲組時(shí)接受的要么是表示組號(hào)的整數(shù)，要么是包含組名的字符串。命名組也可以是數(shù)字，所以你可以通過(guò)兩種方式來(lái)得到一個(gè)組的信息：

#!python
>>> p = re.compile(r'(?P<word>\b\w+\b)')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'
>>> m.group(1)
'Lots'

命名組是便于使用的，因?yàn)樗梢宰屇闶褂萌菀子涀〉拿謥?lái)代替不得不記住的數(shù)字。這里有一個(gè)來(lái)自 imaplib 模塊的 RE 示例：

#!python
InternalDate = re.compile(r'INTERNALDATE "'
r'(?P<day>[ 123][0-9])-(?P<mon>[A-Z][a-z][a-z])-'
	r'(?P<year>[0-9][0-9][0-9][0-9])'
r' (?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])'
r' (?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])'
r'"')

很明顯，得到 m.group('zonem') 要比記住得到組 9 要容易得多。

因?yàn)槟嫦蛞玫恼Z(yǔ)法，象 (...)\1 這樣的表達(dá)式所表示的是組號(hào)，這時(shí)用組名代替組號(hào)自然會(huì)有差別。還有一個(gè) Python 擴(kuò)展：(?P=name) ，它可以使叫 name 的組內(nèi)容再次在當(dāng)前位置發(fā)現(xiàn)。正則表達(dá)式為了找到重復(fù)的單詞，(\b\w+)\s+\1 也可以被寫(xiě)成 (?P<word>\b\w+)\s+(?P=word)：

#!python
>>> p = re.compile(r'(?P<word>\b\w+)\s+(?P=word)')
>>> p.search('Paris in the the spring').group()
'the the'

  前向界定符

另一個(gè)零寬界定符（zero-width assertion）是前向界定符。前向界定符包括前向肯定界定符和前項(xiàng)否定界定符，所下所示：

(?=...)

前向肯定界定符。如果所含正則表達(dá)式，以 ... 表示，在當(dāng)前位置成功匹配時(shí)成功，否則失敗。但一旦所含表達(dá)式已經(jīng)嘗試，匹配引擎根本沒(méi)有提高；模式的剩余部分還要嘗試界定符的右邊。

(?!...)

前向否定界定符。與肯定界定符相反；當(dāng)所含表達(dá)式不能在字符串當(dāng)前位置匹配時(shí)成功

通過(guò)示范在哪前向可以成功有助于具體實(shí)現(xiàn)。考慮一個(gè)簡(jiǎn)單的模式用于匹配一個(gè)文件名，并將其通過(guò) "." 分成基本名和擴(kuò)展名兩部分。如在 "news.rc" 中，"news" 是基本名，"rc" 是文件的擴(kuò)展名。

匹配模式非常簡(jiǎn)單：

.*[.].*$

注意 "." 需要特殊對(duì)待，因?yàn)樗且粋€(gè)元字符；我把它放在一個(gè)字符類中。另外注意后面的 $; 添加這個(gè)是為了確保字符串所有的剩余部分必須被包含在擴(kuò)展名中。這個(gè)正則表達(dá)式匹配 "foo.bar"、"autoexec.bat"、 "sendmail.cf" 和 "printers.conf"。

現(xiàn)在，考慮把問(wèn)題變得復(fù)雜點(diǎn)；如果你想匹配的擴(kuò)展名不是 "bat" 的文件名？一些不正確的嘗試：

.*[.][^b].*$

上面的第一次去除 "bat" 的嘗試是要求擴(kuò)展名的第一個(gè)字符不是 "b"。這是錯(cuò)誤的，因?yàn)樵撃Ｊ揭膊荒芷ヅ?"foo.bar"。

.*[.]([^b]..|.[^a].|..[^t])$

當(dāng)你試著修補(bǔ)第一個(gè)解決方法而要求匹配下列情況之一時(shí)表達(dá)式更亂了：擴(kuò)展名的第一個(gè)字符不是 "b"; 第二個(gè)字符不是 "a"；或第三個(gè)字符不是 "t"。這樣可以接受 "foo.bar" 而拒絕 "autoexec.bat"，但這要求只能是三個(gè)字符的擴(kuò)展名而不接受兩個(gè)字符的擴(kuò)展名如 "sendmail.cf"。我們將在努力修補(bǔ)它時(shí)再次把該模式變得復(fù)雜。

.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$

在第三次嘗試中，第二和第三個(gè)字母都變成可選，為的是允許匹配比三個(gè)字符更短的擴(kuò)展名，如 "sendmail.cf"。

該模式現(xiàn)在變得非常復(fù)雜，這使它很難讀懂。更糟的是，如果問(wèn)題變化了，你想擴(kuò)展名不是 "bat" 和 "exe"，該模式甚至?xí)兊酶鼜?fù)雜和混亂。

前向否定把所有這些裁剪成：

.*[.](?!bat$).*$

前向的意思：如果表達(dá)式 bat 在這里沒(méi)有匹配，嘗試模式的其余部分；如果 bat$ 匹配，整個(gè)模式將失敗。后面的 $ 被要求是為了確保象 "sample.batch" 這樣擴(kuò)展名以 "bat" 開(kāi)頭的會(huì)被允許。

將另一個(gè)文件擴(kuò)展名排除在外現(xiàn)在也容易；簡(jiǎn)單地將其做為可選項(xiàng)放在界定符中。下面的這個(gè)模式將以 "bat" 或 "exe" 結(jié)尾的文件名排除在外。

.*[.](?!bat$|exe$).*$

修改字符串

到目前為止，我們簡(jiǎn)單地搜索了一個(gè)靜態(tài)字符串。正則表達(dá)式通常也用不同的方式，通過(guò)下面的 `RegexObject` 方法，來(lái)修改字符串。

將字符串分片

`RegexObject` 的 split() 方法在 RE 匹配的地方將字符串分片，將返回列表。它同字符串的 split() 方法相似但提供更多的定界符；split()只支持空白符和固定字符串。就象你預(yù)料的那樣，也有一個(gè)模塊級(jí)的 re.split() 函數(shù)。

split(string [, maxsplit = 0])

通過(guò)正則表達(dá)式將字符串分片。如果捕獲括號(hào)在 RE 中使用，那么它們的內(nèi)容也會(huì)作為結(jié)果列表的一部分返回。如果 maxsplit 非零，那么最多只能分出 maxsplit 個(gè)分片。

你可以通過(guò)設(shè)置 maxsplit 值來(lái)限制分片數(shù)。當(dāng) maxsplit 非零時(shí)，最多只能有 maxsplit 個(gè)分片，字符串的其余部分被做為列表的最后部分返回。在下面的例子中，定界符可以是非數(shù)字字母字符的任意序列。

#!python
>>> p = re.compile(r'\W+')
>>> p.split('This is a test, short and sweet, of split().')
['This', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']
>>> p.split('This is a test, short and sweet, of split().', 3)
['This', 'is', 'a', 'test, short and sweet, of split().']

有時(shí)，你不僅對(duì)定界符之間的文本感興趣，也需要知道定界符是什么。如果捕獲括號(hào)在 RE 中使用，那么它們的值也會(huì)當(dāng)作列表的一部分返回。比較下面的調(diào)用：

#!python
>>> p = re.compile(r'\W+')
>>> p2 = re.compile(r'(\W+)')
>>> p.split('This... is a test.')
['This', 'is', 'a', 'test', '']
>>> p2.split('This... is a test.')
['This', '... ', 'is', ' ', 'a', ' ', 'test', '.', '']

模塊級(jí)函數(shù) re.split() 將 RE 作為第一個(gè)參數(shù)，其他一樣。

#!python
>>> re.split('[\W]+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('([\W]+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('[\W]+', 'Words, words, words.', 1)
['Words', 'words, words.']

搜索和替換

其他常見(jiàn)的用途就是找到所有模式匹配的字符串并用不同的字符串來(lái)替換它們。sub() 方法提供一個(gè)替換值，可以是字符串或一個(gè)函數(shù)，和一個(gè)要被處理的字符串。

sub(replacement, string[, count = 0])

返回的字符串是在字符串中用 RE 最左邊不重復(fù)的匹配來(lái)替換。如果模式?jīng)]有發(fā)現(xiàn)，字符將被沒(méi)有改變地返回。

可選參數(shù) count 是模式匹配后替換的最大次數(shù)；count 必須是非負(fù)整數(shù)。缺省值是 0 表示替換所有的匹配。

這里有個(gè)使用 sub() 方法的簡(jiǎn)單例子。它用單詞 "colour" 替換顏色名。

#!python
>>> p = re.compile( '(blue|white|red)')
>>> p.sub( 'colour', 'blue socks and red shoes')
'colour socks and colour shoes'
>>> p.sub( 'colour', 'blue socks and red shoes', count=1)
'colour socks and red shoes'

subn() 方法作用一樣，但返回的是包含新字符串和替換執(zhí)行次數(shù)的兩元組。

#!python
>>> p = re.compile( '(blue|white|red)')
>>> p.subn( 'colour', 'blue socks and red shoes')
('colour socks and colour shoes', 2)
>>> p.subn( 'colour', 'no colours at all')
('no colours at all', 0)

空匹配只有在它們沒(méi)有緊挨著前一個(gè)匹配時(shí)才會(huì)被替換掉。

#!python
>>> p = re.compile('x*')
>>> p.sub('-', 'abxd')
'-a-b-d-'

如果替換的是一個(gè)字符串，任何在其中的反斜杠都會(huì)被處理。"\n" 將會(huì)被轉(zhuǎn)換成一個(gè)換行符，"\r"轉(zhuǎn)換成回車等等。未知的轉(zhuǎn)義如 "\j" 則保持原樣。逆向引用，如 "\6"，被 RE 中相應(yīng)的組匹配而被子串替換。這使你可以在替換后的字符串中插入原始文本的一部分。

這個(gè)例子匹配被 "{" 和 "}" 括起來(lái)的單詞 "section"，并將 "section" 替換成 "subsection"。

#!python
>>> p = re.compile('section{ ( [^}]* ) }', re.VERBOSE)
>>> p.sub(r'subsection{\1}','section{First} section{second}')
'subsection{First} subsection{second}'

還可以指定用 (?P<name>...) 語(yǔ)法定義的命名組。"\g<name>" 將通過(guò)組名 "name" 用子串來(lái)匹配，并且 "\g<number>" 使用相應(yīng)的組號(hào)。所以 "\g<2>" 等于 "\2"，但能在替換字符串里含義不清，如 "\g<2>0"。（"\20" 被解釋成對(duì)組 20 的引用，而不是對(duì)后面跟著一個(gè)字母 "0" 的組 2 的引用。）

#!python
>>> p = re.compile('section{ (?P<name> [^}]* ) }', re.VERBOSE)
>>> p.sub(r'subsection{\1}','section{First}')
'subsection{First}'
>>> p.sub(r'subsection{\g<1>}','section{First}')
'subsection{First}'
>>> p.sub(r'subsection{\g<name>}','section{First}')
'subsection{First}'

替換也可以是一個(gè)甚至給你更多控制的函數(shù)。如果替換是個(gè)函數(shù)，該函數(shù)將會(huì)被模式中每一個(gè)不重復(fù)的匹配所調(diào)用。在每個(gè)調(diào)用時(shí)，函數(shù)被作為 `MatchObject` 的匹配函屬，并可以使用這個(gè)信息去計(jì)算預(yù)期的字符串并返回它。

在下面的例子里，替換函數(shù)將十進(jìn)制翻譯成十六進(jìn)制：

#!python
>>> def hexrepl( match ):
...     "Return the hex string for a decimal number"
...     value = int( match.group() )
...     return hex(value)
...
>>> p = re.compile(r'\d+')
>>> p.sub(hexrepl, 'Call 65490 for printing, 49152 for user code.')
'Call 0xffd2 for printing, 0xc000 for user code.'

當(dāng)使用模塊級(jí)的 re.sub() 函數(shù)時(shí)，模式作為第一個(gè)參數(shù)。模式也許是一個(gè)字符串或一個(gè) `RegexObject`；如果你需要指定正則表達(dá)式標(biāo)志，你必須要么使用 `RegexObject` 做第一個(gè)參數(shù)，或用使用模式內(nèi)嵌修正器，如 sub("(?i)b+", "x", "bbbb BBBB") returns 'x x'。

  常見(jiàn)問(wèn)題

正則表達(dá)式對(duì)一些應(yīng)用程序來(lái)說(shuō)是一個(gè)強(qiáng)大的工具，但在有些時(shí)候它并不直觀而且有時(shí)它們不按你期望的運(yùn)行。本節(jié)將指出一些最容易犯的常見(jiàn)錯(cuò)誤。

  使用字符串方式

有時(shí)使用 re 模塊是個(gè)錯(cuò)誤。如果你匹配一個(gè)固定的字符串或單個(gè)的字符類，并且你沒(méi)有使用 re 的任何象 IGNORECASE 標(biāo)志的功能，那么就沒(méi)有必要使用正則表達(dá)式了。字符串有一些方法是對(duì)固定字符串進(jìn)行操作的，它們通?？旌芏啵?yàn)樗鼈兌际且粋€(gè)個(gè)經(jīng)過(guò)優(yōu)化的 C 小循環(huán)，用以代替大的、更具通用性的正則表達(dá)式引擎。

舉個(gè) 用一個(gè)固定字符串替換另一個(gè) 的例子，如：你可以把 "deed" 替換成 "word"。re.sub() 似乎正是勝任這個(gè)工作的函數(shù)，但還是考慮考慮 replace() 方法吧。注意 replace() 也可以在單詞里面進(jìn)行替換，可以把 "swordfish" 變成 "sdeedfish"。不過(guò) RE 也是可以做到的。（為了避免替換單詞的一部分，模式將寫(xiě)成 \bword\b，這是為了要求 "word" 兩邊有一個(gè)單詞邊界。這是個(gè)超出 replace 能力的工作）。

另一個(gè)常見(jiàn)任務(wù)是從一個(gè)字符串中刪除單個(gè)字符或用另一個(gè)字符來(lái)替代它。你也許可以用 re.sub('\n',' ', s) 這樣來(lái)實(shí)現(xiàn)，但 translate() 能夠?qū)崿F(xiàn)這兩個(gè)任務(wù)，而且比任何正則表達(dá)式操作起來(lái)更快。 （translate 需要配合 string.maketrans 使用。例如：import string 后 'a1b3'.translate(string.maketrans('ab', 'cd')) ）

總之，在使用 re 模塊之前，先考慮一下你的問(wèn)題是否可以用更快、更簡(jiǎn)單的字符串方法來(lái)解決。

match() vs search()

match() 函數(shù)只檢查 RE 是否在字符串開(kāi)始處匹配，而 search() 則是掃描整個(gè)字符串。記住這一區(qū)別是重要的。記住，match() 只報(bào)告一次成功的匹配，它將從 0 處開(kāi)始；如果匹配不是從 0 開(kāi)始的，match() 將不會(huì)報(bào)告它。

#!python
>>> print re.match('super', 'superstition').span()
(0, 5)
>>> print re.match('super', 'insuperable')
None

另一方面，search() 將掃描整個(gè)字符串，并報(bào)告它找到的第一個(gè)匹配。

#!python
>>> print re.search('super', 'superstition').span()
(0, 5)
>>> print re.search('super', 'insuperable').span()
(2, 7)

有時(shí)你可能傾向于使用 re.match()，只在RE的前面部分添加 .* 。請(qǐng)盡量不要這么做，最好采用 re.search() 代替之。正則表達(dá)式編譯器會(huì)對(duì) REs 做一些分析以便可以在查找匹配時(shí)提高處理速度。一個(gè)那樣的分析機(jī)會(huì)指出匹配的第一個(gè)字符是什么；舉個(gè)例子，模式 Crow 必須從 "C" 開(kāi)始匹配。分析機(jī)可以讓引擎快速掃描字符串以找到開(kāi)始字符，并只在 "C" 被發(fā)現(xiàn)后才開(kāi)始全部匹配。

添加 .* 會(huì)使這個(gè)優(yōu)化失敗，這就要掃描到字符串尾部，然后回溯以找到 RE 剩余部分的匹配。使用 re.search() 代替。

貪婪 vs 不貪婪

當(dāng)重復(fù)一個(gè)正則表達(dá)式時(shí)，如用 a*，操作結(jié)果是盡可能多地匹配模式。當(dāng)你試著匹配一對(duì)對(duì)稱的定界符，如 HTML 標(biāo)志中的尖括號(hào)時(shí)這個(gè)事實(shí)經(jīng)常困擾你。匹配單個(gè) HTML 標(biāo)志的模式不能正常工作，因?yàn)?.* 的本質(zhì)是“貪婪”的

#!python
>>> s = '<html><head><title>Title</title>'
>>> len(s)
32
>>> print re.match('<.*>', s).span()
(0, 32)
>>> print re.match('<.*>', s).group()
<html><head><title>Title</title>

RE 匹配 在 "<html>" 中的 "<"，.* 消耗掉子符串的剩余部分。在 RE 中保持更多的左，雖然 > 不能匹配在字符串結(jié)尾，因此正則表達(dá)式必須一個(gè)字符一個(gè)字符地回溯，直到它找到 > 的匹配。最終的匹配從 "<html" 中的 "<" 到 "</title>" 中的 ">",這并不是你所想要的結(jié)果。

在這種情況下，解決方案是使用不貪婪的限定符 *?、+?、?? 或 {m,n}?，盡可能匹配小的文本。在上面的例子里， ">" 在第一個(gè) "<" 之后被立即嘗試，當(dāng)它失敗時(shí)，引擎一次增加一個(gè)字符，并在每步重試 ">"。這個(gè)處理將得到正確的結(jié)果：

#!python
>>> print re.match('<.*?>', s).group()
<html>

注意用正則表達(dá)式分析 HTML 或 XML 是痛苦的。變化混亂的模式將處理常見(jiàn)情況，但 HTML 和 XML 則是明顯會(huì)打破正則表達(dá)式的特殊情況；當(dāng)你編寫(xiě)一個(gè)正則表達(dá)式去處理所有可能的情況時(shí)，模式將變得非常復(fù)雜。象這樣的任務(wù)用 HTML 或 XML 解析器。

不用 re.VERBOSE

現(xiàn)在你可能注意到正則表達(dá)式的表示是十分緊湊，但它們非常不好讀。中度復(fù)雜的 REs 可以變成反斜杠、圓括號(hào)和元字符的長(zhǎng)長(zhǎng)集合，以致于使它們很難讀懂。

在這些 REs 中，當(dāng)編譯正則表達(dá)式時(shí)指定 re.VERBOSE 標(biāo)志是有幫助的，因?yàn)樗试S你可以編輯正則表達(dá)式的格式使之更清楚。

re.VERBOSE 標(biāo)志有這么幾個(gè)作用。在正則表達(dá)式中不在字符類中的空白符被忽略。這就意味著象 dog | cat 這樣的表達(dá)式和可讀性差的 dog|cat 相同，但 [a b] 將匹配字符 "a"、"b" 或 空格。另外，你也可以把注釋放到 RE 中；注釋是從 "#" 到下一行。當(dāng)使用三引號(hào)字符串時(shí)，可以使 REs 格式更加干凈：

#!python
pat = re.compile(r"""
\s*                 # Skip leading whitespace
(?P<header>[^:]+)   # Header name
\s* :               # Whitespace, and a colon
(?P<value>.*?)      # The header's value -- *? used to
# lose the following trailing whitespace
\s*$                # Trailing whitespace to end-of-line
""", re.VERBOSE)

這個(gè)要難讀得多：

#!python
pat = re.compile(r"\s*(?P<header>[^:]+)\s*:(?P<value>.*?)\s*$")

 反饋

正則表達(dá)式是一個(gè)復(fù)雜的主題。本文能否有助于你理解呢？那些部分是否不清晰，或在這兒沒(méi)有找到你所遇到的問(wèn)題？如果是那樣的話，請(qǐng)將建議發(fā)給作者以便改進(jìn)。

描述正則表達(dá)式最全面的書(shū)非Jeffrey Friedl 寫(xiě)的《精通正則表達(dá)式》莫屬，該書(shū)由O'Reilly 出版?？上г摃?shū)只專注于 Perl 和 Java 風(fēng)格的正則表達(dá)式，不含任何 Python 材料，所以不足以用作Python編程時(shí)的參考。（第一版包含有 Python 現(xiàn)已過(guò)時(shí)的 regex 模塊，自然用處不大）。

《精通正則表達(dá)式》第三版已經(jīng)有部分正則表達(dá)式使用python說(shuō)明，另外PHP風(fēng)格的更是獨(dú)立一個(gè)章節(jié)說(shuō)明。--why