189 8069 5689
这篇文章主要介绍“怎么理解并掌握python正则表达式和re模块”，在日常操作中，相信很多人在怎么理解并掌握python正则表达式和re模块问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”怎么理解并掌握python正则表达式和re模块”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！
1.正则表达式
正则表达式，又称规则表达式。(英语：Regular Expression，在代码中常简写为regex、regexp或RE)，计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。
下面是正则表达式常见的使用场景：
检查字符串的合法性
验证用户名 (a-z，0-9，不能全是数字，不能全是字母)
验证邮箱格式 (xxx@qq.com)
验证电话号码 (11位数字)
验证身份证 (18位 )
验证号码格式(5-12纯数字，第一位不能为0);
提取字符串中信息
提取一条短信中数字;
提取文件名的后缀;
采集器(网络爬虫)
替换字符串
替换字符串中的非法字符;
对电话号码进行屏蔽;(1852****0102)
替换占位符 “hello {{name}} ” hello 王老二 (模板框架)
分割字符串
将一个字符串按照指定的规则进行分割;
通俗地说，正则的功能是检索特定形式的字符串，对象是字符串。
1.1 元字符
使用元字符匹配单个字符
字符 功能
. 匹配任意1个字符(除了\n)
[ ] 匹配[ ]中列举的字符
\d 匹配数字，即0-9
\D 匹配非数字，即不是数字
\s 匹配空白，即 空格，tab键
\S 匹配非空白
\w 匹配单词字符，即a-z、A-Z、0-9、_
\W 匹配非单词字符
* 匹配前一个字符出现0次或者无限次，即可有可无
+ 匹配前一个字符出现1次或者无限次，即至少有1次
import re
text = '''
这是用来匹配的字符串
from:1427319758@qq.com
tel:88888888
'''
针对上述字符串进行元字符的正则匹配演示
使用点.匹配任意字符
res = re.findall('.',text)
print(res)
运行结果(注意返回的是列表)：
['这', '是', '用', '来', '匹', '配', '的', '字', '符', '串', 'f', 'r', 'o', 'm', ':', '1', '4', '2', '7', '3', '1', '9', '7', '5', '8', '@', 'q', 'q', '.', 'c', 'o', 'm', 't', 'e', 'l', ':', '8', '8', '8', '8', '8', '8', '8', '8']
\d匹配数字
res = re.findall('\d',text)
print(res)
运行结果：
['1', '4', '2', '7', '3', '1', '9', '7', '5', '8', '8', '8', '8', '8', '8', '8', '8', '8']
+ * 匹配多个字符
res = re.findall('\d+',text)
res_1 = re.findall('\d*',text)
print(res,res_1)
运行结果：
['1427319758', '88888888']
['', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '1427319758', '', '', '', '', '', '', '', '', '', '', '', '', '88888888', '', '']
*匹配前一字符可以是0次，因此\d*会匹配每个不是数字的字符，即为空。\d+等同\d\d*
[](字符集)
人为规定只能匹配出现在字符集中的字符，如要找寻字符串中的qq号，qq号不能以0开头，且位数是5~12
可用[1-9]\d{4,11}来限制
邮箱可能出现为字符串，可用[1-9a-zA-Z]\w+[@]\w+[.][a-zA-z]+可以匹配出任意常规格式的邮箱
res = re.findall('[1-9a-zA-Z]\w+[@]\w+[.][a-zA-z]+','''
1427319758@163.com开会就
1427319758@edu.cn是否
1427319758@xx.mail 阿萨德
asdfbglsafhlf上单发顺丰打打分
''')
print(res)
运行结果：
['1427319758@163.com', '1427319758@edu.cn', '1427319758@xx.mail']
使用.*匹配任意多个字符
res = re.findall('.*',text)
print(res)
运行结果：
['', '这是用来匹配的字符串', '', 'from:1427319758@qq.com', '', 'tel:88888888', '', '']
由于re.findall()函数默认遇到换行符 '\n’会终止当前的匹配，即不匹配换行符，每一行单独匹配，因此会出现空元素。
1.2 数量词
使用数量词匹配多个字符
字符 功能
{m} 匹配前一个字符出现m次
{m,n} 匹配前一个字符出现从m到n次
限制匹配字符出现的次数
res = re.findall('[1-9]\d{4,11}',text)
res_1 = re.findall('([1-9]\d{4,11})@',text)
print(res，res_1)
运行结果：
['1427319758', '88888888'] ['1427319758']
第一种方式匹配了同样满足规则的手机号，第二种方式是考虑到qq号隐藏在邮箱地址里，所以在后面加了@来限制匹配的区域，即只匹配@前的第1位非0的5-12位纯数字。
1.3 精确匹配与泛匹配
泛匹配
泛匹配是匹配包括特征字符在内的所有的东西
res = re.findall('Hello.*like','Hello world! I like python!')
print(res)
运行结果：
['Hello world! I like']
精确匹配
精确匹配是匹配括号里面的东西
res_1 = re.findall('Hello(.*)like','Hello world! I like python!')
print(res_1)
运行结果：
[' world! I ']
我想要Hello和like之间的字符，泛匹配的结果会包含首尾的特征字符Hello和like;而精确匹配只会得到特征字符之间的字符串。
1.4 贪婪匹配与非贪婪匹配
Python里数量词默认是贪婪的(在少数语言里也可能是默认非贪婪)，总是尝试匹配尽可能多的字符;
非贪婪则相反，总是尝试匹配尽可能少的字符。
在"*"，"?"，"+"，"{m,n}"后面加上?，使贪婪变成非贪婪。
res = re.findall('Hello(.*)like','Hello world! I like python! I like you!')
res_1 = re.findall('Hello(.*?)like','Hello world! I like python! I like you!')
print(res,res_1)
运行结果：
[' world! I like python! I ']
[' world! I ']
res返回的是贪婪匹配，它会在找到Hello后，匹配尽可能多的字符，然后在最后一个like停下;
res_1返回的是非贪婪匹配，它在找到Hello后，只匹配第一个like前的字符。
2. re模块
一直以来我们都是使用 re.search() 函数，其实在正则表达式模块中还有一些函数可以很方便的对字符串进行操作。re模块的使用可以分为两种：第一种是对象式的方式，第二种是函数式的方式。
2.1 re.match
match() 用于查找字符串的头部(也可以指定起始位置)，它是一次匹配，只要找到了一个匹配的结果就返回，而不是查找所有匹配的结果。它的一般使用形式如下：
match(pattern， string[， flag])
其中，pattern是正则表达式规则字符串，string 是待匹配的字符串，flag 是可选参数。
当匹配成功时，返回一个 Match 对象，如果没有匹配上，则返回 None。
import re
pattern = 'Python'
string = 'dsgfaPythonahsdgjasghPythonasdjajsk'
result = re.match(pattern,string)
result_1 = re.match(pattern,string[5:])
print(result,result_1)
运行结果：
None
<_sre.SRE_Match object; span=(0, 6), match='Python'>
2.2 re.search
search() 用于查找字符串的任何位置，它也是一次匹配，只要找到了一个匹配的结果就返回，而不是查找所有匹配的结果，它的一般使用形式如下：
search(pattern， string[， flag])
当匹配成功时，返回一个 Match 对象，如果没有匹配上，则返回 None。
ret = re.search('\d+', "python = 9999， c = 7890， c++ = 12345")
print(ret.group())
运行结果：
9999
2.3 re.findall 划重点!
上面的 match 和 search 方法都是一次匹配，只要找到了一个匹配的结果就返回。然而，在大多数时候，我们需要搜索整个字符串，获得所有匹配的结果。findall() 的使用形式如下：
findall(pattern， string[， flag])
findall() 以列表形式返回全部能匹配的子串，如果没有匹配，则返回一个空列表。
ret = re.findall(r"\d+", "python = 9999， c = 7890， c++ = 12345")
print(ret)
运行结果：
['9999', '7890', '12345']
2.4 re.split
split()按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
split(pattern， string[， maxsplit， flags])
其中，maxsplit 用于指定大分割次数，不指定将全部分割。
'''
split():
分割字符串 去掉了匹配到的字符串
结果是列表形式
maxsplit: 默认是0 表示全部切割
1 代表切割一次
2 代表切割两次
'''
pattern = '\d+'
string = 'Pythonasdkjasd464654adhuiaghsdk564654akjsdhkashdkja'
result = re.split(pattern,string,2)
print(result)
运行结果：
['Pythonasdkjasd', 'adhuiaghsdk', 'akjsdhkashdkja']
实际上就是面向字符串操作的string.split的升级版
2.5 re.sub
sub()用于替换，使用形式如下：
sub(pattern， repl， string[， count， flags])
第一个参数为对应的正则表达式，第二个参数为要替换成的字符串，第三个参数为源字符串，第四个参数为可选项，代表最多替换的次数，如果忽略不写，则会将符合模式的结果全部替换。
pattern = 'Java'
repl = '********'
string = 'kjasdJavaadhuiaghsdkJavaakjsd'
result = re.sub(pattern,repl,string,1)
print(result)
运行结果：
kjasd********adhuiaghsdkJavaakjsd
string.replace的升级版
参数flags
方法1：
ret = re.sub("\d+", '18', "age = 12")
print(ret)
运行结果：
age = 18
方法2 用函数：
re.sub()的本质是在字符串中检索符合pattern格式的子串，然后把子串当做参数输入repl中，默认的repl功能可以看成是函数，即不论我输入的子串是什么样的，输出都用repl参数代替，此处repl无法跟子串产生关系
def replace(string,repl):
return repl
如果我们要让输出的repl和子串产生关系，如将字符串中的电话号码15654862043输出成1565****043，仅仅通过设定一个repl字符串是不能实现的，就需要在repl处传入一个函数。
import re
text = '''
15654561654
13905641750
15646575635
18976534547
'''
def replace(string):
string = string.group()
repl = string[0:4] + '****' + string[-4:-1]
return repl
ret = re.sub("\d+", repl = replace, string = text)
print(ret)
运行结果：
1565****165
1390****175
1564****563
1897****454
2.6 re.compile
使用 compile() 函数将正则表达式的字符串形式编译为一个 Pattern 对象。通过该对象提供的一系列方法对文本进行匹配查找，获得匹配结果(Match对象)。编译可以实现更高效的匹配查找等。
compile()函数
compile() 函数用于编译正则表达式，生成一个 Pattern 对象，它的一般使用形式如下：
import re
# 将正则表达式编译成 Pattern 对象
pattern_1 = re.compile('\d+', re.S)
pattern_2 = re.compile('\D+', re.l)
pattern_3 = re.compile('\w+', re.S)
之前定义pattern都是不包括flags参数的，因此不用re.compile，仅用赋值语句让pattern = ‘\d+’也能实现，compile函数的优点在于：1.可以包含flags参数;2.形成模块，便于后续复用
results1 = re.findall(pattern_1, '540775360@qq.com')
results2 = re.findall(pattern_2, "python = 9999， c = 7890， c++ = 12345")
results3 = re.findall(pattern_3, "python = 997")
print(results1, results2, results3)
2.7 原生字符串
>>> mm = "c:\\a\\b\\c"
>>> mm
'c:\\a\\b\\c'
>>> print(mm)
c:\a\b\c
>>> re.match("c:\\\\"，mm).group()
'c:\\'
>>> ret = re.match("c:\\\\"，mm).group()
>>> print(ret)
c:\
>>> ret = re.match("c:\\\\a"，mm).group()
>>> print(ret)
c:\a
>>> ret = re.match(r"c:\\a"，mm).group()
>>> print(ret)
c:\a
>>> ret = re.match(r"c:\a"，mm).group()
Traceback (most recent call last):
File ""， line 1， in
AttributeError: 'NoneType' object has no attribute 'group'
>>>郑州做流产多少钱 http://www.kdwtrl.com/
Python中字符串前面加上 r 表示原生字符串，
与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。
Python里的原生字符串很好地解决了这个问题，有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
>>> ret = re.match(r"c:\\a"，mm).group()
>>> print(ret)
c:\a
2.8 匹配开头结尾
字符 功能
^ 匹配字符串开头
$ 匹配字符串结尾
末尾匹配
需求：匹配163.com的邮箱地址
#coding=utf-8
import re
email_list = ["xiaoWang@163.com"， "xiaoWang@163.comheihei"， ".com.xiaowang@qq.com"]
for email in email_list:
ret = re.match("[\w]{4，20}@163\.com"， email)
if ret:
print("%s 是符合规定的邮件地址，匹配后的结果是:%s" % (email， ret.group()))
else:
print("%s 不符合要求" % email)
运行结果:
xiaoWang@163.com 是符合规定的邮件地址，匹配后的结果是:xiaoWang@163.com
xiaoWang@163.comheihei 是符合规定的邮件地址，匹配后的结果是:xiaoWang@163.com
.com.xiaowang@qq.com 不符合要求
完善后
email_list = ["xiaoWang@163.com"， "xiaoWang@163.comheihei"， ".com.xiaowang@qq.com"]
for email in email_list:
ret = re.match("[\w]{4，20}@163\.com$"， email)
if ret:
print("%s 是符合规定的邮件地址，匹配后的结果是:%s" % (email， ret.group()))
else:
print("%s 不符合要求" % email)
运行结果：
xiaoWang@163.com 是符合规定的邮件地址，匹配后的结果是:xiaoWang@163.com
xiaoWang@163.comheihei 不符合要求
.com.xiaowang@qq.com 不符合要求
这个例子只用于展示，用来匹配邮箱是没有意义的。因为它匹配不出末尾不是com但包含了邮箱信息的多行字符串，如
'''
xiaoWang@163.com
xiaoKang@163.com
以上就是邮箱
'''
万能正则
(.*?) 匹配除了换行以外的任意字符串。无论长短，最多匹配一次，非贪婪匹配。
这个正则表达式可以解决你想要提取的大部分数据，在写正则表达式的时候可以首先尝试这个组合，也许能达到事半功倍的效果。并且常常结合re.findall()函数。
2.9 案例：抓取电影天堂数据
'''
电影天堂思路:
1. 进入最新的电影更多 --> 更多的第一页
2. 翻页 /tupian/20230522/pp 1. > 提取每一页的数据电影的详情页网址
2. > 发送请求 得到响应
3. > 正则提取链接
4. > 保存数据(文件)
抓取之前尽量熟悉网页的布局和结构!! 熟悉网址的关系， 经常查找网页源码中的数据(Ctrl+F).
'''
import re
import requests
for page in range(1， 5):
url_list = f'/tupian/20230522/list_23_{page}.html& # 找到详情页的网址 先进入 列表页
r_list = requests.get(url_list)
# 指定编码
r_list.encoding = 'gb2312'
# 提取详情页的网址 返回列表
url_detail = re.findall(''， r_list.text)
for u in url_detail:
url = 'https://www.dytt8.net' + u
# print(url)
# 再次发请求 得到详情页的响应
response = requests.get(url)
# 也会乱码
response.encoding = 'gb2312'
# 提取数据
result = re.findall('.*?'， response.text)[0:]
print(result)
try:
with open('dytt.txt'， 'a'， encoding='utf-8') as fp:
# write 只能字符串 和 二进制的 不能写字典 列表 等
fp.write(result[0]+'\n')
except:
print('没有提取到数据!!')
'''
歌曲下载:
可见即可爬 电影(VIP) 歌曲
思路:
1. 抓包 找到翻页 http://www.htqyy.com/genre/musicList/3?pageIndex=6&pageSize=20&order=hot
2. 进入上面的网址 提取歌曲id
3. 下载歌曲 http://f2.htqyy.com/play7/{id}/mp3/1
'''
import re
import requests
for page in range(1， 3): # 1， 2
# 翻页的
url_song = f'http://www.htqyy.com/genre/musicList/3?pageIndex={page}&pageSize=20&order=hot'
# 发送请求得到响应 提取响应中的歌曲ID
response_song = requests.get(url_song)
# 提取ID 返回列表
id_songs = re.findall('value="(\d+)">
# 遍历歌曲的id 然后下载
for ids in id_songs:
song_url = 'http://f2.htqyy.com/play7/{}/mp3/1'.format(ids)
try:
# 请求歌曲的网址 然后得到响应
response = requests.get(song_url， timeout=5)
# 保存歌曲
with open(f'{ids}.mp3'， 'wb') as fp:
fp.write(response.content)
except:
print(f'这个歌曲{ids}出错')
到此，关于“怎么理解并掌握python正则表达式和re模块”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注创新互联-成都网站建设公司网站，小编会继续努力为大家带来更多实用的文章！