正则表达式的作用在这里不多赘述了，反正处理文本任务贼六就对了。Python中的正则表达式是内置在re模块中的，我们就对这个模块进行详细地讲解。这是一篇媲美帮助文档的文章！对就这么自信，不服你顺着网线来打我呀！8-)
再次更新于2018-9-21
目录
RE模块
特殊字符
元符号：. ^ $ * + ? { } [ ] \ | ( )
| 元符号 | 用法和例子 |
|---|---|
| . | 默认模式下，匹配换行符以外的任何字符。若 re.DOTALL标志被指定，则它匹配换行符在内的任何字符。 例：>>> re.search('.',"I love China") |
| ^ | 从字符串的开始匹配, 在 re.MULTILINE模式下每个换行符后面立即开始匹配。 例：>>> re.search(r'^ab',"abcdefg") |
| $ | 与上面的相对，匹配字符串的结尾或只是之前换行符结尾的字符串，并在 例：>>> re.search(r'fg$',"abcdefg") |
| * | 匹配前面的子表达式零次或多次（贪婪模式1），等价于{0}。 例：>>> re.search(r'a*','aaaaaab') |
| + | 匹配前面的子表达式一次或多次（贪婪模式），等价于{1}。 例：>>> re.search(r'a+','aaaaaab') |
| ? | 匹配前面的子表达式零次或一次，等价于{0,1}。
|
*?，+?，?? |
默认情况下，*，+，？是贪婪模式，后面再加个？可以启用非贪婪模式。 例：>>> re.search(r'a*?','aaaaaab') |
| {m} | 精确的指定RE应该被匹配m次，少于m次将导致RE不会被匹配上。 例：>>> print(re.search(r'a{5}','aaaab')) |
| {m,n} | m和n都为非负数，且m<n，其表示前面的RE匹配[m,n]，默认也为贪婪模式，后面加上？后可启用非贪婪模式。省略m指定零为下限，省略n指定无穷大为上限。2 例：>>> re.search(r'a{1,4}','aaaaaaab') |
| \ | 特殊符号消除术，消除特殊字符含义(允许匹配像 例：>>> re.search(r'\.','www.aoxiangzhonghua.com') |
| [] | 用来表示一个字符集合。在这个集合中： 例如：>>> re.search(r'[\[]',"[]")
|
| | | 类似于C语言中的或操作，A|B表示匹配正则表达式A或者B。 例：>>> re.search(r'ab|cd','acdf') |
| (...) | 子组，将匹配圆括号内的正则表达式，并指明子组的开始和结束。子组的内容可以在后面通过\number再次引用（稍后提及）。 例：>>> re.search(r'(efg)','abcdefghj') |
| 拓展语法部分 | ?开头的正则表达式为拓展语法，格式如(?...) |
| (?aiLmsux) | 例：>>> re.search(r'(?i)CHINA','我爱China')
|
| (?:...) | 非捕获组，即该子组匹配的字符串无法从后面获得。 例：>>> re.search(r'(?:China)\1','ChinaChina') |
| (?P<name>...) | 为匹配的正则表达式取别名（即除了原有的编号外再指定一个额外的别名），<>为取的别名，每个组名称在正则表达式中只能被定义一次。 |
| (?P=name) | 引用别名为name的子组。 例：>>> print(re.search(r'(?P<love>China)(?P=love)','aaaChinaChinabbb')) |
| (?#...) |
注释，将忽略括号内的内容。 例：>>> re.search(r'(?#啦啦啦)China','I love China') |
| (?=...) | 前向肯定断言，如果 例：>>> re.search(r'love (?=China)','I love China') |
| (?!...) | 与上一个作用相反，如果...不匹配时后面的内容时才算匹配，也举个例子。 例：>>> re.search(r'love (?!America)','I love China') |
| (?<=...) | 后向肯定断言，只有当...匹配之前的内容时才算匹配，举个例子就懂。 例：>>> re.search(r'(?<=I) love','I love China') |
| (?<!...) | 与上一个作用相反，如果...不匹配之前的内容才算匹配，举个例子。 例：>>> re.search(r'(?<!Y) love','I love China') |
| (?(id/name) yes-pattern|no-pattern) |
如果具有给定 id 或 name 的组存在，将尝试匹配 例：>>> re.search(r'(I )(?(1)love|hate)','I love China') #说明，这里开始‘I ‘匹配，所以再启用yes-pattern进行匹配，这里即'love' ，这里的1是id，指代第一组子组，当然前面如果设置name，这里也可以用name来指代。 >>> re.search(r'(Y )?(?(1)hate|love)','I love China') #说明，这里开始’Y ‘不匹配，所以再启用no-pattern进行匹配，即'love'。这里第一个问号是为了当第一个括号中的内容不匹配时，跳过开头进行匹配，因为前面不匹配的内容会消耗字符串中等量的字符。
|
| 反斜杠加普通字符 | 特殊含义 |
| \number | 匹配相对应子组编号的内容，组号从1开始。该特殊序列只能用于匹配前99个组中的一个。如果number的第一个数字为0或number为3个八进制数字，则不会将其解释为组匹配，而是八进制值，这时表示对应ASCII值的字符。 例：>>> re.search(r'(I (love))\2','I lovelove China') |
|
|
仅仅匹配字符串开头。 例：>>> re.search(r'\AI','I love China') |
| \b | 匹配一个单词的边界。这里的单词的定义是由Unicode字母数字或下划线组成的序列，因此单词的边界由空格、非字母数字或非下划线Unicode字符表示。我们可以这么简单理解，一个\b即替代一个空格、非字母数字或非下划线Unicode字符表示的边界。默认情况下，使用Unicode字母和数字，但可以通过使用re.ASCII标志来更改。在字符范围内， 例：>>> re.search(r'\blove\b','I love China') |
| \B | 与\b作用相反，匹配非单词边界。 例：>>> re.search(r'\Blove\B','IloveChina') |
| \d | 对于Unicode模式： 匹配任何Unicode十进制数字。这包括 对于ASCII模式： 匹配任何十进制数字；这相当于 例：>>> re.search(r'\d\d','I 52 China') |
| \D | 匹配任何不是Unicode十进制数字的字符。这与 例：>>> re.search(r'\D','5 love China') |
| \s |
对于Unicode模式： 匹配Unicode空白字符（包括 对于ASCII模式： 匹配ASCII字符集中空白的字符；相当于 例：>>> re.search(r'\s','I love China') |
| \S | 作用与\s相反，匹配不是Unicode空白字符，如果设置re.ASCII标志，则相当于 例：>>> re.search(r'\S','I love China') |
| \w | 对于Unicode模式： 匹配Unicode字符，这包括大多数可以是任何语言的单词的一部分的字符，以及数字和下划线，注意，不能匹配逗号，句号，问号等符号。 对于ASCII模式： 匹配ASCII字符集，这相当于 例：>>> re.search(r'\w','I love China') |
| \W | 与\w作用相反，匹配非Unicode字符，如果设置了re.ASCII标志，则不匹配ASCII字符。 例：>>> re.search(r'\W','I love China') |
| \Z | 只匹配字符串结尾。 例：>>> re.search(r3'China\Z','I love 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.compile(pattern, flags=0) |
将正则表达式模式编译成正则表达式对象4，patten是正则表达式，flag是标志位，默认不设置。表达式在单个程序中多次使用时， 使用 例：>>> regex = re.compile(r'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 ，返回 例：>>> re.fullmatch(r'I love China','I love China') |
re.split(pattern, string, maxsplit=0, flags=0) |
根据pattern的匹配拆分字符串。如果在pattern中使用捕获括号，则模式中所有组的文本也会作为结果的一部分返回。如果maxsplit（最多分割次数）不为零，则至多出现maxsplit分裂，并且字符串的其余部分作为列表的最后一个元素返回。 例：>>> re.split(r' ','I love China') >>> re.split(r'( )','I love China') |
re.findall(pattern, string, flags=0) |
返回字符串中pattern的所有非重叠匹配项作为字符串列表。对string是从左到右扫描的，所以匹配的内容是按照该顺序来的，如果模式中存在一个或多个组，会返回子组列表；如果模式有多个组，会返回一个元组列表。5 例：>>> re.findall(r'love','love I love China love') |
re.finditer(pattern, string, flags=0) |
返回与patten匹配的match object组成的迭代器。对string是从左到右扫描的，所以匹配的内容是按照该顺序来的。 例：>>> for each in re.finditer(r'love','love I love China love'): |
re.sub(pattern, repl, string, count=0, flags=0) |
将于正则表达式匹配的部分替换成设定的repl，repl 可以是一个字符串或一个函数6；如果是一个字符串, 则会处理每个反斜杠转义。 例：>>> re.sub(r'hate','love','I hate China') |
|
|
执行与sub()相同的操作，但返回一个元组 例：>>> re.subn(r'hate','love','I hate China') |
re.escape(string) |
转义模式中除ASCII字母、数字和'_'之外的所有字符。如果你想匹配任何可能具有正则表达式元字符的文本字符串，这非常有用。(笔者也不知道啥意思(＠_＠;)) |
|
|
清除正则表达式缓存。 |
| 模块常量 | 用法介绍 |
|
|
让 例:>>> re.search(r'\w','我爱China',re.A) |
|
|
显示关于编译表达式的调试信息。（不怎用） |
|
|
执行不区分大小写的匹配，如 例：>>> re.search(r'CHINA',' I love China',re.I) |
|
|
自版本3.5起弃用。 |
|
|
指定时，模式字符 例：>>> re.search(r'^T','I love China\nT love Chian\nU love China',re.M) |
|
|
将使'.'特殊字符完全匹配任何字符，包括换行符，没有这个标志，'.'会匹配除换行符之外的任何。例：>>> re.search(r'.','\n',re.S) <_sre.SRE_Match object; span=(0, 1), match='\n'> |
|
|
该标志允许您编写正则表达式，允许您使用空格并添加注释，使正则表达式看起来更好，并且更易读。 例：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。 前面举得很多例子都用到这个函数这里不赘述。类同 |
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 可以是一个字符串或一个函数6；如果是一个字符串, 则会处理每个反斜杠转义。类同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 = re.compile(r'(CHINA)',re.I) |
regex.groupindex |
将由 例：>>> regex = re.compile(r'(?P<name>CHINA)',re.I) |
regex.pattern |
返回编译RE对象的模式字符串。 例：>>> regex = re.compile(r'(?P<name>CHINA)',re.I) >>> regex.pattern |
7.regex为编译好的正则表达式对象。
匹配对象（Match Object）
当正则表达式匹配成功时将返回Match Object，该对象也有很多内置属性和方法。
| 内置方法 | 用法和举例 |
|
|
如sub()方法所做的那样，返回通过对模板字符串template执行反斜杠替换获得的字符串。像 例：>>> matchobj = re.search(r'(China)\1','ChinaChina') >>> matchobj.expand(r'\1') #类似引用前面匹配对象中的子组 |
match.group([group1, ...]) |
返回匹配的一个或多个子组。如果有一个参数，结果是一个单一的字符串；如果有多个参数，则结果是各个参数对应的子组。如果没有参数， group1默认为零 （返回整个match的匹配结果）。如果groupN参数为零，则相应的返回值是整个匹配的字符串；如果它在包含范围[1..99]中，则它是匹配相应括号组的字符串。如果组编号为负数或大于模式中定义的组数，则引发IndexError异常。如果一个组包含在不匹配的模式的一部分中，则相应的结果是 例：>>> re.search(r'(\w+) (\w+) (\w+)','I love China') |
match.groups(default=None) |
返回一个包含匹配所有子组的元组，从1开始，default的作用是但不是全部子组匹配时则不匹配的子组返回default。 例：>>> re.search(r'(\d+)\.?(\d+)?','3').groups('第二个子组没匹配') #这里点号后面的内容可省略，当省略时第二个子组就未匹配，此时返回defult值。 |
match.groupdict(default=None) |
返回一个有别名的组的匹配子组的字典（没有别名的子组不包含在内）。键为子组名，值为子串。默认参数用于未参与匹配的组，它默认为 例：>>> re.search(r'(?P<name1>I )(?P<name2>love )(?P<name3>China)','I love China').groupdict() |
match.start([group]) |
匹配开始的位置。 例：>>> re.search(r'love','I love China').start() |
match.end([group]) |
匹配结束的位置。 例：>>> re.search(r'love','I love China').end() |
match.span([group]) |
匹配范围。 例：>>> re.search(r'love','I love China').span() |
| 内置属性 | 介绍和例子 |
match.pos |
这是RE引擎开始寻找匹配的字符串的索引。 例：>>> re.search(r'love','I love China').pos |
match.endpos |
这是RE引擎匹配的字符串结束的索引。 例：>>> re.search(r'love','I love China').endpos |
match.lastindex |
最后一个匹配捕获组的整数索引，或者 例：>>> re.search(r'(\w+) (\w+) (\w+)','I love China').lastindex |
match.lastgroup |
最后匹配的捕获组的名称，如果组没有名称，或者根本没有匹配组，则 例：>>> re.search(r'(?P<name1>I )(?P<name2>love )(?P<name3>China)','I love China').lastgroup |
match.re |
编译的正则表达式。 例：>>> re.search(r'(\w+) (\w+) (\w+)','I love China').re |
match.string |
被 例：>>> re.search(r'(\w+) (\w+)','I love China').string |
至此，关于python正则表达式几乎所有的内容及用法都讲完了，祝君进步！
参考资料：