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

默认模式下，匹配换行符以外的任何字符。若 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=''>

精确的指定RE应该被匹配m次，少于m次将导致RE不会被匹配上。

例：>>> print(re.search(r'a{5}','aaaab'))
None

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

        例：>>> 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)。。。报错

为匹配的正则表达式取别名（即除了原有的编号外再指定一个额外的别名），<>为取的别名，每个组名称在正则表达式中只能被定义一次。

引用别名为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'>

匹配相对应子组编号的内容，组号从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'>

匹配一个单词的边界。这里的单词的定义是由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作用相反，匹配非单词边界。

例：>>> re.search(r'\Blove\B','IloveChina')
<_sre.SRE_Match object; span=(1, 5), match='love'>

对于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'>

匹配任何不是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相反，匹配不是Unicode空白字符，如果设置re.ASCII标志，则相当于[^ \t\n\r\f\v]。

例：>>> re.search(r'\S','I love China')
<_sre.SRE_Match object; span=(0, 1), match='I'>

对于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作用相反，匹配非Unicode字符，如果设置了re.ASCII标志，则不匹配ASCII字符。

例：>>> re.search(r'\W','I love China')
<_sre.SRE_Match object; span=(1, 2), match=' '>

只匹配字符串结尾。

例：>>> re.search(r3'China\Z','I love China')
<_sre.SRE_Match object; span=(7, 12), match='China'>

将正则表达式模式编译成正则表达式对象4，patten是正则表达式，flag是标志位，默认不设置。表达式在单个程序中多次使用时， 使用re.compile()生成的正则表达式对象重用效率更高。

例：>>> regex = re.compile(r'love')
>>> regex.search('I love China')
<_sre.SRE_Match object; span=(2, 6), match='love'>

搜索函数，寻找正则表达式 pattern 产生匹配的第一个位置，并返回相应的 match object。

前面举得很多例子都用到这个函数这里不赘述。

这个函数只会试图去匹配string字符串的开始位置，如果开始位置不符合则匹配失败。

例：>>> re.match(r'l','I love China') #返回None，即匹配失败。

如果整个字符串匹配正则表达式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'>

根据pattern的匹配拆分字符串。如果在pattern中使用捕获括号，则模式中所有组的文本也会作为结果的一部分返回。如果maxsplit（最多分割次数）不为零，则至多出现maxsplit分裂，并且字符串的其余部分作为列表的最后一个元素返回。

例：>>> re.split(r' ','I love China')
['I', 'love', 'China']

>>> re.split(r'( )','I love China')
['I', ' ', 'love', ' ', 'China']

返回字符串中pattern的所有非重叠匹配项作为字符串列表。对string是从左到右扫描的，所以匹配的内容是按照该顺序来的，如果模式中存在一个或多个组，会返回子组列表；如果模式有多个组，会返回一个元组列表。5

例：>>> re.findall(r'love','love I love China love')
['love', 'love', 'love']

返回与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'>

将于正则表达式匹配的部分替换成设定的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.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

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.X

re.VERBOSE

该标志允许您编写正则表达式，允许您使用空格并添加注释，使正则表达式看起来更好，并且更易读。

例：charref = re.compile(r"""

&[#]                # 开始数字引用

(

     0[0-7]+         # 八进制格式

   | [0-9]+          # 十进制格式

   | x[0-9a-fA-F]+   # 十六进制格式

)

;                   # 结尾分号

""", re.VERBOSE)

搜索函数，寻找正则表达式 pattern 产生匹配的第一个位置，并返回相应的 match object。

前面举得很多例子都用到这个函数这里不赘述。类同re.search(pattern, string, flags=0)。

记录正则表达式匹配标志。

例：>>> regex = re.compile(r'CHINA',re.I)
>>> regex.flags
34

regex.groups

模式中的捕获组数量。

例：>>> regex = re.compile(r'(CHINA)',re.I)
>>> regex.groups
1

将由(?P<id>)定义的任何符号组名称映射到组编号的字典。如果模式中没有使用符号组，则字典为空。

例：>>> regex = re.compile(r'(?P<name>CHINA)',re.I)
>>> regex.groupindex
{'name': 1}

返回编译RE对象的模式字符串。

例：>>> regex = re.compile(r'(?P<name>CHINA)',re.I)

>>> regex.pattern
'(?P<name>CHINA)'

match.expand(template)

如sub()方法所做的那样，返回通过对模板字符串template执行反斜杠替换获得的字符串。像\n之类的转义符会被转换成对应的字符，数字型的反向捕获(\1, \2)和命名反向捕获(\g<1>,\g<name>)会被替换为相应捕获组中的内容。

例：>>> matchobj = re.search(r'(China)\1','ChinaChina')

>>> matchobj.expand(r'\1')  #类似引用前面匹配对象中的子组
'China'

返回匹配的一个或多个子组。如果有一个参数，结果是一个单一的字符串；如果有多个参数，则结果是各个参数对应的子组。如果没有参数， 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'

返回一个包含匹配所有子组的元组，从1开始，default的作用是但不是全部子组匹配时则不匹配的子组返回default。

例：>>> re.search(r'(\d+)\.?(\d+)?','3').groups('第二个子组没匹配')  #这里点号后面的内容可省略，当省略时第二个子组就未匹配，此时返回defult值。
('3', '第二个子组没匹配')

返回一个有别名的组的匹配子组的字典（没有别名的子组不包含在内）。键为子组名，值为子串。默认参数用于未参与匹配的组，它默认为None。

例：>>> re.search(r'(?P<name1>I )(?P<name2>love )(?P<name3>China)','I love China').groupdict()
{'name1': 'I ', 'name3': 'China', 'name2': 'love '}

匹配开始的位置。

例：>>> re.search(r'love','I love China').start()
2

匹配结束的位置。

例：>>> re.search(r'love','I love China').end()
6

匹配范围。

例：>>> re.search(r'love','I love China').span()
(2, 6)

这是RE引擎开始寻找匹配的字符串的索引。

例：>>> re.search(r'love','I love China').pos
0

这是RE引擎匹配的字符串结束的索引。

例：>>> re.search(r'love','I love China').endpos
12

最后一个匹配捕获组的整数索引，或者None，则没有组完全匹配。

例：>>> re.search(r'(\w+) (\w+) (\w+)','I love China').lastindex
3

最后匹配的捕获组的名称，如果组没有名称，或者根本没有匹配组，则None。

例：>>> re.search(r'(?P<name1>I )(?P<name2>love )(?P<name3>China)','I love China').lastgroup
'name3'

编译的正则表达式。

例：>>> re.search(r'(\w+) (\w+) (\w+)','I love China').re
re.compile('(\\w+) (\\w+) (\\w+)')

被match()或者search()匹配的整个字符串。

例：>>> re.search(r'(\w+) (\w+)','I love China').string
'I love China'