Python中的正则表达式详解

@[toc]

一、正则表达式简介

　　正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。 Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。

　　就其本质而言，正则表达式（或 RE）是一种小型的、高度专业化的编程语言，（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

　　re 模块使 Python 语言拥有全部的正则表达式功能。 compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。 re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。　

二、正则表达式相关知识

关于正则表达式的相关知识，大家可以阅读一篇非常有名的博客叫《正则表达式30分钟入门教程》，读完这篇文章后你就可以看懂下面的表格，这是我们对正则表达式中的一些基本符号进行的扼要总结。

符号	解释	示例	说明
.	匹配任意字符	b.t	可以匹配bat / but / b#t / b1t等
\w	匹配字母/数字/下划线	b\wt	可以匹配bat / b1t / b_t等但不能匹配b#t
\s	匹配空白字符（包括\r、\n、\t等）	love\syou	可以匹配love you
\d	匹配数字	\d\d	可以匹配01 / 23 / 99等
\b	匹配单词的边界	\bThe\b
^	匹配字符串的开始	^The	可以匹配The开头的字符串
$	匹配字符串的结束	.exe$	可以匹配.exe结尾的字符串
\W	匹配非字母/数字/下划线	b\Wt	可以匹配b#t / b@t等但不能匹配but / b1t / b_t等
\S	匹配非空白字符	love\Syou	可以匹配love#you等但不能匹配love you
\D	匹配非数字	\d\D	可以匹配9a / 3# / 0F等
\B	匹配非单词边界	\Bio\B
[]	匹配来自字符集的任意单一字符	[aeiou]	可以匹配任一元音字母字符
[^]	匹配不在字符集中的任意单一字符	[^aeiou]	可以匹配任一非元音字母字符
*	匹配0次或多次	\w*
+	匹配1次或多次	\w+
?	匹配0次或1次	\w?
	匹配N次	\w{3}
{M,}	匹配至少M次	\w{3,}
{M,N}	匹配至少M次至多N次	\w{3,6}
\|	分支	foo\|bar	可以匹配foo或者bar
(?#)	注释
(exp)	匹配exp并捕获到自动命名的组中
(? <name>exp)	匹配exp并捕获到名为name的组中
(?:exp)	匹配exp但是不捕获匹配的文本
(?=exp)	匹配exp前面的位置	\b\w+(?=ing)	可以匹配I'm dancing中的danc
(?<=exp)	匹配exp后面的位置	(?<=\bdanc)\w+\b	可以匹配I love dancing and reading中的第一个ing
(?!exp)	匹配后面不是exp的位置
(?<!exp)	匹配前面不是exp的位置
*?	重复任意次，但尽可能少重复	a.b a.?b	将正则表达式应用于aabab，前者会匹配整个字符串aabab，后者会匹配aab和ab两个字符串
+?	重复1次或多次，但尽可能少重复
??	重复0次或1次，但尽可能少重复
{M,N}?	重复M到N次，但尽可能少重复
{M,}?	重复M次以上，但尽可能少重复

说明： 如果需要匹配的字符是正则表达式中的特殊字符，那么可以使用\进行转义处理，例如想匹配小数点可以写成\.就可以了，因为直接写.会匹配任意字符；同理，想匹配圆括号必须写成$和$，否则圆括号被视为正则表达式中的分组。

三、Python对正则表达式的支持

Python提供了re模块来支持正则表达式相关操作，下面是re模块中的核心函数。

函数	说明
compile(pattern, flags=0)	编译正则表达式返回正则表达式对象
match(pattern, string, flags=0)	用正则表达式匹配字符串成功返回匹配对象否则返回None
search(pattern, string, flags=0)	搜索字符串中第一次出现正则表达式的模式成功返回匹配对象否则返回None
split(pattern, string, maxsplit=0, flags=0)	用正则表达式指定的模式分隔符拆分字符串返回列表
sub(pattern, repl, string, count=0, flags=0)	用指定的字符串替换原字符串中与正则表达式匹配的模式可以用count指定替换的次数
fullmatch(pattern, string, flags=0)	match函数的完全匹配（从字符串开头到结尾）版本
findall(pattern, string, flags=0)	查找字符串所有与正则表达式匹配的模式返回字符串的列表
finditer(pattern, string, flags=0)	查找字符串所有与正则表达式匹配的模式返回一个迭代器
purge()	清除隐式编译的正则表达式的缓存
re.I / re.IGNORECASE	忽略大小写匹配标记
re.M / re.MULTILINE	多行匹配标记

说明： 上面提到的re模块中的这些函数，实际开发中也可以用正则表达式对象的方法替代对这些函数的使用，如果一个正则表达式需要重复的使用，那么先通过compile函数编译正则表达式并创建出正则表达式对象无疑是更为明智的选择。

四、字符匹配

1.普通字符：大多数字符和字母都会和自身匹配

re.findall("alexsel","gtuanalesxalexselericapp")
['alexsel']

re.findall("alexsel","gtuanalesxalexswxericapp")
[]

re.findall("alexsel","gtuanalesxalexselwupeiqialexsel")
['alexsel', 'alexsel']

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

•. :匹配一个除了换行符任意一个字符　　　　

re.findall("alexsel.w","aaaalexselaw")
['alexselaw']
#一个点只能匹配一个字符

•^ :只有后面跟的字符串在开头，才能匹配上

re.findall("^alexsel","gtuanalesxalexselgeappalexsel")
[]

re.findall("^alexsel","alexselgtuanalesxalexselwgtappqialexsel")
['alexsel']
#"^"这个符号控制开头，所以写在开头

•$ :只有它前面的字符串在检测的字符串的最后，才能匹配上

re.findall("alexsel$","alexselseguanalesxalexselganapp")
[]

re.findall("alexsel$","alexselgtaanalesxalexsssiqialexsel")
['alexsel']

• ：它控制它前面那个字符，他前面那个字符出现0到多个都可以匹配上*

re.findall("alexsel*","aaaalexse")
['alexse']

re.findall("alexsel*","aaaalexsel")
['alexsel']

re.findall("alex*","aaaalexsellllll")
['alexsellllll']

•+ ：匹配前面那个字符1到多次

re.findall("alexsel+","aaaalexselll")
['aleselll']

re.findall("alexsel+","aaaalexsel")
['alexsel']

re.findall("alexsel+","aaaalexse")
[]

•？：匹配前面那个字符0到1个，多余的只匹配一个

re.findall("alexsel?","aaaalexse")
['ale']

re.findall("alexsel?","aaaalexsel")
['alexsel']

re.findall("alexsel?","aaaalexsellll")
['alexsel']

•{} :控制它前面一个字符的匹配个数，可以有区间（闭区间），有区间的情况下按照多的匹配

re.findall("alexsel{3}","aaaalexselllll")
['alexselll']

re.findall("alexsel{3}","aaaalexsell")
[]

re.findall("alexsel{3}","aaaalexse")
[]

re.findall("alexsel{3}","aaaalexselll")
['alexselll']

re.findall("alexsel{3,5}","aaaalexsellllllll")
['alexselllll']

re.findall("alexsel{3,5}","aaaalexselll")
['alexselll']

re.findall("alexsel{3,5}","aaaalexsell")
[]

•\ :
　　后面跟元字符去除特殊功能，
　　后面跟普通字符实现特殊功能。
　　引用序号对应的字组所匹配的字符串（一个括号为一个组）。
　　在开头加上 r 表示不转义。

#\2 就相当于第二个组(eric)

re.search(r"(alexsel)(eric)com\2","alexselericcomeric").group()
'alexselericcomeric'

re.search(r"(alexsel)(eric)com\1","alexselericcomalex").group()
'alexselericcomalex'

re.search(r"(alexsel)(eric)com\1\2","alexselericcomalexseleric").group()
'alexselericcomalexeric'

\d :匹配任何十进制数；它相当于类[0-9]

re.findall("\d","aaazz1111344444c")
['1', '1', '1', '1', '3', '4', '4', '4', '4', '4']

re.findall("\d\d","aaazz1111344444c")
['11', '11', '34', '44', '44']

re.findall("\d0","aaazz1111344444c")
[]

re.findall("\d3","aaazz1111344444c")
['13']

re.findall("\d4","aaazz1111344444c")
['34', '44', '44']

　\D :匹配任何非数字字符；它相当于类[^0-9]

re.findall("\D","aaazz1111344444c")
['a', 'a', 'a', 'z', 'z', 'c']

re.findall("\D\D","aaazz1111344444c")
['aa', 'az']

re.findall("\D\d\D","aaazz1111344444c")
[]

re.findall("\D\d\D","aaazz1z111344444c")
['z1z']

　　\s :匹配任何空白字符；它相当于类[ \t\n\r\f\v]

re.findall("\s","aazz1 z11..34c")
[' ']

　　\S :匹配任何非空白字符；它相当于类[^\t\n\r\f\v]
\w :匹配任何字母数字字符；他相当于类[a-zA-Z0-9_]

re.findall("\w","aazz1z11..34c")
['a', 'a', 'z', 'z', '1', 'z', '1', '1', '3', '4', 'c']

　　\W :匹配任何非字母数字字符；它相当于类[^a-zA-Z0-9_]
\b :匹配一个单词边界，也就是指单词和空格间的位置

re.findall(r"\babc\b","abc sdsadasabcasdsadasdabcasdsa")
['abc']

re.findall(r"\balexsel\b","abc alexsel abcasdsadasdabcasdsa")
['alexsel']

re.findall("\\balexsel\\b","abc alexsel abcasdsadasdabcasdsa")
['alexsel']

re.findall("\balexsel\b","abc alexsel abcasdsadasdabcasdsa")
[]

　　() :把括号内字符作为一个整体去处理

re.search(r"a(\d+)","a222bz1144c").group()
'a222'

re.findall("(ab)*","aabz1144c")
['', 'ab', '', '', '', '', '', '', ''] #将括号里的字符串作为整和后面字符逐个进
#行匹配，在这里就首先将后面字符串里的a和ab进
#行匹配，开头匹配成功，在看看后面是a，和ab中的第二个不匹配，然后就看后面字符串中的第
#二个a，和ab匹配，首先a匹配成功，b也匹配成功，拿到匹配
#然后在看后面字符串中的第三个是b，开头匹配失败，到第四个，后面依次
re.search(r"a(\d+)","a222bz1144c").group()
'a222'

re.search(r"a(\d+?)","a222bz1144c").group() +的最小次数为1
'a2'

re.search(r"a(\d*?)","a222bz1144c").group() *的最小次数为0
'a'

#非贪婪匹配模式 加？ ,但是如果后面还有匹配字符，就无法实现非贪婪匹配
#（如果前后均有匹配条件，则无法实现非贪婪模式）
re.findall(r"a(\d+?)b","aa2017666bz1144c")
['2017666']

re.search(r"a(\d*?)b","a222bz1144c").group()
'a222b'

re.search(r"a(\d+?)b","a277722bz1144c").group()
'a277722b'
 元字符在字符集里就代表字符，没有特殊意义（有几个例外）

re.findall("a[.]d","aaaacd")
[]

re.findall("a[.]d","aaaa.d")
['a.d']

例外
[-] [^] []** **[-]

#匹配单个字符，a到z所有的字符
re.findall("[a-z]","aaaa.d")
['a', 'a', 'a', 'a', 'd']

re.findall("[a-z]","aaazzzzzaaccc")
['a', 'a', 'a', 'z', 'z', 'z', 'z', 'z', 'a', 'a', 'c', 'c', 'c']

re.findall("[1-3]","aaazz1111344444c")
['1', '1', '1', '1', '3']

[^]
#匹配除了这个范围里的字符，(^在这里有 非 的意思)
re.findall("[^1-3]","aaazz1111344444c")
['a', 'a', 'a', 'z', 'z', '4', '4', '4', '4', '4', 'c']

re.findall("[^1-4]","aaazz1111344444c")
['a', 'a', 'a', 'z', 'z', 'c']
#[\]
re.findall("[\d]","aazz1144c")
['1', '1', '4', '4']

#我们首先考察的元字符是"[" 和 "]"。它们常用来指定一个字符类别，所谓字符类 别就是你想
#匹配的一个字符集。字符可以单个列出，也可以用“-”号分隔的两个给定 字符来表示一个字符区
#间。例如，[abc] 将匹配"a", "b", 或 "c"中的任意一个字 符；也可以用区间[a-c]来表
#示同一字符集，和前者效果一致。如果你只想匹配小写 字母，那么 RE 应写成 [a-z]，元字符
#在类别里并不起作用。例如，[akm$]将匹配字符"a", "k", "m", 或 "$" 中 的任意一
#个；"$"通常用作元字符，但在字符类别里，其特性被除去，恢复成普通字符。

五、Python正则表达式各种函数以及参数解析

1.match: re.match(pattern,string,flags=0)
flags 编译标志位，用于修改正则表达式的匹配方式，如：是否区别大小写
默认从string的开始进行匹配，如果开始没匹配上，就直接返回None，一旦找到匹配立即返回

re.match("com","comwww.runcomoob").group()
'com'

re.match("com","Comwww.runComoob",re.I).group()
'Com'

flags 编译标志位

re.I 使匹配对大小写不敏感

re.search("com","COM",re.I).group()
  'COM'

re.L 做本地化识别（locale-aware）匹配

re.M 多行匹配，影响^和$

re.S 使.匹配包括换行在内的所有字符

re.findall(".","abc\nde")
['a', 'b', 'c', 'd', 'e']

re.findall(".","abc\nde",re.S)
['a', 'b', 'c', '\n', 'd', 'e']

re.U 根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B

re.X 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

search:re.search(pattern,string,flags=0)
匹配整个字符串，如果一开始没匹配上还会继续往后匹配，一旦找到匹配立即返回

re.search("\dcom","www.4comrunoob.5com").group()
'4com'

re.match与re.search的区别

　　re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

　　match和search一旦匹配成功，就是一个match object对象，而match object对象有以下方法：

•group() 　　 返回被RE匹配的字符串
•start() 　　    返回匹配开始的位置
•end() 　　     返回匹配结束的位置
•span() 　　   返回一个元组包含匹配（开始，结束）的位置
•group() 　　 返回re整体匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串,获
#取匹配到的所有结果（无论是否有组）
•a. group ()　 返回re整体匹配的字符串，
•b. group (n,m)  　　返回组号为n，m所匹配的字符串，如果组号不存在，则返回indexError异常
•c. groups() 　　groups() 方法返回一个包含正则表达式中所有小组字符串的元组，从 1 
#到所含的小组号，通常groups()不需要参数，返回一个元组，元组中的元就是正则表达式中定义的组。
a = "123abc456"
re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0)   #123abc456,返回整体
re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1)   #123
re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2)   #abc
re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3)   #456

#在上面的代码练习中，我们看到很多代码后面加有group，在这我们就针对这个group进行解析。

m = re.match("([abc])+", "abc")

#一般，m.group(N) 返回第N组括号匹配的字符。 而m.group() == m.group(0) == 所有
#匹配的字符，与括号无关，这个是API规定的。 m.groups() 返回所有括号匹配的字符，以
#tuple格式。m.groups() == (m.group(0), m.group(1), ...)

sub 和subn：

re.sub(pattern, repl, string, max=0)
 
re.sub("g.t","have","I get A, I got B, I gut C")#匹配g.t字符，用have替换(.匹配一个除了换行符任意一个字符)
'I have A, I have B, I have C'

re.sub("got","have","I get A, I got B, I gut C")
'I get A, I have B, I gut C'

re.sub("g.t","have","I get A, I got B, I gut C",2)#替换两个
'I have A, I have B, I gut C'

re.sub("g.t","have","I get A, I got B, I gut C",1)
'I have A, I got B, I gut C'

re.subn("g.t","have","I get A, I got B, I gut C")#使用re.subn显示替换里多少个
('I have A, I have B, I have C', 3)

re.compile(strPattern[, flag]):

　　这个方法是Pattern类的工厂方法，用于 将字符串形式的正则表达式编译为Pattern对象。
第二个参数flag是匹配模式，取值可以使用按位或运算符‘|‘表示同时生效，比如re.I | re.M可以把正则表达式编译成一个正则表达式对象。可以把那些经常使用的正则表达式编译成正则表达式对象，这样可以提高一定的效率。

　　一个正则表达式对象的一个例子：

text = "JGood is a handsome boy, he is cool, clever, and so on..."
regex = re.compile(r"\w*oo\w*")
print regex.findall(text)
['JGood', 'cool']

split:

p = re.compile(r"\d+")    #+：匹配前面那个字符1到多次
p.split("one1two2three3four4")    #spilt分割

p = re.compile(r"\d+")
p.split("one1two2three3four4")
['one', 'two', 'three', 'four', '']

re.split("\d+","one1two2three3four4")
re.split("\d+","one1two2three3four4")
['one', 'two', 'three', 'four', '']

re.split("\d+","4one1two2three3four4")
['', 'one', 'two', 'three', 'four', '']#如果分割时左边或者右边已经被分过

re.split("[bc]","abcd")#或者是无字符的情况下，就分出一个空字符
['a', '', 'd']

finditer():

p = re.compile(r"\d+")
iterator = p.finditer("12 drumm44ers drumming, 11 ... 10 ...")

iterator
<callable-iterator object at 0x02626990>
for match in iterator:
...   match.group() , match.span()#每个数字以及它们出现的位置
...
('12', (0, 2))
('44', (8, 10))
('11', (24, 26))
('10', (31, 33))
由于我们是在python下使用的正则表达式，所以特殊字符需要多次转意，而使用了rawstring之后，就不用在多次转意仅仅就使用正则的规则就可以。

re.findall(r"\d","www4dd6")
['4', '6']

re.findall("\\d","www4dd6")
['4', '6']

re.findall("\d","www4dd6")
['4', '6']
#在这里\d成功的原因是因为\d在ascii码中没有特殊含义，所以在这里就自动转意了，不过正规的写法就是前两个

8.单词边界

re.findall(r"\babc","abcsd abc")
['abc', 'abc']

re.findall(r"abc\b","abcsd abc")
['abc']

re.findall(r"abc\b","abcsd abc*")
['abc']

re.findall(r"\babc","*abcsd*abc")
['abc', 'abc']
#检测单词边界不一定就是空格，还可以是除了字母以外的特殊字符

六、例

例子1：验证输入用户名和QQ号是否有效并给出对应的提示信息。

"""
验证输入用户名和QQ号是否有效并给出对应的提示信息

要求：用户名必须由字母、数字或下划线构成且长度在6~20个字符之间，QQ号是5~12的数字且首位不能为0
"""
import re


def main():
    username = input('请输入用户名: ')
    qq = input('请输入QQ号: ')
    # match函数的第一个参数是正则表达式字符串或正则表达式对象
    # 第二个参数是要跟正则表达式做匹配的字符串对象
    m1 = re.match(r'^[0-9a-zA-Z_]{6,20}$', username)
    if not m1:
        print('请输入有效的用户名.')
    m2 = re.match(r'^[1-9]\d{4,11}$', qq)
    if not m2:
        print('请输入有效的QQ号.')
    if m1 and m2:
        print('你输入的信息是有效的!')


if __name__ == '__main__':
    main()

提示： 上面在书写正则表达式时使用了“原始字符串”的写法（在字符串前面加上了r），所谓“原始字符串”就是字符串中的每个字符都是它原始的意义，说得更直接一点就是字符串中没有所谓的转义字符啦。因为正则表达式中有很多元字符和需要进行转义的地方，如果不使用原始字符串就需要将反斜杠写作\\，例如表示数字的\d得书写成\\d，这样不仅写起来不方便，阅读的时候也会很吃力。

例子2：从一段文字中提取出国内手机号码。

import re


def main():
    # 创建正则表达式对象 使用了前瞻和回顾来保证手机号前后不应该出现数字
    pattern = re.compile(r'(?<=\D)1[34578]\d{9}(?=\D)')
    sentence = '''
    重要的事情说8130123456789遍，我的手机号是13512346789这个靓号，
    不是15600998765，也是110或119，王大锤的手机号才是15600998765。
    '''
    # 查找所有匹配并保存到一个列表中
    mylist = re.findall(pattern, sentence)
    print(mylist)
    print('--------华丽的分隔线--------')
    # 通过迭代器取出匹配对象并获得匹配的内容
    for temp in pattern.finditer(sentence):
        print(temp.group())
    print('--------华丽的分隔线--------')
    # 通过search函数指定搜索位置找出所有匹配
    m = pattern.search(sentence)
    while m:
        print(m.group())
        m = pattern.search(sentence, m.end())


if __name__ == '__main__':
    main()

说明： 上面匹配国内手机号的正则表达式并不够好，因为像14开头的号码只有145或147，而上面的正则表达式并没有考虑这种情况，要匹配国内手机号，更好的正则表达式的写法是：(?<=\D)(1[38]\d{9}|14[57]\d{8}|15[0-35-9]\d{8}|17[678]\d{8})(?=\D)，国内最近好像有19和16开头的手机号了，但是这个暂时不在我们考虑之列。

例子3：替换字符串中的不良内容

import re


def main():
    sentence = '你丫是傻叉吗? 我操你大爷的. Fuck you.'
    purified = re.sub('[操肏艹]|fuck|shit|傻[比屄逼叉缺吊屌]|煞笔',
                      '*', sentence, flags=re.IGNORECASE)
    print(purified)  # 你丫是*吗? 我*你大爷的. * you.


if __name__ == '__main__':
    main()

说明： re模块的正则表达式相关函数中都有一个flags参数，它代表了正则表达式的匹配标记，可以通过该标记来指定匹配时是否忽略大小写、是否进行多行匹配、是否显示调试信息等。如果需要为flags参数指定多个值，可以使用按位或运算符进行叠加，如flags=re.I | re.M。

例子4：拆分长字符串

import re


def main():
    poem = '窗前明月光，疑是地上霜。举头望明月，低头思故乡。'
    sentence_list = re.split(r'[，。, .]', poem)
    while '' in sentence_list:
        sentence_list.remove('')
    print(sentence_list)  # ['窗前明月光', '疑是地上霜', '举头望明月', '低头思故乡']


if __name__ == '__main__':
    main()

Python使用正则表达式获取网页中所需要的信息

python 正则表达式 re.sub & re.subn

python使用正则表达式的search()函数实现指定位置搜索功能

python正则表达式re之compile函数解析

python爬虫正则表达式使用技巧及爬取个人博客的实例讲解

Python基于正则表达式实现检查文件内容的方法【文件检索】

Python基于正则表达式实现文件内容替换的方法

Python正则表达式非贪婪、多行匹配功能示例

Python正则表达式分组概念与用法详解

Python正则表达式常用函数总结述

Python使用正则表达式实现文本替换的方法

Python正则表达式教程之三：贪婪/非贪婪特性