摘要：多行模式，改變?cè)址偷男袨?。模塊級(jí)方法編譯正則表達(dá)式，返回一個(gè)對(duì)象。掃描參數(shù)，查找正則表達(dá)式產(chǎn)生匹配的第一個(gè)結(jié)果，返回一個(gè)對(duì)象。清空正則表達(dá)式緩存。和參數(shù)意義同與模塊級(jí)的相同與模塊級(jí)的相同屬性返回一個(gè)正整數(shù)，表示正則匹配模式。

re.ASCII
同re.A，對(duì)應(yīng)的內(nèi)聯(lián)標(biāo)識(shí)為(?a)，用于向后兼容。使元字符w, W, , B, d, D, s和S僅匹配ASCII字符。該模式只在string模式下有意義，在byte模式下將被忽略。

re.DEBUG
顯示debug信息，沒(méi)有對(duì)應(yīng)的內(nèi)聯(lián)標(biāo)識(shí)。

re.IGNORECASE
同re.I，對(duì)應(yīng)的內(nèi)聯(lián)標(biāo)識(shí)是(?i)。忽略大小寫(xiě)匹配，如表達(dá)式[A-Z]也會(huì)匹配小寫(xiě)的字母a-z。對(duì)Unicode字符同樣生效(如"ü"可以匹配"ü")，除非指定了re.ASCII禁止匹配非ASCII字符。

當(dāng)前l(fā)ocale不會(huì)改變此標(biāo)識(shí)的效果，除非指定了re.LOCALE。

在string模式下[a-z],[A-Z]和IGNORECASE標(biāo)識(shí)結(jié)合使用時(shí)，將匹配52個(gè)ASCII字母和4個(gè)非ASCII字母。

re.LOCALE
同re.L，對(duì)應(yīng)的內(nèi)聯(lián)標(biāo)識(shí)為(?L)。不推薦使用。

re.MULTILINE
同re.M，對(duì)應(yīng)的內(nèi)聯(lián)標(biāo)識(shí)為(?m)。多行模式，改變?cè)址?b>^和$的行為。
默認(rèn)^只匹配字符串開(kāi)始，指定后還會(huì)匹配每行的開(kāi)始（換行符之后）；默認(rèn)$只匹配字符串結(jié)尾，指定后還會(huì)匹配每行結(jié)尾（換行符之前）。

re.DOTALL
同re.S，對(duì)應(yīng)的內(nèi)聯(lián)標(biāo)識(shí)為(?s)。此模式下，元字符.匹配任意字符，包括換行符。

re.VERBOSE
同re.X，對(duì)應(yīng)的內(nèi)聯(lián)標(biāo)識(shí)為(?x)。冗余模式，此模式下可以在表達(dá)式中添加注釋?zhuān)蛊涓呖勺x性，但在編譯時(shí)會(huì)忽略多余的空格和注釋。

編譯正則表達(dá)式pattern，返回一個(gè)SRE_Pattern對(duì)象。flags參數(shù)指定匹配模式。

掃描string參數(shù)，查找正則表達(dá)式pattern產(chǎn)生匹配的第一個(gè)結(jié)果，返回一個(gè)SRE_Match對(duì)象。如果返回None表示匹配失敗

如果string參數(shù)開(kāi)頭的0個(gè)或多個(gè)字符匹配正則表達(dá)式pattern，返回一個(gè)SRE_Match對(duì)象。如果返回None表示匹配失敗

即使在MULTILINE模式下，match()函數(shù)也只會(huì)匹配字符串開(kāi)頭，而不會(huì)匹配每行開(kāi)頭

如果string參數(shù)整個(gè)匹配正則表達(dá)式pattern，返回一個(gè)SRE_Match對(duì)象。如果返回None表示匹配失敗。

正則表達(dá)式pattern作為分隔符拆分string參數(shù)，返回拆分后的列表。maxsplit如果不為0，最多拆分maxsplit次，string參數(shù)的余下部分將作為列表的最后一個(gè)元素返回。如果在pattern中使用了分組(...)，返回列表中還會(huì)包含所有匹配的分組本身。

>>> re.split(r"W+", "Words, words, words.")
["Words", "words", "words", ""]

>>> re.split(r"(W+)", "Words, words, words.")
["Words", ", ", "words", ", ", "words", ".", ""]

>>> re.split(r"W+", "Words, words, words.", 1)
["Words", "words, words."]

>>> re.split("[a-f]+", "0a3B9", flags=re.IGNORECASE)
["0", "3", "9"]

如果pattern在字符串的開(kāi)頭匹配，那么返回列表第一個(gè)元素是空字符串；同樣地，如果pattern在字符串末尾匹配，返回列表的最后一個(gè)元素是空字符串：

>>> re.split(r"(W+)", "...words, words...")
["", "...", "words", ", ", "words", "...", ""]

返回一個(gè)列表，按順序排列所有成功的分組匹配。如果pattern參數(shù)中只有一個(gè)分組，列表元素為所有成功的分組匹配；如果存在超過(guò)一個(gè)以上的分組，列表元素為元組形式的各個(gè)分組匹配。如果返回空列表表示匹配失敗

>>> content = "333STR1666STR299"

>>> regex = r"([A-Z]+(d))"
>>> re.findall(regex, content)
[("STR1", "1"), ("STR2", "2")]

>>> regex1 = r"[A-Z]+(d)"
>>> re.findall(regex1, content)
["1", "2"]

# 如果正則表達(dá)式不含分組，視其整體為一個(gè)分組
>>> regex2 = r"[A-Z]+d"
>>> re.findall(regex2, content)
["STR1", "STR2"]

>>> regex3 = r"([A-Z]+d)"
>>> re.findall(regex3, content)
["STR1", "STR2"]

查找所有匹配成功的字符串, 返回一個(gè)迭代器，元素為SRE_Match對(duì)象。如果返回空迭代器表示匹配失敗

content = "333STR1666STR299"
regex = r"([A-Z]+(d))"
result = re.finditer(regex, content)
for i in result:
    print(i.group(0))

# STR1
# STR2

使用pattern匹配原始字符串string，將匹配到的結(jié)果用repl替換，返回一個(gè)新的字符串。如果沒(méi)有匹配返回原字符串。

count是一個(gè)正整數(shù)，表示字符串替換的最大次數(shù)。

repl可以是字符串或函數(shù)，如果是字符串，其中的的所有都將進(jìn)行轉(zhuǎn)義處理，比如 表示換行符，反向引用6表示pattern匹配的第六個(gè)分組，而某些無(wú)意義的轉(zhuǎn)義可能原樣保留或?qū)е庐惓＃?/p>

>>> re.sub(r"defs+([a-zA-Z_][a-zA-Z_0-9]*)s*(s*):",
...        r"static PyObject*
py_1(void)
{",
...        "def myfunc():")
"static PyObject*
py_myfunc(void)
{"

如果repl是函數(shù)，該函數(shù)接收單個(gè)SRE_Match對(duì)象為參數(shù)，pattern匹配到一次結(jié)果便會(huì)調(diào)用一次該函數(shù)，返回要替換的字符串：

>>> def dashrepl(matchobj):
...     if matchobj.group(0) == "-": return " "
...     else: return "-"
>>> re.sub("-{1,2}", dashrepl, "pro----gram-files")
"pro--gram files"
>>> re.sub(r"sANDs", " & ", "Baked Beans And Spam", flags=re.IGNORECASE)
"Baked Beans & Spam"

同sub()，但返回值為(new_string, number_of_subs_made)

轉(zhuǎn)義特殊字符。

清空正則表達(dá)式緩存。

exception re.error(msg, pattern=None, pos=None)

屬性

msg：未格式化的錯(cuò)誤信息

pattern：正則表達(dá)式

pos：導(dǎo)致異常的pattern索引位置，可能為None

lineno：pos在第幾行，可能為None

colno：pos在所在行的位置，可能為None

方法

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

與模塊級(jí)的search()類(lèi)似。pos和endpos表示string參數(shù)的前endpos個(gè)字符中，從索引為pos的位置開(kāi)始匹配，如果endpos小于等于pos，返回None

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

與模塊級(jí)的match()類(lèi)似。pos和endpos參數(shù)意義同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".

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

與模塊級(jí)的fullmatch()類(lèi)似。pos和endpos參數(shù)意義同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.

Pattern.split(string, maxsplit=0)

與模塊級(jí)的split()相同

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

與模塊級(jí)的findall()類(lèi)似。pos和endpos參數(shù)意義同search()

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

與模塊級(jí)的finditer()類(lèi)似。pos和endpos參數(shù)意義同search()

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

與模塊級(jí)的sub()相同

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

與模塊級(jí)的subn()相同

屬性

Pattern.flags：返回一個(gè)正整數(shù)，表示正則匹配模式。該值是compile()函數(shù)中pattern參數(shù)中的內(nèi)聯(lián)標(biāo)識(shí)以及flags參數(shù)指定的模式，和隱式的re.UNICODE(如果pattern為Unicode字符串)的值的和

>>> re.UNICODE


>>> re.IGNORECASE


# 32 + 2
>>> re.compile("", flags=re.IGNORECASE).flags
34

Pattern.groups：pattern中存在的分組數(shù)量

Pattern.groupindex：正則表達(dá)式中所有命名分組名稱(chēng)和對(duì)應(yīng)分組號(hào)的映射；如果沒(méi)有使用命名分組，返回一個(gè)空字典

>>> pattern = re.compile(r"(?Pw+) (?Pw+)")
>>> pattern.groupindex
mappingproxy({"first_name": 1, "last_name": 2})

Pattern.pattern：編譯pattern對(duì)象的正則表達(dá)式

方法

通過(guò)對(duì)template中的反斜杠引用進(jìn)行替換，返回替換后的字符串。例如 將轉(zhuǎn)義為換行符，1, g將替換為Match對(duì)象中對(duì)應(yīng)的分組：

>>> m = re.search("(b)+(z)?", "cba")
>>> m

>>> m.expand(r"ab1")
"abb"
>>> m.expand(r"ab2")
"ab"
>>> print(m.expand(r"ab
"))
ab

>>>

返回Match對(duì)象的一個(gè)或多個(gè)子分組。如果傳入單個(gè)參數(shù)，返回單個(gè)字符串；如果傳入多個(gè)參數(shù)，返回一個(gè)元組，元組中的每個(gè)元素代表每個(gè)參數(shù)對(duì)應(yīng)的分組。

如果參數(shù)為0，返回值為pattern匹配的完整字符串

如果參數(shù)在1-99范圍內(nèi)，返回對(duì)應(yīng)分組匹配的字符串

如果參數(shù)為負(fù)數(shù)或大于pattern中定義的分組數(shù)量，拋出IndexError異常

如果對(duì)應(yīng)分組無(wú)匹配，返回None

如果一個(gè)分組匹配多次，只返回最后一次匹配的結(jié)果

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

>>> m.group(0)       # (1)
"Isaac Newton

>>> m.group(1)       # (2)
"Isaac"
>>> m.group(2)       # (2)
"Newton"
>>> m.group(1, 2)    # Multiple arguments give us a tuple.
("Isaac", "Newton")

>>> type(m.group(3)) # (4)


>>> m = re.match(r"(..)+", "a1b2c3")  # Matches 3 times.
>>> m.group(1)                        # (5)
"c3"

如果正則表達(dá)式中使用了(?P...)，group()也支持通過(guò)分組名的方式訪問(wèn)分組，分組名不存在將拋出IndexError異常：

>>> m = re.match(r"(?Pw+) (?Pw+)", "Malcolm Reynolds")
>>> m.group("first_name")
"Malcolm"
>>> m.group("last_name")
"Reynolds"

# 仍然可以通過(guò)索引訪問(wèn)
>>> m.group(1)
"Malcolm"
>>> m.group(2)
"Reynolds"

等同于group()，提供了更簡(jiǎn)單的訪問(wèn)分組的方式：

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

>>> m = re.match(r"(?Pw+) (?Pw+)", "Malcolm Reynolds")
>>> m["first_name"]
"Malcolm"

返回一個(gè)包含所有子分組的元組，元組長(zhǎng)度等同于pattern中的分組數(shù)量；如果沒(méi)有分組，返回空元組。default參數(shù)作為分組無(wú)匹配值時(shí)的默認(rèn)值，默認(rèn)為None：

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

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

返回一個(gè)字典，key為pattern中定義的分組名稱(chēng)，value為分組的匹配值；如果沒(méi)有使用命名元組，返回空字典。default參數(shù)作為分組無(wú)匹配值時(shí)的默認(rèn)值，默認(rèn)為None：

>>> m = re.match(r"(?Pw+) (?Pw+)", "Malcolm Reynolds")
>>> m.groupdict()
{"first_name": "Malcolm", "last_name": "Reynolds"}

返回由group匹配的子字符串在原始字符串中的開(kāi)始和結(jié)束索引。

group默認(rèn)為0，表示完整匹配結(jié)果。

如果返回-1，表示group存在但沒(méi)有匹配值

如果m.start(group)等同于m.end(group)，表示group匹配一個(gè)空字符串

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


# (1)
>>> m.start()
0
>>> m.end()
12

# (2)
>>> type(m[3])

>>> m.start(3)
-1
>>> m.end(3)
-1

# (3)
>>> m[3]
""
>>> m.start(3)
12
>>> m.end(3)
12

返回(m.start(group), m.end(group))形式的元組，如果group不存在對(duì)應(yīng)匹配值，返回(-1, -1)。group默認(rèn)為0，表示完整匹配結(jié)果

屬性

Match.pos：傳遞給Pattern對(duì)象的search(), match(), fullmatch()方法的pos參數(shù)

Match.endpos：傳遞給Pattern對(duì)象的search(), match(), fullmatch()方法的endpos參數(shù)

Match.lastindex：具有匹配值的最后一個(gè)分組的位置，如果沒(méi)有任何分組匹配，返回None。

>>> m = re.search(r"a(z)?", "ab")
>>> type(m.lastindex)


>>> m = re.match(r"(w+) (w+)(d)?", "Isaac Newton, physicist")
>>> m.lastindex
2

Match.lastgroup：具有匹配值的最后一個(gè)分組的名稱(chēng)，如果沒(méi)有命名分組或沒(méi)有任何分組匹配，返回None

Match.re：創(chuàng)建當(dāng)前Match對(duì)象的Pattern對(duì)象

Match.string：進(jìn)行匹配的原始字符串

Non-empty matches can now start just after a previous empty match：

# python3.7之前
>>> re.sub("x*", "-", "abxd")
"-a-b-d-"

# python3.7
>>> re.sub("x*", "-", "abxd")
"-a-b--d-"

Unknown escapes in repl consisting of "" and an ASCII letter now are errors：

# python3.7之前
>>> print(re.sub(r"w+", r"d", "ab&xd&"))
d&d&

# python3.7
>>> print(re.sub(r"w+", r"d", "ab&xd&"))
...
re.error: bad escape d at position 0

Only characters that can have special meaning in a regular expression are escaped：

# python3.7之前
>>> print(re.escape("!#$%&"))
!#$\%&

# python3.7
>>> print(re.escape("!#$%&"))
!#$%&

Added support of splitting on a pattern that could match an empty string：

# python3.7之前
>>> re.split(r"", "Words, words, words.")
...
ValueError: split() requires a non-empty pattern match.

>>> re.split(r"W*", "...words...")
["", "words", ""]

>>> re.split(r"(W*)", "...words...")
["", "...", "words", "...", ""]

# python3.7
>>> re.split(r"", "Words, words, words.")
["", "Words", ", ", "words", ", ", "words", "."]

>>> re.split(r"W*", "...words...")
["", "", "w", "o", "r", "d", "s", "", ""]

>>> re.split(r"(W*)", "...words...")
["", "...", "", "", "w", "", "o", "", "r", "", "d", "", "s", "...", "", "", ""]

Added support of copy.copy() and copy.deepcopy(). Match objects are considered atomic