Python中正则表达式的应用非常广泛，如数据挖掘、数据分析、网络爬虫、输入有效性验证等。
正则表达式（Regular Expression，在代码中简写为regex、regexp、RE或re）是预先定义好的一个“规则字符串”，通过这个“规则字符串”可以匹配、查找和替换那些符合“规则”的文本。可以把它当成增强版的通配符。
虽然文本的查找和替换功能可通过字符串提供的方法实现，但是实现起来极为困难，且运算效率比较低。而使用正则表达式实现这些功能会比较简单，且效率很高，唯一困难之处在于编写合适的正则表达式。Python提供了利用正则表达式实现文本的匹配、查找和替换等操作的 re 模块。
正则表达式中的字符
正则表达式是一种字符串，是由普通字符和元字符（Metacharacters）组成的。
（1）普通字符
普通字符是按照字符字面意义表示的字符，如CSDN - 专业开发者社区、http://www.baidu.com
（2）元字符
元字符是预先定义好的一些特殊字符串，如：\w 和 \.
元字符
元字符是用来描述其他字符的特殊字符，它由基本元字符和普通字符构成。基本元字符是构成元字符的组成要素。学习正则表达式某种意义上就是在学习元字符的使用。
| 字符 | 说明 |
|---|---|
| \ | 转义符，表示转义 |
| . | 表示任意一个字符（但不包含换行符） |
| + | 表示重复一次或多次 |
| * | 表示重复零次或多次 |
| ？ | 表示重复零次或一次 |
| | | 选择符号，表示“或关系”，如：A | B 表示匹配A或B |
| {} | 定义量词 |
| () | 定义分组 |
| ^ | 可以表示取反或匹配一行的开始 |
| $ | 匹配一行的结束 |
字符转义
反斜杠 “ \ ” 不仅可以对普通字符进行转义，还可以对基本元字符进行转义。如“ . ”表示任意一个字符，而“ \. ”表示普通字符点。
开始与结束字符
基本元字符 ^ 和 $，它们可以用于匹配一行字符串的开始和结束。当正则表达式以“^”开始时，则从字符串的开始位置匹配；当正则表达式以“$”结束时，则从字符串的结束位置匹配。
注意：由于正则表达式中经常会有反斜杠“ \ ”等特殊字符，如果采用普通字符串表示需要转义。而在字符串前面加上 r 则不需要转义，因此一般正则表达式采用原始字符串表示。
示例代码如下
import rep1 = r'\w+@zhangsan\.com' # 匹配包含 @zhangsan.com 的任何字符串中的任何位置
p2 = r'^\w+@zhangsan\.com$' # 要求整个字符串必须是有效的电子邮件地址，并且只匹配完整的字符串
text = "Tony's email is tony_guan588@zhangsan.com"
m = re.search(p1,text)
#re.search 函数在 text 中搜索与 p1 匹配的模式
# 如果找到匹配项，它将返回一个匹配对象；如果没有找到
# 它将返回 None。然后打印这个匹配对象
print(m)m1 = re.search(p2,text)
print(m)
email1 = 'tony_guan588@zhangsan.com'
m2 = re.search(p2,email1)
print(m2)代码运行结果
<re.Match object; span=(16, 41), match='tony_guan588@zhangsan.com'>
<re.Match object; span=(16, 41), match='tony_guan588@zhangsan.com'>
<re.Match object; span=(0, 25), match='tony_guan588@zhangsan.com'>字符类
正则表达式可以使用字符类（Character class），一个字符类定义一组字符的集合，其中的任一字符出现在输入字符串中即匹配成功。注意每次匹配只能匹配字符类中的一个字符。
定义字符类
定义一个普通的字符类需要使用“[”和“]”元字符类。例如想要在输入字符串中匹配Python或python，可以使用正则表达式[Pp]ython。
示例代码如下
import rep = r'[Pp]ython'm = re.search(p,'I like python')
print(m)
m1 = re.search(p,'I like Python')
print(m1)
m2 = re.search(p,'I like Java')
print(m2)代码运行结果
<re.Match object; span=(7, 13), match='python'>
<re.Match object; span=(7, 13), match='Python'>
None字符类取反
在正则表达式中指定不想出现的字符，可以在字符前加“^”符号
示例代码如下
import rep = r'[^1234567890]' # 表示输入字符串中非0123456789即匹配m = re.search(p,'10000')
print(m)
m1 = re.search(p,'I like Python')
print(m1)代码运行结果
None
<re.Match object; span=(0, 1), match='I'>区间
区间使用连字符“-”表示的，例如[0-9]等同于[0123456789]；也可以表示多个不用区间，如[0-9a-zA-Z]表示所有的数字和字母字符类。
示例代码如下
import rep = r'[0-9a-zA-Z]' # 表示输入字符串中非0123456789即匹配m = re.search(p,'_10000')
print(m)
m1 = re.search(p,'I like Python')
print(m1)代码运行结果
<re.Match object; span=(1, 2), match='1'>
<re.Match object; span=(0, 1), match='I'>预定义字符类
| 字符 | 说明 |
|---|---|
| . | 匹配任意一个字符 |
| \\ | 匹配反斜杠 \ 字符 |
| \n | 匹配换行 |
| \r | 匹配回车 |
| \f | 匹配一个换页符 |
| \t | 匹配一个水平制表符 |
| \v | 匹配一个垂直制表符 |
| \s | 匹配一个空格符，等价于[\t\n\r\f\v] |
| \S | 匹配一个非空格符，等价于[^\s] |
| \d | 匹配一个数字字符，等价于[0-9] |
| \D | 匹配一个非数字字符，等价于[^0-9] |
| \w | 匹配任何语言的单词字符、数字和下划线“_”等字符 |
| \W | 等价于[^\w] |
量词
前面提到的正则表达式元字符只能匹配显示一次字符或字符串，如果想匹配显示多次字符或字符串可以使用量词，量词表示字符或字符串重复的次数。
使用量词
| 字符 | 说明 |
|---|---|
| ？ | 出现零次或一次 |
| * | 出现零次或多次 |
| + | 出现一次或多次 |
| {n} | 出现 n 次 |
| {n,m} | 至少出现 n 次但不超过 m 次 |
| {n,} | 至少出现 n 次 |
示例代码如下
import rem = re.search(r'\d?','654321') # 出现数字一次
print(m)m = re.search(r'\d?','ABC') # 出现数字0次
print(m)m = re.search(r'\d*','654321') # 出现数字多次
print(m)m = re.search(r'\d+','654321') # 出现数字多次
print(m)m = re.search(r'\d+','ABC') # 不匹配
print(m)m = re.search(r'\d{8}','87654321') # 出现数字8次
print(m)m = re.search(r'\d{8}','ABC') # 不匹配
print(m)m = re.search(r'\d{9,}','87654321') # 不匹配
print(m)代码运行结果
<re.Match object; span=(0, 1), match='6'>
<re.Match object; span=(0, 0), match=''>
<re.Match object; span=(0, 6), match='654321'>
<re.Match object; span=(0, 6), match='654321'>
None
<re.Match object; span=(0, 8), match='87654321'>
None
NoneProcess finished with exit code 0贪婪量词和懒惰量词
贪婪量词会尽可能多地匹配字符，懒惰量词会尽可能少地匹配字符。Python 中的正则表达式量词默认是贪婪的，要想使用懒惰量词在后面加“？”即可。
示例代码如下
import re# 贪婪量词，会匹配数字 8 次
m = re.search(r'\d{5,8}','87654321') # 出现数字8次
print(m)
# 懒惰量词，会匹配数字 5 次
m = re.search(r'\d{5,8}?','87654321') # 出现数字8次
print(m)代码运行结果
<re.Match object; span=(0, 8), match='87654321'>
<re.Match object; span=(0, 5), match='87654'>分组
如果想让一个字符串作为整体使用量词，则需要对整体字符串进行分组，也称子表达式。
定义分组
定义正则表达式分组，则需要将字符串放到一对小括号中。
示例代码如下
import rep = r'(121){2}'
m = re.search(p,'121121abcabc')
print(m)
print(m.group()) # 返回匹配字符串
print(m.group(1)) # 获得第一组内容p = r'(\d{3,4}-\d{7,8})'
m = re.search(p, '010-87654321')
print(m)
print(m.group()) # 返回匹配字符串
print(m.groups()) # 获得所有组内容代码运行结果
<re.Match object; span=(0, 6), match='121121'>
121121
121
<re.Match object; span=(0, 12), match='010-87654321'>
010-87654321
('010-87654321',)Process finished with exit code 0其中上面代码调用 match 对象的 group() 方法返回匹配的字符串，group() 方法语法如下：
match.group([1,...])
其中 1 代表组编号，在正则表达式中组编号是从 1 开始的命名分组
在 Python 中访问分组时，除了可以通过组编号进行访问，还可以通过组名进行访问，前提是要在正则表达式中为组命名，组命名通过在组开头添加“?P<组名>”实现。当在程序中访问这些带有名字的组时，可以通过组编号或组名字进行访问。
反向引用分组
除了可以在程序代码中访问正则表达式匹配之后的分组内容，还可以在正则表达式内部访问之前的分组，称为“反向引用分组”。正则表达式中反向引用语法是“\组编号”，组编号是从1开始的。如果组有名字，也可以用组名反向引用，语法是“(?P=组名)”。
示例代码如下
import rep = r'<([\w]+)>.*</([\w]+)>' # 用于匹配 HTML 或 XML 等标记语言中的标签结构，并捕获标签的名称。m = re.search(p,'<a>abc</a>')
print(m)m = re.search(p,'<a>abc</b>')
print(m)# 使用组编号反向引用
print()
p = r'<([\w]+)>.*</\1>'
'''
使用组名来反向引用
p = r"<(?P<tag>[\w]+)>.*</(?P=tag)>"
'''m = re.search(p,'<a>abc</a>')
print(m)m = re.search(p,'<a>abc</b>')
print(m)代码运行结果
<re.Match object; span=(0, 10), match='<a>abc</a>'>
None<re.Match object; span=(0, 10), match='<a>abc</a>'>
NoneProcess finished with exit code 0非捕获分组
前文介绍的分组称为“捕获分组”。捕获分组的匹配结果被暂时保存到内存中，以备正则表达式或其他程序引用。这个过程称为“捕获”，捕获结果可以通过组编号或组名进行引用。能够反向引用分组就是因为分组时捕获的。如果正则表达式比较复杂，要处理的文本有很多，可能严重影响性能。因此当使用分组，又不需要引用分组时，可使用“非捕获分组”，在组开头使用“?:” 可以实现非捕获分组。需要注意非捕获分组不会匹配组内容。
示例代码如下
import rep = r'(?:121){2}'
m = re.search(p,'121121abcabc')
print(m)
print(m.group())print()
p = r'(?:\d{3,4}-(?:\d{7,8}))'
m = re.search(p,'010-12345678')
print(m)
print(m.group())
print(m.groups())代码运行结果
<re.Match object; span=(0, 6), match='121121'>
121121<re.Match object; span=(0, 12), match='010-12345678'>
010-12345678
()Process finished with exit code 0re模块中重要函数
re是Python内置的正则表达式模块
search() 和 match() 函数
| 函数名 | 说明 |
|---|---|
| search(a,b) | 在输入的字符串中查找，返回第一个匹配的内容，如果找到则match 对象；如果没有找到则返回None；其中参数 a 为查找的规则（正则表达式），参数 b 为要查找的字符串 |
| match(a,b) | 在输入的字符串开始处查找匹配内容，如果找到一个则match 对象；如果没有找到则返回None；其中参数 a 为查找的规则（正则表达式），参数 b 为要查找的字符串 |
| 函数名 | 说明 |
|---|---|
| group() | 返回匹配的字符串 |
| start() | 返回子字符串的开始索引 |
| end() | 返回子字符串的结束索引 |
| span() | 返回子字符串的跨度 |
示例代码如下
import rep = r'\w+@zhangsan\.com'text = "Tony's email is tony_guan588@zhangsan.com"
m = re.search(p,text)
print(m) # successfulm1 = re.match(p,text)
print(m1) #failtext1 = "tony_guan588@zhangsan.com"
m1 = re.match(p,text1)
print(m1) # successful
# match对象的几个方法：
print()
print(m1.group()) # 返回匹配的字符串
print(m1.start()) # 返回子字符串的开始索引
print(m1.end()) # 返回子字符串的结束索引
print(m1.span()) # 返回子字符串的跨度代码运行结果
<re.Match object; span=(16, 41), match='tony_guan588@zhangsan.com'>
None
<re.Match object; span=(0, 25), match='tony_guan588@zhangsan.com'>tony_guan588@zhangsan.com
0
25
(0, 25)Process finished with exit code 0findall() 和 finditer() 函数
示例代码如下
import rep = r'[Pp]ython'
text = 'I like Python and python'match_list = re.findall(p,text) # 返回match 列表对象
print(match_list)match_iter = re.finditer(p,text) # 返回可迭代对象
for m in match_iter:print(m.group())代码运行结果
['Python', 'python']
Python
pythonProcess finished with exit code 0字符串分割
字符串分割使用 split() 函数，该函数按照匹配的子字符串进行字符串分割，返回字符串列表对象，split()函数语法如下
re.split(pattern,string,maxsplit = 0,flags = 0)其中参数 pattern 是正则表达式；参数 string 是要分割的子字符串；参数 maxsplit 是最大分割次数，默认值为0，表示分割次数没有限制；参数 flags 是编译标志。
示例代码如下
import rep = r'\d+'# 根据匹配的规则即匹配到数字就分割
text = 'AB12CD34EF'
clist = re.split(p,text)
print(clist)text1 = 'AB12CD34EF56'
clist1 = re.split(p,text1)
print(clist1)clist2 = re.split(p,text,maxsplit=1) # 设置最大分割次数为1
print(clist2)clist3 = re.split(p,text,maxsplit=2) # 设置最大可能分割次数为2
print(clist3)代码运行结果
['AB', 'CD', 'EF']
['AB', 'CD', 'EF', '']
['AB', 'CD34EF']
['AB', 'CD', 'EF']Process finished with exit code 0字符串替换
字符串替换使用 sub() 函数，该函数用于替换匹配的子字符串，返回值是替换之后的字符串，其语法如下
re.sub(pattern,rep,string,count=0,flags=0)其中参数 pattern 是正则表达式；参数 rep 是替换字符串；参数 string 是要提供的字符串；参数 count 是要替换的最大数量，默认值为0，表示替换数量没有限制；参数 flags 是编译标志。
示例代码如下
import rep = r'\d+'
text = 'AB12CD34EF56'replace_text = re.sub(p,' ',text)
print(replace_text)replace_text1 = re.sub(p,' ',text,count=1) # 只替换一次
print(replace_text1)代码运行结果
AB CD EF
AB CD34EF56Process finished with exit code 0编译正则表达式
编译的正则表达式可以重复使用，这样能减少正则表达式的解析和验证，提高效率。在 re 模块中的 compile() 函数可以编译正则表达式，其语法如下：
re.compile(pattern [, flags=0])其中参数 pattern 是正则表达式，参数 flags 是编译标志，compile() 函数返回一个编译的正则表达式对象 regex。
已编译正则表达式对象
compile() 函数返回一个编译的正则表达式对象，该对象也提供了与 re 模块类似的方法。下面表格中参数 pos 为开始查找索引，参数 endpos 为结束查找索引。
| 常用函数 | 已编译正则表达式对象方法 | re 模块函数 |
|---|---|---|
| search() | regex.search(string[,pos[,endpos]]) | re.search(pattern,string,flags=0) |
| match() | regex.match(string[pos,[endpos]]) | re.match(pattern,string,flags=0) |
| findall | regex.findall(string[pos,[endpos]]) | re.findall(pattern,string,flags=0) |
| finditer() | regex.finditer(string[pos,[endpos]]) | re.finditer(pattern,string,flags=0) |
| sub() | regex.sub(repl,string,count=0) | re.sub(pattern,repl,string,count=0,flags=0) |
| split() | regex.split(string,maxsplit=0) | re.split(pattern,string,maxsplit=0,flags=0) |
示例代码如下
import re# 通过编译的正则表达式对象 regex 调用方法实现文本匹配、查找和替换操作 p = r'\w+@zhangsan\.com'
regex = re.compile(p) # 编译正则表达式text = "Tom's email is tom_guan588@zhangsan.com."
m = regex.search(text)
print(m)p1 = r'[Pp]ython'
regex1 = re.compile(p1) # 编译正则表达式
text1 = 'I like Python and python'
match_list = regex1.findall(text1)
print(match_list)match_iter = regex1.finditer(text1)
for m in match_iter:print(m)p = r'\d+'
regex = re.compile(p) # 编译正则表达式
text3 = 'AB12CD34EF56'
clist = regex.split(text3)
print(clist)
replace_text = regex.sub(' ',text3)
print(replace_text)代码运行结果
<re.Match object; span=(15, 39), match='tom_guan588@zhangsan.com'>
['Python', 'python']
<re.Match object; span=(7, 13), match='Python'>
<re.Match object; span=(18, 24), match='python'>
['AB', 'CD', 'EF', '']
AB CD EF Process finished with exit code 0编译标志
compile() 函数编译正则表达式对象时，还可以设置编译标志。编译标志可以改变正则表达式引擎行为。
（1）ASCII 和 Unicode
通过编译标志 re.ASCII（或re.A）设置采用ASCII编码，通过编译标志 re.UNICODE（或re.U）设置采用 Unicode 编码。
示例代码如下
import retext = '你们好 Hello'p = r'\w+'
regex = re.compile(p,re.U) # 设置采用Unicode编码，此时所有字符都可以匹配m = regex.search(text)
print(m)m = regex.match(text)
print(m)regex = re.compile(p,re.A) # 设置采用ASCII编码，此时中文并不会显示出来m = regex.search(text)
print(m)m = regex.match(text) # 匹配失败，因为开头为中文，而ASCII编码并没有中文
print(m)代码运行结果
<re.Match object; span=(0, 3), match='你们好'>
<re.Match object; span=(0, 3), match='你们好'>
<re.Match object; span=(4, 9), match='Hello'>
NoneProcess finished with exit code 0（2）忽略大小写
默认情况下正则表达式引擎对大小写是敏感的，可以通过 re.IGNORECASE（或re.I）实现忽略大小写。
示例代码如下
import rep = r'(java).*(python)'
regex = re.compile(p,re.I)m = regex.search('I like Java and Python.')
print(m)m1 = regex.search('I like JAVA and Python.')
print(m1)代码运行结果
<re.Match object; span=(7, 22), match='Java and Python'>Process finished with exit code 0（3）点元字符匹配换行符
默认情况下正则表达式引擎中点 “.” 元字符可以匹配除换行符外的任何字符，但是有时候需要点 “.” 元字符也能匹配换行符，此时可以通过 re.DOTALL（或re.S）实现。
示例代码如下
import rep = r'.+'
regex = re.compile(p) # 没有设置编译标志m = regex.search('Hello\nWorld.')
print(m)regex1 =re.compile(p,re.DOTALL)m1 = regex1.search('Hello\nWorld.')
print(m1)代码运行结果
<re.Match object; span=(0, 5), match='Hello'>
<re.Match object; span=(0, 12), match='Hello\nWorld.'>Process finished with exit code 0（4）多行模式
编译标志 re.MULTILINE（或 re.M）可以设置多行模式，默认情况下 ^ 和 $ 匹配字符串的开始和结束，而在多行模式下 ^ 和 $ 匹配任意一行的开始和结束。
示例代码如下
import rep = r'^World'
regex = re.compile(p) # 未设置多行模式m = regex.search('Hello\nWorld.')
print(m)regex1 = re.compile(p,re.M) # 设置多行模式m1 = regex1.search('Hello\nWorld.')
print(m1)代码运行结果
None
<re.Match object; span=(6, 11), match='World'>Process finished with exit code 0（5）详细模式
编译标志 re.VERBOSE（或 re.X）可以设置详细模式，详细模式下可以在正则表达式中添加注释，可以有空格和换行。
示例代码如下
import rep = '''(java) # 匹配java字符串.* # 匹配任意字符零或多个(python) # 匹配Python字符串'''
# 由于正则表达式中包含了换行等符号，所以需要使用双重单引号或三重单引号括起来，而不是原始字符串regex = re.compile(p,re.I | re.VERBOSE) # 设置了两个编译标志m = regex.search('I like Java and Python.')
print(m)m1 = regex.search('I like JAVA and Python.')
print(m1)m2 = regex.search('I like java and Python.')
print(m2)代码运行结果
<re.Match object; span=(7, 22), match='Java and Python'>
<re.Match object; span=(7, 22), match='JAVA and Python'>
<re.Match object; span=(7, 22), match='java and Python'>Process finished with exit code 0参考书籍：《python从小白到大牛》（第2版）关东升 编著
文章创作不易，本文共11000+字，为了大家能理解，写的很详细，这也让我花了很多时间。最后，如果觉得本文对大家有帮助的话，还请给我点个赞和关注，谢谢大家！！！