python正则re

re --- 正则表达式操作 — Python 3.9.6 文档

Python 正则表达式 | 菜鸟教程 (runoob.com)

介绍

python为字符串的处理提供了re库和语法，高效声明判断和提取规则。

• 字符组成：包括什么字符、不包括什么字符

• 位置和顺序：以什么开始，以什么结束

• 重复次数：只是1次，0次或任意次数、指定次数、指定次数范围

• 匹配到的文本

• 匹配到的文本的起始与结束索引

正则匹配的语法

（1）匹配直接文本

pattern='abc'

（2）匹配包含和不包含

pattern_1 = 'abc[123]'
pattern_2 = 'abc[^123]'

（3）匹配字符简写

pattern_1 = 'abc\d'
pattern_2 = 'abc\s'
pattern_2 = 'abc.'

实例	描述
.	匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
\d	匹配一个数字字符。等价于 [0-9]。
\D	匹配一个非数字字符。等价于 [^0-9]。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\w	匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
\W	匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
\n，\t，$等	匹配转义字符或者正则中敏感字符

（4）匹配分租

pattern_1 = 'a(bc)\s'
pattern_2 = 'a(bc)|(cb)\s'

• 分组有两个作用，一是可以定向查询分组内的匹配内容，二是可以基于分组进行匹配次数指定或者其它操作

（5）匹配次数

pattern_1 = 'abc*'	# 0次或任意次
pattern_2 = 'abc+'	# 至少1次
pattern_3 = 'abc?'	# 0次或1次

pattern_4 = 'abc{n}'	# 匹配n次
pattern_5 = 'abc{n,}'	# 匹配至少n次
pattern_6 = 'abc{,m}'	# 匹配至多n次
pattern_7 = 'abc{n.m}'	# 匹配至少n次，至多m次

（6）匹配开始和结束

pattern_1 = '^abc\s'
pattern_2 = 'abc\s$'

（7）贪婪匹配

在*、+、？符号后面加？可以使得匹配变为非贪婪模式，默认是贪婪模式

贪婪模式：在符合匹配的情况下尽可能长的匹配

非贪婪模式：在符合匹配的情况下尽可能短的匹配

ababc
(ab)*：匹配结果abab
(ab)+?：匹配结果ab

正则匹配的方法

结果：

• 是否匹配
• 匹配次数
• 匹配的首项值
• 匹配的值的列表
• 匹配的值的开始和结束索引
• 匹配的值的子区域
• 基于匹配的替换操作

1、findall

def findall(pattern:str, string:str, flags=0)-->list

• string：str类型，表示正则匹配的文本
• pattern：str类型，表示正则规则
• flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

返回一个list类型，如果pattern中没有()分组，list元素是匹配到的字符串文本

如果pattern中有()分组，则list元素是元组，元组的第一项表示匹配到的整体文本，其后的项表示分组内的文本

如果没有找到，返回空列表

2、finditer

def finditer(pattern, string, flags=0)

参数与findall一致，返回的是一个可迭代对象，其元素是re.Match

如果没有找到，返回也是iter对象

3、fullmatch

def fullmatch(pattern, string, flags=0)

其默认是对整体进行匹配，是否以什么开始，以什么结束，返回结果如果匹配是re.Match，不匹配则为None

4、match

def match(pattern, string, flags=0)

匹配是否以xx开头，返回结果如果匹配是re.Match，不匹配则为None

5、search

def search(pattern, string, flags=0)

匹配第一次匹配的内容，返回结果如果匹配是re.Match，不匹配则为None

6、split

def split(pattern, string, maxsplit=0, flags=0)

• maxsplit：分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。

• 以匹配项作为分隔符，返回list，其元素为str

  如果没有匹配项，返回list，其有且只有一个str类型元素，为整个匹配文本

re.Match

re.Match作为众多的正则方法的返回类型，具有以下的属性和方法。

一个re.Match表示一个匹配项。如果没有匹配项，则返回None，也就无法进行re.Match的属性或方法操作

1、属性

string:str
re:re.Pattern

2、匹配项的索引

在匹配文本中的开始索引和结束索引，左闭右开

start()--int
end()-->int
span()-->tuple (start,end)
regs:tuple	# 其元素也是tuple，第一个元素是匹配项的开始和结束索引，其后是分组的开始和结束索引

3、匹配文本与分组

group()-->str	# 返回匹配到的整个文本
group(0)-->str # 相当于无参
group(1)-->str # 返回匹配到的第一个分组的文本，如果没有分组或者超出分组数，会报错

groups()-->tuple	# 是否有参数不影响返回值，都是返回一个tuple，其元素是分组的文本

4、sub

def sub(pattern, repl, string, count=0, flags=0)

作用：替换字符串中的匹配项，返回一个str对象

• repl：用于替换的字符，也可为一个函数
• count：被替换的最大次数，默认为0表示替换所有。当实际匹配次数小于count时，替换所有；反之则替换前count个
• 如果pattern为空字符串''，sub方法返回''

import re
 
# 将匹配的数字乘以 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
 
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))

• double方法中的matched表示依次匹配的匹配项

5、compile

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

def compile(pattern, flags=0)

• pattern : 一个字符串形式的正则表达式
• flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
  1. re.I 忽略大小写
  2. re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
  3. re.M 多行模式
  4. re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
  5. re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
  6. re.X 为了增加可读性，忽略空格和 # 后面的注释

pattern_1 = re.compile('abc')
print(pattern_1, type(pattern_1))
# re.compile('abc') <class 're.Pattern'>
r_4 = re.match(pattern=pattern_1, string=string)
print(r_4, type(r_4))
# <re.Match object; span=(0, 2), match='ab'> <class 're.Match'>

Pattern对象具有的方法：

def search(self, string: AnyStr, pos: int = ..., endpos: int = ...)
def match(self, string: AnyStr, pos: int = ..., endpos: int = ...)
def fullmatch(self, string: AnyStr, pos: int = ..., endpos: int = ...)
def split(self, string: AnyStr, maxsplit: int = ...)
def findall(self, string: AnyStr, pos: int = ..., endpos: int = ...)
def finditer(self, string: AnyStr, pos: int = ..., endpos: int = ...)
@overload
def sub(self, repl: AnyStr, string: AnyStr, count: int = ...)
@overload
def sub(self, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ...)
@overload
def subn(self, repl: AnyStr, string: AnyStr, count: int = ...)
@overload
def subn(self, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ...)

9、escape

e = re.escape(r'''.,\r''')
print(e, type(e))
# \.,\\r <class 'str'>

作用1：对字符串中可以被转义的字符添加\，防止被转义

e = re.escape('''.,\nabc''')
print(e, type(e))
'''
\.,\
abc <class 'str'>
'''

作用2：对字符串中出现的转义字符进行替换为字符，保留\占位表示其后是一个转义字符

10、purge

清除re的缓存，一般不建议也没必要使用，容易导致错误

re.fullmatch()
re.subn()
re.template()

正则表达式修饰符

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

正则表达式模式

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾。
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...]	用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re*	匹配0个或多个的表达式。
re+	匹配1个或多个的表达式。
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}	精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。
re{ n,}	匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。
re{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b	匹配a或b
(re)	对正则表达式分组并记住匹配的文本
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re)	类似 (...), 但是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#...)	注释.
(?= re)	前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)	匹配的独立模式，省去回溯。
\w	匹配字母数字及下划线
\W	匹配非字母数字及下划线
\s	匹配任意空白字符，等价于 [ \t\n\r\f]。
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0-9].
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z	匹配字符串结束
\G	匹配最后匹配完成的位置。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等.	匹配一个换行符。匹配一个制表符。等
\1...\9	匹配第n个分组的内容。
\10	匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

特殊字符

实例	描述
.	匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
\d	匹配一个数字字符。等价于 [0-9]。
\D	匹配一个非数字字符。等价于 [^0-9]。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\w	匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
\W	匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。