【python】python的正則表達式 re

時間 2019-11-20

原文原文鏈接

ps：本文摘自互聯網，以爲結構很好，講的也很清晰。記下，備查。python

延伸閱讀：python的內建函數和 subprocess 。此文是本系列的第三篇文章了，和以前同樣，內容出自官方文檔，可是會有本身的理解，並不是單純的翻譯。因此，若是我理解有誤，歡迎指正，謝謝。git

本模塊提供了和Perl裏的正則表達式相似的功能，不關是正則表達式自己仍是被搜索的字符串，均可以是Unicode字符，這點不用擔憂，python會處理地和Ascii字符同樣漂亮。正則表達式

正則表達式使用反斜杆（\）來轉義特殊字符，使其能夠匹配字符自己，而不是指定其餘特殊的含義。這可能會和python字面意義上的字符串轉義相沖突，這也許有些使人費解。好比，要匹配一個反斜杆自己，你也許要用'\\\\'來作爲正則表達式的字符串，由於正則表達式要是\\，而字符串裏，每一個反斜杆都要寫成\\。express

你也能夠在字符串前加上 r 這個前綴來避免部分疑惑，由於 r 開頭的python字符串是 raw 字符串，因此裏面的全部字符都不會被轉義，好比r'\n'這個字符串就是一個反斜杆加上一字母n，而'\n'咱們知道這是個換行符。所以，上面的'\\\\'你也能夠寫成r'\\'，這樣，應該就好理解不少了。能夠看下面這段：安全

>>> import re函數

>>> s = '\x5c' #0x5c就是反斜杆測試

>>> print sthis

\spa

>>> re.match('\\\\', s) #這樣能夠匹配.net

<_sre.SRE_Match object at 0xb6949e20>

>>> re.match(r'\\', s) #這樣也能夠

<_sre.SRE_Match object at 0x80ce2c0>

>>> re.match('\\', s) #可是這樣不行

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

File "/usr/lib/python2.6/re.py", line 137, in match

return _compile(pattern, flags).match(string)

File "/usr/lib/python2.6/re.py", line 245, in _compile

raise error, v # invalid expression

sre_constants.error: bogus escape (end of line)

>>>

另外值得一提的是，re模塊的方法，大多也就是RegexObject對象的方法，二者的區別在於執行效率。這個在最後再展開吧。

正則表達式語法

正則表達式（RE）指定一個與之匹配的字符集合；本模塊所提供的函數，將能夠用來檢查所給的字符串是否與指定的正則表達式匹配。

正則表達式能夠被鏈接，從而造成新的正則表達式；例如A和B都是正則表達式，那麼AB也是正則表達式。通常地，若是字符串p與A匹配，q與B匹配的話，那麼字符串pq也會與AB匹配，但A或者B裏含有邊界限定條件或者命名組操做的狀況除外。也就是說，複雜的正則表達式能夠用簡單的鏈接而成。

正則表達式能夠包含特殊字符和普通字符，大部分字符好比'A'，'a'和'0'都是普通字符，若是作爲正則表達式，它們將匹配它們自己。因爲正則表達式能夠鏈接，因此鏈接多個普通字符而成的正則表達式last也將匹配'last'。（後面將用不帶引號的表示正則表達式，帶引號的表示字符串）

下面就來介紹正則表達式的特殊字符：

'.'

點號，在普通模式，它匹配除換行符外的任意一個字符；若是指定了 DOTALL 標記，匹配包括換行符之內的任意一個字符。

'^'

尖尖號，匹配一個字符串的開始，在 MULTILINE 模式下，也將匹配任意一個新行的開始。

'$'

美圓符號，匹配一個字符串的結尾或者字符串最後面的換行符，在 MULTILINE 模式下，也匹配任意一行的行尾。也就是說，普通模式下，foo.$去搜索'foo1\nfoo2\n'只會找到’foo2′，可是在 MULTILINE 模式，還能找到 ‘foo1′，並且就用一個 $ 去搜索'foo\n'的話，會找到兩個空的匹配：一個是最後的換行符，一個是字符串的結尾，演示：

>>> re.findall('(foo.$)', 'foo1\nfoo2\n')

['foo2']

>>> re.findall('(foo.$)', 'foo1\nfoo2\n', re.MULTILINE)

['foo1', 'foo2']

>>> re.findall('($)', 'foo\n')

['', '']

'*'

星號，指定將前面的RE重複0次或者任意屢次，並且老是試圖儘可能屢次地匹配。

'+'

加號，指定將前面的RE重複1次或者任意屢次，並且老是試圖儘可能屢次地匹配。

'?'

問號，指定將前面的RE重複0次或者1次，若是有的話，也儘可能匹配1次。

*?， +?， ??

從前面的描述能夠看到'*'，'+'和'?'都是貪婪的，但這也許並非咱們說要的，因此，能夠在後面加個問號，將策略改成非貪婪，只匹配儘可能少的RE。示例，體會二者的區別：

>>> re.findall('<(.*)>', '<H1>title</H1>')

['H1>title</H1']

>>> re.findall('<(.*?)>', '<H1>title</H1>')

['H1', '/H1']

{m}

m是一個數字，指定將前面的RE重複m次。

{m,n}

m和n都是數字，指定將前面的RE重複m到n次，例如a{3,5}匹配3到5個連續的a。注意，若是省略m，將匹配0到n個前面的RE；若是省略n，將匹配n到無窮多個前面的RE；固然中間的逗號是不能省略的，否則就變成前面那種形式了。

{m,n}?

前面說的{m,n}，也是貪婪的，a{3,5}若是有5個以上連續a的話，會匹配5個，這個也能夠經過加問號改變。a{3,5}?若是可能的話，將只匹配3個a。

'\'

反斜杆，轉義'*'，'?'等特殊字符，或者指定一個特殊序列（下面會詳述）

因爲以前所述的緣由，強烈建議用raw字符串來表述正則。

[]

方括號，用於指定一個字符的集合。能夠單獨列出字符，也能夠用'-'鏈接起止字符以表示一個範圍。特殊字符在中括號裏將失效，好比[akm$]就表示字符'a'，'k'，'m'，或'$'，在這裏$也變身爲普通字符了。[a-z]匹配任意一個小寫字母，[a-zA-Z0-9]匹配任意一個字母或數字。若是你要匹配']'或'-'自己，你須要加反斜杆轉義，或者是將其置於中括號的最前面，好比[]]能夠匹配']'

你還能夠對一個字符集合取反，以匹配任意不在這個字符集合裏的字符，取反操做用一個'^'放在集合的最前面表示，放在其餘地方的'^'將不會起特殊做用。例如[^5]將匹配任意不是'5'的字符；[^^]將匹配任意不是'^'的字符。

注意：在中括號裏，+、*、(、)這類字符將會失去特殊含義，僅做爲普通字符。反向引用也不能在中括號內使用。

'|'

(...)

匹配圓括號裏的RE匹配的內容，並指定組的開始和結束位置。組裏面的內容能夠被提取，也能夠採用\number這樣的特殊序列，被用於後續的匹配。要匹配字面意義上的'('和')'，能夠用反斜杆轉義：$、$，或是包含在反括號內：[(]、[)]。

(?...)

這是一個表達式的擴展符號。'?'後的第一個字母決定了整個表達式的語法和含義，除了(?P...)之外，表達式不會產生一個新的組。下面介紹幾個目前已被支持的擴展：

(?iLmsux)

'i'、'L'、'm'、's'、'u'、'x'裏的一個或多個字母。表達式不匹配任何字符，可是指定相應的標誌：re.I(忽略大小寫)、re.L(依賴locale)、re.M(多行模式)、re.S(.匹配全部字符)、re.U(依賴Unicode)、re.X(詳細模式)。關於各個模式的區別，下面會有專門的一節來介紹的。使用這個語法能夠代替在re.compile()的時候或者調用的時候指定flag參數。

例如，上面舉過的例子，能夠改寫成這樣（和指定了re.MULTILINE是同樣的效果）：

>>> re.findall('(?m)(foo.$)', 'foo1\nfoo2\n')

['foo1', 'foo2']

另外，還要注意(?x)標誌若是有的話，要放在最前面。

(?:...)

匹配內部的RE所匹配的內容，可是不創建組。

(?P<name>...)

和普通的圓括號相似，可是子串匹配到的內容將能夠用命名的name參數來提取。組的name必須是有效的python標識符，並且在本表達式內不重名。命名了的組和普通組同樣，也用數字來提取，也就是說名字只是個額外的屬性。

演示一下：

>>> m=re.match('(?P<var>[a-zA-Z_]\w*)', 'abc=123')

>>> m.group('var')

'abc'

>>> m.group(1)

'abc'

(?P=name)

匹配以前以name命名的組裏的內容。

演示一下：

>>> re.match('<(?P<tagname>\w*)>.*</(?P=tagname)>', '<h1>xxx</h2>') #這個不匹配

>>> re.match('<(?P<tagname>\w*)>.*</(?P=tagname)>', '<h1>xxx</h1>') #這個匹配

<_sre.SRE_Match object at 0xb69588e0>

(?#...)

註釋，圓括號裏的內容會被忽略。

(?=...)

若是 ... 匹配接下來的字符，纔算匹配，可是並不會消耗任何被匹配的字符。例如 Isaac (?=Asimov) 只會匹配後面跟着 'Asimov' 的 'Isaac '，這個叫作「前瞻斷言」。

(?!...)

和上面的相反，只匹配接下來的字符串不匹配 ... 的串，這叫作「反前瞻斷言」。

(?<=...)

只有噹噹前位置以前的字符串匹配 ... ，整個匹配纔有效，這叫「後顧斷言」。(?<=abc)def會找到 'abcdef'，由於會後向查找3個字符，看是否爲abc。因此內置的子RE，須要是固定長度的，好比能夠是abc、a|b，但不能是a*、a{3,4}。注意這種RE永遠不會匹配到字符串的開頭。舉個例子，找到連字符（'-'）後的單詞：

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

>>> m.group(0)

'egg'

(?<!...)

同理，這個叫作「反後顧斷言」，子RE須要固定長度的，含義是前面的字符串不匹配 ... 整個纔算匹配。

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

若有由id或者name指定的組存在的話，將會匹配yes-pattern，不然將會匹配no-pattern，一般狀況下no-pattern也能夠省略。例如：()能夠匹配 '<user@host.com>' 和 'user@host.com'，可是不會匹配 '<user@host.com'。

下面列出以'\'開頭的特殊序列。若是某個字符沒有在下面列出，那麼RE的結果會只匹配那個字母自己，好比，\$只匹配字面意義上的'$'。

\number

匹配number所指的組相同的字符串。組的序號從1開始。例如：(.+) \1能夠匹配'the the'和'55 55'，但不匹配'the end'。這種序列在一個正則表達式裏最多能夠有99個，若是number以0開頭，或是有3位以上的數字，就會被當作八進制表示的字符了。同時，這個也不能用於方括號內。

只匹配字符串的開始。

匹配單詞邊界（包括開始和結束），這裏的「單詞」，是指連續的字母、數字和下劃線組成的字符串。注意，\b的定義是\w和\W的交界，因此精確的定義有賴於UNICODE和LOCALE這兩個標誌位。

和\b相反，\B匹配非單詞邊界。也依賴於UNICODE和LOCALE這兩個標誌位。

未指定UNICODE標誌時，匹配數字，等效於：[0-9]。指定了UNICODE標誌時，還會匹配其餘Unicode庫裏描述爲字符串的符號。便於理解，舉個例子（好不容易找的例子啊，呵呵）：

#\u2076\和u2084分別是上標的6和下標的4，屬於unicode的DIGIT

>>> unistr = u'\u2076\u2084abc'

>>> print unistr

⁶₄abc

>>> print re.findall('\d+', unistr, re.U)[0]

⁶₄

和\d相反，很少說了。

當未指定UNICODE和LOCALE這兩個標誌位時，匹配任何空白字符，等效於[ \t\n\r\f\v]。若是指定了LOCALE，則還要加LOCALE相關的空白字符；若是指定了UNICODE，還要加上UNICODE空白字符，如較常見的空寬度鏈接空格（\uFEFF）、零寬度非鏈接空格(\u200B)等。

和\s相反，也很少說。

當未指定UNICODE和LOCALE這兩個標誌位時，等效於[a-zA-Z0-9_]。當指定了LOCALE時，爲[0-9_]加上當前LOCAL指定的字母。當指定了UNICODE時，爲[0-9_]加上UNICODE庫裏的全部字母。

和\w相反，很少說。

只匹配字符串的結尾。

匹配之於搜索

python提供了兩種基於正則表達式的操做：匹配（match）從字符串的開始檢查字符串是否個正則匹配。而搜索（search）檢查字符串任意位置是否有匹配的子串（perl默認就是如此）。

注意，即便search的正則以'^'開頭，match和search也仍是有許多不一樣的。

>>> re.match("c", "abcdef") # 不匹配

>>> re.search("c", "abcdef") # 匹配

<_sre.SRE_Match object at ...>

模塊的屬性和方法

re.compile(pattern[, flags])

把一個正則表達式pattern編譯成正則對象，以即可以用正則對象的match和search方法。

獲得的正則對象的行爲（也就是模式）能夠用flags來指定，值能夠由幾個下面的值OR獲得。

如下兩段內容在語法上是等效的：

prog = re.compile(pattern)

result = prog.match(string)

result = re.match(pattern, string)

區別是，用了re.compile之後，正則對象會獲得保留，這樣在須要屢次運用這個正則對象的時候，效率會有較大的提高。再用上面用過的例子來演示一下，用相同的正則匹配相同的字符串，執行100萬次，就體現出compile的效率了（數據來自我那1.86G CPU的神舟本本）：

>>> timeit.timeit(

... setup='''import re; reg = re.compile('<(?P<tagname>\w*)>.*</(?P=tagname)>')''',

... stmt='''reg.match('<h1>xxx</h1>')''',

... number=1000000)

1.2062149047851562

>>> timeit.timeit(

... setup='''import re''',

... stmt='''re.match('<(?P<tagname>\w*)>.*</(?P=tagname)>', '<h1>xxx</h1>')''',

... number=1000000)

4.4380838871002197

re.I

re.IGNORECASE

讓正則表達式忽略大小寫，這樣一來，[A-Z]也能夠匹配小寫字母了。此特性和locale無關。

re.L

re.LOCALE

讓\w、\W、\b、\B、\s和\S依賴當前的locale。

re.M

re.MULTILINE

影響'^'和'$'的行爲，指定了之後，'^'會增長匹配每行的開始（也就是換行符後的位置）；'$'會增長匹配每行的結束（也就是換行符前的位置）。

re.S

re.DOTALL

影響'.'的行爲，平時'.'匹配除換行符之外的全部字符，指定了本標誌之後，也能夠匹配換行符。

re.U

re.UNICODE

讓\w、\W、\b、\B、\d、\D、\s和\S依賴Unicode庫。

re.X

re.VERBOSE

運用這個標誌，你能夠寫出可讀性更好的正則表達式：除了在方括號內的和被反斜槓轉義的之外的全部空白字符，都將被忽略，並且每行中，一個正常的井號後的全部字符也被忽略，這樣就能夠方便地在正則表達式內部寫註釋了。也就是說，下面兩個正則表達式是等效的：

a = re.compile(r"""\d + # the integral part

\. # the decimal point

\d * # some fractional digits""", re.X)

b = re.compile(r"\d+\.\d*")

re.search(pattern, string[, flags])

掃描string，看是否有個位置能夠匹配正則表達式pattern。若是找到了，就返回一個MatchObject的實例，不然返回None，注意這和找到長度爲0的子串含義是不同的。搜索過程受flags的影響。

re.match(pattern, string[, flags])

若是字符串string的開頭和正則表達式pattern匹配的話，返回一個相應的MatchObject的實例，不然返回None

注意：要在字符串的任意位置搜索的話，須要使用上面的search()。

re.split(pattern, string[, maxsplit=0])

用匹配pattern的子串來分割string，若是pattern裏使用了圓括號，那麼被pattern匹配到的串也將做爲返回值列表的一部分。若是maxsplit不爲0，則最多被分割爲maxsplit個子串，剩餘部分將整個地被返回。

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

若是正則有圓括號，而且能夠匹配到字符串的開始位置的時候，返回值的第一項，會多出一個空字符串。匹配到字符結尾也是一樣的道理：

>>> re.split('(\W+)', '...words, words...')

['', '...', 'words', ', ', 'words', '...', '']

注意，split不會被零長度的正則所分割，例如：

>>> re.split('x*', 'foo')

['foo']

>>> re.split("(?m)^$", "foo\n\nbar\n")

['foo\n\nbar\n']

re.findall(pattern, string[, flags])

以列表的形式返回string裏匹配pattern的不重疊的子串。string會被從左到右依次掃描，返回的列表也是從左到右一次匹配到的。若是pattern裏含有組的話，那麼會返回匹配到的組的列表；若是pattern裏有多個組，那麼各組會先組成一個元組，而後返回值將是一個元組的列表。

因爲這個函數不會涉及到MatchObject之類的概念，因此，對新手來講，應該是最好理解也最容易使用的一個函數了。下面就此來舉幾個簡單的例子：

#簡單的findall

>>> re.findall('\w+', 'hello, world!')

['hello', 'world']

#這個返回的就是元組的列表

>>> re.findall('(\d+)\.(\d+)\.(\d+)\.(\d+)', 'My IP is 192.168.0.2, and your is 192.168.0.3.')

[('192', '168', '0', '2'), ('192', '168', '0', '3')]

re. finditer(pattern, string[, flags])

和上面的findall()相似，但返回的是MatchObject的實例的迭代器。

仍是例子說明問題：

>>> for m in re.finditer('\w+', 'hello, world!'):

... print m.group()

...

hello

world

re.sub(pattern, repl, string[, count])

替換，將string裏，匹配pattern的部分，用repl替換掉，最多替換count次（剩餘的匹配將不作處理），而後返回替換後的字符串。若是string裏沒有能夠匹配pattern的串，將被原封不動地返回。repl能夠是一個字符串，也能夠是一個函數（也能夠參考我之前的例子）。若是repl是個字符串，則其中的反斜杆會被處理過，好比 \n 會被轉成換行符，反斜杆加數字會被替換成相應的組，好比 \6 表示pattern匹配到的第6個組的內容。

例子：

>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*$\s*$:',

... r'static PyObject*\npy_\1(void)\n{',

... 'def myfunc():')

'static PyObject*\npy_myfunc(void)\n{'

若是repl是個函數，每次pattern被匹配到的時候，都會被調用一次，傳入一個匹配到的MatchObject對象，須要返回一個字符串，在匹配到的位置，就填入返回的字符串。

例子：

>>> def dashrepl(matchobj):

... if matchobj.group(0) == '-': return ' '

... else: return '-'

>>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')

'pro--gram files'

零長度的匹配也會被替換，好比：

>>> re.sub('x*', '-', 'abcxxd')

'-a-b-c-d-'

特殊地，在替換字符串裏，若是有\g這樣的寫法，將匹配正則的命名組（前面介紹過的，(?P...)這樣定義出來的東西）。\g這樣的寫法，也是數字的組，也就是說，\g通常和\2是等效的，可是萬一你要在\2後面緊接着寫上字面意義的0，你就不能寫成\20了（由於這表明第20個組），這時候必須寫成\g0，另外，\g表明匹配到的整個子串。

例子：

>>> re.sub('-(\d+)-', '-\g<1>0\g<0>', 'a-11-b-22-c')

'a-110-11-b-220-22-c'

re.subn(pattern, repl, string[, count])

跟上面的sub()函數同樣，只是它返回的是一個元組 (新字符串, 匹配到的次數)

，仍是用例子說話：

>>> re.subn('-(\d+)-', '-\g<1>0\g<0>', 'a-11-b-22-c')

('a-110-11-b-220-22-c', 2)

re.escape(string)

把string中，除了字母和數字之外的字符，都加上反斜杆。

>>> print re.escape('abc123_@#$')

abc123\_\@\#\$

exception re.error

若是字符串不能被成功編譯成正則表達式或者正則表達式在匹配過程當中出錯了，都會拋出此異常。可是若是正則表達式沒有匹配到任何文本，是不會拋出這個異常的。

正則對象

正則對象由re.compile()返回。它有以下的屬性和方法。

match(string[, pos[, endpos]])

做用和模塊的match()函數相似，區別就是後面兩個參數。

pos是開始搜索的位置，默認爲0。endpos是搜索的結束位置，若是endpos比pos還小的話，結果確定是空的。也就是說只有pos 到 endpos-1 位置的字符串將會被搜索。

例子：

>>> pattern = re.compile("o")

>>> pattern.match("dog") # 開始位置不是o，因此不匹配

>>> pattern.match("dog", 1) # 第二個字符是o，因此匹配

<_sre.SRE_Match object at ...>

search(string[, pos[, endpos]])

做用和模塊的search()函數相似，pos和endpos參數和上面的match()函數相似。

split(string[, maxsplit=0])

findall(string[, pos[, endpos]])

finditer(string[, pos[, endpos]])

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

subn(repl, string[, count=0])

這幾個函數，都和模塊的相應函數一致。

flags

編譯本RE時，指定的標誌位，若是未指定任何標誌位，則爲0。

>>> pattern = re.compile("o", re.S|re.U)

>>> pattern.flags

groups

RE所含有的組的個數。

groupindex

一個字典，定義了命名組的名字和序號之間的關係。

例子：

這個正則有3個組，若是匹配到，第一個叫區號，最後一個叫分機號，中間的那個未命名

>>> pattern = re.compile("(?P<quhao>\d+)-(\d+)-(?P<fenjihao>\d+)")

>>> pattern.groups

>>> pattern.groupindex

{'fenjihao': 3, 'quhao': 1}

pattern

創建本RE的原始字符串，至關於源代碼了，呵呵。

仍是上面這個正則，能夠看到，會原樣返回：

>>> print pattern.pattern

(?P<quhao>\d+)-(\d+)-(?P<fenjihao>\d+)

Match對象

re.MatchObject被用於布爾判斷的時候，始終返回True，因此你用 if 語句來判斷某個 match() 是否成功是安全的。

它有如下方法和屬性：

expand(template)

用template作爲模板，將MatchObject展開，就像sub()裏的行爲同樣，看例子：

>>> m = re.match('a=(\d+)', 'a=100')

>>> m.expand('above a is \g<1>')

'above a is 100'

>>> m.expand(r'above a is \1')

'above a is 100'

group([group1, ...])

返回一個或多個子組。若是參數爲一個，就返回一個子串；若是參數有多個，就返回多個子串註冊的元組。若是不傳任何參數，效果和傳入一個0同樣，將返回整個匹配。若是某個groupN未匹配到，相應位置會返回None。若是某個groupN是負數或者大於group的總數，則會拋出IndexError異常。

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")

>>> m.group(0) # 整個匹配

'Isaac Newton'

>>> m.group(1) # 第一個子串

'Isaac'

>>> m.group(2) # 第二個子串

'Newton'

>>> m.group(1, 2) # 多個子串組成的元組

('Isaac', 'Newton')

若是有其中有用(?P...)這種語法命名過的子串的話，相應的groupN也能夠是名字字符串。例如：

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

>>> m.group('first_name')

'Malcolm'

>>> m.group('last_name')

'Reynolds'

若是某個組被匹配到屢次，那麼只有最後一次的數據，能夠被提取到：

>>> m = re.match(r"(..)+", "a1b2c3") # 匹配到3次

>>> m.group(1) # 返回的是最後一次

'c3'

groups([default])

返回一個由全部匹配到的子串組成的元組。default參數，用於給那些沒有匹配到的組作默認值，它的默認值是None

例如：

>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")

>>> m.groups()

('24', '1632')

default的做用：

>>> m = re.match(r"(\d+)\.?(\d+)?", "24")

>>> m.groups() # 第二個默認是None

('24', None)

>>> m.groups('0') # 如今默認是0了

('24', '0')

groupdict([default])

返回一個包含全部命名組的名字和子串的字典，default參數，用於給那些沒有匹配到的組作默認值，它的默認值是None，例如：

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

>>> m.groupdict()

{'first_name': 'Malcolm', 'last_name': 'Reynolds'}

start([group])

end([group])

返回的是：被組group匹配到的子串在原字符串中的位置。若是不指定group或group指定爲0，則表明整個匹配。若是group未匹配到，則返回 -1。

對於指定的m和g，m.group(g)和m.string[m.start(g):m.end(g)]等效。

注意：若是group匹配到空字符串，m.start(group)和m.end(group)將相等。

例如：

>>> m = re.search('b(c?)', 'cba')

>>> m.start(0)

>>> m.end(0)

>>> m.start(1)

>>> m.end(1)

下面是一個把email地址裏的「remove_this」去掉的例子：

>>> email = "tony@tiremove_thisger.net"

>>> m = re.search("remove_this", email)

>>> email[:m.start()] + email[m.end():]

'tony@tiger.net'

span([group])

返回一個元組： (m.start(group), m.end(group))

pos

就是傳給RE對象的search()或match()方法的參數pos，表明RE開始搜索字符串的位置。

endpos

就是傳給RE對象的search()或match()方法的參數endpos，表明RE搜索字符串的結束位置。

lastindex

最後一次匹配到的組的數字序號，若是沒有匹配到，將獲得None。

例如：(a)b、((a)(b))和((ab))正則去匹配'ab'的話，獲得的lastindex爲1。而用(a)(b)去匹配'ab'的話，獲得的lastindex爲2。

lastgroup

最後一次匹配到的組的名字，若是沒有匹配到或者最後的組沒有名字，將獲得None。

獲得本Match對象的正則表達式對象，也就是執行search()或match()的對象。

string

傳給search()或match()的字符串。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。