python re库的使用（正则表达式笔记）

---

1.正则表达式字典

(1)字典

${}^1$

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符
[…]	用来表示一组字符,单独列出：[amk] 匹配 ‘a’，‘m’或’k’
[^…]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符
*	匹配0个或多个的表达式
+	匹配1个或多个的表达式
?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪模式
{n}	精确匹配n个前面表达式
{n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a|b	匹配a或b
(…)	被括起来的表达式将作为一个分组，比如：(abc){2}==abcabc
\w	匹配字母数字下划线
\W	匹配非字母数字下划线
\s	匹配任意空白字符，等价于 [\t\n\r\f].
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0-9]
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串
\G	匹配最后匹配完成的位置
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配"never" 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’
\B	匹配非单词边界。‘er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’

#部分示例：
# \A (匹配字符串开始,即必须在字符串开始处匹配，\A不占位):
#（1）
import re
m=re.search(r'\A\d\d','1i12ndex3145')
if m:
    print(m.group(0))
'''
输出：(没有输出)

'''

#(2)
import re
m=re.search(r'\A\d\d','12i12ndex3145')
if m:
    print(m.group(0))
'''
输出：
12
'''

# \Z:
import re
m=re.search(r'\d\d\Z','12i12nader31s45')
if m:
    print(m.group(0))
'''
输出：
45
'''

(2)部分模式的区别

一些模式的区别：
^与\A (只有在使用re.M or re.MULTILINE时，两者才有区别，而且\A在此时不能匹配换行后的开头，^可以)

import re
m=re.search(r'^\d\d','d12i12nader31s45\n12w2',flags=re.M)
if m:
    print(m.group(0))
'''
输出：
12
'''

import re
m=re.search(r'\A\d\d','d12i12nader31s45\n12w2',flags=re.M)
if m:
    print(m.group(0))
'''
输出：
(没有输出)
'''

$与\Z (只有在使用re.M or re.MULTILINE时，两者才有区别，而且\A在此时只能匹配最后一行的结尾，^可以匹配任意行的结尾)

import re
m=re.search(r'\d\d\Z','d12i12nader31s45\n1w2',flags=re.M)
if m:
    print(m.group(0))
'''
输出：
(没有输出)
'''

import re
m=re.search(r'\d\d$','d12i12nader31s45\n1w2',flags=re.M)
if m:
    print(m.group(0))
'''
输出：
45
'''

---

2.re库的使用

(1)常用函数

re库采用raw string 类型表示正则表达式，表达为：r’text’
raw string 是不包含转义符的字符串

• re.search(pattern,string,flags=0) 在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象（match对象就是re库里面的一个对象）

pattern:正则表达式的字符串或原生字符串表示

string：待匹配字符串

flags:正则表达式使用时的控制标记

常用控制标记	说明
re.I, re.IGNORECASE	忽略正则表达式的大小写
re.M, re.MULTILINE	正则表达式中的^操作符能够将给定字符串的每行当做匹配开始
re.S, re.DOTALL	正则表达式中的.操作符能够匹配所有字符（包括\n）

#比如：
import re
match=re.search(r'[1-9]\d{5}','ABD14357521')
if match:
    print(match)
    print(match.group(0))
    
'''
输出：
<re.Match object; span=(3, 9), match='143575'>
143575
'''

---

• re.match(pattern,string,flags=0) 从一个字符串的开始位置起匹配正则表达式，返回match对象

pattern:正则表达式的字符串或原生字符串表示

string：待匹配字符串

flags:正则表达式使用时的控制标记

---

• re.findall(pattern,string,flags=0)搜索字符串，以列表类型返回全部能匹配的子串

pattern:正则表达式的字符串或原生字符串表示

string：待匹配字符串

flags:正则表达式使用时的控制标记

• re.split(pattern,string,maxsplit=0,flags=0) 将一个字符串按照正则表达式匹配结果进行分割，返回列表类型。

pattern:正则表达式的字符串或原生字符串表示

string：待匹配字符串

maxsplit:最大分割数，剩余部分作为最后一个元素输出

flags:正则表达式使用时的控制标记

#比如：
#(1)
import re
list=re.split(r'[1-9]\d{0,5}','ABC12345 CDE67890')
print(list)
#输出：['ABC', ' CDE', '']

#(2)
import re
list=re.split(r'[1-9]\d{0,5}','ABC12345 CDE67890',maxsplit=1)
print(list)

#输出：['ABC', ' CDE67890']

• re.finditer(pattern,string,flags=0) 搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象(注意和findall()返回结果的区别)

import re
match=re.finditer(r'[1-9]\d{5}','ABD14357521 1111111')
if match:
    print(match)
    for m in match:
        print(m.group(0))
'''
输出：
<callable_iterator object at 0x...>
143575
111111
'''

• re.sub(pattern,repl,string,count=0,flags=0) 在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串

pattern:正则表达式的字符串或原生字符串表示

repl:替换匹配字符串的字符串

string：待匹配字符串

count:匹配的最大替换次数

flags:正则表达式使用时的控制标记

import re
names=re.sub(r'[1-9]\d{8}','good name:','123456789index 987654321nino')
if names:
    print(names)
'''
输出：
good name:index good name:nino
'''

(2)Match对象

Match对象的属性

属性	说明
.string	待匹配的文本
.re	匹配时使用的pattern对象（正则表达式）
.pos	正则表达式搜索文本的开始位置
.endpos	正则表达式搜索文本的结束位置

Match对象的方法

方法	说明
.group(0)	获得匹配后的字符串
.start()	匹配字符串在原始字符串的开始位置
.end()	匹配字符串在原始字符串的结束位置
.span()	返回一个元组(.start(),.end())， span()也可以带参数，见下面group()例子

以上结束位置都是字符串实际位置的下一个位置（左闭右开）

#例子：
import re
m=re.search(r'\d\d','nino12345s6789')
if m:
    print(m.string)
    print(m.re)
    print(m.pos)
    print(m.endpos)
    print(m.group(0))
    print(m.start())
    print(m.end())
    print(m.span())
'''
输出：
nino12345s6789
re.compile('\\d\\d')
0
14
12
4
6
(4, 6)
'''

(3)group方法

m.group(n) 返回第n组括号匹配的字符。
规定m.group() == m.group(0) == 所有匹配的字符(即使没有括号)
m.groups() 返回所有括号匹配的字符（没有括号时，返回"()"）
m.groups() == (m.group(1), m.group(2), ...)

#例子：
import re
m=re.search(r'(\d{2})\w([0-9]\d)','nino12345s6789')
if m:
    print(m.string)
    print(m.re)
    print(m.pos)
    print(m.endpos)
    print(m.groups())
    print(m.start())
    print(m.end())
    print(m.span())
    print(m.span(2))
'''
输出：
nino12345s6789
re.compile('(\\d{2})\\w([0-9]\\d)')
0
14
('12', '45')
4
9
(4, 9)
(7, 9)

'''

(4)最小匹配操作符

非贪婪模式
re库正则表达式默认模式为贪婪模式，
即re.search(‘PY+’,‘PYYYYY’)匹配的字符串是’PYYYYY’。可以在操作符后面加?使其变成非贪婪模式

操作符	说明
*?	前一个字符0次或者无限次扩展，最小匹配
+?	前一个字符1次或者无限次扩展，最小匹配
??	前一个字符0次或者1次扩展，最小匹配
{m,n}?	扩展前一个字符m至n次（含n），最小匹配

上面表格的“字符”也可以替换成“组”，即括号内容也可以扩展，但是一个括号扩展后的结果还是一个括号，括号的数目没有变化

#例子：
import re
m=re.search(r'(\d\d)+','nino12345235s6789')
if m:
    print(m.string)
    print(m.re)
    print(m.pos)
    print(m.endpos)
    print(m.group())
    print("m.group(1): ",m.group(1))
    print("m.groups(): ", m.groups())
    print(m.start())
    print(m.end())
    print(m.span())

'''
输出：
nino12345235s6789
re.compile('(\\d\\d)+')
0
17
12345235
m.group(1):  35
m.groups():  ('35',)
4
12
(4, 12)
'''

Re库的另一种等价用法

re.compile(pattern,flags=0)
将正则表达式的字符串形式编译成正则表达式对象

---

3.Reference

${}^1$ https://blog.csdn.net/weixin_40907382/article/details/79654372 (修改了部分表格)