标签：groups 就是 ima 第一个 等等 除了 ali 理解 ble
一、正则表达式
re模块是python独有的匹配字符串的模块，该模块中提供的很多功能是基于正则表达式实现的，而正则表达式是对字符串进行模糊匹配，提取自己需要的字符串部分，它对所有的语言都通用。
1.常用元字符
| 字符 |
说明 |
| . |
匹配除换行符（\n)外的所有字符；如果DOTALL已指定标志，则它匹配包括换行符在内的任何字符
|
| \w |
匹配数字或字母或下划线，相当于[a-zA-Z0-9_] |
| \W |
匹配任意非数字、字母、下划线、汉字的字符[^a-zA-Z0-9_] |
| \s |
匹配任意的空白符，包括空格、制表符、换页符等等。等价于 [\f\n\r\t\v] |
| \S |
匹配任意非空白符；等价于[^\f\n\r\t\v] |
| \d |
匹配数字，相当于[0-9] |
| \D |
匹配非数字 ，相当于[^0-9] |
| \n |
匹配换行符 |
| \f |
匹配一个换页 |
| \r |
匹配一个回车 |
| \t |
匹配一个制表符 |
| \v |
匹配一个垂直制表符 |
| \b |
匹配字符串的开始或结束 |
| \B |
匹配非字符串的开始或结束 |
| ^ |
匹配字符串的开始 |
| $ |
匹配字符串的结束 |
| a|b |
匹配a或是b |
| () |
匹配括号内的表达式，也表示一个组；()内的字符是and的关系 |
| [...] |
匹配[]内字符组中的字符；[]内的字符是or的关系；例[abc]匹配a或b或c；[a-z]匹配小写字母；[0-9]匹配数字；[a-zA-Z0-9]匹配任意字母数字 |
| [^...] |
^放在[]内，表示非；匹配除了[]内字符组中的所有字符 |
2.常用限定符
| 代码 |
说明 |
| * |
重复0次或是多次，默认贪婪模式（尽可能匹配多的次数）；可以匹配0次，match()和search()不会返回None，会返回"" |
| + |
重复1次或是多次，默认贪婪模式 |
| ？ |
重复0次或是1次，默认贪婪模式 |
| *?/+?/?? |
非贪婪模式，尽可能匹配少的次数 |
| {n} |
重复n次 |
| {n,} |
重复n次或是更多次，默认贪婪模式 |
| {n,m} |
重复n到m次，包括n次和m次，默认贪婪模式 |
二、re模块
1.re.search(pattern, string, flags=0)
扫描整个string，找到匹配样式的第一个位置，并返回一个相应的匹配对象。如果没有匹配，就返回一个None ；
- pattern：正则表达式
- string：被匹配的字符串
- flags：可选匹配标志；正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志；以下是部分修饰符：
| 修饰符 |
描述 |
| re.I(IGNORECASE) |
是匹配对大小写不敏感 |
| re.S(DOTALL） |
使.可以匹配任意字符，包含\n |
| re.M |
多行匹配，影响^和$ |
| re.X |
允许编写更易于理解的表达式，通过分段和注释 |
| re.U |
根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B |
实例
import re
str = "abacad"
r = re.search("a.",str)
print(r) #<_sre.sre_match object span="(0," match="‘ab‘">; 返回的匹配对象
print(r.span()) #(0, 2)； 返回匹配字符串的位置，左闭右开
print(r.group()) #ab；整个匹配的字符串
print(r.groups()) #()；组
r1 = re.search("a.*",str) #贪婪匹配，匹配尽可能多的次数
print(r1) #<_sre.sre_match object span="(0," match="‘abacad‘">；
r2 = re.search("a.*?",str) #加?变成非贪婪匹配，匹配尽可能少的次数
print(r2) #<_sre.sre_match object span="(0," match="‘a‘">；
r3 = re.search("1",str)
print(r3) #None；匹配不到返回None
1.1 匹配对象Match
匹配对象总是有一个布尔值 True。如果没有匹配的话 match()和 search() 返回 None 所以你可以简单的用 if 语句来判断是否匹配
match = re.match(pattern,string)
if match:
process(match)
- Match.group([group1,...])：返回一个或是多个匹配的子组； 如果只有一个参数，就返回一个字符串，如果有多个参数，就返回一个元组； group()/group(0)返回整个匹配的字符串，group(1)表示返回第一个组，group(1,2)返回第一个组和第二个组组成的元组
- Match.groups(deflaut=None)：返回一个元组，包括所有匹配的组，default参数用于不参与匹配的情况，默认为None
- Match.groupdict(default=None)：返回一个字典，包含所有命名组，key是组名；default参数用于不参与匹配的组合，默认为None
- Match.start([group])/Match.end([group])：返回字符串开始匹配/结束匹配的位置(从0开始，开始是闭区间，结束时开区间)；group默认为0，表示整个匹配的字符串；start(1)表示第一个组的开始位置，如果组没有匹配，返回-1
- Match.span([group])：返回一个元组；对于一个匹配对象m，返回(m.start(group),m.end(group))；group默认为0，如果group没有在这个匹配中，就返回（-1，-1）
- Match.pos：返回正则引擎开始在字符串搜索第一个匹配的索引位置
- Match.endpos：返回正则引擎在结束搜索第一个匹配的索引位置
- Match.lastindex：返回捕获组的最后一个索引值，如果没有组，返回None
- Match.lastgroup：返回最后一个命名组的名字，如果没有就返回None
- Match.re：返回正则对象
- Match.string：返回被匹配的字符串
import re
#如果一个组匹配成功多次，就只返回最后一个匹配
m = re.search(r"(..)+","a1b2c3")
print(m) #匹配对象，<_sre.sre_match object span="(0," match="‘a1b2c3‘">
print(m.group(0)) #整个匹配的字符串，a1b2c3
print(m.group(1)) #第一个组，c3
print(m[0]) #整个匹配的字符串，a1b2c3
print(m[1]) #第一个组，c3
print(m.groups()) #所有组，(‘c3‘,)
print(m.start()) #开始位置，0
print(m.start(1)) #第一个组开始位置，4
print(m.span(1)) #第一个组位置，(4, 6)
print(m.pos) #正则开始搜索位置，0
print(m.endpos) #正则结束搜素位置,6
print(m.lastindex) #最后一个组的索引，1
print(m.re) #正则对象，re.compile(‘(..)+‘)
print(m.string) #被匹配的字符串，a1b2c3
2.re.match(pattern,string,flags=0)
从string的开始位置开始匹配正则表达式样式，匹配成功返回一个相应的匹配对象 ，匹配失败，就返回None
import re
str = "abacad"
r = re.match("a.",str)
print(r) #<_sre.sre_match object span="(0," match="‘ab‘">; 返回的匹配对象
print(r.span()) #(0, 2)； 返回匹配字符串的位置，左闭右开
print(r.group()) #ab；匹配的对象
r1 = re.match("b",str) #开头不能匹配到b，返回None
print(r1) #None
3.re,fullmatch(pattern,string,flags=0)
如果整个string匹配到正则表达式样式，就返回一个相应的匹配对象 。 否则就返回一个None
import re
str = "abacad"
#fullmatch()
r= re.fullmatch("a.",str)
print(r) #None
r1= re.fullmatch("a.*",str)
print(r1) #<_sre.sre_match object span="(0," match="‘abacad‘">
4. re.split(pattern,string,maxsplit=0,flags=0)
用pattern分开string ，返回一个列表； 如果在pattern中捕获到括号，那么所有的组里的文字也会包含在列表里。如果maxsplit非零， 最多进行maxsplit次分隔， 剩下的字符全部返回到列表的最后一个元素。
#re.split，如果字符串的开头或结尾匹配到了，返回的列表的第一个元素或是最后一个元素是空字符串
import re
str = "abcdabcdeabcdef"
s = re.split("abc",str)
print(s)
s1 = re.split("a(bc)",str)
print(s1)
5. re.findall(pattern,string,flags=0）
从左到右在string中找到所有匹配正则表达式的子串，并返回一个列表，没有匹配返回空列表。如果样式里存在一到多个组，就返回一个组合列表；就是一个元组的列表（如果样式里有超过一个组合的话）。空匹配也会包含在结果里。
#findall,如果正则表达式里面没有组，返回的是整个正则匹配的字符串；
#如果正则里面有组，则返回匹配组的字符串；如果正则里有多个组，则用元组包裹
import re
str = "abc123wer234dfg345"
r = re.findall(r"\D\d+",str)
print(r)
r1 = re.findall(r"(\D)\d+",str)
print(r1)
r2 = re.findall(r"(\D)(\d)\d+",str)
print(r2)
6. re.sub(pattern,repl,string,count=0,flags=0)
用repl替换pattern匹配的字符串（匹配一个替换一个），返回替换后的字符串，如果没有匹配返回原字符串
repl：可以是字符串也可以是函数；如果是字符串，其中的反斜杠转义序列会被处理，例如\n会被转移成换行符，\1会用样式中的匹配到的第一组子串来替换；如果是函数，参数会调用pattern的match对象
count：模式匹配后替换的最大次数；默认是0，全部替换
import re
#repl是字符串
str = "abc123wer234dfg345"
s = re.sub("[a-z]+","字母",str,2)
print(s)
s1 = re.sub("([a-z]{2})[a-z]","字母",str) #会替换整个正则匹配的字符串，而不是括号内的子串
print(s1)
#repl是函数
def f(a):
print(a)
return a.group()+"字母"
s2 = re.sub("[a-z]+",f,str)
print(s2)
7. re.escape(string) :对字符串内的特殊字符串进行转义
import re
e = re.escape("http://www.baidu.com")
print(e) #http\:\/\/www\.baidu\.com
8. re.compile(pattern [,flags])
编译正则表达式，生成一个正则表达式(pattern)对象；如果一个正则表达式会多次匹配，使用这种方式
import re
str = "abc123wer234dfg345"
pattern = re.compile(r"\D(\d)\d+")
print(pattern)
#match方法
m = pattern.match(str)
print(m) #None
#search方法
s = pattern.search(str)
print(s) #<_sre.sre_match object span="(2," match="‘c123‘">
#findall方法
f = pattern.findall(str)
print(f) #[‘1‘, ‘2‘, ‘3‘]
#sub方法，把匹配的字符串替换成第一个组
s1 = pattern.sub(r"\1",str)
print(s1) #ab1we2df3
print(pattern.groups) #1，pattern对象的组的对象
print(pattern.pattern) #\D(\d)\d+，打印写的正则表达式
三、其他正则表达式
1.分组
| (...) |
分组匹配，从左到右，每匹配一个分组，索引+1 |
| \number |
例\1匹配第一个组，这个特殊序列只能匹配前面99个组合，如果数字的开头是0或是三位数，会代表八进制数 |
| \g
|
例\g匹配第一个组，不能直接用于正则表达式中，可以用于sub中repl |
| (?P...)
|
命名组合 |
| (?P=name) |
匹配上面的命名组合；虽然在括号内，但是不是一个组 |
import re
str = "abcbce"
r = re.search(r"(a)(b)\w(\2)\w",str) #\2表示第二个组b
print(r)
print(r.groups())
# r1 = re.search(r"(a)(b)\w(\g)\w",str) #此种方式会报错sre_constants.error: bad escape \g at position 9
# print(r1)
r1 = re.sub(r"(a)(b)","a\gc",str)
print(r1)
r2= re.search(r"(?Pa)(?Pb)\w(?P=名字2)\w",str)
print(r2)
print(r2.groups())
print(r2.groupdict())
r3= re.sub(r"(?Pa)(?Pb)","dd\g",str)
print(r3)
2.特殊构造
| (?:...) |
()里面有?:表示不是分组 |
| (?aiLmsux) |
字符对正则表达式设置以下标记 re.A (只匹配ASCII字符), re.I (忽略大小写), re.L (语言依赖), re.M (多行模式), re.S (点dot匹配全部字符), re.U (Unicode匹配), and re.X (冗长模式) |
| (?#...) |
注释，里面的内容会被忽略 |
| (?=...) |
表示匹配...的表达式，对后进行匹配 |
| (?!...) |
表示不匹配...的表达式，对后进行匹配 |
| (?(id/name)yes-pattern|no-pattern) |
如果id/name表示的组匹配成功，则使用yes-pattern匹配，否则使用no-pattern匹配 |
import re
#(?:...)表示()里面的不是组
r = re.search(r"(?:a)bc","abcd")
print(r) #<_sre.sre_match object span="(0," match="‘abc‘">
print(r.groups()) #()
#(?=...)表示匹配...的表达式；对后面进行匹配
pattern = re.compile(r"\w(?=\d)")
r1 = pattern.findall("abc123efg456")
print(r1) #[‘c‘, ‘1‘, ‘2‘, ‘g‘, ‘4‘, ‘5‘]
#(?
r2 = re.findall(r"(?","abc132efg456")
print(r2) #[‘3‘, ‘2‘, ‘e‘, ‘5‘, ‘6‘]
#(?!...)表示不匹配...表达式，对后进行匹配
r4 = re.findall(r"\w(?!\d)","abc123efg456")
print(r4) #[‘a‘, ‘b‘, ‘3‘, ‘e‘, ‘f‘, ‘6‘]
#(?
r5 = re.findall(r"(?","abc132efg456")
print(r5) #[‘a‘, ‘b‘, ‘c‘, ‘1‘, ‘f‘, ‘g‘, ‘4‘]
#(?(id/name)yes-pattern|no-pattern) 如果id/name表示的组匹配，就yes-pattern;不匹配就no-pattern
pattern = re.compile(r"(a)\w(?(1)\d|\w)")
r6 = pattern.search("abca12345")
print(r6) #<_sre.sre_match object span="(3," match="‘a12‘">
r7 = pattern.search("abcdefg")
print(r7) #None
#(?i) #忽略大小写
r8 = re.findall(r"(?i)abc","abcAbcABC")
print(r8) #[‘abc‘, ‘Abc‘, ‘ABC‘]
python---re模块
标签：groups 就是 ima 第一个 等等 除了 ali 理解 ble
原文地址：https://www.cnblogs.com/he-202007/p/14039296.html