re --- 正則表達(dá)式操作?

正則表達(dá)式語(yǔ)法?

正則表達(dá)式（或 RE）指定了一組與之匹配的字符串；模塊內(nèi)的函數(shù)可以檢查某個(gè)字符串是否與給定的正則表達(dá)式匹配（或者正則表達(dá)式是否匹配到字符串，這兩種說(shuō)法含義相同）。

正則表達(dá)式可以拼接；如果 A 和 B 都是正則表達(dá)式，則 AB 也是正則表達(dá)式。通常，如果字符串 p 匹配 A，并且另一個(gè)字符串 q 匹配 B，那么 pq 可以匹配 AB。除非 A 或者 B 包含低優(yōu)先級(jí)操作，A 和 B 存在邊界條件；或者命名組引用。所以，復(fù)雜表達(dá)式可以很容易的從這里描述的簡(jiǎn)單源語(yǔ)表達(dá)式構(gòu)建。更多正則表達(dá)式理論和實(shí)現(xiàn)，詳見(jiàn) the Friedl book [Frie09] ，或者其他構(gòu)建編譯器的書籍。

以下是正則表達(dá)式格式的簡(jiǎn)要說(shuō)明。更詳細(xì)的信息和演示，參考 正則表達(dá)式HOWTO。

正則表達(dá)式可以包含普通或者特殊字符。絕大部分普通字符，比如 'A', 'a', 或者 '0'，都是最簡(jiǎn)單的正則表達(dá)式。它們就匹配自身。你可以拼接普通字符，所以 last 匹配字符串 'last'. （在這一節(jié)的其他部分，我們將用 this special style 這種方式表示正則表達(dá)式，通常不帶引號(hào)，要匹配的字符串用 'in single quotes' ，單引號(hào)形式。）

有些字符，比如 '|' 或者 '('，屬于特殊字符。 特殊字符既可以表示它的普通含義， 也可以影響它旁邊的正則表達(dá)式的解釋。

Repetition operators or quantifiers (*, +, ?, {m,n}, etc) cannot be directly nested. This avoids ambiguity with the non-greedy modifier suffix ?, and with other modifiers in other implementations. To apply a second repetition to an inner repetition, parentheses may be used. For example, the expression (?:a{6})* matches any multiple of six 'a' characters.

特殊字符有：

.

(點(diǎn)) 在默認(rèn)模式，匹配除了換行的任意字符。如果指定了標(biāo)簽 DOTALL ，它將匹配包括換行符的任意字符。

^

(插入符號(hào)) 匹配字符串的開(kāi)頭， 并且在 MULTILINE 模式也匹配換行后的首個(gè)符號(hào)。

$

匹配字符串尾或者在字符串尾的換行符的前一個(gè)字符，在 MULTILINE 模式下也會(huì)匹配換行符之前的文本。 foo 匹配 'foo' 和 'foobar'，但正則表達(dá)式 foo$ 只匹配 'foo'。 更有趣的是，在 'foo1\nfoo2\n' 中搜索 foo.$，通常匹配 'foo2'，但在 MULTILINE 模式下可以匹配到 'foo1'；在 'foo\n' 中搜索 $ 會(huì)找到兩個(gè)（空的）匹配：一個(gè)在換行符之前，一個(gè)在字符串的末尾。

*

對(duì)它前面的正則式匹配0到任意次重復(fù)， 盡量多的匹配字符串。 ab* 會(huì)匹配 'a'，'ab'，或者 'a' 后面跟隨任意個(gè) 'b'。

+

對(duì)它前面的正則式匹配1到任意次重復(fù)。 ab+ 會(huì)匹配 'a' 后面跟隨1個(gè)以上到任意個(gè) 'b'，它不會(huì)匹配 'a'。

?

對(duì)它前面的正則式匹配0到1次重復(fù)。 ab? 會(huì)匹配 'a' 或者 'ab'。

*?, +?, ??

The '*', '+', and '?' quantifiers are all greedy; they match as much text as possible. Sometimes this behaviour isn't desired; if the RE <.*> is matched against '<a> b <c>', it will match the entire string, and not just '<a>'. Adding ? after the quantifier makes it perform the match in non-greedy or minimal fashion; as few characters as possible will be matched. Using the RE <.*?> will match only '<a>'.

*+, ++, ?+

Like the '*', '+', and '?' quantifiers, those where '+' is appended also match as many times as possible. However, unlike the true greedy quantifiers, these do not allow back-tracking when the expression following it fails to match. These are known as possessive quantifiers. For example, a*a will match 'aaaa' because the a* will match all 4 'a's, but, when the final 'a' is encountered, the expression is backtracked so that in the end the a* ends up matching 3 'a's total, and the fourth 'a' is matched by the final 'a'. However, when a*+a is used to match 'aaaa', the a*+ will match all 4 'a', but when the final 'a' fails to find any more characters to match, the expression cannot be backtracked and will thus fail to match. x*+, x++ and x?+ are equivalent to (?>x*), (?>x+) and (?>x?) correspondingly.

3.11 新版功能.

{m}

對(duì)其之前的正則式指定匹配 m 個(gè)重復(fù)；少于 m 的話就會(huì)導(dǎo)致匹配失敗。比如， a{6} 將匹配6個(gè) 'a' , 但是不能是5個(gè)。

{m,n}

對(duì)正則式進(jìn)行 m 到 n 次匹配，在 m 和 n 之間取盡量多。 比如，a{3,5} 將匹配 3 到 5個(gè) 'a'。忽略 m 意為指定下界為0，忽略 n 指定上界為無(wú)限次。 比如 a{4,}b 將匹配 'aaaab' 或者1000個(gè) 'a' 尾隨一個(gè) 'b'，但不能匹配 'aaab'。逗號(hào)不能省略，否則無(wú)法辨別修飾符應(yīng)該忽略哪個(gè)邊界。

{m,n}?

Causes the resulting RE to match from m to n repetitions of the preceding RE, attempting to match as few repetitions as possible. This is the non-greedy version of the previous quantifier. For example, on the 6-character string 'aaaaaa', a{3,5} will match 5 'a' characters, while a{3,5}? will only match 3 characters.

{m,n}+

Causes the resulting RE to match from m to n repetitions of the preceding RE, attempting to match as many repetitions as possible without establishing any backtracking points. This is the possessive version of the quantifier above. For example, on the 6-character string 'aaaaaa', a{3,5}+aa attempt to match 5 'a' characters, then, requiring 2 more 'a's, will need more characters than available and thus fail, while a{3,5}aa will match with a{3,5} capturing 5, then 4 'a's by backtracking and then the final 2 'a's are matched by the final aa in the pattern. x{m,n}+ is equivalent to (?>x{m,n}).

3.11 新版功能.

\

轉(zhuǎn)義特殊字符（允許你匹配 '*', '?', 或者此類其他），或者表示一個(gè)特殊序列；特殊序列之后進(jìn)行討論。

如果你沒(méi)有使用原始字符串（ r'raw' ）來(lái)表達(dá)樣式，要牢記Python也使用反斜杠作為轉(zhuǎn)義序列；如果轉(zhuǎn)義序列不被Python的分析器識(shí)別，反斜杠和字符才能出現(xiàn)在字符串中。如果Python可以識(shí)別這個(gè)序列，那么反斜杠就應(yīng)該重復(fù)兩次。這將導(dǎo)致理解障礙，所以高度推薦，就算是最簡(jiǎn)單的表達(dá)式，也要使用原始字符串。

[]

用于表示一個(gè)字符集合。在一個(gè)集合中：

• 字符可以單獨(dú)列出，比如 [amk] 匹配 'a'， 'm'， 或者 'k'。

• 可以表示字符范圍，通過(guò)用 '-' 將兩個(gè)字符連起來(lái)。比如 [a-z] 將匹配任何小寫ASCII字符， [0-5][0-9] 將匹配從 00 到 59 的兩位數(shù)字， [0-9A-Fa-f] 將匹配任何十六進(jìn)制數(shù)位。 如果 - 進(jìn)行了轉(zhuǎn)義 （比如 [a\-z]）或者它的位置在首位或者末尾（如 [-a] 或 [a-]），它就只表示普通字符 '-'。

• 特殊字符在集合中，失去它的特殊含義。比如 [(+*)] 只會(huì)匹配這幾個(gè)文法字符 '(', '+', '*', or ')'。

• 字符類如 \w 或者 \S (如下定義) 在集合內(nèi)可以接受，它們可以匹配的字符由 ASCII 或者 LOCALE 模式?jīng)Q定。

• 不在集合范圍內(nèi)的字符可以通過(guò) 取反 來(lái)進(jìn)行匹配。如果集合首字符是 '^' ，所有 不 在集合內(nèi)的字符將會(huì)被匹配，比如 [^5] 將匹配所有字符，除了 '5'， [^^] 將匹配所有字符，除了 '^'. ^ 如果不在集合首位，就沒(méi)有特殊含義。

• 在集合內(nèi)要匹配一個(gè)字符 ']'，有兩種方法，要么就在它之前加上反斜杠，要么就把它放到集合首位。比如， [()[\]{}] 和 []()[{}] 都可以匹配括號(hào)。

• Unicode Technical Standard #18 里的嵌套集合和集合操作支持可能在未來(lái)添加。這將會(huì)改變語(yǔ)法，所以為了幫助這個(gè)改變，一個(gè) FutureWarning 將會(huì)在有多義的情況里被 raise，包含以下幾種情況，集合由 '[' 開(kāi)始，或者包含下列字符序列 '--', '&&', '~~', 和 '||'。為了避免警告，需要將它們用反斜杠轉(zhuǎn)義。

在 3.7 版更改: 如果一個(gè)字符串構(gòu)建的語(yǔ)義在未來(lái)會(huì)改變的話，一個(gè) FutureWarning 會(huì) raise 。

|

A|B， A 和 B 可以是任意正則表達(dá)式，創(chuàng)建一個(gè)正則表達(dá)式，匹配 A 或者 B. 任意個(gè)正則表達(dá)式可以用 '|' 連接。它也可以在組合（見(jiàn)下列）內(nèi)使用。掃描目標(biāo)字符串時(shí)， '|' 分隔開(kāi)的正則樣式從左到右進(jìn)行匹配。當(dāng)一個(gè)樣式完全匹配時(shí)，這個(gè)分支就被接受。意思就是，一旦 A 匹配成功， B 就不再進(jìn)行匹配，即便它能產(chǎn)生一個(gè)更好的匹配?；蛘哒f(shuō)，'|' 操作符絕不貪婪。 如果要匹配 '|' 字符，使用 \|， 或者把它包含在字符集里，比如 [|].

(...)

（組合），匹配括號(hào)內(nèi)的任意正則表達(dá)式，并標(biāo)識(shí)出組合的開(kāi)始和結(jié)尾。匹配完成后，組合的內(nèi)容可以被獲取，并可以在之后用 \number 轉(zhuǎn)義序列進(jìn)行再次匹配，之后進(jìn)行詳細(xì)說(shuō)明。要匹配字符 '(' 或者 ')', 用 \( 或 \), 或者把它們包含在字符集合里: [(], [)].

(?…)

這是個(gè)擴(kuò)展標(biāo)記法 （一個(gè) '?' 跟隨 '(' 并無(wú)含義）。 '?' 后面的第一個(gè)字符決定了這個(gè)構(gòu)建采用什么樣的語(yǔ)法。這種擴(kuò)展通常并不創(chuàng)建新的組合； (?P<name>...) 是唯一的例外。 以下是目前支持的擴(kuò)展。

(?aiLmsux)

( 'a', 'i', 'L', 'm', 's', 'u', 'x' 中的一個(gè)或多個(gè)) 這個(gè)組合匹配一個(gè)空字符串；這些字符對(duì)正則表達(dá)式設(shè)置以下標(biāo)記 re.A (只匹配ASCII字符), re.I (忽略大小寫), re.L (語(yǔ)言依賴), re.M (多行模式), re.S (點(diǎn)dot匹配全部字符), re.U (Unicode匹配), and re.X (冗長(zhǎng)模式)。 (這些標(biāo)記在 模塊內(nèi)容 中描述) 如果你想將這些標(biāo)記包含在正則表達(dá)式中，這個(gè)方法就很有用，免去了在 re.compile() 中傳遞 flag 參數(shù)。標(biāo)記應(yīng)該在表達(dá)式字符串首位表示。

在 3.11 版更改: This construction can only be used at the start of the expression.

(?:…)

正則括號(hào)的非捕獲版本。 匹配在括號(hào)內(nèi)的任何正則表達(dá)式，但該分組所匹配的子字符串 不能 在執(zhí)行匹配后被獲取或是之后在模式中被引用。

(?aiLmsux-imsx:…)

('a', 'i', 'L', 'm', 's', 'u', 'x' 中的0或者多個(gè)， 之后可選跟隨 '-' 在后面跟隨 'i' , 'm' , 's' , 'x' 中的一到多個(gè) .) 這些字符為表達(dá)式的其中一部分 設(shè)置 或者 去除 相應(yīng)標(biāo)記 re.A (只匹配ASCII), re.I (忽略大小寫), re.L (語(yǔ)言依賴), re.M (多行), re.S (點(diǎn)匹配所有字符), re.U (Unicode匹配), and re.X (冗長(zhǎng)模式)。(標(biāo)記描述在 模塊內(nèi)容 .)

'a', 'L' and 'u' 作為內(nèi)聯(lián)標(biāo)記是相互排斥的， 所以它們不能結(jié)合在一起，或者跟隨 '-' 。 當(dāng)他們中的某個(gè)出現(xiàn)在內(nèi)聯(lián)組中，它就覆蓋了括號(hào)組內(nèi)的匹配模式。在Unicode樣式中， (?a:...) 切換為 只匹配ASCII， (?u:...) 切換為Unicode匹配 (默認(rèn)). 在byte樣式中 (?L:...) 切換為語(yǔ)言依賴模式， (?a:...) 切換為 只匹配ASCII (默認(rèn))。這種方式只覆蓋組合內(nèi)匹配，括號(hào)外的匹配模式不受影響。

3.6 新版功能.

在 3.7 版更改: 符號(hào) 'a', 'L' 和 'u' 同樣可以用在一個(gè)組合內(nèi)。

(?>...)

Attempts to match ... as if it was a separate regular expression, and if successful, continues to match the rest of the pattern following it. If the subsequent pattern fails to match, the stack can only be unwound to a point before the (?>...) because once exited, the expression, known as an atomic group, has thrown away all stack points within itself. Thus, (?>.*). would never match anything because first the .* would match all characters possible, then, having nothing left to match, the final . would fail to match. Since there are no stack points saved in the Atomic Group, and there is no stack point before it, the entire expression would thus fail to match.

3.11 新版功能.

(?P<name>…)

Similar to regular parentheses, but the substring matched by the group is accessible via the symbolic group name name. Group names must be valid Python identifiers, and in bytes patterns they must contain only characters in the ASCII range. Each group name must be defined only once within a regular expression. A symbolic group is also a numbered group, just as if the group were not named.

命名組合可以在三種上下文中引用。如果樣式是 (?P<quote>['"]).*?(?P=quote) （也就是說(shuō)，匹配單引號(hào)或者雙引號(hào)括起來(lái)的字符串)：

引用組合 "quote" 的上下文	引用方法
在正則式自身內(nèi)	(?P=quote) (如示) \1
處理匹配對(duì)象 m	m.group('quote') m.end('quote') (等)
傳遞到 re.sub() 里的 repl 參數(shù)中	\g<quote> \g<1> \1

在 3.12 版更改: In bytes patterns group names must contain only characters in the ASCII range.

(?P=name)

反向引用一個(gè)命名組合；它匹配前面那個(gè)叫 name 的命名組中匹配到的串同樣的字串。

(?#…)

注釋；里面的內(nèi)容會(huì)被忽略。

(?=…)

匹配 … 的內(nèi)容，但是并不消費(fèi)樣式的內(nèi)容。這個(gè)叫做 lookahead assertion。比如， Isaac (?=Asimov) 匹配 'Isaac ' 只有在后面是 'Asimov' 的時(shí)候。

(?!…)

匹配 … 不符合的情況。這個(gè)叫 negative lookahead assertion （前視取反）。比如說(shuō)， Isaac (?!Asimov) 只有后面 不 是 'Asimov' 的時(shí)候才匹配 'Isaac ' 。

(?<=…)

匹配字符串的當(dāng)前位置，它的前面匹配 ... 的內(nèi)容到當(dāng)前位置。這叫 positive lookbehind assertion （正向后視斷定）。 (?<=abc)def 會(huì)在 'abcdef' 中找到一個(gè)匹配，因?yàn)楹笠晻?huì)往后看3個(gè)字符并檢查是否包含匹配的樣式。包含的匹配樣式必須是定長(zhǎng)的，意思就是 abc 或 a|b 是允許的，但是 a* 和 a{3,4} 不可以。注意以 positive lookbehind assertions 開(kāi)始的樣式，如 (?<=abc)def ，并不是從 a 開(kāi)始搜索，而是從 d 往回看的。你可能更加愿意使用 search() 函數(shù)，而不是 match() 函數(shù)：

>>>

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

這個(gè)例子搜索一個(gè)跟隨在連字符后的單詞：

>>>

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

在 3.5 版更改: 添加定長(zhǎng)組合引用的支持。

(?<!…)

匹配當(dāng)前位置之前不是 ... 的樣式。這個(gè)叫 negative lookbehind assertion （后視斷定取非）。類似正向后視斷定，包含的樣式匹配必須是定長(zhǎng)的。由 negative lookbehind assertion 開(kāi)始的樣式可以從字符串搜索開(kāi)始的位置進(jìn)行匹配。

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

如果給定的 id 或 name 存在，將會(huì)嘗試匹配 yes-pattern ，否則就嘗試匹配 no-pattern，no-pattern 可選，也可以被忽略。比如， (<)?(\w+@\w+(?:\.\w+)+)(?(1)>|$) 是一個(gè)email樣式匹配，將匹配 '<user@host.com>' 或 'user@host.com' ，但不會(huì)匹配 '<user@host.com' ，也不會(huì)匹配 'user@host.com>'。

在 3.12 版更改: Group id can only contain ASCII digits.

由 '\' 和一個(gè)字符組成的特殊序列在以下列出。 如果普通字符不是ASCII數(shù)位或者ASCII字母，那么正則樣式將匹配第二個(gè)字符。比如，\$ 匹配字符 '$'.

\number

匹配數(shù)字代表的組合。每個(gè)括號(hào)是一個(gè)組合，組合從1開(kāi)始編號(hào)。比如 (.+) \1 匹配 'the the' 或者 '55 55', 但不會(huì)匹配 'thethe' (注意組合后面的空格)。這個(gè)特殊序列只能用于匹配前面99個(gè)組合。如果 number 的第一個(gè)數(shù)位是0， 或者 number 是三個(gè)八進(jìn)制數(shù)，它將不會(huì)被看作是一個(gè)組合，而是八進(jìn)制的數(shù)字值。在 '[' 和 ']' 字符集合內(nèi)，任何數(shù)字轉(zhuǎn)義都被看作是字符。

\A

只匹配字符串開(kāi)始。

\b

匹配空字符串，但只在單詞開(kāi)始或結(jié)尾的位置。一個(gè)單詞被定義為一個(gè)單詞字符的序列。注意，通常 \b 定義為 \w 和 \W 字符之間，或者 \w 和字符串開(kāi)始/結(jié)尾的邊界， 意思就是 r'\bfoo\b' 匹配 'foo', 'foo.', '(foo)', 'bar foo baz' 但不匹配 'foobar' 或者 'foo3'。

默認(rèn)情況下，Unicode字母和數(shù)字是在Unicode樣式中使用的，但是可以用 ASCII 標(biāo)記來(lái)更改。如果 LOCALE 標(biāo)記被設(shè)置的話，詞的邊界是由當(dāng)前語(yǔ)言區(qū)域設(shè)置決定的，\b 表示退格字符，以便與Python字符串文本兼容。

\B

匹配空字符串，但 不 能在詞的開(kāi)頭或者結(jié)尾。意思就是 r'py\B' 匹配 'python', 'py3', 'py2', 但不匹配 'py', 'py.', 或者 'py!'. \B 是 \b 的取非，所以Unicode樣式的詞語(yǔ)是由Unicode字母，數(shù)字或下劃線構(gòu)成的，雖然可以用 ASCII 標(biāo)志來(lái)改變。如果使用了 LOCALE 標(biāo)志，則詞的邊界由當(dāng)前語(yǔ)言區(qū)域設(shè)置。

\d

對(duì)于 Unicode (str) 樣式：

匹配任何Unicode十進(jìn)制數(shù)（就是在Unicode字符目錄[Nd]里的字符）。這包括了 [0-9] ，和很多其他的數(shù)字字符。如果設(shè)置了 ASCII 標(biāo)志，就只匹配 [0-9] 。

對(duì)于8位(bytes)樣式：

匹配任何十進(jìn)制數(shù)，就是 [0-9]。

\D

匹配任何非十進(jìn)制數(shù)字的字符。就是 \d 取非。 如果設(shè)置了 ASCII 標(biāo)志，就相當(dāng)于 [^0-9] 。

\s

對(duì)于 Unicode (str) 樣式：

匹配任何Unicode空白字符（包括 [ \t\n\r\f\v] ，還有很多其他字符，比如不同語(yǔ)言排版規(guī)則約定的不換行空格）。如果 ASCII 被設(shè)置，就只匹配 [ \t\n\r\f\v] 。

對(duì)于8位(bytes)樣式：

匹配ASCII中的空白字符，就是 [ \t\n\r\f\v] 。

\S

匹配任何非空白字符。就是 \s 取非。如果設(shè)置了 ASCII 標(biāo)志，就相當(dāng)于 [^ \t\n\r\f\v] 。

\w

對(duì)于 Unicode (str) 樣式：

匹配Unicode詞語(yǔ)的字符，包含了可以構(gòu)成詞語(yǔ)的絕大部分字符，也包括數(shù)字和下劃線。如果設(shè)置了 ASCII 標(biāo)志，就只匹配 [a-zA-Z0-9_] 。

對(duì)于8位(bytes)樣式：

匹配ASCII字符中的數(shù)字和字母和下劃線，就是 [a-zA-Z0-9_] 。如果設(shè)置了 LOCALE 標(biāo)記，就匹配當(dāng)前語(yǔ)言區(qū)域的數(shù)字和字母和下劃線。

\W

匹配非單詞字符的字符。這與 \w 正相反。如果使用了 ASCII 旗標(biāo)，這就等價(jià)于 [^a-zA-Z0-9_]。如果使用了 LOCALE 旗標(biāo)，則會(huì)匹配當(dāng)前區(qū)域中既非字母數(shù)字也非下劃線的字符。

\Z

只匹配字符串尾。

絕大部分Python的標(biāo)準(zhǔn)轉(zhuǎn)義字符也被正則表達(dá)式分析器支持。:

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

（注意 \b 被用于表示詞語(yǔ)的邊界，它只在字符集合內(nèi)表示退格，比如 [\b] 。）

'\u', '\U' 和 '\N' 轉(zhuǎn)義序列只在 Unicode 模式中可被識(shí)別。 在 bytes 模式中它們會(huì)導(dǎo)致錯(cuò)誤。 未知的 ASCII 字母轉(zhuǎn)義序列保留在未來(lái)使用，會(huì)被當(dāng)作錯(cuò)誤來(lái)處理。

八進(jìn)制轉(zhuǎn)義包含為一個(gè)有限形式。如果首位數(shù)字是 0， 或者有三個(gè)八進(jìn)制數(shù)位，那么就認(rèn)為它是八進(jìn)制轉(zhuǎn)義。其他的情況，就看作是組引用。對(duì)于字符串文本，八進(jìn)制轉(zhuǎn)義最多有三個(gè)數(shù)位長(zhǎng)。

模塊內(nèi)容?

模塊定義了幾個(gè)函數(shù)、常量，和一個(gè)異常。有些函數(shù)是編譯后的正則表達(dá)式方法的簡(jiǎn)化版本（少了一些特性）。重要的應(yīng)用程序大多會(huì)在使用前先編譯正則表達(dá)式。

正則表達(dá)式對(duì)象 （正則對(duì)象）?

編譯后的正則表達(dá)式對(duì)象支持以下方法和屬性：

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

掃描整個(gè) string 尋找第一個(gè)匹配的位置， 并返回一個(gè)相應(yīng)的 匹配對(duì)象。如果沒(méi)有匹配，就返回 None ；注意它和零長(zhǎng)度匹配是不同的。

可選的第二個(gè)參數(shù) pos 給出了字符串中開(kāi)始搜索的位置索引；默認(rèn)為 0，它不完全等價(jià)于字符串切片； '^' 樣式字符匹配字符串真正的開(kāi)頭，和換行符后面的第一個(gè)字符，但不會(huì)匹配索引規(guī)定開(kāi)始的位置。

可選參數(shù) endpos 限定了字符串搜索的結(jié)束；它假定字符串長(zhǎng)度到 endpos ， 所以只有從 pos 到 endpos - 1 的字符會(huì)被匹配。如果 endpos 小于 pos，就不會(huì)有匹配產(chǎn)生；另外，如果 rx 是一個(gè)編譯后的正則對(duì)象， rx.search(string, 0, 50) 等價(jià)于 rx.search(string[:50], 0)。

>>>

>>> pattern = re.compile("d")
>>> pattern.search("dog")     # Match at index 0
<re.Match object; span=(0, 1), match='d'>
>>> pattern.search("dog", 1)  # No match; search doesn't include the "d"

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

如果 string 的 開(kāi)始位置 能夠找到這個(gè)正則樣式的任意個(gè)匹配，就返回一個(gè)相應(yīng)的 匹配對(duì)象。如果不匹配，就返回 None ；注意它與零長(zhǎng)度匹配是不同的。

可選參數(shù) pos 和 endpos 與 search() 含義相同。

>>>

>>> pattern = re.compile("o")
>>> pattern.match("dog")      # No match as "o" is not at the start of "dog".
>>> pattern.match("dog", 1)   # Match as "o" is the 2nd character of "dog".
<re.Match object; span=(1, 2), match='o'>

如果你想定位匹配在 string 中的位置，使用 search() 來(lái)替代（另參考 search() vs. match()）。

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

如果整個(gè) string 匹配這個(gè)正則表達(dá)式，就返回一個(gè)相應(yīng)的 匹配對(duì)象 。 否則就返回 None ； 注意跟零長(zhǎng)度匹配是不同的。

可選參數(shù) pos 和 endpos 與 search() 含義相同。

>>>

>>> pattern = re.compile("o[gh]")
>>> pattern.fullmatch("dog")      # No match as "o" is not at the start of "dog".
>>> pattern.fullmatch("ogre")     # No match as not the full string matches.
>>> pattern.fullmatch("doggie", 1, 3)   # Matches within given limits.
<re.Match object; span=(1, 3), match='og'>

3.4 新版功能.

Pattern.split(string, maxsplit=0)?

等價(jià)于 split() 函數(shù)，使用了編譯后的樣式。

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

類似函數(shù) findall() ， 使用了編譯后樣式，但也可以接收可選參數(shù) pos 和 endpos ，限制搜索范圍，就像 search()。

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

類似函數(shù) finditer() ， 使用了編譯后樣式，但也可以接收可選參數(shù) pos 和 endpos ，限制搜索范圍，就像 search()。

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

等價(jià)于 sub() 函數(shù)，使用了編譯后的樣式。

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

等價(jià)于 subn() 函數(shù)，使用了編譯后的樣式。

Pattern.flags?

正則匹配標(biāo)記。這是可以傳遞給 compile() 的參數(shù)，任何 (?…) 內(nèi)聯(lián)標(biāo)記，隱性標(biāo)記比如 UNICODE 的結(jié)合。

Pattern.groups?

捕獲到的模式串中組的數(shù)量。

Pattern.groupindex?

映射由 (?P<id>) 定義的命名符號(hào)組合和數(shù)字組合的字典。如果沒(méi)有符號(hào)組，那字典就是空的。

Pattern.pattern?

編譯對(duì)象的原始樣式字符串。

匹配對(duì)象?

匹配對(duì)象總是有一個(gè)布爾值 True。如果沒(méi)有匹配的話 match() 和 search() 返回 None 所以你可以簡(jiǎn)單的用 if 語(yǔ)句來(lái)判斷是否匹配

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

匹配對(duì)象支持以下方法和屬性：

Match.expand(template)?

對(duì) template 進(jìn)行反斜杠轉(zhuǎn)義替換并且返回，就像 sub() 方法中一樣。轉(zhuǎn)義如同 \n 被轉(zhuǎn)換成合適的字符，數(shù)字引用(\1, \2)和命名組合(\g<1>, \g<name>) 替換為相應(yīng)組合的內(nèi)容。

在 3.5 版更改: 不匹配的組合替換為空字符串。

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

返回一個(gè)或者多個(gè)匹配的子組。如果只有一個(gè)參數(shù)，結(jié)果就是一個(gè)字符串，如果有多個(gè)參數(shù)，結(jié)果就是一個(gè)元組（每個(gè)參數(shù)對(duì)應(yīng)一個(gè)項(xiàng)），如果沒(méi)有參數(shù)，組1默認(rèn)到0（整個(gè)匹配都被返回）。 如果一個(gè)組N 參數(shù)值為 0，相應(yīng)的返回值就是整個(gè)匹配字符串；如果它是一個(gè)范圍 [1..99]，結(jié)果就是相應(yīng)的括號(hào)組字符串。如果一個(gè)組號(hào)是負(fù)數(shù)，或者大于樣式中定義的組數(shù)，就引發(fā)一個(gè) IndexError 異常。如果一個(gè)組包含在樣式的一部分，并被匹配多次，就返回最后一個(gè)匹配。:

>>>

>>> 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')

如果正則表達(dá)式使用了 (?P<name>...) 語(yǔ)法， groupN 參數(shù)就也可能是命名組合的名字。如果一個(gè)字符串參數(shù)在樣式中未定義為組合名，就引發(fā)一個(gè) IndexError 異常。

一個(gè)相對(duì)復(fù)雜的例子

>>>

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

命名組合同樣可以通過(guò)索引值引用

>>>

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

如果一個(gè)組匹配成功多次，就只返回最后一個(gè)匹配

>>>

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

Match.__getitem__(g)?

這個(gè)等價(jià)于 m.group(g)。這允許更方便的引用一個(gè)匹配

>>>

>>> 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'

3.6 新版功能.

Match.groups(default=None)?

返回一個(gè)元組，包含所有匹配的子組，在樣式中出現(xiàn)的從1到任意多的組合。 default 參數(shù)用于不參與匹配的情況，默認(rèn)為 None。

例如：

>>>

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

如果我們使小數(shù)點(diǎn)可選，那么不是所有的組都會(huì)參與到匹配當(dāng)中。這些組合默認(rèn)會(huì)返回一個(gè) None ，除非指定了 default 參數(shù)。

>>>

>>> 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)?

返回一個(gè)字典，包含了所有的 命名 子組。key就是組名。 default 參數(shù)用于不參與匹配的組合；默認(rèn)為 None。 例如

>>>

>>> 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])?

返回 group 匹配到的字串的開(kāi)始和結(jié)束標(biāo)號(hào)。group 默認(rèn)為0（意思是整個(gè)匹配的子串）。如果 group 存在，但未產(chǎn)生匹配，就返回 -1 。對(duì)于一個(gè)匹配對(duì)象 m， 和一個(gè)未參與匹配的組 g ，組 g (等價(jià)于 m.group(g))產(chǎn)生的匹配是

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

注意 m.start(group) 將會(huì)等于 m.end(group) ，如果 group 匹配一個(gè)空字符串的話。比如，在 m = re.search('b(c?)', 'cba') 之后，m.start(0) 為 1, m.end(0) 為 2, m.start(1) 和 m.end(1) 都是 2, m.start(2) 引發(fā)一個(gè) IndexError 異常。

這個(gè)例子會(huì)從email地址中移除掉 remove_this

>>>

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

Match.span([group])?

對(duì)于一個(gè)匹配 m ， 返回一個(gè)二元組 (m.start(group), m.end(group)) 。 注意如果 group 沒(méi)有在這個(gè)匹配中，就返回 (-1, -1) 。group 默認(rèn)為0，就是整個(gè)匹配。

Match.pos?

pos 的值，會(huì)傳遞給 search() 或 match() 的方法 a 正則對(duì)象 。這個(gè)是正則引擎開(kāi)始在字符串搜索一個(gè)匹配的索引位置。

Match.endpos?

endpos 的值，會(huì)傳遞給 search() 或 match() 的方法 a 正則對(duì)象 。這個(gè)是正則引擎停止在字符串搜索一個(gè)匹配的索引位置。

Match.lastindex?

捕獲組的最后一個(gè)匹配的整數(shù)索引值，或者 None 如果沒(méi)有匹配產(chǎn)生的話。比如，對(duì)于字符串 'ab'，表達(dá)式 (a)b, ((a)(b)), 和 ((ab)) 將得到 lastindex == 1 ， 而 (a)(b) 會(huì)得到 lastindex == 2 。

Match.lastgroup?

最后一個(gè)匹配的命名組名字，或者 None 如果沒(méi)有產(chǎn)生匹配的話。

Match.re?

返回產(chǎn)生這個(gè)實(shí)例的 正則對(duì)象 ， 這個(gè)實(shí)例是由 正則對(duì)象的 match() 或 search() 方法產(chǎn)生的。

Match.string?

傳遞到 match() 或 search() 的字符串。

正則表達(dá)式例子?

def displaymatch(match):
    if match is None:
        return None
    return '<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>", line 1, 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 - 0 errors, 4 warnings

%s - %d errors, %d warnings

(\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.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, 3) for entry in 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, 4) for entry in 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']]

>>> def repl(m):
...     inner_word = list(m.group(2))
...     random.shuffle(inner_word)
...     return m.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."
>>> for m in re.finditer(r"\w+ly\b", text):
...     print('%02d-%02d: %s' % (m.start(), m.end(), m.group(0)))
07-16: carefully
40-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='\\'>

from typing import NamedTuple
import re

class Token(NamedTuple):
    type: str
    value: str
    line: int
    column: int

def tokenize(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)' % pair for pair in token_specification)
    line_num = 1
    line_start = 0
    for mo in re.finditer(tok_regex, code):
        kind = mo.lastgroup
        value = mo.group()
        column = mo.start() - line_start
        if kind == 'NUMBER':
            value = float(value) if '.' in value else int(value)
        elif kind == 'ID' and value in keywords:
            kind = value
        elif kind == 'NEWLINE':
            line_start = mo.end()
            line_num += 1
            continue
        elif kind == 'SKIP':
            continue
        elif kind == 'MISMATCH':
            raise RuntimeError(f'{value!r} unexpected on line {line_num}')
        yield Token(kind, value, line_num, column)

statements = '''
    IF quantity THEN
        total := total + price * quantity;
        tax := price * 0.05;
    ENDIF;
'''

for token in tokenize(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)