Python之正则表达式模块(re)详解
本文章以授权于微信公众号：HarLearn
有什么建议可以到公众号里进行留言。
在上一篇文章Python之正则表达式基础语法中我们简单的学习了正则表达式的一些基础语法，今天这篇文章将讲一下python如何使用正则表达式，它有那些方法。
正则表达式模块(re)内容
re模块是python的一个库，里面有很多方法可以对正则表达式进行运用。
re.search(pattern，string，flags = 0)
| 参数 | 描述 |
|---|---|
| pattern | 正则表达式 |
| string | 要匹配的字符串 |
| flags | 标志值，用于改变正则表达式的行为 |
flags有哪些值：
| 标志 | 含义 |
|---|---|
| re.S(DOTALL) | 使.匹配包括换行在内的所有字符 |
| re.I(IGNORECASE) | 使匹配对大小写不敏感 |
| re.L(LOCALE) | 做本地化识别（locale-aware)匹配，法语等 |
| re.M(MULTILINE) | 多行匹配，影响^和$ |
| re.X(VERBOSE) | 该标志通过给予更灵活的格式以便将正则表达式写得更易于理解 |
| re.U(UNICODE) | 根据Unicode字符集解析字符。在python3是多余的,python3默认使用Unicode字符串 |
| re.A(ASCII) | 使\w,\W,\b,\B,\d,\D,\s和\S只执行ASCII匹配而不完全是Unicode匹配。 |
**注：**下面方法中的同名参数和上述介绍的参数意思一样，将不再过多的解释。
作用：从左到右扫描整个字符串 返回第一个与正则表达式匹配的对象，如果没有匹配成功就返回None
比如： 查找 字符串中 CodeId 第一次出现的位置
import re
text = 'Welcome to CodeId. CodeId'
result = re.search(r'CodeId',text)
print(result.start())
# 结果为：11
**注：**返回的result为匹配对象，其中result.start()是返回开始匹配的位置索引。由此我们可以猜到result.end()应该是返回匹配结束时的位置索引。
re.match(pattern，string，flags = 0 )
作用：查找字符串开头的零个或几个字符是否与正则表达式匹配，如果成功则返回相应的匹配对象，否则返回None
比如：判断 python变量 的开头是否是数字。
result = re.match(r'\d+','123CodeId')
if result :
print("python变量 的开头含有数字")
# 结果为：python变量 的开头含有数字
注意:re.match()只会匹配字符串的开头，即使在MULTILINE(多行)模式下，也不会匹配每行的开头。
result = re.match(r'a','b\na',re.MULTILINE)
print(result)
# 结果为：None
# 证明匹配失败
re.fullmatch(pattern，string，flags = 0 )
作用：如果整个字符串都与正则表达式匹配，则返回相应的匹配对象，否则返回None
比如：判断输入的邮箱是否合法
# 判断输入的邮箱是否合法
email = '[email protected]'
result = re.fullmatch(r'^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$',email)
if result :
print("你输入的邮箱:",result.group(),"是合法的")
# 结果为：你输入的邮箱: [email protected] 是合法的
注：result.group()是匹配对象的一个方法，作用是：返回匹配的所有子串。后面会进行详细介绍。
re.split(pattern，string，maxsplit = 0，flags = 0 )
作用：以字符串中与正则表达式匹配的子串，为分隔符，对字符串进行分割。返回分割之后的列表。
比如：把英文句子分割为单词组成的列表
text = 'Welcome to CodeId'
result = re.split(r'\W+',text)
print(result)
# 结果为：['Welcome', 'to', 'CodeId']
参数maxsplit为最大分割次数，默认是0表示无限分割。
text = 'Welcome to CodeId'
result = re.split(r'\W+',text,maxsplit=1)
print(result)
# 结果为：['Welcome', 'to CodeId']
# 最大分割一次 剩下的部分 作为列表的最后一个元素
**注意：**如果在正则表达式中使用组括号，则正则表达式中所有组的文本也会作为结果列表的一部分返回。
text = 'Welcome to CodeId'
result = re.split(r'(\W+)',text)
print(result)
# 结果为：['Welcome', ' ', 'to', ' ', 'CodeId']
re.findall(pattern，string，flags = 0 )
作用：从左到右对字符串进行扫描，以列表的形式返回所有与正则表达式匹配的子串。
比如：匹配一句话中所有的带小数点的数
text = '我有3.5元钱，给你1.5元，我还剩2元'
result = re.findall(r'-?\d+\.\d+',text)
print(result)
# 结果为 ['3.5', '1.5']
**注意：**如果正则表达式中存在一个组，则返回组列表; 如果正则表达式中有多个组，这将是一个元组列表。
text = '我有3.5元钱，给你1.5元，我还剩2元'
result = re.findall(r'(-?\d+\.\d+)',text) # 一个组
print(result)
# 结果为 ['3.5', '1.5']
result = re.findall(r'(-?\d)+(\.\d+)',text) # 多个组
print(result)
# 结果为 [('3', '.5'), ('1', '.5')]
re.finditer(pattern，string，flags = 0)
作用：从左到右对字符串进行扫描，以迭代器的形式返回所有与正则表达式匹配的子串。
比如：上面的例子 ，换成以迭代器的形式返回
# 匹配一句话中所有的带小数点的数
text = '我有3.5元钱，给你1.5元，我还剩2元'
result = re.finditer(r'-?\d+\.\d+',text) # 返回一个迭代器
print(result)
# 结果为 re.sub(pattern，repl，string，count = 0，flags = 0)
作用：把字符串中与正则表达式匹配的子串替换为repl。repl可以是一个字符串也可以是一个函数。
repl是一个字符串时，可以处理任何转义字符
比如：
1.处理普通字符串
# 把关键信息替换为 ****，比如手机号
text = '有事请拨打电话：15589878888'
result = re.sub(r'(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}','****',text)
print(result)
# 结果为：有事请拨打电话：****
2.反向引用
#隐藏手机号的中间四位数
text = '有事请拨打电话：15589878888'
# 字符串 r'\1****\3' 中的 \1和\3 就是应用组1和组3的内容
result = re.sub(r'(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])(\d{4})(\d{4})',r'\1****\3',text)
print(result)
# 结果为：有事请拨打电话：155****8888
**注：**除了上述的字符转义和反向引用外， 使用\g还可以引用那些使用(?P语法定义的组。同时\g等价于\number,\g在替代方法中表达的更加清楚。后面会进行举例。
反向引用\g<0>替换正则表达式中匹配的整个子串。
repl是一个函数时，这个函数的参数是一个单匹配对象，并返回一个替换的字符串。
比如：
def dashrepl(matchobj):
if matchobj.group(0) == '-':
return ' '
else:
return '*'
result = re.sub(r'-{1,3}', dashrepl, 'pro--a--gram-files')
print(result)
# 结果为：pro*a*gram files
text = "JGood is a handsome boy, he is cool, clever, and so on..."
print(re.sub(r'\S+', lambda m:'['+m.group(0)+']', text,0))
# 结果为：[JGood] [is] [a] [handsome] [boy,] [he] [is] [cool,] [clever,] [and] [so] [on...]
- 参数
count用于控制最大替换次数。count必须是一个非负整数。如果省略或为零，则所有匹配的都将被替换。比如：
result = re.sub(r'-',r'*','------------------',count=4)
print(result)
# 结果为：****--------------
result = re.sub(r'-',r'*','------------------',count=8)
print(result)
# 结果为：********----------
re.subn(pattern，repl，string，count = 0，flags = 0)
作用：和re.sub()一样，只是re.subn()返回的是一个元组。元组里面的内容包括替换后的字符串，和替换的次数
比如：
# 把一些私密信息替换为 ****，比如手机号
text = '有事请拨打电话：15589878888,以前的手机号：15888886666 不在使用'
result = re.subn(r'(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}','****',text)
print(result)
# 结果为：('有事请拨打电话：****,以前的手机号：**** 不在使用', 2)
re.escape(pattern)
作用：对字符串中的特殊字符加上转义，也就是在每个特殊字符前面加上\
比如：
result = re.escape('CodeId*&@_.\.')
print(result)
# 结果为 CodeId\*\&\@_\.\\\.
re.purge（）
作用：清除正则表达式缓存。
re.compile(pattern，flags = 0)
作用：把一个正则表达式编译为正则表达式对象，它可用于匹配match()，search()以及其他方法。
比如：
com = re.compile('CodeId')
result = com.search('Welcome to CodeId.CodeId')
print(result.start())
# 结果是 11
**注：**正则表达式对象的匹配方法和上面介绍的模块级匹配方法 在得到效果上是一样的，但是效率上有所不同，re.compile()是对正则表达式进行一次编译，然后保存便以后重用，适合那些单个程序中多次使用的正则表达式。
正则表达式对象的方法在参数上和上面的方法有些不同。比如：Pattern.match(string [，pos [，endpos ] ])。
- 参数
pos用于设置字符串在什么位置开始匹配。 - 参数
endpos用于设置字符串最长的匹配距离。
其他的所有方法和上面差不多 不在细讲，可以查看https://docs.python.org/3/library/re.html了解更多详细的内容。
匹配对象(Match)
匹配对象的布尔值始终返回True。 由于match()和search()在没有匹配时返回None，因此我们可以通过if语句测试是否是匹配对象。比如：
result = re.search(r"CodeId", "Welcome to CodeId")
if result :
print('Yes')
# 结果为 Yes
Match.expand(template)
作用：把模板字符串template中指定的位置 替换为 指定组的内容。template中可以使用\id、\g或\g引用分组，但不能使用编号0。\id与\g是等价的；如果你想表达\1之后是字符'0'，只能使用\g<1>0，因为\10将被认为是第10个分组。
比如：匹配日期
# 匹配日期
data = '2018-8-9'
result = re.fullmatch(r'^(\d{4})-(\d{1,2})-(?P\d{1,2})$' ,data)
expand = result.expand(r'今天是 \1 年 \g<2> 月 \g 号' )
print(expand)
# 结果为 今天是 2018 年 8 月 9 号
print(result.group())
# 结果为 2018-8-9
Match.group([ group1，… ] )
作用：返回匹配的一个或多个子组。其中如果有一个参数，结果是返回一个单一的字符串;如果有多个参数，则结果是返回每个参数对应的组内容 组成的 元组。没有参数，group1默认为0(整个匹配结果被返回)。如果groupN参数为零，则相应的返回值是整个匹配的字符串比如：
data = '2018-8-9'
result = re.fullmatch(r'^(\d{4})-(\d{1,2})-(?P\d{1,2})$' ,data)
print(result.group()) # 没有参数时
# 结果为 2018-8-9
print(result.group(1)) # 一个参数时
# 结果为 2018
print(result.group(1,2)) # 两个参数时
# 结果为 ('2018', '8')
print(result.group(1,2,3,0)) # 参数中有为 0 的
# 结果为 ('2018', '8', '9', '2018-8-9')
如果组编号为负数或大于正则表达式中定义的组数，则会引发IndexError异常。
print(result.group(4)) # 超过组数
# 结果为 IndexError: no such group
如果正则表达式使用(?P语法，则groupN参数也可以是通过其组名称来访问组内容。
print(result.group('day')) # 通过组名称
# 结果为 9
如果一个组匹配多次，只能访问最后一次匹配。
**注：**返回结果还可以通过数组的方式来访问，这得益于Match.__getitem__(g)方法，它是在 3.6版本中新加的。
data = '2018-8-9'
result = re.fullmatch(r'^(\d{4})-(\d{1,2})-(?P\d{1,2})$' ,data)
print(result[0])
# 结果为 2018-8-9
print(result[1])
# 结果为 2018
print(result['day'])
# 结果为 9
Match.groups(default=None)
作用：从1开始，返回一个包含匹配所有子组的元组。参数default为那些没有匹配成功的子组设置默认值。没有参数时默认是None.
比如：匹配浮点数
result = re.match(r"(\d+)\.?(\d+)?", "24")
print(result.groups())
# 结果为 ('24', None)
print(result.groups('0')) # 设置默认参数为 0
# 结果为 ('24', '0')
Match.groupdict(default=None)
作用：对于使用(?P语法的所有子组，以字典的形式返回。默认参数default用于那些没有匹配成功的子组; 它默认为None
result = re.match(r"(?P\w+) (?P\w+)" , "Malcolm Reynolds")
print(result.groupdict())
# 结果为 {'first_name': 'Malcolm', 'last_name': 'Reynolds'}
Match.start([group])和Match.end([group])
作用：返回按组匹配子串的开始和结束索引; 组默认为零（意味着整个匹配的子字符串）。如果组没有匹配成功则返回-1。
比如：
result = re.match(r"(\d+)\.?(\d+)?", "24.59")
print(result.start()) # 整个串的开始索引
# 结果为 0
print(result.end()) # 整个串的结束索引
# 结果为 5
print(result.start(2)) # 第二组的开始索引
# 结果为 3
print(result.end(2)) # 第二组的结束索引
# 结果为 5
Match.span([group])
作用：返回一个由匹配子组的开始和结束组成的元组。如果分组没有成功匹配，返回(-1,-1)。
比如：
result = re.match(r"(\d+)\.?(\d+)?", "24.59")
print(result.span())
# 结果为 (0, 5)
print(result.span(2))
# 结果为 (3, 5)
下面是公众号:HarLearn 欢迎关注