👏作者简介：大家好，我是爱敲代码的小王，CSDN博客博主,Python小白
📕系列专栏：python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
📧如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀
🔥如果感觉博主的文章还不错的话，请👍三连支持👍一下博主哦
🍂博主正在努力完成2023计划中：以梦为马，扬帆起航，2023追梦人
🔥🔥🔥 python入门到实战专栏：从入门到实战🔥🔥🔥 Python爬虫开发专栏：从入门到实战
🔥🔥🔥 Python办公自动化专栏：从入门到实战
🔥🔥🔥 Python数据分析专栏：从入门到实战
🔥🔥🔥 Python前后端开发专栏：从入门到实战
目录
[compile 函数](#compile 函数)
[findall 函数](#findall 函数)
原生字符串
和大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可以能造成反斜杠困扰。
【示例】"\"作为转义字符
python
sxiao = 'c:\\a\\b\\c'
print(sxiao )
sxiao = '\n123'
print(sxiao )
sxiao = '\\n123'
print(sxiao )假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表 达式里将需要4个反斜杠"\\"：前面两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成 一个反斜杠。
Python里的原生字符串很好地解决了这个问题，使用Python的r前 缀。例如匹配一个数字的"\d"可以写成r"\d"。有了原生字符串，再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
【示例】Python中的r前缀的使用
python
import re
sxiao = r'\n123'
print(sxiao )
#目标字符串
sxiao = '\\n123'
pattern = '\\n\d{3}'
print(re.match(pattern,sxiao)) #返回None
#如果想匹配两个反斜杠需要使用两个反斜杠作为转义,即正则中要写四个反斜杠
pattern = '\\\\n\d{3}'
print(re.match(pattern,sxiao))
#使用原生字符串r比较方便
pattern = r'\\n\d{3}'
print(re.match(pattern,sxiao))边界字符
注意：
1、^与[ ^m ] 中的"^"的含义并不相同，后者"^"表示"除了...."的意思
【示例】匹配符$的使用
python
import re
#匹配qq邮箱， 5-10位
print('未限制结尾'.center(30,'-'))
pattern = '[\d]{5,10}@qq.com'
print('正确的邮箱匹配结果：\n',re.match(pattern,'2423@qq.com'))
print('不正确的邮箱匹配结果：\n',re.match(pattern,'2423@qq.comabc'))
print('限制结尾'.center(30,'-'))
pattern = '[1-9]\d{4,9}@qq.com$'
print('正确的邮箱匹配结果：\n',re.match(pattern,'2423@qq.com'))
print('不正确的邮箱匹配结果：\n',re.match(pattern,'2423@qq.comabc'))【示例】匹配符^的使用
python
import re
sxiao='hello python'
pattern=r'^hello.*'
print('匹配字符串hello python的结果：\n',re.match(pattern,sxiao))
sxiao='hepython'
pattern=r'^hello.*'
print('匹配字符串hepython的结果：\n',re.match(pattern,sxiao))【示例】\b 匹配单词边界
python
pattern = r'.*\bab'
#ab左边界的情况
vxiao = re.match(pattern,'123 abr')
print(vxiao )
pattern = r'.*ab\b'
#ab为右边界的情况
vxiao = re.match(pattern,'wab')
print(vxiao )【示例】\B 匹配非单词边界
python
#ab不为左边界
pattern = r'.*\Bab'
vxiao = re.match(pattern,'123 abr')
print(vxiao)
#ab不为右边界
pattern = r'.*ab\B'
vxiao= re.match(pattern,'wab')
print(vxiao)search函数
search在一个字符串中搜索满足文本模式的字符串。
语法格式如下：
python
re.search(pattern, string, flags=0)函数参数与match类似
|---------|----------------------------------------------------------|
| 参数 | 描述 |
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。如下表列出正则表达式修饰符 - 可选标志 |
【示例】search函数的使用
python
import re
mxiao=re.search('abc','abcdefg')
print(mxiao)
print(mxiao.group())match与search的区别
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串， 直到找到一个匹配。
【示例】match方法与search方法的使用对比
python
import re
#进行文本模式匹配，匹配失败，match方法返回None
mxiao=re.match('love','I love you')
if mxiaois not None:
print(mxiao.group())
print('match运行结果：',mxiao)
#进行文本模式搜索，
mxiao=re.search('love','I love you')
if mxiaois not None:
print(mxiao.group())
print('search的运行结果：',mxiao)择一匹配（|）的使用
search方法搜索一个字符串，要想搜索多个字符串，如搜索aa、bb 和cc，最简单的方法是在文本模式字符串中使用择一匹配符号 （|)。择一匹配符号和逻辑或类似，只要满足任何一个，就算匹配 成功。
【示例】择一匹配符号（|）的使用
python
import re
sxiao='aa|bb|cc'
#match进行匹配
mxiao=re.match(sxiao,'aa') #aa满足要求，匹配成功
print(mxiao.group())
mxiao=re.match(sxiao,'bb') #bb满足要求，匹配成功
print(mxiao.group())
#search查找
mxiao=re.search(sxiao,'Where is cc')
print(mxiao.group())【示例】匹配0-100之间所有的数字
python
import re
pattern = '[1-9]?\d$|100$'
print(re.match(pattern,'0'))
print(re.match(pattern,'10'))
print(re.match(pattern,'100'))
print(re.match(pattern,'99'))
print(re.match(pattern,'200'))如果待匹配的字符串中，某些字符可以有多个选择，就需要使用字符集（[]），也就是一对中括号括起来的字符串。例如，[xyz]表示 x、y、z三个字符可以取其中任何一个，相当于"x|y|z"，所以对单个字符使用或关系时，字符集和择一匹配符的效果是一样的。
示例如下：
【示例】字符集（[]）和择一匹配符(|)完成相同的效果
python
import re
mxiao=re.match('[xyz]','x') #匹配成功
print(mxiao.group())
mxiao=re.match('x|y|z','x') #匹配成功
print(mxiao.group())【示例】字符集（[]）和择一匹配符(|)的用法，及它们的差异
python
import re
#匹配以第1个字母是a或者b，第2个字母是c或者d，如ac、bc、ad、bd
mxiao =re.match('[ab][cd]','aceg')
print(mxiao)
#匹配以ab开头，第3个字母是c或者d，如abc、abd
mxiao =re.match('ab[cd]','abcd')
print(mxiao)
#匹配ab或者cd
mxiao =re.match('ab|cd','cd')
print(mxiao)分组
如果一个模式字符串中有用一对圆括号括起来的部分，那么这部分就会作为一组，可以通过group方法的参数获取指定的组匹配的字符串。当然，如果模式字符串中没有任何用圆括号括起来的部分， 那么就不会对待匹配的字符串进行分组。
【示例】匹配座机号码
python
pattern = r'(\d+)-(\d{5,8}$)'
vxiao = re.match(pattern,'010-66668888')
print(vxiao)
print(vxiao.group())
print(vxiao.group(1))
print(vxiao.group(2))
print(vxiao.groups())
print(vxiao.groups()[0])
print(vxiao.groups()[1])【示例】\num 的使用
python
import re
#匹配合法的网页标签
sxiao = '<html><title>我是标题</title></html>'
#匹配不合法的网页标签
ssxiao = '<html><title>我是标题</html></title>'
#优化前
pattern = r'<.+><.+>.+</.+></.+>'
print(re.match(pattern,sxiao))
print(re.match(pattern,ssxiao))
#优化后 可以使用分组 \2 表示引用第2个分组 \1表示
引用第1个分组
pattern = r'<(.+)><(.+)>.+</\2></\1>'
print(re.match(pattern,sxiao))
print(re.match(pattern,ssxiao))【示例】?P (?P=起好的别名)
python
sxiao = '<html><h1>我是一号字体</h1></html>'
# pattern = r'<(.+)><(.+)>.+</\2></\1>'
#如果分组比较多的话，数起来比较麻烦，可以使用起别名的方法?P<要起的名字> 以及使用别名(?P=之前起的别名)
pattern = r'<(?P<key1>.+)><(?P<key2>.+)>.+</(?P=key2)></(?P=key1)>'
vxiao = re.match(pattern,sxiao)
print(vxiao )使用分组要了解如下几点：
1、只有圆括号括起来的部分才算一组，如果模式字符串中既有圆括号括起来的部分，也有没有被圆括号括起来的部分，那么只会将被圆括号括起来的部分算作一组，其它的部分忽略。
2、用group方法获取指定组的值时，组从1开始，也就是说，group(1)获取第1组的值，group(2)获取第2组的值，以此类推。
3、groups方法用于获取所有组的值，以元组形式返回。所以除了使用group(1)获取第1组的值外，还 可以使用groups()[0]获取第1组的值。获取第2组以及其它组的值的方式类似。
re模块中其他常用的函数
sub和subn搜索与替换
sub函数和subn函数用于实现搜索和替换功能。这两个函数的功能几乎完全相同，都是将某个字符串中所有匹配正则表达式的部分替 换成其他字符串。用来替换的部分可能是一个字符串，也可以是一个函数，该函数返回一个用来替换的字符串。sub函数返回替换后的结果，subn函数返回一个元组，元组的第1个元素是替换后的结 果，第2个元素是替换的总数。
语法格式如下：
python
re.sub(pattern, repl, string, count=0,flags=0)|---------|-----------------------------|
| 参数 | 描述 |
| pattern | 匹配的正则表达式 |
| repl | 替换的字符串，也可为一个函数 |
| string | 要被查找替换的原始字符串。 |
| count | 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配 |
【示例】sub和subn方法的使用
python
import re
phone = "2004-959-559 # 这是一个国外电话号码"
# 删除字符串中的 Python注释
numtong = re.sub(r'#.*$', "", phone)
print("电话号码是: ", numtong )
# 删除非数字(-)的字符串
numtong = re.sub(r'\D', "", phone)
print("电话号码是 : ", numtong )
#subn函数的使用
result=re.subn(r'\D', "", phone)
print(result)
print('替换的结果：',result[0])
print('替换的次数：',result[1])compile 函数
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。语法格式为：
python
re.compile(pattern[, flags])|---------|--------------------------|
| 参数 | 描述 |
| pattern | 一个字符串形式的正则表达式 |
| flags | 可选，表示匹配模式，比如忽略大小写，多行模式等， |
【示例】compile 函数的使用
python
import re
sxiao='first123 line'
regex=re.compile(r'\w+') #匹配至少一个字母或数字
mtong=regex.match(sxiao)
print(mtong.group())
# s 的开头是 "f", 但正则中限制了开始为 i 所以匹配失败
regex = re.compile("^i\w+")
print(regex.match(sxiao))findall 函数
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表， 如果没有找到匹配的，则返回空列表。语法格式如下：
python
findall(pattern, string, flags=0)|---------|----------------------------------------------------------|
| 参数 | 描述 |
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。如下表列出正则表达式修饰符 - 可选标志 |
【示例】findall 函数的使用
python
import re
pattern=r'\w+'
sxiao='first 1 second 2 third 3'
otong=re.findall(pattern,sxiao)
print(otong)注意：
match 和 search是匹配一次 findall 匹配所有
finditer函数
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
【示例】finditer函数的使用
python
pattern=r'\w+'
sxiao='first 1 second 2 third 3'
otong=re.finditer(pattern,sxiao)
print(otong)
for i in otong:
print(i.group())split函数
split函数用于根据正则表达式分隔字符串，也就是说，将字符串与模式匹配的子字符串都作为分隔符来分隔这个字符串。split函数返回一个列表形式的分隔结果，每一个列表元素都是分隔的子字符 串。
语法格式如下：
python
re.split(pattern, string[, maxsplit=0,flags=0])|----------|--------------------------------------|
| 参数 | 描述 |
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串。 |
| maxsplit | 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。 |
【示例】split函数的使用
python
import re
stong='first 11 second 22 third 33'
#按数字切分
print(re.split(r'\d+',stong))
# maxsplit 参数限定分隔的次数，这里限定为1，也就是只分隔一次
print(re.split(r'\d+',stong,1))贪婪模式和非贪婪模式
贪婪模式指Python里数量词默认是贪婪的，总是尝试匹配尽可能多的字符。非贪婪模式与贪婪相反，总是尝试匹配尽可能少的字符， 可以使用**"*"，"?"，"+"，"{m,n}"**后面加上？，使贪婪变成非贪婪。
【示例】贪婪模式，.+中的'.'会尽量多的匹配
python
vtong = re.match(r'(.+)(\d+-\d+-\d+)','This is my tel:133-1234-1234')
print('----------贪婪模式---------')
print(vtong .group(1))
print(vtong .group(2))
print('----------非贪婪模式---------')
vtong = re.match(r'(.+?)(\d+-\d+-\d+)','This is my tel:133-1234-1234')
print(vtong .group(1))
print(vtong .group(2))【示例】贪婪模式非贪婪模式测试
python
print('贪婪模式')
vtong= re.match(r'abc(\d+)','abc123')
print(vtong.group(1))
#非贪婪模式
print('非贪婪模式')
vtong= re.match(r'abc(\d+?)','abc123')
print(vtong.group(1))