Python - Python正则表达式

正则表达式（Regular Expression），又称规则表达式。正则表达式（Regular Expression）是一组由字母和符号组成的特殊文本，用于从文本中找出满足特定格式的句子。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。

Python 自1.5版本起增加了re 模块

官网文档：正则表达式指南 — Python 3.11.11 文档

re.match

re.match 尝试从字符串的起始位置匹配一个规则，匹配成功就返回match对象，否则返回None。可以使用group()获取匹配成功的字符串

语法：re.match(pattern, string, flags=0)

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等

flags可选标志位 

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

group(num) 或 groups() 匹配对象函数来获取匹配表达式

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

import re'''
re.match 尝试从字符串的起始位置匹配一个规则，匹配成功就返回match对象，否则返回None。可以使用group()获取匹配成功的字符串。
语法：re.match(pattern, string, flags=0)
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。flags可选标志位
修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
'''
print('---------re.match()基本用法--------')
str = "Hello World,I am Python!"
# match()无标志位
result = re.match('H', str) # 'P','h'
# 匹配成功使用group方法取出字符串，还区分大小写
# 找不到报错；AttributeError: 'NoneType' object has no attribute 'group'
print(result.group()) # 'H'# match()有标志位
# 忽略大小写
result = re.match('h', str, re.I|re.M)
print(result.group()) # 'H'str = 'Python is the best language in the world'
result = re.match('(.*) is (.*?) .*', str)
print(result) # <re.Match object; span=(0, 40), match='Python is the best language in the world'>
print(result.group()) # Python is the best language in the world
print(result.group(1)) # Python
print(result.group(2)) # the
print(result.groups()) # ('Python', 'the')

一、匹配规则

（一）匹配规则-匹配字符

符号	匹配规则
.（点）	匹配任意1个字符除了换行符\n
[abc ]	匹配abc中的任意一个字符
\d	匹配一个数字，即0-9
\D	匹配非数字，即不是数字
\s	匹配空白，即空格，tab键
\S	匹配非空白，除空格，tab键之类的
\w	匹配单词字符，即a-z、A-Z、0-9、_
\W	匹配非单词字符

'''
常用的匹配规则-匹配字符
符号	    匹配规则
.（点）	匹配任意1个字符除了换行符\n
[abc ]	匹配abc中的任意一个字符
\d	    匹配一个数字，即0-9
\D	    匹配非数字，即不是数字
\s	    匹配空白，即空格，tab键
\S	    匹配非空白，除空格，tab键之类的
\w	    匹配单词字符，即a-z、A-Z、0-9、_
\W	    匹配非单词字符
'''
import reprint('--------.(点)--------')
# .(点)：匹配任意除换行符\n之外的字符
str = 'aa\nbb'
result = re.match('.', str)
print(result.group()) # a
result = re.match('..', str)
print(result.group()) # aa
# result = re.match('...', str) # AttributeError: 'NoneType' object has no attribute 'group'
# print(result.group())print('--------[ ]--------')
# [ ] ：匹配中括号内的任意一个字符
str = 'hello'
result = re.match('[he]',str)
print(result.group()) # h
result = re.match('[eh]',str)
print(result.group()) # h
# result = re.match('[He]',str) # AttributeError: 'NoneType' object has no attribute 'group'
# print(result.group())print('--------\d--------')
# \d ：匹配一个数字
str = '123abc'
result = re.match('\d', str)
print(result.group()) # 1
result = re.match('\d\d', str)
print(result.group()) # 12
# str = 'abc123'
# result = re.match('\d', str)
# print(result.group()) # AttributeError: 'NoneType' object has no attribute 'group'print('--------\D--------')
# \D 匹配非数字，即不是数字
str = 'abc123'
result = re.match('\D', str)
print(result.group()) # a
result = re.match('\D\D', str)
print(result.group()) # ab
# str = '123abc'
# result = re.match('\D', str)
# print(result.group()) # AttributeError: 'NoneType' object has no attribute 'group'print('--------\s--------')
# \s：匹配空白字符串
str = ' abc'
result = re.match('\s', str)
print(result.group()) #
str = '  abc'
result = re.match('\s\s', str)
print(result.group()) #
# str = 'abc '
# result = re.match('\s', str)
# print(result.group()) # AttributeError: 'NoneType' object has no attribute 'group'print('--------\S--------')
# \S：匹配非空白字符串
str = 'abc '
result = re.match('\S', str)
print(result.group()) # a
str = 'abc  '
result = re.match('\S\S', str)
print(result.group()) # ab
# str = ' abc'
# result = re.match('\S', str)
# print(result.group()) # AttributeError: 'NoneType' object has no attribute 'group'print('--------\w--------')
# \w：匹配单词字符，即a-z、A-Z、0-9、_
str = 'abc'
result = re.match('\w', str)
print(result.group()) # a
str = '_0abc'
result = re.match('\w\w', str)
print(result.group()) # _0
# str = ' abc'
# result = re.match('\w', str)
# print(result.group()) # AttributeError: 'NoneType' object has no attribute 'group'print('--------\W--------')
# \W：非单词字符
str = ' abc'
result = re.match('\W', str)
print(result.group()) # a
str = '  abc'
result = re.match('\W\W', str)
print(result.group()) # ab
# str = 'a_bc'
# result = re.match('\W', str)
# print(result.group()) # AttributeError: 'NoneType' object has no attribute 'group'

（二）匹配规则-字符数量

符号	匹配规则
*	匹配前一个字符出现0次或者无限次，即可有可无
+	匹配前一个字符出现1次或者无限次，即至少有1次
\?	匹配前一个字符出现1次或者0次，即要么有1次，要么没有
{m}	匹配前一个字符出现m次
{m,}	匹配前一个字符至少出现m次
{n,m}	匹配前一个字符出现从n到m次

'''
常用的匹配规则-匹配字符数量
符号	    匹配规则
*	    匹配前一个字符出现0次或者无限次，即可有可无
+	    匹配前一个字符出现1次或者无限次，即至少有1次
\?	    匹配前一个字符出现1次或者0次，即要么有1次，要么没有
{m}	    匹配前一个字符出现m次
{m,}	匹配前一个字符至少出现m次
{n,m}	匹配前一个字符出现从n到m次
'''
import reprint('--------*--------')
# *：匹配前一个字符出现0次或者无限次，即可有可无
str = 'Abc'
result = re.match('[A-Z][A-Z]*', str)
print(result.group()) # A
str = 'Abc'
result = re.match('[A-Z][a-z]*', str)
print(result.group()) # Abc
str = 'Abcdefg'
result = re.match('[A-Z][a-z]*', str)
print(result.group()) # Abcdefgprint('--------+--------')
# + ：匹配前一个字符出现1次或者无限次，即至少有1次
# 变量名的语法规则：不能以数字开头，变量名只能包含字母，数字，下划线
pattern = '[a-zA-Z_]+[\w]*'
str = 'name'
result = re.match(pattern, str)
print(result.group()) # A
str = '_12name'
result = re.match(pattern, str)
print(result.group()) # Abc
# str = '22Abcdefg'
# result = re.match(pattern, str)
# print(result.group()) # AttributeError: 'NoneType' object has no attribute 'group'print('--------?--------')
# ？：匹配前一个字符出现1次或者0次，即要么有1次，要么没有
# 匹配0-99的数字
pattern = '[0-9]?[0-9]'
str = '20'
result = re.match(pattern, str)
print(result.group()) # 20
str = '09'
result = re.match(pattern, str)
print(result.group()) # 09
str = '101'
result = re.match(pattern, str)
print(result.group()) # 10print('--------{n,m}--------')
# {n,m} ：匹配前一个字符出现从n到m次
# 匹配0-99的数字
pattern = '[0-9]{6,10}@qq.com'
str = '123456@qq.com'
result = re.match(pattern, str)
print(result.group()) # 123456@qq.com
str = '12345678@qq.com'
result = re.match(pattern, str)
print(result.group()) # 12345678@qq.com
# str = '1234567891011@qq.com'
# result = re.match(pattern, str)
# print(result.group()) # AttributeError: 'NoneType' object has no attribute 'group'
str = '1234@qq.com'
result = re.match(pattern, str)
print(result.group()) # AttributeError: 'NoneType' object has no attribute 'group'

（三）匹配规则-原生字符串

Python字符串中\作为转义字符开头，比如\n表示换行，\t表示tab键，为了表示\本身，再加一个\，成为\\形式

'''
Python字符串中\作为转义字符开头，比如\n表示换行，\t表示tab键，为了表示\本身，再加一个\，成为\\形式
'''
import re# mypath = 'D:\py资料\正则表达式\regx.py'
# print(mypath) # SyntaxWarning: invalid escape sequence '\p'mypath = 'D:\\py资料\正则表达式\\regx.py'
print(mypath) # D:\py资料\正则表达式\regx.py# AttributeError: 'NoneType' object has no attribute 'group'
# print(re.match('c:\\a.txt','c:\\a.txt').group())
# 正则中\也表示转义，所以要匹配字符串中的\需要再次转义
print(re.match('c:\\\\a.txt','c:\\a.txt').group()) # c:\a.txt# 正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\"
# r表示原生字符串，即不转义
# 在正则前加r，表示原生字符串，python字符串不转义
print(re.match(r'c:\\a.txt','c:\\a.txt').group()) # c:\a.txt

正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\"

r表示原生字符串，即不转义；在正则前加r，表示原生字符串，python字符串不转义

（四）匹配规则-开头结尾

符号	匹配规则
^	匹配字符串开头
$	匹配字符串结尾

'''
匹配规则-开头结尾
符号	    匹配规则
^	    匹配字符串开头
$	    匹配字符串结尾
'''
import re
from tokenize import group# 匹配163.com的邮箱地址
patter = '[\w]{6,20}@163.com'
print(re.match(patter, 'abc123@163.com').group()) # abc123@163.com
print(re.match(patter, 'abc123@163.comvvsd').group()) # abc123@163.com
# print(re.match(patter, 'abc1@163.com').group()) # AttributeError: 'NoneType' object has no attribute 'group'# 通过$来限定结尾
patter = '[\w]{6,20}@163.com$'
print(re.match(patter, 'abc123@163.com').group()) # abc123@163.com
# print(re.match(patter, 'abc123@163.comvvsd').group()) # AttributeError: 'NoneType' object has no attribute 'group'# 通过^来限定开头
print(re.match('^P.*','Python is langage').group()) # Python is langage
print(re.match('^P\w{5}','Python is langage').group()) # Python

（五）匹配规则-分组匹配

符号	匹配规则
|	匹配左右任意一个表达式
(ab)	将括号中字符作为一个分组
\num	引用分组num匹配到的字符串
(?P)	分组起别名
(?P=name)	引用别名为name分组匹配到的字符串

'''
匹配规则-分组匹配
符号	    匹配规则
|	    匹配左右任意一个表达式
(ab)	将括号中字符作为一个分组
\num	引用分组num匹配到的字符串
(?P)	分组起别名
(?P=name)	引用别名为name分组匹配到的字符串
'''
import refrom 函数.函数 import resultprint('--------|--------')
#|：匹配左右任意一个表达式
str = '99'
result = re.match('[0-9]?\d', str)
print(result.group()) # 99
str = '99'
result = re.match('[0-9]?\d$|100', str)
print(result.group()) # 99
str = '100'
result = re.match('[0-9]?\d$|100', str)
print(result.group()) # 100print('--------(ab)--------')
#(ab)：将括号中字符作为一个分组
str = '0512-12345678'
pattern = '([^-]*)-(\d*)'
result = re.match(pattern, str)
print(result.group()) # 0512-12345678
print(result.group(0)) # 0512-12345678
print(result.group(1)) # 0512
print(result.group(2)) # 12345678print('--------\\num--------')
#\num：引用分组num匹配到的字符串
str = '<div>hello world</div>'
result = re.match('<[a-zA-Z]*>(.*)</[a-zA-Z]*>',str)
print(result.group()) # <div>hello world</div>
print(result.group(0)) # <div>hello world</div>
print(result.group(1)) # hello world
str = '<div>hello world</div>'
result = re.match(r'<([a-zA-Z]*)>.*</\1>',str)
print(result.group()) # <div>hello world</div>
str = '<div><h1>www.baidu.com</h1></div>'
result = re.match(r'<([a-zA-Z]*)>.*</\1>',str)
print(result.group()) # <div><h1>www.baidu.com</h1></div>print('--------(?P)--------')
#(?P)：分组起别名
#(?P=name)：引用别名为name分组匹配到的字符串
str = '<div><h1>www.baidu.com</h1></div>'
ret = re.match(r'<(?P<name1>\w*)><(?P<name2>\w*)>.*</(?P=name2)></(?P=name1)>',str)
print(ret.group()) # <div><h1>www.baidu.com</h1></div>

二、re常用方法

（一）re.compile()

compile 将正则表达式模式编译成一个正则表达式对象

reg = re.compile(pattern) result = reg.match(string)

等效于

result = re.match(pattern, string)

使用re.compile()和保存所产生的正则表达式对象重用效率更高

（二）re.search()

search 在全文中匹配一次，匹配到就返回

语法：re.search(pattern, string, flags=0)

函数参数说明：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

（三）re.findall()

findall 匹配所有返回一个列表，这个方法使用频率较高

语法：findall(string[, pos[, endpos]])

参数说明：

参数	描述
string	待匹配的字符串。
pos	可选参数，指定字符串的起始位置，默认为 0。
endpos	可选参数，指定字符串的结束位置，默认为字符串的长度。

（四）re.sub()

sub 将匹配到的数据进行替换

语法：sub(pattern, repl, string, count=0, flags=0)

参数说明：

参数	描述
pattern	正则中的模式字符串。
repl	替换的字符串，也可为一个函数。
string	要被查找替换的原始字符串。
count	模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
flags	标志位，用于控制正则表达式的匹配方式

（五）re.split()

split 根据匹配进行切割字符串，并返回一个列表

语法：split(pattern, string, maxsplit=0, flags=0)

参数说明

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
maxsplit	分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
flags	标志位，用于控制正则表达式的匹配方式

import re'''
compile：re模块中的编译方法，可以把一个字符串编译成字节码
优点:complie则只需要完成一次转换即可，以后再使用模式对象的话，无需重复转换，而在使用正则表达式进行match的操作时，python会将字符串转为正则表达式对象
compile 将正则表达式模式编译成一个正则表达式对象
reg = re.compile(pattern) result = reg.match(string)
等效于 result = re.match(pattern, string)
使用re.compile()和保存所产生的正则表达式对象重用效率更高
'''
print('---------compile--------')
# compile:将正则表达式模式编译成一个正则表达式对象
resObj = re.compile('\d{4}')
result = resObj.match('123456')
print(result.group()) # 1234print('---------search--------')
# search:在全文中匹配一次，匹配到就返回
result = re.search('bc', 'abcd')
print(result.group()) # bc
result = re.search('祖国', '我爱伟大的祖国,I love China')
print(result.group()) # 祖国print('---------findall--------')
# findall:匹配所有返回一个列表
str = '冬天喜欢在冬湖里冬泳'
result = re.findall('冬.', str)
print(result) # ['冬天', '冬湖', '冬泳']
result = re.search('冬.', str)
print(result.group()) # 冬天print('---------sub--------')
# re.sub 实现目标的搜索和替换
# re.subn 实现目标的搜索和替换  还返回被替换的数量 以元组形式
dataS='Python是很受欢迎的编程语言Python'
pattern='[a-zA-Z]+'  #字符集的范围 + 号 代表 前导字符模式出现1次以上
res=re.sub(pattern,'Java',dataS)
resn=re.subn(pattern,'Java',dataS)
print(res) # Java是很受欢迎的编程语言Java
print(resn) # ('Java是很受欢迎的编程语言Java', 2)print('---------split--------')
# re.split：实现分割字符串
data='百度,腾讯,阿里,华为,360'
rs=re.split(',',data)
print(type(rs)) # <class 'list'>
print(rs) # ['百度', '腾讯', '阿里', '华为', '360']

三、贪婪模式与非贪婪模式

Python里数量词默认是贪婪的,总是尝试匹配尽可能多的字符,非贪婪则相反，总是尝试匹配尽可能少的字符。

在"*","?","+","{m,n}"后面加上？，使贪婪变成非贪婪

import re# 贪婪模式（默认的匹配规则）：在满足条件的情况下尽可能多的去匹配到数据
rs=re.match('\d{6,9}','111222333')
# print(rs.group())
content='aacbacbc'
pattern=re.compile('a.*b')
result=pattern.search(content)
print('贪婪模式：%s'%result.group())data='小王出生于1997年'
patt='.*(\d{4})年'
print(re.match(patt,data).group(1))# 非贪婪模式：在满足条件的情况下尽可能【少】的去匹配到数据
rs=re.match('\d{6,9}?','111222333')
print(rs.group())content='aacbacbc'
pattern=re.compile('a.*?b') #非贪婪模式匹配
result=pattern.search(content)
print('非贪婪模式：%s'%result.group())

总结

元字符     说明                  正确    错误
\d      匹配任意单个数字           2      i、$
\D      匹配非数字                A/a     3
\w      匹配任意单个字母数字下划线  u       &
\W      匹配\w之外的任意单个字符    &       u
\s      匹配单个空格                       x
\S      匹配非空白，除空格，tab键之类 x
\n      匹配换行符
.       匹配任意单个字符【换行符除外】
\num    匹配前面引用的分组多次的重复匹配
正则表达式     说明               正确   错误
A{3}          精准N次匹配        AAA     AA|A|AAAA
A{3,}          最少出现n次       AAA      A
\d{3,5}       约定出现最少次数和最大次数
\d*           可以出现0次至无限次 相当于{0,}
\d+           最少出现一次 相当于{1,}
\d?           最多出现一次 相当于{0,1} 1  12定位匹配
正则表达式     说明            正确    错误
^A.*           头匹配          ABC    CBA
.*A$           尾部匹配        CBA     ABC
^A.*A$         全字匹配        ACCA    BAAA
字符的范围匹配
正则表达式     说明             正确   错误
A              精准匹配         A      a
x|y            匹配左右两边的字符 x/y   n
[xyz]          字符集合允许出现集合内任意单个字符 z、x、y     c、b
[a-z][A-Z][0-9]  字符范围
[^xyz][^0-9]     取反  集合内字符不允许出现的 0 A     y8贪婪模式
在满足条件的情况下尽可能的去匹配多的字符串
实例:111222333  \d{6,8}
数据 ：小王出生于1997年   .*\d{4}年   贪婪模式非贪婪模式
在满足条件的情况下尽可能的去匹配少的字符串
实例:111222333  \d{6,8}?
数据 ：小王出生于1997年   .*?\d{4}年   贪婪模式