link之家

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

1- 简介

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。

re 模块使 Python 语言拥有全部的正则表达式功能。

compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。

re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。

模式和被搜索的字符串既可以是 Unicode 字符串 ( str ) ，也可以是8位字节串 ( bytes )。但是，Unicode 字符串与8位字节串不能混用：也就是说，你不能用一个字节串模式去匹配 Unicode 字符串，反之亦然；类似地，当进行替换操作时，替换字符串的类型也必须与所用的模式和搜索字符串的类型一致。

正则表达式使用反斜杠（ '\' ）来表示特殊形式，或者把特殊字符转义成普通字符。而反斜杠在普通的 Python 字符串里也有相同的作用，所以就产生了冲突。比如说，要匹配一个字面上的反斜杠，正则表达式模式不得不写成 '\\\\' ，因为正则表达式里匹配一个反斜杠必须是 \\ ，而每个反斜杠在普通的 Python 字符串里都要写成 \\ 。

解决办法是对于正则表达式样式使用 Python 的原始字符串表示法；在带有 'r' 前缀的字符串字面值中，反斜杠不必做任何特殊处理。因此 r"\n" 表示包含 '\' 和 'n' 两个字符的字符串，而 "\n" 则表示只包含一个换行符的字符串。样式在 Python 代码中通常都会使用这种原始字符串表示法来表示。

绝大部分正则表达式操作都提供为模块函数和方法，在编译正则表达式 . 这些函数是一个捷径，不需要先编译一个正则对象，但是损失了一些优化参数。

2- 语法

一个正则表达式（或RE）指定了一集与之匹配的字符串；模块内的函数可以让你检查某个字符串是否跟给定的正则表达式匹配（或者一个正则表达式是否匹配到一个字符串，这两种说法含义相同）。

正则表达式可以拼接；如果 A 和 B 都是正则表达式，那么 AB 也是正则表达式。通常，如果字符串 p 匹配 A 并且另一个字符串 q 匹配 B , 那么 pq 可以匹配 AB。除非 A 或者 B 包含低优先级操作， A 和 B 存在边界条件；或者命名组引用。所以，复杂表达式可以很容易的从这里描述的简单源语表达式构建。了解更多正则表达式理论和实现，参考the Friedl book [ Frie09] ，或者其他编译器构建的书籍。

以下是正则表达式格式的简要说明。更详细的信息和演示，参考正则表达式HOWTO 。

正则表达式可以包含普通或者特殊字符。绝大部分普通字符，比如 'A' , 'a' , 或者 '0' ，都是最简单的正则表达式。它们就匹配自身。你可以拼接普通字符，所以 last 匹配字符串 'last' . （在这一节的其他部分，我们将用 this special style 这种方式表示正则表达式，通常不带引号，要匹配的字符串用 'in single quotes' ，单引号形式。）

有些字符，比如 '|' 或者 '(' ，属于特殊字符。特殊字符既可以表示它的普通含义，也可以影响它旁边的正则表达式的解释。

重复修饰符 ( * , + , ? , {m,n} , 等) 不能直接嵌套。这样避免了非贪婪后缀 ? 修饰符，和其他实现中的修饰符产生的多义性。要应用一个内层重复嵌套，可以使用括号。比如，表达式 (?:a{6})* 匹配6个 'a' 字符重复任意次数。

3- 特殊字符

(点) 在默认模式，匹配除了换行的任意字符。如果指定了标签


    DOTALL

，它将匹配包括换行符的任意字符。 $ | 匹配字符串尾或者换行符的前一个字符，在


    MULTILINE

模式匹配换行符的前一个字符。

foo

匹配


   'foo'

和


   'foobar'

, 但正则


   foo$

只匹配


   'foo'

。更有趣的是，在


   'foo1\nfoo2\n'

搜索 `foo. ----------------------------------- ------------------------------------------------------------ (插入符号) 匹配字符串的开头，并且在


    MULTILINE

模式也匹配换行后的首个符号。，通常匹配


   'foo2'

，但在


    MULTILINE

模式，可以匹配到


   'foo1'

；在


   'foo\n'

搜索

会找到两个空串：一个在换行前，一个在字符串最后。对它前面的正则式匹配0到任意次重复，尽量多的匹配字符串。

ab*

会匹配

'a'

，


   'ab'

，或者


   'a'``后面跟随任意个 ``'b'

。对它前面的正则式匹配0到1次重复。

ab?

会匹配

'a'

或者


   'ab'

。 *?

'*'

'+'

，和

'?'

修饰符都是 贪婪的 ；它们在字符串进行尽可能多的匹配。有时候并不需要这种行为。如果正则式


   <.*>

希望找到


   '<a> b <c>'

，它将会匹配整个字符串，而不仅是


   '<a>'

。在修饰符之后添加

将使样式以 非贪婪 方式或者 :dfn: 最小 方式进行匹配；尽量少的字符将会被匹配。使用正则式


   <.*?>

将会仅仅匹配


   '<a>'

。 "{m}" 对其之前的正则式指定匹配 m 个重复；少于 m 的话就会导致匹配失败。比如，


   a{6}

将匹配6个

'a'

, 但是不能是5个。 "{m, n}" 对正则式进行 m 到 n 次匹配，在 m 和 n 之间取尽量多。比如，


   a{3,5}

将匹配 3 到 5个

'a'

。忽略 m 意为指定下界为0，忽略 n 指定上界为无限次。比如


   a{4,}b

将匹配


   'aaaab'

或者1000个

'a'

尾随一个

'b'

，但不能匹配


   'aaab'

。逗号不能省略，否则无法辨别修饰符应该忽略哪个边界。 {m,n}? 前一个修饰符的非贪婪模式，只匹配尽量少的字符次数。比如，对于


   'aaaaaa'

，


   a{3,5}

匹配 5个

'a'

，而


   a{3,5}?

只匹配3个

'a'

。转义特殊字符（允许你匹配

'*'

'?'

, 或者此类其他），或者表示一个特殊序列；
如果你没有使用原始字符串（


   r'raw'

）来表达样式，要牢记Python也使用反斜杠作为转义序列；如果转义序列不被Python的分析器识别，反斜杠和字符才能出现在字符串中。如果Python可以识别这个序列，那么反斜杠就应该重复两次。这将导致理解障碍，所以高度推荐，就算是最简单的表达式，也要使用原始字符串。用于表示一个字符集合。在一个集合中：
1. 字符可以单独列出，比如


   [amk]

匹配

'a'

，

'm'

，或者

'k'

。
2. 可以表示字符范围，通过用

'-'

将两个字符连起来。比如


   [a-z]

将匹配任何小写ASCII字符，


   [0-5][0-9]

将匹配从

到

的两位数字，


   [0-9A-Fa-f]

将匹配任何十六进制数位。如果

进行了转义（比如


   [a\-z]

）或者它的位置在首位或者末尾（如


   [-a]

或


   [a-]

），它就只表示普通字符

'-'

。
3. 特殊字符在集合中，失去它的特殊含义。比如


   [(+*)]

只会匹配这几个文法字符

'('

'+'

'*'

, or

')'

。
4. 不在集合范围内的字符可以通过取反来进行匹配。如果集合首字符是

'^'

，所有不在集合内的字符将会被匹配，比如


   [^5]

将匹配所有字符，除了

'5'

，


   [^^]

将匹配所有字符，除了

'^'

如果不在集合首位，就没有特殊含义。
5. 在集合内要匹配一个字符

']'

，有两种方法，要么就在它之前加上反斜杠，要么就把它放到集合首位。比如，


   [()[\]{}]

和


   []()[{}]

都可以匹配括号。
6. Unicode Technical Standard #18 里的嵌套集合和集合操作支持可能在未来添加。这将会改变语法，所以为了帮助这个改变，一个


    FutureWarning

将会在有多义的情况里被


   raise

，包含以下几种情况，集合由

'['

开始，或者包含下列字符序列


   '--'


   '&&'


   '~~'


   |，或者把它包含在字符集里，比如

[|] (...) （组合），匹配括号内的任意正则表达式，并标识出组合的开始和结尾。匹配完成后，组合的内容可以被获取，并可以在之后用


   \number

转义序列进行再次匹配，之后进行详细说明。要匹配字符

'('

或者

')'

, 用

\(

或

\)

, 或者把它们包含在字符集合里:

[(]

[)]

. 这是个扩展标记法（一个

'?'

跟随

'('

并无含义）。

'?'

后面的第一个字符决定了这个构建采用什么样的语法。这种扩展通常并不创建新的组合；


   (?P<name>...)

是唯一的例外。以下是目前支持的扩展。 (?aiLmsux) (

'a'

'i'

'L'

'm'

's'

'u'

'x'

中的一个或多个) 这个组合匹配一个空字符串；这些字符对正则表达式设置以下标记


    re.A

(只匹配ASCII字符),


    re.I

(忽略大小写),


    re.L

(语言依赖),


    re.M

(多行模式),


    re.S

(点dot匹配全部字符),


   re.U

(Unicode匹配), and


    re.X

(冗长模式)。 (这些标记在模块内容中描述) 如果你想将这些标记包含在正则表达式中，这个方法就很有用，免去了在


    re.compile()

中传递 flag 参数。标记应该在表达式字符串首位表示。 (?:…) 正则括号的非捕获版本。匹配在括号内的任何正则表达式，但该分组所匹配的子字符串不能在执行匹配后被获取或是之后在模式中被引用。 (?aiLmsux-imsx:…) (

'a'

'i'

'L'

'm'

's'

'u'

'x'

中的0或者多个，之后可选跟随

'-'

在后面跟随

'i'

'm'

's'

'x'

中的一到多个 .) 这些字符为表达式的其中一部分设置或者去除相应标记


    re.A

(只匹配ASCII),


    re.I

(忽略大小写),


    re.L

(语言依赖),


    re.M

(多行),


    re.S

(点匹配所有字符),


   re.U

(Unicode匹配), and


    re.X

(冗长模式)。(标记描述在模块内容 .)

'a'

'L'

and

'u'

作为内联标记是相互排斥的，所以它们不能结合在一起，或者跟随

'-'

。当他们中的某个出现在内联组中，它就覆盖了括号组内的匹配模式。在Unicode样式中，


   (?a:...)

切换为只匹配ASCII，


   (?u:...)

切换为Unicode匹配 (默认). 在byte样式中


   (?L:...)

切换为语言依赖模式，


   (?a:...)

切换为只匹配ASCII (默认)。这种方式只覆盖组合内匹配，括号外的匹配模式不受影响。 (?P …) （命名组合）类似正则组合，但是匹配到的子串组在外部是通过定义的 name 来获取的。组合名必须是有效的Python标识符，并且每个组合名只能用一个正则表达式定义，只能定义一次。一个符号组合同样是一个数字组合，就像这个组合没有被命名一样。 (?P=name) 反向引用一个命名组合；它匹配前面那个叫 name 的命名组中匹配到的串同样的字串。 (?#…) 注释；里面的内容会被忽略。 (?=…) 匹配

…

的内容，但是并不消费样式的内容。这个叫做 lookahead assertion 。比如，


   Isaac (?=Asimov)

匹配


   'Isaac '

只有在后面是


   'Asimov'

的时候。 (?!…) 匹配

…

不符合的情况。这个叫 negative lookahead assertion （前视取反）。比如说，


   Isaac (?!Asimov)

只有后面不是


   'Asimov'

的时候才匹配


   'Isaac '

。 (?<=…) 匹配字符串的当前位置，它的前面匹配

…

的内容到当前位置。这叫:dfn:positive lookbehind assertion （正向后视断定）。


   (?<=abc)def

会在


   'abcdef'

中找到一个匹配，因为后视会往后看3个字符并检查是否包含匹配的样式。包含的匹配样式必须是定长的，意思就是

abc

或 `a (?<!…) 匹配当前位置之前不是

…

的样式。这个叫:dfn:negative lookbehind assertion （后视断定取非）。类似正向后视断定，包含的样式匹配必须是定长的。由 negative lookbehind assertion 开始的样式可以从字符串搜索开始的位置进行匹配。 (?(id/name)yes-pattern|no-pattern) 如果给定的 id 或 name 存在，将会尝试匹配


   yes-pattern

，否则就尝试匹配


   no-pattern

，


   no-pattern

可选，也可以被忽略。比如， `(<)?(\w+@\w+(?:.\w+)+)(?(1)> \number 匹配数字代表的组合。每个括号是一个组合，组合从1开始编号。比如


   (.+) \1

匹配


   'the the'

或者


   '55 55'

, 但不会匹配


   'thethe'

(注意组合后面的空格)。这个特殊序列只能用于匹配前面99个组合。如果 number 的第一个数位是0，或者 number 是三个八进制数，它将不会被看作是一个组合，而是八进制的数字值。在

'['

和

']'

字符集合内，任何数字转义都被看作是字符。只匹配字符串开始。匹配空字符串，但只在单词开始或结尾的位置。一个单词被定义为一个单词字符的序列。注意，通常

\b

定义为

\w

和

\W

字符之间，或者

\w

和字符串开始/结尾的边界，意思就是


   r'\bfoo\b'

匹配


   'foo'


   'foo.'


   '(foo)'


   'bar foo baz'

但不匹配


   'foobar'

或者


   'foo3'

。
默认情况下，Unicode字母和数字是在Unicode样式中使用的，但是可以用


    ASCII

标记来更改。如果


    LOCALE

标记被设置的话，词的边界是由当前语言区域设置决定的，

\b

表示退格字符，以便与Python字符串文本兼容。匹配空字符串，但不能在词的开头或者结尾。意思就是


   r'py\B'

匹配


   'python'


   'py3'


   'py2'

, 但不匹配


   'py'


   'py.'

, 或者


   'py!'

\B

是

\b

的取非，所以Unicode样式的词语是由Unicode字母，数字或下划线构成的，虽然可以用


    ASCII

标志来改变。如果使用了


    LOCALE

标志，则词的边界由当前语言区域设置。对于 Unicode (str) 样式：匹配任何Unicode十进制数（就是在Unicode字符目录[Nd]里的字符）。这包括了


   [0-9]

，和很多其他的数字字符。如果设置了


    ASCII

标志，就只匹配


   [0-9]

。
对于8位(bytes)样式：
匹配任何十进制数，就是


   [0-9]

。匹配任何非十进制数字的字符。就是

\d

取非。如果设置了


    ASCII

标志，就相当于


   [^0-9]

。对于 Unicode (str) 样式：
匹配任何Unicode空白字符（包括


   [ \t\n\r\f\v]

，还有很多其他字符，比如不同语言排版规则约定的不换行空格）。如果


    ASCII

被设置，就只匹配


   [ \t\n\r\f\v]

。
对于8位(bytes)样式：
匹配ASCII中的空白字符，就是


   [ \t\n\r\f\v]

。对于 Unicode (str) 样式:
匹配Unicode词语的字符，包含了可以构成词语的绝大部分字符，也包括数字和下划线。如果设置了


    ASCII

标志，就只匹配


   [a-zA-Z0-9_]

。
对于8位(bytes)样式：
匹配ASCII字符中的数字和字母和下划线，就是


   [a-zA-Z0-9_]

。如果设置了


    LOCALE

标记，就匹配当前语言区域的数字和字母和下划线。匹配任何不是单词字符的字符。这与

\w

正相反。如果使用了


    ASCII

旗标，这就等价于


   [^a-zA-Z0-9_]

。如果使用了


    LOCALE

旗标，则会匹配在当前区域设置中不是字母数字又不是下划线的字符。只匹配字符串尾。

re.``compile`( pattern , flags=0 )

将正则表达式的样式编译为一个正则表达式对象（正则对象），可以用于匹配，通过这个对象的方法 match() , search() 以及其他如下描述。

这个表达式的行为可以通过指定标记的值来改变。值可以是以下任意变量，可以通过位的OR操作来结合（ | 操作符）。

re.``A

re.``ASCII

让 \w , \W , \b , \B , \d , \D , \s 和 \S 只匹配ASCII，而不是Unicode。这只对Unicode样式有效，会被byte样式忽略。相当于前面语法中的内联标志 (?a) 。注意，为了保持向后兼容， re.U 标记依然存在（还有他的同义 re.UNICODE 和嵌入形式 (?u) ) ，但是这些在 Python 3 是冗余的，因为默认字符串已经是Unicode了（并且Unicode匹配不允许byte出现)。

re.``DEBUG

显示编译时的debug信息，没有内联标记。

re.``I

re.``IGNORECASE

进行忽略大小写匹配；表达式如 [A-Z] 也会匹配小写字符。Unicode匹配（比如 Ü 匹配 ü ）同样有用，除非设置了 re.ASCII 标记来禁用非ASCII匹配。当前语言区域不会改变这个标记，除非设置了 re.LOCALE 标记。这个相当于内联标记 (?i) 。注意，当设置了 IGNORECASE 标记，搜索Unicode样式 [a-z] 或 [A-Z] 的结合时，它将会匹配52个ASCII字符和4个额外的非ASCII字符： 'İ' (U+0130, 拉丁大写的 I 带个点在上面), 'ı' (U+0131, 拉丁小写没有点的 I ), 'ſ' (U+017F, 拉丁小写长 s) and 'K' (U+212A, 开尔文符号).如果使用 ASCII 标记，就只匹配 'a' 到 'z' 和 'A' 到 'Z' 。

re.``L

re.``LOCALE

由当前语言区域决定 \w , \W , \b , \B 和大小写敏感匹配。这个标记只能对byte样式有效。这个标记不推荐使用，因为语言区域机制很不可靠，它一次只能处理一个 "习惯”，而且只对8位字节有效。Unicode匹配在Python 3 里默认启用，并可以处理不同语言。这个对应内联标记 (?L) 。 在 3.6 版更改: re.LOCALE 只能用于byte样式，而且不能和 re.ASCII 一起用。 在 3.7 版更改: 设置了 re.LOCALE 标记的编译正则对象不再在编译时依赖语言区域设置。语言区域设置只在匹配的时候影响其结果。

re.``M

re.``MULTILINE

设置以后，样式字符 '^' 匹配字符串的开始，和每一行的开始（换行符后面紧跟的符号）；样式字符 '$' 匹配字符串尾，和每一行的结尾（换行符前面那个符号）。默认情况下， ’^’ 匹配字符串头， '$' 匹配字符串尾。对应内联标记 (?m) 。

re.``S

re.``DOTALL

让 '.' 特殊字符匹配任何字符，包括换行符；如果没有这个标记， '.' 就匹配除了换行符的其他任意字符。对应内联标记 (?s) 。

re.``X

re.``VERBOSE

这个标记允许你编写更具可读性更友好的正则表达式。通过分段和添加注释。空白符号会被忽略，除非在一个字符集合当中或者由反斜杠转义，或者在 *? , (?: or (?P<…> 分组之内。当一个行内有 # 不在字符集和转义序列，那么它之后的所有字符都是注释

re.``search ( pattern , string , flags=0 )

扫描整个 字符串 找到匹配样式的第一个位置，并返回一个相应的匹配对象。如果没有匹配，就返回一个 None ；注意这和找到一个零长度匹配是不同的。

re.``match ( pattern , string , flags=0 )

如果 string 开始的0或者多个字符匹配到了正则表达式样式，就返回一个相应的匹配对象。如果没有匹配，就返回 None ；注意它跟零长度匹配是不同的。注意即便是 MULTILINE 多行模式， re.match() 也只匹配字符串的开始位置，而不匹配每行开始。如果你想定位 string 的任何位置，使用 search() 来替代（也可参考 search() vs. match() ）

re.``fullmatch ( pattern , string , flags=0 )

如果整个 string 匹配到正则表达式样式，就返回一个相应的匹配对象。否则就返回一个 None ；注意这跟零长度匹配是不同的。 3.4 新版功能.

re.``split ( pattern , string , maxsplit=0 , flags=0 )

用 pattern 分开 string 。如果在 pattern 中捕获到括号，那么所有的组里的文字也会包含在列表里。如果 maxsplit 非零，最多进行 maxsplit 次分隔，剩下的字符全部返回到列表的最后一个元素。

re.``findall ( pattern , string , flags=0 )

对 string 返回一个不重复的 pattern 的匹配列表， string 从左到右进行扫描，匹配按找到的顺序返回。如果样式里存在一到多个组，就返回一个组合列表；就是一个元组的列表（如果样式里有超过一个组合的话）。空匹配也会包含在结果里。 在 3.7 版更改: 非空匹配现在可以在前一个空匹配之后出现了。

re.``finditer ( pattern , string , flags=0 )

pattern 在 string 里所有的非重复匹配，返回为一个迭代器 iterator 保存了匹配对象。 string 从左到右扫描，匹配按顺序排列。空匹配也包含在结果里。 在 3.7 版更改: 非空匹配现在可以在前一个空匹配之后出现了。

re.``sub ( pattern , repl , string , count=0 , flags=0 )

返回通过使用 repl 替换在 string 最左边非重叠出现的 pattern 而获得的字符串。如果样式没有找到，则不加改变地返回 string 。 repl 可以是字符串或函数；如为字符串，则其中任何反斜杠转义序列都会被处理。也就是说， \n 会被转换为一个换行符， \r 会被转换为一个回车附，依此类推。未知的 ASCII 字符转义序列保留在未来使用，会被当作错误来处理。其他未知转义序列例如 \& 会保持原样。向后引用像是 \6 会用样式中第 6 组所匹配到的子字符串来替换。

re.``subn ( pattern , repl , string , count=0 , flags=0 )

行为与 sub() 相同，但是返回一个元组 (字符串, 替换次数) . 在 3.1 版更改: 增加了可选标记参数。 在 3.5 版更改: 不匹配的组合替换为空字符串。

re.``escape ( pattern )

转义 pattern 中的特殊字符。如果你想对任意可能包含正则表达式元字符的文本字符串进行匹配，它就是有用的。

re.``purge ()

清除正则表达式缓存。

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

raise 一个例外。当传递到函数的字符串不是一个有效正则表达式的时候（比如，包含一个不匹配的括号）或者其他错误在编译时或匹配时产生。如果字符串不包含样式匹配，是不会被视为错误的。错误实例有以下附加属性： msg 未格式化的错误消息。 pattern 正则表达式样式。 pos 编译失败的 pattern 的位置索引（可以是 None ）。 lineno 对应 pos (可以是 None ) 的行号。 colno 对应 pos (可以是 None ) 的列号。 在 3.5 版更改: 添加了附加属性。

5- 正则对象

编译后的正则表达式对象支持以下方法和属性：

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

扫描整个 string 寻找第一个匹配的位置，并返回一个相应的匹配对象。如果没有匹配，就返回 None ；注意它和零长度匹配是不同的。

可选的第二个参数 pos 给出了字符串中开始搜索的位置索引；默认为 0 ，它不完全等价于字符串切片； '^' 样式字符匹配字符串真正的开头，和换行符后面的第一个字符，但不会匹配索引规定开始的位置。

可选参数 endpos 限定了字符串搜索的结束；它假定字符串长度到 endpos ，所以只有从 pos 到 endpos - 1 的字符会被匹配。如果 endpos 小于 pos ，就不会有匹配产生；另外，如果 rx 是一个编译后的正则对象， rx.search(string, 0, 50) 等价于 rx.search(string[:50], 0) 。

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

如果 string 的 开始位置 能够找到这个正则样式的任意个匹配，就返回一个相应的匹配对象。如果不匹配，就返回 None ；注意它与零长度匹配是不同的。

可选参数 pos 和 endpos 与 search() 含义相同。

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

如果整个 string 匹配这个正则表达式，就返回一个相应的匹配对象。否则就返回 None ；注意跟零长度匹配是不同的。

Pattern.``split ( string , maxsplit=0 )

等价于 split() 函数，使用了编译后的样式。

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

类似函数 findall() ，使用了编译后样式，但也可以接收可选参数 pos 和 endpos ，限制搜索范围，就像 search() 。

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

类似函数 finiter() ，使用了编译后样式，但也可以接收可选参数 pos 和 endpos ，限制搜索范围，就像 search() 。

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

等价于 sub() 函数，使用了编译后的样式。

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

等价于 subn() 函数，使用了编译后的样式。

Pattern.``flags

正则匹配标记。这是可以传递给 compile() 的参数，任何 (?…) 内联标记，隐性标记比如 UNICODE 的结合。

Pattern.``groups

捕获组合的数量。

Pattern.``groupindex

映射由 (?P<id>) 定义的命名符号组合和数字组合的字典。如果没有符号组，那字典就是空的。

Pattern.``pattern

编译对象的原始样式字符串。

6- 匹配对象

匹配对象总是有一个布尔值 True 。如果没有匹配的话 match() 和 search() 返回 None 所以你可以简单的用 if 语句来判断是否匹配

匹配对象支持以下方法和属性：

Match.``expand ( template )

对 template 进行反斜杠转义替换并且返回，就像 sub() 方法中一样。转义如同 \n 被转换成合适的字符，数字引用( \1 , \2 )和命名组合( \g<1> , \g<name> ) 替换为相应组合的内容。 在 3.5 版更改: 不匹配的组合替换为空字符串。

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

返回一个或者多个匹配的子组。如果只有一个参数，结果就是一个字符串，如果有多个参数，结果就是一个元组（每个参数对应一个项），如果没有参数，组1默认到0（整个匹配都被返回）。如果一个组N 参数值为 0，相应的返回值就是整个匹配字符串；如果它是一个范围 [1..99]，结果就是相应的括号组字符串。如果一个组号是负数，或者大于样式中定义的组数，一个 IndexError 索引错误就 raise 。如果一个组包含在样式的一部分，并被匹配多次，就返回最后一个匹配。:

Match.``__getitem__ ( g )

这个等价于 m.group(g) 。这允许更方便的引用一个匹配

Match.``groups ( default=None )

返回一个元组，包含所有匹配的子组，在样式中出现的从1到任意多的组合。 default 参数用于不参与匹配的情况，默认为 None 。

Match.``groupdict ( default=None )

返回一个字典，包含了所有的命名子组。key就是组名。 default 参数用于不参与匹配的组合；默认为 None 。

Match.``start ([ group ])

Match.``end ([ group ])

返回 group 匹配到的字串的开始和结束标号。 group 默认为0（意思是整个匹配的子串）。如果 group 存在，但未产生匹配，就返回 -1 。

Match.``span ([ group ])

对于一个匹配 m ，返回一个二元组 (m.start(group), m.end(group)) 。注意如果 group 没有在这个匹配中，就返回 (-1, -1) 。 group 默认为0，就是整个匹配。

Match.``pos

pos 的值，会传递给 search() 或 match() 的方法 a 正则对象。这个是正则引擎开始在字符串搜索一个匹配的索引位置。

Match.``endpos

endpos 的值，会传递给 search() 或 match() 的方法 a 正则对象。这个是正则引擎停止在字符串搜索一个匹配的索引位置。

Match.``lastindex

捕获组的最后一个匹配的整数索引值，或者 None 如果没有匹配产生的话。比如，对于字符串 'ab' ，表达式 (a)b , ((a)(b)) , 和 ((ab)) 将得到 lastindex == 1 ，而 (a)(b) 会得到 lastindex == 2 。

Match.``lastgroup

最后一个匹配的命名组名字，或者 None 如果没有产生匹配的话。

Match.``re

返回产生这个实例的正则对象，这个实例是由正则对象的 match() 或 search() 方法产生的。

Match.``string

传递到 match() 或 search() 的字符串。