正则表达式常用操作符：
| 操作符 | 说明 | 实例 |
|---|---|---|
| . | 表示任何单个字符，不包括换行符 | |
| [] | 字符集，对单个字符给出取值范围 | [abc]表示a、b、c，[a-z]表示a到z单个字符 |
| [^ ] | 非字符集 | [^abc]表示非a或b或c |
| * | 前一个字符0次或无限次扩展 | abc*表示ab、abc、abcc、abccc、…… |
| + | 前一个字符一次或无限次扩展 | abc+表示abc、abcc、abccc、…… |
| ？ | 前一个字符0次或1次扩展 | abc?表示ab、abc |
| | | 左右表达式任意一个 | abc|def表示abc、def |
| {m} | 扩展前一个字符m次 | ab{2}c表示abbc |
| {m,n} | 扩展前一个字符m至n次（含n） | {ab{1,2}c表示abc、abbc |
| ^ | 匹配字符串开头 | ^abc表示abc且在一个字符串的开头 |
| $ | 匹配字符串结尾 | abc$表示abc且在一个字符串的结尾 |
| () | 分组标记，内部只能有|操作符 | (abc)表示abc，(abc |
| \d | 数字 | |
| \w | 单词字符，等价于[A-Za-z0-9] |
import re
re库常用方法：
| 函数 | 说明 |
|---|---|
| re.search() | 在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象 |
| re.match() | 从一个字符串的开始位置起匹配正则表达式，返回match对象 |
| re.findall() | 搜索字符串，以列表类型返回全部能匹配的子串 |
| re.split() | 将字符串按照正则表达式匹配结果进行分割，返回列表类型 |
| re.finditer() | 搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象 |
| re.sub() | 在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串 |
flags：正则表达式使用时的控制标记
| 常用标记 | 说明 |
|---|---|
| re.I re.IGNORECASE | 忽略大小写，[A-Z]可以匹配小写字母 |
| re.M re.MULTILINE | ^操作符能够将给定的字符串每行都当作匹配开始 |
| re.S re.DOTALL | .操作符能够匹配所有字符，包括换行符 |
s = "abc 123 abc 456"
match = re.search("\d+", s)
print("match的类型：", type(match))
print("匹配的子串：", match.group(0))
match的类型： <class ‘re.Match‘>
匹配的子串： 123
s = "123 abc"
match = re.match("\d+", s)
print("match的类型：", type(match))
print("匹配的子串：", match.group(0))
print("----------------")
s = "abc 123 abc"
match = re.match("\d+", s)
print("match的类型：", type(match))
try:
print("匹配的子串：", match.group(0))
except:
pass
match的类型： <class ‘re.Match‘>
匹配的子串： 123
----------------
match的类型： <class ‘NoneType‘>
s = "abc 123 456 bcd 23 dsssa12"
match = re.findall("1\d+", s) # 以1开头的数字
match
[‘123‘, ‘12‘]
s = "abc 123 456 bcd 23 dsssa12"
match = re.finditer("1\d+", s)
while True:
try:
print(next(match).group(0))
except:
break
123
12
maxsplit：最大分隔数，将剩余部分作为一个整体当作最后一个元素，默认的0表示最大分隔
s = "abc 123 456 bcd 23 dsssa12"
match1 = re.split("\d{2}", s) #以连续的两个数字作为分隔条件
match2 = re.split("\d{2}", s, maxsplit=2) #以连续的两个数字作为分隔条件
print(match1, match2)
[‘abc ‘, ‘3 ‘, ‘6 bcd ‘, ‘ dsssa‘, ‘‘] [‘abc ‘, ‘3 ‘, ‘6 bcd 23 dsssa12‘]
repl：将匹配的子串换成该字符串
s = "abc 123 456 bcd 23 dsssa12"
s1 = re.sub("[0-9][^a-z]*", "**", s)
s2 = re.sub("[0-9][^a-z]*", "**", s, count=2)
print(s1, s2, sep=‘\n‘)
abc **bcd **dsssa**
abc **bcd **dsssa12
s = "abc 123 456 bcd 23 dsssa12"
pat = re.compile("\d+")
rst = pat.search(s)
print(rst.group(0))
rst = pat.findall(s)
print(rst)
123
[‘123‘, ‘456‘, ‘23‘, ‘12‘]
s = "sdf 123 asd"
match = re.search("\d+", s)
print(match.string) # 被匹配的文本
print(match.re) # 匹配时使用的pattern对象
print(match.pos) # 从该位置开始搜索的文本
print(match.endpos) # 搜索文本的结束位置
print(match.group(0)) # 一般的正则表达式使用group(0)就可以获得匹配的字符串
print(match.start()) # 匹配的字符串在原字符串中的起始位置
print(match.end()) # 匹配的字符串在原字符串中的结束位置
print(match.span()) # 起始和结束位置的元组
sdf 123 asd
re.compile(‘\\d+‘)
0
11
123
4
7
(4, 7)
s = "PYANBNCNDN"
match = re.search("PY.*N", s)
print(match.group(0))
PYANBNCNDN
对于代码中的模式串和字符串，正则匹配可以有"PYAN"、"PYANBN"、"PYANBNCN"、"PYANBNCNDN"些个匹配结果。
而上述代码说明re库默认是贪婪匹配，即输出最长的子串。
下面将贪婪模式改成最小模式:
| 操作符 | 说明 |
|---|---|
| *? | 将*扩展为最小匹配 |
| +? | 将+扩展为最小匹配 |
| ?? | 将?扩展为最小匹配 |
| {m,n}? | 将{m,n}扩展为最小匹配 |
当我们发现一个模式串中的每个操作符可匹配不同长度的子串时，我们都可以在该操作符的后面添加?来获得最小匹配。
match = re.search("PY.*?N", s)
print(match.group(0))
PYAN
原文：https://www.cnblogs.com/xxmmqg/p/13285530.html