Python正則表達式詳解——re庫

時間 2020-06-29

標籤 python 正則表達式詳解欄目 Python 简体版

原文原文鏈接

1、簡介

1.一、相關連接

官方文檔：html

Python2：https://docs.python.org/2/library/re.htmlpython

Python3：https://docs.python.org/3/library/re.htmlgit

HOWTO：正則表達式

Python2：https://docs.python.org/2/howto/regex.html緩存

Python3：https://docs.python.org/3/howto/regex.htmlapp

2、函數詳解

2.一、正則匹配的基本事項

函數中使用參數標識：

參數ssh	描述函數
pattern測試	匹配的正則表達式ui
string	要匹配的字符串。
flags	標誌位，用於控制正則表達式的匹配方式，如：是否區分大小寫，多行匹配等等。

函數中flags取值：

Flag	Meaning
DOTALL, S	Make . match any character, including newlines 使 . 匹配包括換行在內的全部字符
IGNORECASE, I	Do case-insensitive matches 使匹配對大小寫不敏感
LOCALE, L	Do a locale-aware match 作本地化識別（locale-aware）匹配
MULTILINE, M	Multi-line matching, affecting ^ and $ 多行匹配，影響 ^ 和 $
VERBOSE, X	Enable verbose REs, which can be organized more cleanly and understandably. 該標誌經過給予你更靈活的格式以便你將正則表達式寫得更易於理解。
UNICODE, U	Makes several escapes like \w, \b, \s and \d dependent on the Unicode character database. 根據Unicode字符集解析字符。這個標誌影響 \w, \W, \b, \B.

正則表達式的通配符表示含義：

模式字符串使用特殊的語法來表示一個正則表達式：

字母和數字表示他們自身。一個正則表達式模式中的字母和數字匹配一樣的字符串。

多數字母和數字前加一個反斜槓時會擁有不一樣的含義。

標點符號只有被轉義時才匹配自身，不然它們表示特殊的含義。

反斜槓自己須要使用反斜槓轉義。

因爲正則表達式一般都包含反斜槓，因此你最好使用原始字符串來表示它們。模式元素(如 r'\t'，等價於 '\\t')匹配相應的特殊字符。

下表列出了正則表達式模式語法中的特殊元素。若是你使用模式的同時提供了可選的標誌參數，某些模式元素的含義會改變。

模式	描述
^	匹配字符串的開頭
$	匹配字符串的末尾。
.	匹配除了換行符(\n)的任意字符，當re.DOTALL標記被指定時，則能夠匹配包括換行符的任意字符。
[...]	用來表示一組字符,單獨列出：[amk] 匹配 'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c以外的字符。
re*	匹配0個或多個的表達式。
re+	匹配1個或多個的表達式。
re?	匹配0個或1個由前面的正則表達式定義的片斷，非貪婪方式
re{ n}
re{ n,}	精確匹配n個前面表達式。
re{ n, m}	匹配 n 到 m 次由前面的正則表達式定義的片斷，貪婪方式
a\| b	匹配a或b
(re)	G匹配括號內的表達式，也表示一個組
(?imx)	正則表達式包含三種可選標誌：i, m, 或 x 。隻影響括號中的區域。
(?-imx)	正則表達式關閉 i, m, 或 x 可選標誌。隻影響括號中的區域。
(?: re)	相似 (...), 可是不表示一個組
(?imx: re)	在括號中使用i, m, 或 x 可選標誌
(?-imx: re)	在括號中不使用i, m, 或 x 可選標誌
(?#...)	註釋.
(?= re)	前向確定界定符。若是所含正則表達式，以 ... 表示，在當前位置成功匹配時成功，不然失敗。但一旦所含表達式已經嘗試，匹配引擎根本沒有提升；模式的剩餘部分還要嘗試界定符的右邊。
(?! re)	前向否認界定符。與確定界定符相反；當所含表達式不能在字符串當前位置匹配時成功
(?> re)	匹配的獨立模式，省去回溯。
\w	匹配字母數字及下劃線，等價於'[A-Za-z0-9_]'。
\W	匹配非字母數字及下劃線，等價於 '[^A-Za-z0-9_]'。
\s	匹配任意空白字符，等價於 [\t\n\r\f].
\S	匹配任意非空字符，等價於 [^ \f\n\r\t\v]。
\d	匹配任意數字，等價於 [0-9].
\D	匹配任意非數字，等價於 [^0-9]。
\A	匹配字符串開始
\Z	匹配字符串結束，若是是存在換行，只匹配到換行前的結束字符串。c
\z	匹配字符串結束
\G	匹配最後匹配完成的位置。
\b	匹配一個單詞邊界，也就是指單詞和空格間的位置。例如， 'er\b' 能夠匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非單詞邊界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等.	匹配一個換行符。匹配一個製表符。等
\1...\9	匹配第n個分組的內容。
\10	匹配第n個分組的內容，若是它經匹配。不然指的是八進制字符碼的表達式。

2.二、經常使用函數

如下是re模塊經常使用的七個函數：

函數名

含義

實例

re.compile()

將正則表達式模式編譯成一個正則表達式對象，它能夠用於匹配使用它的match ()和search ()方法，以下所述。

能夠經過指定flags值修改表達式的行爲。值能夠是任何如下變量，使用組合 OR （ |運算符）。

但使用re.compile()和保存所產生的正則表達式對象重用效率更高時該表達式會在單個程序中屢次使用。

語法：compile(pattern, flags=0)

>>> s = '[a-z]+\d*'

>>> a = re.compile(s)

>>> a

<_sre.SRE_Pattern object at 0x0000000003308738>

>>> type(a)

>>> b = a.match('a123')

>>> b.group()

'a123'

等價於：

>>> b = re.match('[a-z]+\d*', 'a123')

>>> b.group()

'a123'

re.escape()

返回的字符串與全部非字母數字帶有反斜槓；這是有用的若是你想匹配一個任意的文本字符串，在它可能包含正則表達式元字符

簡單理解：把字符串按照可能會是正則表達式來理解，這樣就須要把特殊字符都轉義。這樣才能方便匹配時精確匹配每一個字符。

字符'[a-z]'這個字符串能夠看做是正則表達式的模式，這樣就不能做爲被匹配的字符串。若是想把這個字符串做爲被匹配的模式就須要轉義這些特殊字符。print(re.escape('[a-z]'))

\[a\-z\]

語法：escape(pattern)

>>> s = 'abc.|123'

>>> print s

abc.|123

>>> print(re.escape(s))

abc\.\|123

re.findall()

做爲一個字符串列表，在字符串中，返回全部非重疊匹配的模式。該字符串是從左到右掃描的，匹配按照發現的順序返回。若是一個或多個組是本模式中，返回一個列表的羣體；若是該模式具備多個組，這將是元組的列表。空匹配包含在結果中，除非他們接觸到另外一場匹配的開頭。

返回一個匹配的全部內容的列表。若是沒有匹配內容則返回空列表。

在 1.5.2 版本新。

2.4 版本中的更改：添加可選的標誌參數。

語法：findall(pattern, string, flags=0)

>>> a = 'abc,123.abc.123'

>>> s = '[a-z]+'

>>> r = re.findall(s,a)

>>> r

['abc', 'abc']

re.match()

若是在字符串的開頭的零個或更多字符匹配這個正則表達式，將返回相應的做法實例。返回沒有若是，則該字符串與模式不匹配請注意這是不一樣於零長度匹配。

簡單理解：就是從字符串的開始作正則匹配。能匹配到的最大位置返回。返回的對象用group/groups方法讀取。能夠不匹配到字符串的末尾。可是字符串的開始必須匹配，不然返回空字符串。

語法：match(pattern, string, flags=0)

>>> s = '[a-z]*'

>>> a = 'test123'

>>> b = re.match(s,a)

>>> b.group()

'test'

>>> a = '123abc'

>>> b = re.match(s,a)

>>> b.group()

re.search()

掃描字符串尋找第一個匹配位置，在此正則表達式產生的匹配，並返回相應的MatchObject實例。若是沒有字符串中的位置匹配模式返回空。

可選的第二個參數pos給索引在字符串中搜索在哪裏開始；它將默認爲0。這並不徹底等於切片的字符串； ' ^'模式字符匹配在真正開始的字符串和位置剛換行，但不是必定是在開始搜索的索引。

可選參數endpos限制了多遠的字符串將被搜索；它將，若是字符串是endpos個字符長，所以，只有從pos到字符endpos - 1將搜索匹配項。若是endpos小於pos，沒有比賽會發現，不然，若是rx是已編譯的正則表達式對象， rx.search （字符串， 0， 50)至關於rx.search （字符串 [： 50]， 0)。

注意：若是查找字符時用*則會默認匹配0個對應的字符。這樣就會返回空字符串。

語法：search(pattern, string, flags=0)

>>> s = '\d*'

>>> a = 'abc123,31'

>>> s = re.search(s,a)

>>> s.group()

>>> s.span()

(0, 0)

>>> s = '\d+'

>>> s = re.search(s,a)

>>> s.span()

(3, 6)

>>> s.group()

'123'

re.split()

將字符串拆分的模式的匹配項。若是在模式中使用捕獲括號，則而後也做爲結果列表的一部分返回的文本模式中的全部組。若是maxsplit不爲零，頂多maxsplit分裂發生，而且該字符串的其他部分將做爲列表的最後一個元素返回。（不兼容性說明：在原始的 Python 1.5 版本中， maxsplit被忽略。這已被固定在之後的版本。）

語法：split(pattern, string, maxsplit=0, flags=0)

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

re.sub()

Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. 若是pattern沒有被找到， string不變。repl 能夠是一個字符串或一個函數；若是是一個字符串, 任何反斜槓轉義都會實現。那就是，\n會轉化成一個換行符，\r 會轉化成一個回車，等等。未知的轉義字符例如 \j不作處理。

簡單理解：按照規則pattern匹配字符串string，匹配的字符串按照規則repl來替換。替換後和原來字符串組合返回。repl可使字符串也能夠是函數。

語法：sub(pattern, repl, string, count=0, flags=0)

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

>>> def dashrepl(matchobj):

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

... else: return '-'

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

'pro--gram files'

>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)

'Baked Beans & Spam'

2.二、函數彙總

注意：python3中新增一個函數：

re.fullmatch()，這個函數和re.match()的不一樣之處是須要所有匹配才能返回字符串。若是沒有所有匹配則返回空。

序號	函數名	做用	實例
1	re.DEBUG	顯示正則表達式的調試信息	>>> s = '\d\W' >>> r = re.compile(s, re.DEBUG) in category category_digit in category category_not_word
2	re.DOTALL	使'.'特殊字符匹配任何字符，包括換行；若是沒有此標誌， '.'將匹配除換行符的任何內容。	>>> s = '.*' >>> r = re.match(s,'a.123\nabc') >>> r.group() 'a.123' >>> r = re.match(s,'a.123\nabc',re.DOTALL) >>> r.group() 'a.123\nabc'
3	re.I	測試和re.IGNORECASE做用相同是re.IGNORECASE的簡寫模式	>>> r = re.match('a*','aA',re.I) >>> r.group() 'aA'
4	re.IGNORECASE	執行不區分大小寫的匹配；如[A-Z]表達式將太匹配小寫字母。這不被受當前的區域設置。	>>> r = re.match('a*','aA',re.IGNORECASE) >>> r.group() 'aA'
5	re.L	和re.LOCALE做用相同。是re.LOCALE簡寫模式
6	re.LOCALE	使用當前環境的\w, \W, \b, \B, \s and \S
7	re.M
8	re.MULTILINE	當指定時，模式字符' ^'匹配字符串的開頭以及每一個行的開頭（緊接每一個換行符）；模式字符'$'匹配字符串的末尾以及每一行的結尾（緊靠每一個換行符以前）。默認狀況下， '^'只匹配字符串的開始，'$'只匹配字符串的末尾和字符串末尾換行符（若是有的話）以前的位置
9	re.S	做用和re.DOTALL相同。使'.'特殊字符匹配任何字符，包括換行；若是沒有此標誌， '.'將匹配除換行符的任何內容。	>>> s = '.*' >>> r = re.match(s,'a.123\nabc') >>> r.group() 'a.123' >>> r = re.match(s,'a.123\nabc',re.S) >>> r.group() 'a.123\nabc'
10	re.Scanner
11	re.T
12	re.TEMPLATE
13	re.U	和re.UNICODE做用相同
14	re.UNICODE	使得\w, \W, \b, \B, \d, \D, \s和 \S 取決於UNICODE定義的字符屬性
15	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*")
16	re.X
17	re._MAXCACHE
18	re.__all__
19	re.__class__()
20	re.__delattr__()
21	re.__dict__
22	re.__doc__
23	re.__file__
24	re.__format__()
25	re.__getattribute__()
26	re.__hash__()
27	re.__init__()
28	re.__name__
29	re.__new__()
30	re.__package__
31	re.__reduce__()
32	re.__reduce_ex__()
33	re.__repr__()
34	re.__setattr__()
35	re.__sizeof__()
36	re.__str__()
37	re.__subclasshook__()
38	re.__version__
39	re._alphanum
40	re._cache
41	re._cache_repl
42	re._compile()
43	re._compile_repl()
44	re._expand()
45	re._locale
46	re._pattern_type()
47	re._pickle()
48	re._subx()
49	re.compile()	將正則表達式模式編譯成一個正則表達式對象，它能夠用於匹配使用它的match ()和search ()方法，以下所述。能夠經過指定flags值修改表達式的行爲。值能夠是任何如下變量，使用組合 OR （ \|運算符）。但使用re.compile()和保存所產生的正則表達式對象重用效率更高時該表達式會在單個程序中屢次使用。	語法：compile(pattern, flags=0) >>> s = '[a-z]+\d' >>> a = re.compile(s) >>> a <_sre.SRE_Pattern object at 0x0000000003308738> >>> type(a) <type '_sre.SRE_Pattern'> >>> b = a.match('a123') >>> b.group() 'a123' 等價於： >>> b = re.match('[a-z]+\d', 'a123') >>> b.group() 'a123'
50	re.copy_reg	幫助提供pickle/cPickle的可擴展性。
51	re.error()	正則表達式異常，當一個字符串傳遞給這裏的函數之一時引起的異常不是有效的正則表達式（例如，它可能包含不匹配的括號）或其餘一些錯誤在編譯或匹配過程當中發生的時。若是一個字符串包含不匹配的一種模式，它永遠不會是一個錯誤。
52	re.escape()	返回的字符串與全部非字母數字帶有反斜槓；這是有用的若是你想匹配一個任意的文本字符串，在它可能包含正則表達式元字符簡單理解：把字符串按照可能會是正則表達式來理解，這樣就須要把特殊字符都轉義。這樣才能方便匹配時精確匹配每一個字符。字符'[a-z]'這個字符串能夠看做是正則表達式的模式，這樣就不能做爲被匹配的字符串。若是想把這個字符串做爲被匹配的模式就須要轉義這些特殊字符。print(re.escape('[a-z]')) \[a\-z\]	語法：escape(pattern) >>> s = 'abc.\|123' >>> print s abc.\|123 >>> print(re.escape(s)) abc\.\\|123
53	re.findall()	做爲一個字符串列表，在字符串中，返回全部非重疊匹配的模式。該字符串是從左到右掃描的，匹配按照發現的順序返回。若是一個或多個組是本模式中，返回一個列表的羣體；若是該模式具備多個組，這將是元組的列表。空匹配包含在結果中，除非他們接觸到另外一場匹配的開頭。返回一個匹配的全部內容的列表。若是沒有匹配內容則返回空列表。在 1.5.2 版本新。 2.4 版本中的更改：添加可選的標誌參數。	語法：findall(pattern, string, flags=0) >>> a = 'abc,123.abc.123' >>> s = '[a-z]+' >>> r = re.findall(s,a) >>> r ['abc', 'abc']
54	re.finditer()	返回一個迭代器符合MatchObject狀況在 RE模式字符串中的全部非重疊的匹配。該字符串是掃描的左到右，和按發現的順序返回匹配。空匹配包含在結果中，除非他們接觸的另外一個匹配的開頭。新版本 2.2 中的。 2.4 版本中的更改：添加可選的標誌參數。	>>> a = 'testestest' >>> s = 'test' >>> r = re.finditer(s,a) >>> c = r.next() >>> c.group() 'test' >>> c = r.next() >>> c.group() 'test' >>> c = r.next() Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration >>> text = "He was carefully disguised but captured quickly by police." >>> for m in re.finditer(r"\w+ly", text): ... print '%02d-%02d: %s' % (m.start(), m.end(), m.group(0)) 07-16: carefully 40-47: quickly
55	re.match()	若是在字符串的開頭的零個或更多字符匹配這個正則表達式，將返回相應的做法實例。返回沒有若是，則該字符串與模式不匹配請注意這是不一樣於零長度匹配。簡單理解：就是從字符串的開始作正則匹配。能匹配到的最大位置返回。返回的對象用group/groups方法讀取。能夠不匹配到字符串的末尾。可是字符串的開始必須匹配，不然返回空字符串。	語法：match(pattern, string, flags=0) >>> s = '[a-z]*' >>> a = 'test123' >>> b = re.match(s,a) >>> b.group() 'test' >>> a = '123abc' >>> b = re.match(s,a) >>> b.group() ''
56	re.purge()	清除正則表達式緩存。
57	re.search()	掃描字符串尋找第一個匹配位置，在此正則表達式產生的匹配，並返回相應的MatchObject實例。若是沒有字符串中的位置匹配模式返回空。可選的第二個參數pos給索引在字符串中搜索在哪裏開始；它將默認爲0。這並不徹底等於切片的字符串； ' ^'模式字符匹配在真正開始的字符串和位置剛換行，但不是必定是在開始搜索的索引。可選參數endpos限制了多遠的字符串將被搜索；它將，若是字符串是endpos個字符長，所以，只有從pos到字符endpos - 1將搜索匹配項。若是endpos小於pos，沒有比賽會發現，不然，若是rx是已編譯的正則表達式對象， rx.search （字符串， 0， 50)至關於rx.search （字符串 [： 50]， 0)。注意：若是查找字符時用*則會默認匹配0個對應的字符。這樣就會返回空字符串。	語法：search(pattern, string, flags=0) >>> s = '\d*' >>> a = 'abc123,31' >>> s = re.search(s,a) >>> s.group() '' >>> s.span() (0, 0) >>> s = '\d+' >>> s = re.search(s,a) >>> s.span() (3, 6) >>> s.group() '123'
58	re.split()	將字符串拆分的模式的匹配項。若是在模式中使用捕獲括號，則而後也做爲結果列表的一部分返回的文本模式中的全部組。若是maxsplit不爲零，頂多maxsplit分裂發生，而且該字符串的其他部分將做爲列表的最後一個元素返回。（不兼容性說明：在原始的 Python 1.5 版本中， maxsplit被忽略。這已被固定在之後的版本。）	語法：split(pattern, string, maxsplit=0, flags=0) >>> 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']]
59	re.sre_compile
60	re.sre_parse
61	re.sub()	Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl. 若是pattern沒有被找到， string不變。repl 能夠是一個字符串或一個函數；若是是一個字符串, 任何反斜槓轉義都會實現。那就是，\n會轉化成一個換行符，\r 會轉化成一個回車，等等。未知的轉義字符例如 \j不作處理。簡單理解：按照規則pattern匹配字符串string，匹配的字符串按照規則repl來替換。替換後和原來字符串組合返回。repl可使字符串也能夠是函數。	語法：sub(pattern, repl, string, count=0, flags=0) >>> 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{' >>> def dashrepl(matchobj): ... if matchobj.group(0) == '-': return ' ' ... else: return '-' >>> re.sub('-{1,2}', dashrepl, 'pro----gram-files') 'pro--gram files' >>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE) 'Baked Beans & Spam'
62	re.subn()	執行相同的操做，如sub()，但返回一個元組（new_string， number_of_subs_made)。 2.7 版本中的更改：添加可選的標誌參數。	語法：subn(pattern, repl, string, count=0, flags=0)
63	re.sys
64	re.template()

2.三、函數返回的MatchObject對象的內置函數

search、match返回對象是MatchObject或者是None。

findall返回對象是列表。列表每一個元素都是一個能夠匹配的一段子串。

若是是MatchObject則這個對象的內置函數包括：

序號	函數名	做用
1	re.__class__()
2	re.__copy__()
3	re.__deepcopy__()
4	re.__delattr__()
5	re.__doc__
6	re.__format__()
7	re.__getattribute__()
8	re.__hash__()
9	re.__init__()
10	re.__new__()
11	re.__reduce__()
12	re.__reduce_ex__()
13	re.__repr__()
14	re.__setattr__()
15	re.__sizeof__()
16	re.__str__()
17	re.__subclasshook__()
18	re.end()	返回這個對象的內容長度
19	re.endpos
20	re.expand()
21	re.group()	返回對象匹配的內容，這是全部內容。若是匹配的正則表達式分組了，那麼這個函數返回的值就是元組，元組每一個元素都是匹配的一個子串
22	re.groupdict()
23	re.groups()	若是匹配的正則表達式分組了，那麼能夠用這個函數返回指定組名的字符串。默認時組0
24	re.lastgroup	最後一個分組內容
25	re.lastindex
26	re.pos
27	re.re
28	re.regs
29	re.span()	返回這個對象匹配的字符串在源字符串的起始和結束的索引值，以元組形式返回
30	re.start()	返回匹配結果的內容匹配到源字符串的起始位置的索引值，返回整型
31	re.string	返回源字符串。