py正则表达式（全是干货系列）

  正则表达式的作用在这里不多赘述了，反正处理文本任务贼六就对了。Python中的正则表达式是内置在re模块中的，我们就对这个模块进行详细地讲解。这是一篇媲美帮助文档的文章！对就这么自信，不服你顺着网线来打我呀！8-)

再次更新于2018-9-21

---

目录

RE模块

特殊字符

模块内容

正则表达式对象

匹配对象（Match Object）

---

RE模块

特殊字符

元符号：. ^ $ * + ? { } [ ] \ | ( )

re模块中的特殊符号

元符号	用法和例子
.	默认模式下，匹配换行符以外的任何字符。若 re.DOTALL标志被指定，则它匹配换行符在内的任何字符。 例：>>> re.search('.',"I love China") <_sre.SRE_Match object; span=(0, 1), match='I'>
^	从字符串的开始匹配, 在 re.MULTILINE模式下每个换行符后面立即开始匹配。 例：>>> re.search(r'^ab',"abcdefg") <_sre.SRE_Match object; span=(0, 2), match='ab'>
$	与上面的相对，匹配字符串的结尾或只是之前换行符结尾的字符串，并在 re.MULTILINE 模式下也匹配在换行符之前。 例：>>> re.search(r'fg$',"abcdefg") <_sre.SRE_Match object; span=(5, 7), match='fg'>
*	匹配前面的子表达式零次或多次（贪婪模式1），等价于{0}。 例：>>> re.search(r'a*','aaaaaab') <_sre.SRE_Match object; span=(0, 6), match='aaaaaa'>
+	匹配前面的子表达式一次或多次（贪婪模式），等价于{1}。 例：>>> re.search(r'a+','aaaaaab') <_sre.SRE_Match object; span=(0, 6), match='aaaaaa'>
?	匹配前面的子表达式零次或一次，等价于{0,1}。 例：ab?将匹配'a'或'ab'。
*?，+?，??	默认情况下，*，+，？是贪婪模式，后面再加个？可以启用非贪婪模式。 例：>>> re.search(r'a*?','aaaaaab') <_sre.SRE_Match object; span=(0, 0), match=''>
{m}	精确的指定RE应该被匹配m次，少于m次将导致RE不会被匹配上。 例：>>> print(re.search(r'a{5}','aaaab')) None
{m,n}	m和n都为非负数，且m<n，其表示前面的RE匹配[m,n]，默认也为贪婪模式，后面加上？后可启用非贪婪模式。省略m指定零为下限，省略n指定无穷大为上限。2 例：>>> re.search(r'a{1,4}','aaaaaaab') <_sre.SRE_Match object; span=(0, 4), match='aaaa'>
\	特殊符号消除术，消除特殊字符含义(允许匹配像'*', '?',等特殊字符), 或者发出特殊序列信号。 例：>>> re.search(r'\.','www.aoxiangzhonghua.com') <_sre.SRE_Match object; span=(3, 4), match='.'>
[]	用来表示一个字符集合。在这个集合中： 例如：>>> re.search(r'[\[]',"[]")          <_sre.SRE_Match object; span=(0, 1), match='['> 字符可以被单独罗列，例如：[amk] 会匹配 'a', 'm', 或 'k'. 字符范围可以表明通过给予两个字符和分离他们的 '-'。例如 [a-z] 将匹配任何小写字母的 ASCII 字母，[0-5] [0-9] 将匹配所有两位数数字从 00 到 59，和 [0-9A-Fa-f] 将都匹配任何十六进制数字。如果-被转义（例如，[a\-z]），或者将它放置为第一个或最后一个字符（例如，[a-]），它将匹配字符'-'。 在集合内，特殊字符失去特殊意义。例如，[(+*)] 将匹配任何字符 '('，'+'，'* '，或 '')''。 如\w or \S等字符类别也是可以被接受的，并且不会失去特殊意义，尽管匹配的这些字符取决于re.ASCII or re.LOCALE 模式是否被设置。 如果这个集合的第一个字符是'^', 那么所有不在集合内的将会被匹配上。例如, [^5]将会配对除 '5'以外的任何字符，并且和[^^]将会匹配除'^'以外的任何字符。如果^不在集合的第一个位置那么它将没有特殊意义。 想要在一个集合内匹配']'，需要在它的前面使用一个反斜杠转义，或者在集合开头处将它替换。
|	类似于C语言中的或操作，A|B表示匹配正则表达式A或者B。 例：>>> re.search(r'ab|cd','acdf') <_sre.SRE_Match object; span=(1, 3), match='cd'>
(...)	子组，将匹配圆括号内的正则表达式，并指明子组的开始和结束。子组的内容可以在后面通过\number再次引用（稍后提及）。 例：>>> re.search(r'(efg)','abcdefghj') <_sre.SRE_Match object; span=(4, 7), match='efg'>
拓展语法部分	?开头的正则表达式为拓展语法，格式如(?...)
(?aiLmsux)	例：>>> re.search(r'(?i)CHINA','我爱China')         <_sre.SRE_Match object; span=(2, 7), match='China'> ？后可跟'a', 'i', 'L', 'm', 's', 'u', 'x'中的一个或多个 用来设置正则表达式的标志，每个字符对应一种匹配标志：a (仅匹配ASCII), i (不管大小写), L (区域设置), m (多行模式), s (不匹配所有), and x (详细表达式)。
(?:...)	非捕获组，即该子组匹配的字符串无法从后面获得。 例：>>> re.search(r'(?:China)\1','ChinaChina') Traceback (most recent call last)。。。报错
(?P<name>...)	为匹配的正则表达式取别名（即除了原有的编号外再指定一个额外的别名），<>为取的别名，每个组名称在正则表达式中只能被定义一次。
(?P=name)	引用别名为name的子组。 例：>>> print(re.search(r'(?P<love>China)(?P=love)','aaaChinaChinabbb')) <_sre.SRE_Match object; span=(3, 13), match='ChinaChina'>
(?#...)	注释，将忽略括号内的内容。 例：>>> re.search(r'(?#啦啦啦)China','I love China') <_sre.SRE_Match object; span=(7, 12), match='China'>
(?=...)	前向肯定断言，如果...匹配后面的内容则匹配，但不消耗字符串的任何字符，很绕对不对，看个例子。 例：>>> re.search(r'love (?=China)','I love China') <_sre.SRE_Match object; span=(2, 7), match='love '>
(?!...)	与上一个作用相反，如果...不匹配时后面的内容时才算匹配，也举个例子。 例：>>> re.search(r'love (?!America)','I love China') <_sre.SRE_Match object; span=(2, 7), match='love '>
(?<=...)	后向肯定断言，只有当...匹配之前的内容时才算匹配，举个例子就懂。 例：>>> re.search(r'(?<=I) love','I love China') <_sre.SRE_Match object; span=(1, 6), match=' love'>
(?<!...)	与上一个作用相反，如果...不匹配之前的内容才算匹配，举个例子。 例：>>> re.search(r'(?<!Y) love','I love China') <_sre.SRE_Match object; span=(1, 6), match=' love'>
(?(id/name) yes-pattern|no-pattern)	如果具有给定 id 或 name 的组存在，将尝试匹配 yes-pattern，否则匹配 no-pattern。no-pattern是可选的，可以省略。又是神马意思，别急，举几个例子就懂。 例：>>> re.search(r'(I )(?(1)love|hate)','I love China') #说明，这里开始‘I ‘匹配，所以再启用yes-pattern进行匹配，这里即'love' ，这里的1是id，指代第一组子组，当然前面如果设置name，这里也可以用name来指代。 <_sre.SRE_Match object; span=(0, 6), match='I love'> >>> re.search(r'(Y )?(?(1)hate|love)','I love China') #说明，这里开始’Y ‘不匹配，所以再启用no-pattern进行匹配，即'love'。这里第一个问号是为了当第一个括号中的内容不匹配时，跳过开头进行匹配，因为前面不匹配的内容会消耗字符串中等量的字符。 <_sre.SRE_Match object; span=(2, 6), match='love'>
反斜杠加普通字符	特殊含义
\number	匹配相对应子组编号的内容，组号从1开始。该特殊序列只能用于匹配前99个组中的一个。如果number的第一个数字为0或number为3个八进制数字，则不会将其解释为组匹配，而是八进制值，这时表示对应ASCII值的字符。 例：>>> re.search(r'(I (love))\2','I lovelove China') <_sre.SRE_Match object; span=(0, 10), match='I lovelove'>
\A	仅仅匹配字符串开头。 例：>>> re.search(r'\AI','I love China') <_sre.SRE_Match object; span=(0, 1), match='I'>
\b	匹配一个单词的边界。这里的单词的定义是由Unicode字母数字或下划线组成的序列，因此单词的边界由空格、非字母数字或非下划线Unicode字符表示。我们可以这么简单理解，一个\b即替代一个空格、非字母数字或非下划线Unicode字符表示的边界。默认情况下，使用Unicode字母和数字，但可以通过使用re.ASCII标志来更改。在字符范围内，\b表示退格字符，以便与Python的字符串字面值兼容。 例：>>> re.search(r'\blove\b','I love China') <_sre.SRE_Match object; span=(2, 6), match='love'>
\B	与\b作用相反，匹配非单词边界。 例：>>> re.search(r'\Blove\B','IloveChina') <_sre.SRE_Match object; span=(1, 5), match='love'>
\d	对于Unicode模式： 匹配任何Unicode十进制数字。这包括[0-9]以及许多其他数字字符。如果使用re.ASCII标志，则只匹配[0-9]（但该标志影响整个正则表达式，因此在这种情况下使用明确的[0-9]可能是更好的选择）。 对于ASCII模式： 匹配任何十进制数字；这相当于[0-9]。 例：>>> re.search(r'\d\d','I 52 China') <_sre.SRE_Match object; span=(2, 4), match='52'>
\D	匹配任何不是Unicode十进制数字的字符。这与\d相反。如果使用re.ASCII标志，则这变成等效于[^0-9]（但该标志影响整个正则表达式，所以在这种情况下使用明确的[^0-9]可能是更好的选择）。 例：>>> re.search(r'\D','5 love China') <_sre.SRE_Match object; span=(1, 2), match=' '>
\s	对于Unicode模式： 匹配Unicode空白字符（包括[ \t\n\r\f\v]以及许多其它字符，例如在许多语言中由排版规则强制不换行的空白）。如果使用re.ASCII标志，则只匹配[ \t\n\r\f\v]（该标志会影响整个正则表达式，所以在这种情况下，使用明确的[ \t\n\r\f\v]可能是更好的选择）。 对于ASCII模式： 匹配ASCII字符集中空白的字符；相当于[ \t\n\r\f\v]。 例：>>> re.search(r'\s','I love China') <_sre.SRE_Match object; span=(1, 2), match=' '>
\S	作用与\s相反，匹配不是Unicode空白字符，如果设置re.ASCII标志，则相当于[^ \t\n\r\f\v]。 例：>>> re.search(r'\S','I love China') <_sre.SRE_Match object; span=(0, 1), match='I'>
\w	对于Unicode模式： 匹配Unicode字符，这包括大多数可以是任何语言的单词的一部分的字符，以及数字和下划线，注意，不能匹配逗号，句号，问号等符号。 对于ASCII模式： 匹配ASCII字符集，这相当于[a-zA-Z0-9_]。 例：>>> re.search(r'\w','I love China') <_sre.SRE_Match object; span=(0, 1), match='I'>
\W	与\w作用相反，匹配非Unicode字符，如果设置了re.ASCII标志，则不匹配ASCII字符。 例：>>> re.search(r'\W','I love China') <_sre.SRE_Match object; span=(1, 2), match=' '>
\Z	只匹配字符串结尾。 例：>>> re.search(r3'China\Z','I love China') <_sre.SRE_Match object; span=(7, 12), match='China'>
转义字符	正则表达式还支持大部分 Python 字符串的转义符号：\a，\b，\f，\n，\r，\t，\u，\U，\v，\x，\\

补充说明

1.贪婪模式指尽可能多的匹配字符。

例：>>> re.search(r'a*','aaaaaab')

<_sre.SRE_Match object; span=(0, 6), match='aaaaaa'> #这个例子中，正则表达式尽可能多地匹配a字符直至不满足条件。

2.这里的无穷大不是真的无穷大，由于受到 C 语言的 int 类型大小的内部限制，其上界为20多亿，但这再实际应用中完全足够大。

3.有细心的童鞋可能注意到我们这里的RE表达式都采用原始字符串形式，因为这样可能避免\过分放飞自我，举个例子：

如果不适用原始字符串，我要匹配两个\要写成以下格式：re.search('\\\\','\\')，因为\\才会转义成\，而使用原始字符串只需写成re.search(r'\\','\\')，是不是简洁不少。

模块内容

模块定义了几个函数、 常量和一个异常。某些函数是编译正则表达式全特性方法的简化版本。大多数复杂应用程序总是使用已编译的形式。

re模块中的内容

模块函数	用法讲解及举例
re.compile(pattern, flags=0)	将正则表达式模式编译成正则表达式对象4，patten是正则表达式，flag是标志位，默认不设置。表达式在单个程序中多次使用时， 使用re.compile()生成的正则表达式对象重用效率更高。 例：>>> regex = re.compile(r'love') >>> regex.search('I love China') <_sre.SRE_Match object; span=(2, 6), match='love'>
re.search(pattern, string, flags=0)	搜索函数，寻找正则表达式 pattern 产生匹配的第一个位置，并返回相应的 match object。 前面举得很多例子都用到这个函数这里不赘述。
re.match(pattern, string, flags=0)	这个函数只会试图去匹配string字符串的开始位置，如果开始位置不符合则匹配失败。 例：>>> re.match(r'l','I love China') #返回None，即匹配失败。
re.fullmatch(pattern, string, flags=0)	如果整个字符串匹配正则表达式pattern，则返回相应的match object。若该 string 不匹配该 pattern ，返回 None。 例：>>> re.fullmatch(r'I love China','I love China') <_sre.SRE_Match object; span=(0, 12), match='I love China'>
re.split(pattern, string, maxsplit=0, flags=0)	根据pattern的匹配拆分字符串。如果在pattern中使用捕获括号，则模式中所有组的文本也会作为结果的一部分返回。如果maxsplit（最多分割次数）不为零，则至多出现maxsplit分裂，并且字符串的其余部分作为列表的最后一个元素返回。 例：>>> re.split(r' ','I love China') ['I', 'love', 'China'] >>> re.split(r'( )','I love China') ['I', ' ', 'love', ' ', 'China']
re.findall(pattern, string, flags=0)	返回字符串中pattern的所有非重叠匹配项作为字符串列表。对string是从左到右扫描的，所以匹配的内容是按照该顺序来的，如果模式中存在一个或多个组，会返回子组列表；如果模式有多个组，会返回一个元组列表。5 例：>>> re.findall(r'love','love I love China love') ['love', 'love', 'love']
re.finditer(pattern, string, flags=0)	返回与patten匹配的match object组成的迭代器。对string是从左到右扫描的，所以匹配的内容是按照该顺序来的。 例：>>> for each in re.finditer(r'love','love I love China love'):     print(each)      <_sre.SRE_Match object; span=(0, 4), match='love'> <_sre.SRE_Match object; span=(7, 11), match='love'> <_sre.SRE_Match object; span=(18, 22), match='love'>
re.sub(pattern, repl, string, count=0, flags=0)	将于正则表达式匹配的部分替换成设定的repl，repl 可以是一个字符串或一个函数6；如果是一个字符串, 则会处理每个反斜杠转义。 例：>>> re.sub(r'hate','love','I hate China') 'I love China'
re.subn(pattern, repl, string, count=0, flags=0)	执行与sub()相同的操作，但返回一个元组（替换后的字符串，替换次数）。 例：>>> re.subn(r'hate','love','I hate China') ('I love China', 1)
re.escape(string)	转义模式中除ASCII字母、数字和'_'之外的所有字符。如果你想匹配任何可能具有正则表达式元字符的文本字符串，这非常有用。(笔者也不知道啥意思(＠_＠;))
re.purge()	清除正则表达式缓存。
模块常量	用法介绍
re.A re.ASCII	让 \w, \W, \b, \B, \d, \D, \s and \S 执行纯 ASCII 匹配，而不是全部Unicode匹配。 例:>>> re.search(r'\w','我爱China',re.A) <_sre.SRE_Match object; span=(2, 3), match='C'>
re.DEBUG	显示关于编译表达式的调试信息。（不怎用）
re.I re.IGNORECASE	执行不区分大小写的匹配，如[A-Z]也会匹配小写字母。这不受当前语言环境的影响，对于Unicode字符能如愿地正常工作。 例：>>> re.search(r'CHINA',' I love China',re.I) <_sre.SRE_Match object; span=(8, 13), match='China'>
re.L re.LOCALE	自版本3.5起弃用。
re.M re.MULTILINE	指定时，模式字符'^'匹配字符串的开头和每行的开始处（紧跟在每个换行符后面）以及字符'$'匹配字符串的末尾和每行的末尾（紧接在每个换行符的前面）。默认情况下，'^'仅在字符串的开头匹配，而'$'仅在字符串的末尾和紧接换行符之前（如果有的话）匹配字符串的结尾。 例：>>> re.search(r'^T','I love China\nT love Chian\nU love China',re.M) <_sre.SRE_Match object; span=(13, 14), match='T'>
re.S re.DOTALL	将使'.'特殊字符完全匹配任何字符，包括换行符，没有这个标志，'.'会匹配除换行符之外的任何。 例：>>> re.search(r'.','\n',re.S) <_sre.SRE_Match object; span=(0, 1), match='\n'>
re.X re.VERBOSE	该标志允许您编写正则表达式，允许您使用空格并添加注释，使正则表达式看起来更好，并且更易读。 例：charref = re.compile(r""" &[#]                # 开始数字引用 ( 0[0-7]+         # 八进制格式 | [0-9]+          # 十进制格式 | x[0-9a-fA-F]+   # 十六进制格式 ) ;                   # 结尾分号 """, re.VERBOSE)

补充说明

4.其实再使用模块函数譬如re.search()时，如果匹配成功其就会返回match object即匹配对象。

5.子组的这个特性很好用，

例：>>> re.findall(r'(..(love)(..))','I love China U love China T love China')

[('I love C', 'love', ' C'), ('U love C', 'love', ' C'), ('T love C', 'love', ' C')]

可以很方便的返回子组匹配成功的子字符串，当然我们也可以使其只返回整体的形式，不单独返回子组中的内容，(?:...),

例：>>> re.findall(r'(?:..(?:love)(?:..))','I love China U love China T love China')

['I love C', 'U love C', 'T love C']

这里我们也要对子组的编号做说明，左括号出现的顺序就是编号顺序，就拿上面的例子来说明，正则表达式中最开始的（为(..(love)(..))，所以该子组编号为1，第二个左括号（为 (love)，所以该子组的编号为2，第三个左括号（为(..)，所以其编号为3。

6.对sub函数repl参数进行说明，这个参数可以为函数，这就给我们很大的自由，相当于我们可以自由来定义规则。

例：>>> def my_replace(matchobj):

    if matchobj.group(0) == 'hate':  #关于group函数的用法稍后给出

        return 'love'

>>> re.sub(r'hate',my_replace,'I hate China')

'I love China'

正则表达式对象

正则表达式对象只不过是把之前的正则表达式编译成一个对象，这样的好处是后面使用时可以直接拿来用，不用重复地写正则表达式。其内置方法和re模块内容中的函数差不多，再此我们不赘述，只给出其内置函数的名称和用法。

正则表达式对象内容

正则表达式对象内置方法	用法
regex7.search(string[, pos[, endpos]])	搜索函数，寻找正则表达式 pattern 产生匹配的第一个位置，并返回相应的 match object。 前面举得很多例子都用到这个函数这里不赘述。类同re.search(pattern, string, flags=0)。
regex.match(string[, pos[, endpos]])	这个函数只会试图去匹配string字符串的开始位置，如果开始位置不符合则匹配失败。类同re.match(pattern, string, flags=0)。
regex.fullmatch(string[, pos[, endpos]])	如果整个字符串匹配正则表达式pattern，则返回相应的match object。若该 string 不匹配该 pattern ，返回 None。类同re.fullmatch(pattern, string, flags=0)。
regex.split(string, maxsplit=0)	根据pattern的匹配拆分字符串。如果在pattern中使用捕获括号，则模式中所有组的文本也会作为结果的一部分返回。如果maxsplit（最多分割次数）不为零，则至多出现maxsplit分裂，并且字符串的其余部分作为列表的最后一个元素返回。类同re.split(pattern, string, maxsplit=0, flags=0)。
regex.findall(string[, pos[, endpos]])	返回字符串中pattern的所有非重叠匹配项作为字符串列表。对string是从左到右扫描的，所以匹配的内容是按照该顺序来的，如果模式中存在一个或多个组，会返回子组列表；如果模式有多个组，会返回一个元组列表。类同re.findall(pattern, string, flags=0)。
regex.finditer(string[, pos[, endpos]])	返回与patten匹配的match object组成的迭代器。对string是从左到右扫描的，所以匹配的内容是按照该顺序来的。类同re.finditer(pattern, string, flags=0)。
regex.sub(repl, string, count=0)	将于正则表达式匹配的部分替换成设定的repl，repl 可以是一个字符串或一个函数7；如果是一个字符串, 则会处理每个反斜杠转义。类同re.sub(pattern, repl, string, count=0, flags=0)。
regex.subn(repl, string, count=0)	执行与sub()相同的操作，但返回一个元组（替换后的字符串，替换次数）。类同re.subn(pattern, repl, string, count=0, flags=0)。
正则表达式对象内置方法	介绍和举例
regex.flags	记录正则表达式匹配标志。 例：>>> regex = re.compile(r'CHINA',re.I) >>> regex.flags 34
regex.groups	模式中的捕获组数量。 例：>>> regex = re.compile(r'(CHINA)',re.I) >>> regex.groups 1
regex.groupindex	将由(?P<id>)定义的任何符号组名称映射到组编号的字典。如果模式中没有使用符号组，则字典为空。 例：>>> regex = re.compile(r'(?P<name>CHINA)',re.I) >>> regex.groupindex {'name': 1}
regex.pattern	返回编译RE对象的模式字符串。 例：>>> regex = re.compile(r'(?P<name>CHINA)',re.I) >>> regex.pattern '(?P<name>CHINA)'

7.regex为编译好的正则表达式对象。

匹配对象（Match Object）

当正则表达式匹配成功时将返回Match Object，该对象也有很多内置属性和方法。

Match Object内容

内置方法	用法和举例
match.expand(template)	如sub()方法所做的那样，返回通过对模板字符串template执行反斜杠替换获得的字符串。像\n之类的转义符会被转换成对应的字符，数字型的反向捕获(\1, \2)和命名反向捕获(\g<1>,\g<name>)会被替换为相应捕获组中的内容。 例：>>> matchobj = re.search(r'(China)\1','ChinaChina') >>> matchobj.expand(r'\1')  #类似引用前面匹配对象中的子组 'China'
match.group([group1, ...])	返回匹配的一个或多个子组。如果有一个参数，结果是一个单一的字符串；如果有多个参数，则结果是各个参数对应的子组。如果没有参数， group1默认为零 （返回整个match的匹配结果）。如果groupN参数为零，则相应的返回值是整个匹配的字符串；如果它在包含范围[1..99]中，则它是匹配相应括号组的字符串。如果组编号为负数或大于模式中定义的组数，则引发IndexError异常。如果一个组包含在不匹配的模式的一部分中，则相应的结果是None。如果一个组包含在多次匹配的模式的一部分中，则返回最后的匹配。 例：>>> re.search(r'(\w+) (\w+) (\w+)','I love China') <_sre.SRE_Match object; span=(0, 12), match='I love China'> >>> re.search(r'(\w+) (\w+) (\w+)','I love China').group(0) 'I love China' >>> re.search(r'(\w+) (\w+) (\w+)','I love China').group(1) 'I' >>> re.search(r'(\w+) (\w+) (\w+)','I love China').group(2) 'love' >>> re.search(r'(\w+) (\w+) (\w+)','I love China').group(3) 'China'
match.groups(default=None)	返回一个包含匹配所有子组的元组，从1开始，default的作用是但不是全部子组匹配时则不匹配的子组返回default。 例：>>> re.search(r'(\d+)\.?(\d+)?','3').groups('第二个子组没匹配')  #这里点号后面的内容可省略，当省略时第二个子组就未匹配，此时返回defult值。 ('3', '第二个子组没匹配')
match.groupdict(default=None)	返回一个有别名的组的匹配子组的字典（没有别名的子组不包含在内）。键为子组名，值为子串。默认参数用于未参与匹配的组，它默认为None。 例：>>> re.search(r'(?P<name1>I )(?P<name2>love )(?P<name3>China)','I love China').groupdict() {'name1': 'I ', 'name3': 'China', 'name2': 'love '}
match.start([group])	匹配开始的位置。 例：>>> re.search(r'love','I love China').start() 2
match.end([group])	匹配结束的位置。 例：>>> re.search(r'love','I love China').end() 6
match.span([group])	匹配范围。 例：>>> re.search(r'love','I love China').span() (2, 6)
内置属性	介绍和例子
match.pos	这是RE引擎开始寻找匹配的字符串的索引。 例：>>> re.search(r'love','I love China').pos 0
match.endpos	这是RE引擎匹配的字符串结束的索引。 例：>>> re.search(r'love','I love China').endpos 12
match.lastindex	最后一个匹配捕获组的整数索引，或者None，则没有组完全匹配。 例：>>> re.search(r'(\w+) (\w+) (\w+)','I love China').lastindex 3
match.lastgroup	最后匹配的捕获组的名称，如果组没有名称，或者根本没有匹配组，则None。 例：>>> re.search(r'(?P<name1>I )(?P<name2>love )(?P<name3>China)','I love China').lastgroup 'name3'
match.re	编译的正则表达式。 例：>>> re.search(r'(\w+) (\w+) (\w+)','I love China').re re.compile('(\\w+) (\\w+) (\\w+)')
match.string	被match()或者search()匹配的整个字符串。 例：>>> re.search(r'(\w+) (\w+)','I love China').string 'I love China'

至此，关于python正则表达式几乎所有的内容及用法都讲完了，祝君进步！

参考资料：

1.python官方文档

2.Python3 如何优雅地使用正则表达式（完整版）