1.使用场景：
1.-爬数据：爬取某个网站信息
2.洗数据：清理某个网站的广告信息
3.验数据：验证手机号等
2.re模块的使用过程
1. 导入模块 import re
2. 验证匹配： ret=re.match("正则表达式","要匹配的字符串")
re.match("itcast","itcast.cn")
3. 验证匹配是否成功
返回值为空，则失败
返回值不为空，则匹配成功
4. 取得匹配结果
ret.group()
3.匹配命令格式：
--'.':表示匹配任意一个字符，除\n换行以外
In [3]: ret = re.match("a.c","aac")
In [4]: ret
Out[4]: <_sre.SRE_Match object; span=(0, 3), match='aac'>
--[] :表示匹配[]中的字符
In [5]: ret = re.match("速度与激情[0-9]","速度与激情7")
In [6]: ret
Out[6]: <_sre.SRE_Match object; span=(0, 6), match='速度与激情7'>
提示：[^]表示对里面列举的字符取反
In [11]: ret = re.match("速度与激情[^0-9]","速度与激情p")
In [12]: ret
Out[12]: <_sre.SRE_Match object; span=(0, 6), match='速度与激情p'>
--\d表示匹配数字，即0-9 \表示转义
In [13]: ret = re.match("速度与激情\d","速度与激情8")
In [14]: ret
Out[14]: <_sre.SRE_Match object; span=(0, 6), match='速度与激情8'>
--\D表示匹配非数字，即不是数字
ret = re.match("速度与激情\D","速度与激情8")
In [16]: ret
In [17]: ret = re.match("速度与激情\D","速度与激情s")
In [18]: ret
Out[18]: <_sre.SRE_Match object; span=(0, 6), match='速度与激情s'
--\s :表示匹配空白，包含空格和tap键，回车和换行\n
In [44]: ret = re.match("速度与激情\s","速度与激情 ")
In [45]: ret
Out[45]: <_sre.SRE_Match object; span=(0, 6), match='速度与激情 '>
In [50]: ret = re.match("速度与激情\s","速度与激情\n")
In [51]: ret
Out[51]: <_sre.SRE_Match object; span=(0, 6), match='速度与激情\n'>
--\S:表示匹配非空白
In [58]: ret = re.match("速度与激情\S","速度与激情S")
In [59]: ret
Out[59]: <_sre.SRE_Match object; span=(0, 6), match='速度与激情S'>
--\w:表示匹配单词字符 即包含（0-9，a-z A-Z,_）数字，小写字母大写字母下划线
In [60]: ret = re.match("速度与激情\w","速度与激情dd")
In [61]: ret
Out[61]: <_sre.SRE_Match object; span=(0, 6), match='速度与激情d'>
In [62]: ret = re.match("速度与激情\w","速度与激情5")
In [63]: ret
Out[63]: <_sre.SRE_Match object; span=(0, 6), match='速度与激情5'>
In [64]: ret = re.match("速度与激情\w","速度与激情_")
In [65]: ret
Out[65]: <_sre.SRE_Match object; span=(0, 6), match='速度与激情_'>
--\W:表示匹配非单词字符
In [66]: ret = re.match("速度与激情\W","速度与激情*")
In [67]: ret
Out[67]: <_sre.SRE_Match object; span=(0, 6), match='速度与激情*'>
In [68]: ret = re.match("速度与激情\W","速度与激情0")
In [69]: ret
--{m}:匹配前一个字符出现的m次
ret = re.match("1\d{10}","12222222222")
In [73]: ret
Out[73]: <_sre.SRE_Match object; span=(0, 11), match='12222222222'>
--{m,n}:表示匹配前一个字符出现m到n次
In [84]: ret = re.match("\d{1,11}","12222222222")
In [85]: ret
Out[85]: <_sre.SRE_Match object; span=(0, 11), match='12222222222'>
In [86]:
In [86]: ret = re.match("0\d{2,3}-\d{7,8}","0773-7459765")
In [87]: ret
Out[87]: <_sre.SRE_Match object; span=(0, 12), match='0773-7459765'>
--？：表示前一个字符出现1次或者0次，要么出现一次，要么一次都没有
In [88]: ret = re.match("0\d{2,3}-?\d{7,8}","0773-7459765")
In [89]: ret
Out[89]: <_sre.SRE_Match object; span=(0, 12), match='0773-7459765'>
In [90]: ret = re.match("0\d{2,3}-?\d{7,8}","07737459765")
In [91]: ret
Out[91]: <_sre.SRE_Match object; span=(0, 11), match='07737459765'>
--*:表示匹配一个字符出现0次或者多次
In [153]: ret =re.match(".*",connect,re.S)
In [154]: ret
Out[154]: <_sre.SRE_Match object; span=(0, 49), match='sfefefgegwgwg\nfbbdbfnyny\nfergagrahbath\nbebatnn>
In [156]: ret =re.match(".*","sss")
In [157]: ret
Out[157]: <_sre.SRE_Match object; span=(0, 3), match='sss'>
In [158]: ret =re.match(".*","")
In [159]: ret
Out[159]: <_sre.SRE_Match object; span=(0, 0), match=''>
--+：匹配一个字符出现1次或者无限次，即最少有一次
In [162]: ret =re.match("a+","aaaa")
In [163]: ret
Out[163]: <_sre.SRE_Match object; span=(0, 4), match='aaaa'>
In [164]: ret =re.match("a+","")
In [165]: ret
--^:匹配以xxx开头的字符串
In [169]: ret= re.match('^itcast','itcast.cn')
In [170]: ret
Out[170]: <_sre.SRE_Match object; span=(0, 6), match='itcast'>
In [171]: ret =re.match("^aaassdsd","aaassdsd")
In [172]: ret
Out[172]: <_sre.SRE_Match object; span=(0, 8), match='aaassdsd'>
--$:匹配以xxx结尾的字符串
In [173]: ret =re.match("aaassdsd$","aaassdsd")
In [174]: ret
Out[174]: <_sre.SRE_Match object; span=(0, 8), match='aaassdsd'>
In [175]: ret =re.match("^1\d{10}$","12345678911")
In [176]: ret
Out[176]: <_sre.SRE_Match object; span=(0, 11), match='12345678911'>
4.匹配分组
1. | ：匹配左右任意一个表达式，相当于或者
In [177]: ret =re.match("\w{4,20}@163.com$|\w{4,20}@qq.com$","sdssd@qq.com")
In [178]: ret
Out[178]: <_sre.SRE_Match object; span=(0, 12), match='sdssd@qq.com'>
2.(ab):分组
说明：这里的分组默认情况下一整串都是一个大组，里面再有括号则是第一组，依次下去
In [181]: ret =re.match("\w{4,20}@(163|qq|126).com$","sdssd@163.com")
In [182]: ret
Out[182]: <_sre.SRE_Match object; span=(0, 13), match='sdssd@163.com'>
In [183]: ret.group(1)
Out[183]: '163'
In [184]: ret.group(0)
Out[184]: 'sdssd@163.com'
In [185]: ret =re.match("(\w{4,20})@(163|qq|126).com$","sdssd@163.com")
In [186]: ret
Out[186]: <_sre.SRE_Match object; span=(0, 13), match='sdssd@163.com'>
In [187]: ret.group(1)
Out[187]: 'sdssd'
3.\.num:引用分组num匹配到的字符串，也就是用括号分组方式获得字符串
示例：检验html网页语法的合法性
语法规则: html双标签必须配对， 比如<h1>dsafagd</h1>
# 错误的写法，在python中，、\1返回的是一个奇怪的字符
ret=re.match('<(\w+)>.*</\1>','<h1>dsafagd</h1>')
#正确的写法，需要对\再进行转义，回到原来的本义 \\1
ret=re.match('<(\w+)>.*</\\1>','<h1>dsafagd</h1>')
4. (?P<name>):分组起别名
5. (?P=name) : 引用别名为name分组匹配到的字符串
示例：检验html网页语法的合法性
语法规则: html双标签必须配对， 比如<body><h1>dsafagd</h1></body>
1. ret=re.match('<(\w+)><(\w+)>.*</\\2></\\1>','<body><h1>dsafagd</h1></body>')
2. ret=re.match('<(?P（）<p1>\w+)><(?P<p2>\w+)>.*</(?P=p2)></(?P=p1)>','<body><h1>dsafagd</h1></body>')
5. re模块的高级用法
1.re.search(): 查找匹配的数据，匹配到第一个则立即返回，返回的是match对象
"""
a>re.search() ：查找匹配的数据，匹配到第一个则立即返回，返回的是match对象
语法:re.search("正则表达式","查找的字符串或者文本")
示例：匹配微信公众号文章阅读的次数
文本如下： "本文章阅读次数: 9998次，博客的阅读次数: 50"
"""
import re
def main():
conect = "本文章阅读次数: 9998次，博客的阅读次数: 50"
ret = re.search("\d+",conect)
print(ret.group())#9998,匹配到第一个则立即返回
if __name__ == '__main__':
main()
2.re.findall():查找字符串中所有匹配的数据，返回的是列表
"""
语法:re.findall("正则表达式","查找的字符串或者文本")
查找字符串中所有匹配的数据，返回的是列表
示例：找到本文的所有数字
文本如下:"本文章阅读次数: 9998次，博客的阅读次数: 50"
"""
import re
def main():
conect = "本文章阅读次数: 9998次，博客的阅读次数: 50"
ret = re.findall("\d+",conect)
print(ret)#9998,查找字符串中所有匹配的数据，返回的是列表
if __name__ == '__main__':
main()
3.re.sub():查找与替换，返回的是替换后的字符
In [201]: def add (match):
...: strNum = match.group()
...: num=int(strNum)+1
...: return str(num)
...:
In [202]: ret = re.sub("\d+",add,"本文章阅读次数: 9998次，博客的阅读次数: 50")
In [203]: ret
Out[203]: '本文章阅读次数: 9999次，博客的阅读次数: 51'
4.split:按照规则分离字符串，返回的是分离后的列表
In [209]: ret = re.split(" ","wang 22 jijjji wddwd:dwdd")
In [210]: ret
Out[210]: ['wang', '22', 'jijjji', 'wddwd:dwdd']
In [211]: ret = re.split(" |:","wang 22 jijjji wddwd:dwdd")
In [212]: ret
Out[212]: ['wang', '22', 'jijjji', 'wddwd', 'dwdd']
6.贪婪与非贪婪
1.python里数量词默认都是贪婪的，(在少数语言中可能是非贪婪)，总是尝试匹配更多的字符，非贪婪相反，总是尝试匹配尽可能少的字符
2.贪婪与非贪婪的大前提，在满足整体匹配结果的情况下
3.在”*“，”？“，”+“，”{m,n}“后面加上”？“，使贪婪变成非贪婪
7.r的作用：
1.python中字符串前面加上r表示原生字符串
2.大多数编程语言相同，正则表达式里使用“\”作为转义字符，这可能会造成反斜杠困扰
所以加r后完美避免了这个问题
python 正则表达式详解
最新推荐文章于 2025-08-05 20:41:21 发布
扫一扫
7355
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
