正则表达式（python3）
发布时间
阅读量：
阅读量
文章目录
以下是基于给定规则对原文的改写
正则表达式（python3）
正则表达式是一种用于对字符进行操作的逻辑公式。它通过预先设定的一系列特定符号以及这些符号的组合方式来形成一个"规则模式串"（Rule Pattern String），这个"规则模式串"被用来描述一种过滤逻辑（能够实现截取或替换操作）。
作用
1.给定的字符串是否符合正则表达式的过滤逻辑(称作“匹配")。
2.可以通过正则表达式，从字符串中获取我们想要的特定部分。
3.还可以对目标字符串进行替换操作。
match方法
re.match被用于在字符串的起始位置匹配一个模式；如果无法在起始位置成功匹配，则match()不会返回任何结果。
re.match(pattern,string,flags = 0)函数参数说明
| 参数 | 描述 |
|---|---|
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串 |
flags 是一种标志字段，在正则表达式中用于决定匹配模式的方式设置。例如：它可指定是否区分大小写字母、是否进行多行匹配等可选参数设置。
| 修饰符 | 描述 |
|---|---|
| re.I | 使匹配对大小写不敏感 |
| re.L | 做本地化识别（localle-aware）匹配 |
| re.M | 多行匹配，影响^ $ |
| re.S | 匹配包括换行在内的所有字符 |
| re.U | 根据Unicode字符集解析字符。影响\w，\W，\b，\B |
| re.X | 该标志给予更灵活的格式 |
#match方法的使用
import re
s = 'hello python'
pattern = 'Hello'
o = re.match(pattern,s,re.I)
print(re.match(pattern,s))
print(dir(o))#查看当前对象使用了什么方法
print(o.group())#返回匹配的字符串
print(o.span())#匹配字符串的范围
print(o.start())search方法
re.match(pattern,string,flags = 0)search函数参数说明
| 参数 | 描述 |
|---|---|
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串 |
Flags| 标志位用于控制正则表达式的匹配方式，例如是否区分大小写以及多行模式等其他设置。
search与match的区别
仅识别字符串开头的部分；当遇到不满足正则表达式的开头时无法进行匹配操作；导致函数返回None值；相比之下，在整个字符串中进行搜索；继续扫描直至发现第一个匹配项。
m = 'i love you'
print(re.search('love',m))
print(re.match('love',m))
###################结果#############################
<re.Match object; span=(2, 6), match='love'>
None常用匹配符
| 符号 | 描述 |
|---|---|
| . | 匹配任意一个字符（除了\n） |
| [] | 匹配列表中的字符串 |
| \w | 匹配字母、数字、下划线（a-z，A-Z，0-9，_） |
| \W | 匹配不是字母，数字，下划线 |
| \s | 匹配空白字符，（空格\n\t） |
| \S | 匹配不是空白的字符 |
| \d | 匹配数字（0-9） |
| \D | 匹配非数字的字符 |
部分匹配符测试
#
import re
##########.的使用###############
q = 'a'
w = 'A'
e = '_'
r = '\n'
pattern = '.'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pattern,e)
r1 = re.match(pattern,r)
print(q1,'\n',w1,'\n',e1,'\n',r1)
#########\d的使用###########
q = '0123'#由结果看只能匹配一个
w = '5'
e = 'a'
r = ' 9'
pattern = '\d'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pattern,e)
r1 = re.match(pattern,r)
print(q1,'\n',w1,'\n',e1,'\n',r1)
##########\s的使用#############
q = ' '
w = '\n'
e = '\t'
r = '_'
pattern = '\s'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pattern,e)
r1 = re.match(pattern,r)
print(q1,'\n',w1,'\n',e1,'\n',r1)
##############[]的使用#############
q = '2'
w = '3'
e = '4'
pattern = '[2468]'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pattern,e)
print(q1,'\n',w1,'\n',e1)
#################测试结果#########################################
<re.Match object; span=(0, 1), match='a'>
<re.Match object; span=(0, 1), match='A'>
<re.Match object; span=(0, 1), match='_'>
None
<re.Match object; span=(0, 1), match='0'>
<re.Match object; span=(0, 1), match='5'>
None
None
<re.Match object; span=(0, 1), match=' '>
<re.Match object; span=(0, 1), match='\n'>
<re.Match object; span=(0, 1), match='\t'>
None
<re.Match object; span=(0, 1), match='2'>
None
<re.Match object; span=(0, 1), match='4'>
Process finished with exit code 0泽一匹配符（|）和列表
import re
#泽一和列表的相同点
pattern = '[xyz]'
pa1 = 'x|y|z'
s = 'z'
o = re.search(pattern,s)
o1 = re.search(pa1,s)
print(o,'\n',o1)
print('#########不同点#######')
#泽一和列表的不同点
pattern = '[ab][cd]'
pa1 = 'ab|cd'
s1 = 'bc'
s2 = 'ab'
o1 = re.search(pattern,s1)
o2 = re.search(pattern,s2)
a1 = re.search(pa1,s1)
a2 = re.search(pa1,s2)
print(o1,'\n',o2,'\n',a1,'\n',a2)
################结果##############################
<re.Match object; span=(0, 1), match='z'>
<re.Match object; span=(0, 1), match='z'>
#########不同点#######
<re.Match object; span=(0, 2), match='bc'>
None
None
<re.Match object; span=(0, 2), match='ab'>
Process finished with exit code 0重复数量限定符
提供了对表达式的一部分进行重复处理的功能。
正则表达式中常用的限定符
| 符号 | 描述 |
|---|---|
| * | 匹配零次或多次 |
| + | 匹配一次或多次 |
| ？ | 匹配一次或零次 |
| {m} | 重复m次 |
| {m,n} | 重复m到n次 |
| {m，} | 至少m次 |
部分限定符测试
import re
#############*的使用############
pattern = '\d*'
q = '123qwe'
w = '12345qwe'
e = 'qwe'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pattern,e) #匹配空
print(q1,'\n',w1,'\n',e1)
#############+的使用############
pattern = '\d+'
q = '123qwe'
w = '12345qwe'
e = 'qwe'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pattern,e)
print(q1,'\n',w1,'\n',e1)
#############{}的使用############
pattern = '\d{2}'
pa1 = '\d{1,}'
q = '123qwe'
w = '1qwe'
e = 'qwe'
q1 = re.match(pattern,q)
w1 = re.match(pattern,w)
e1 = re.match(pa1,e)
q2 = re.match(pa1,q)
w2 = re.match(pa1,w)
e2 = re.match(pa1,e)
print(q1,'\n',w1,'\n',e1)
print(q2,'\n',w2,'\n',e2)
##################结果#######################################
<re.Match object; span=(0, 3), match='123'>
<re.Match object; span=(0, 5), match='12345'>
<re.Match object; span=(0, 0), match=''>
<re.Match object; span=(0, 3), match='123'>
<re.Match object; span=(0, 5), match='12345'>
None
<re.Match object; span=(0, 2), match='12'>
None
None
<re.Match object; span=(0, 3), match='123'>
<re.Match object; span=(0, 1), match='1'>
None
Process finished with exit code 0原生字符串
正则表达式里使用“\”作为转移字符。
Python中字符串前面加上 r 表示原生字符串
例：在输出路径的时候要使用两次反斜杠
import re
print('c:\ a\ c\ d')
s = '\ t123'
pattern = '\ \ t\d*'
o = re.match(pattern,s)
pa1 = r'\ t\d*'
o1 = re.match(pa1,s)
print(o,'\n',o1)
############输出结果#################################
c:\a\c\d
<re.Match object; span=(0, 5), match='\ t123'>
<re.Match object; span=(0, 5), match='\ t123'>
Process finished with exit code 0边界字符
| 字符 | 功能 |
|---|---|
| ^ | 匹配字符串开头 |
| $ | 匹配字符串结尾 |
| \b | 匹配一个单词的边界 |
| \B | 匹配非单词的边界 |
示例
import re
#匹配QQ邮箱，数字5,10位
# $的使用
a = '321123@qq.com'
b = '321123@qq.com.126'
pattern = '[1-9]\d{4,9}@qq.com'
pa1 = '[1-9]\d{4,9}@qq.com$'
q1 = re.match(pattern,a)
w1 = re.match(pattern,b)
q2 = re.match(pa1,a)
w2 = re.match(pa1,b)
print(q1,'\n',w1,'\n',q2,'\n',w2)
# ^的使用
a = 'hello world'
b = 'python'
pattern = 'hello.*'
pa1 = r'^hello.*'
q1 = re.match(pattern,a)
w1 = re.match(pattern,b)
q2 = re.match(pa1,a)
w2 = re.match(pa1,b)
print(q1,'\n',w1,'\n',q2,'\n',w2)
# \b的使用
a = '1234 abc'
b = '123 ab'
pattern = r'.*\bab'
pa1 = r'.*ab\b'
q1 = re.match(pattern,a)
w1 = re.match(pattern,b)
q2 = re.match(pa1,a)
w2 = re.match(pa1,b)
print(q1,'\n',w1,'\n',q2,'\n',w2)
#########################结果##########################
<re.Match object; span=(0, 13), match='321123@qq.com'>
<re.Match object; span=(0, 13), match='321123@qq.com'>
<re.Match object; span=(0, 13), match='321123@qq.com'>
None
<re.Match object; span=(0, 11), match='hello world'>
None
<re.Match object; span=(0, 11), match='hello world'>
None
<re.Match object; span=(0, 7), match='1234 ab'>
<re.Match object; span=(0, 6), match='123 ab'>
None
<re.Match object; span=(0, 6), match='123 ab'>
Process finished with exit code 0分组
在某个模式中使用一对圆括号括起来的一个部分，在这种情况下它会被视为一组，并且可以通过group方法中的参数来获取对应匹配字符串
| 字符 | 功能 |
|---|---|
| （ab） | 将括号中的字符作为一个分组 |
| \num | 引用分组num匹配到的字符串 |
| (?p) | 分别起组名 |
| (?p=name) | 引用别名为name分组匹配到的字符串 |
示例
import re
#匹配座机号码 区号-电话号码 010-43222 0432-447721
#(ab)的使用
pa = '(\d{3,4})-([1-9]\d{4,7}$)'
s = '010-43222'
o = re.search(pa,s)
print(o.group())
print(o.group(1))
print(o.groups())
print(o.groups()[0])
#########################结果#############################
010-43222
010
('010', '43222')
010 #\num的使用
pattern = r'<(.+)><(.+)>.+</\2></\1>'
s = '<html><head>head部分</head></html>'
s1 = '<html><title>head部分</head></body>'
o = re.search(pattern,s)
o1 = re.search(pattern,s1)
print(o,'\n',o1)
#########################结果#############################
<re.Match object; span=(0, 32), match='<html><head>head部分</head></html>'>
None #(?p<name)
pattern = r'<(?P<k_html>.+)><(?P<k_head>.+)>.+</(?P=k_head)></(?P=k_html)>'
s = '<html><head>head部分</head></html>'
s1 = '<html><title>head部分</head></body>'
o = re.search(pattern,s)
o1 = re.search(pattern,s1)
print(o,'\n',o1)
#########################结果#############################
<re.Match object; span=(0, 32), match='<html><head>head部分</head></html>'>
None其他常用函数
sub、subn函数
sub函数与subn函数用于执行搜索与替换操作。这两个函数的作用基本一致，均能将某个字符串中所有满足正则表达式匹配的部分替换成另一个字符串。被替换的部分既可以是直接的字符串内容，也可以是一个函数运行后返回的结果字符串。
sub函数后会给出被替代的结果；而subn函数则会提供一个tuple, 其中第一个元素是被替代的结果, 第二个则是总共替换了的数量。
语法格式如下:
re.sub(pattern, repl string, count=0,flags=0) import re
#sub和subn的使用
s = '2021-959-456 # 这是一个国外的电话 123'
pa1 = r'#.*'
pa2 = r'#\D*'
result1 = re.sub(pa1,"",s)
result2 = re.sub(pa2,"",s)
result3 = re.subn(pa2,"",s)
print(result1)
print(result2)
print(result3,'\t',result3[0],'\t',result3[1])
#########################结果#############################
2021-959-456
2021-959-456 123
('2021-959-456 123', 1) 2021-959-456 123 1compile函数
compile函数用于执行正则表达式的解析，并生成一个正则表达式（Pattern）对象供匹配和搜索操作使用。
语法格式：
re.compile(pattern[ flags])参数说明
| 参数 | 描述 |
|---|---|
| pattern | 一个字符串形式的正则表达式 |
| flags | 可选，表示匹配模式，例如：忽略大小写，多行模式等 |
#compile
s = '2021-959-456 # 这是一个国外的电话 123'
pattern = re.compile(r'\w*')
o = pattern.search(s)
print(o)
#########################结果#############################
<re.Match object; span=(0, 4), match='2021'>findall函数
在字符串中使用正则表达式找出所有匹配的子串，并将它们放入一个列表中；如果没有发现任何匹配项，则返回空列表
findal[(pattern, string, flags=0)参数说明
| 参数 | 描述 |
|---|---|
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串 |
| flags | 可选，表示匹配模式，例如：忽略大小写，多行模式等 |
finditer函数
类似于findall函数，在整个字符串上运行正则表达式以获取所有匹配的子串，并将其作为迭代器返回
#findall和finditer函数
s = 'first 1 second 2 third 3'
pattern = r'\w+'
o1 = re.findall(pattern,s)
o2 = re.finditer(pattern,s)
print(o1)
print(o2)
for i in o2:
print(i.group(),end="\t")
#########################结果#############################
['first', '1', 'second', '2', 'third', '3']
<callable_iterator object at 0x000001BE65638668>
first 1 second 2 third 3split函数
split函数用于基于正则表达式对字符串进行分割。具体而言，该函数会将所有与模式匹配的子字符串作为分隔符使用来分割该字符串。split 函数返回一个列表形式的结果，其中每个列表项代表一次分割后的子串。
语法格式如下:
re.split(pattern, string[ maxsplit=0, flags=0])参数说明
| 参数 | 描述 |
|---|---|
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串 |
| maxsplit | 分隔次数，maxsplit = 1分隔一次，默认为0，不限制次数 |
| flags | 可选，表示匹配模式，例如：忽略大小写，多行模式等 |
#split函数
s = 'first1second22third 3'
pattern = r'\d+'
o1 = re.split(pattern,s)
o2 = re.split(pattern,s,maxsplit=2)
print(o1)
print(o2)
#########################结果#############################
['first', 'second', 'third ', '']
['first', 'second', 'third 3']贪婪模式和非贪婪模式
Python的数量词默认采用的是贪婪策略，在这种情况下它会尽量匹配最多的字符序列。与其相对应的是非贪婪策略，在这种情况下它会尽量匹配最少的字符序列，并且可以通过在重复数量限定符之后添加一个问号来实现转换。
import re
v = re.match(r'(.+)(\d+-\d+-\d+)','This is my tel:133-1234-1234')
print('--------贪婪模式-------')
print(v.group(1))
print(v.group(2))
print('--------非贪婪模式-------')
v = re.match(r'(.+?)(\d+-\d+-\d+)','This is my tel:133-1234-1234')
print(v.group(1))
print(v.group(2))
#########################结果#############################
--------贪婪模式-------
This is my tel:13
3-1234-1234
--------非贪婪模式-------
This is my tel:
133-1234-1234
Process finished with exit code 0全部评论 (0)
还没有任何评论哟~