python基础—re模块下的函数及匹配对象的属性与方法（re.match()/re.search()...等）
文章目录
- 一、re模块下的函数
-
- 1.re.match()
- 2.re.search()
- 3.re.fullmatch()
- 4.re.findall()
- 5.re.finditer()
- 6.re.split()
- 7.re.sub()
- 8.re.compile()
-
- 正则对象的方法和属性
- 二、re模块下函数的匹配对象
一、re模块下的函数
1.re.match()
re.match() 函数是从头开始匹配一个符合规则的字符串，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None。
函数语法：
re.match(pattern,string,flags=0)
参数说明如下：
| 参数 | 描述 |
|---|---|
| pattern | 匹配正则表达式 |
| string | 要匹配的字符串 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等 |
要求：匹配"hello"字符串。
import re
result=re.match("hello","hello world")
print(result)
输出结果：
2.re.search()
re.search() 函数会在整个字符串内查找匹配，只要找到第一个匹配然后返回，如果字符串没有匹配，则返回None。
函数语法：
re.search(pattern,string,flags=0)
参数说明如下：
| 参数 | 描述 |
|---|---|
| pattern | 匹配正则表达式 |
| string | 要匹配的字符串 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等 |
要求：匹配出文章阅读的次数。
import re
ret = re.search(r"\d+", "阅读次数为 9999")
print(ret.group())
输出结果：
9999
3.re.fullmatch()
re.fullmatch() 函数要求整个字符串完全匹配到正则表达式，就返回一个相应的匹配对象，否则就返回一个None。
函数语法：
re.fullmatch(pattern, string, flags=0)
参数说明如下：
| 参数 | 描述 |
|---|---|
| pattern | 匹配正则表达式 |
| string | 要匹配的字符串 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等 |
要求：匹配出"hello"字符串。
import re
result=re.fullmatch("hello","hello world")
if result:
print(result.group())
else:
print("匹配失败!")
输出结果：
匹配失败!
re.match() 、re.search() 和 re.fullmatch()三者区别
- match()函数只检测RE是不是在string的开始位置匹配
- search()函数会扫描整个string查找匹配
- fullmatch()函数会扫描整个string是否完全匹配
- match()只有在0位置匹配成功才有返回，如果不是开始位置匹配成功的话，match()则返回none。fullmatch()要整个字符串完全匹配上，从0位置开始到结束位置，如果不是，fullmatch()则返回none。
import re
print(re.match('super', 'superstition').span())
print(re.match('super','insuperable'))
输出结果：
(0, 5)
None
import re
print(re.search('super','superstition').span())
print(re.search('super','insuperable').span())
输出结果：
(0, 5)
(2, 7)
import re
print(re.fullmatch('super','superstition').span())
print(re.fullmatch('super','insuperable').span())
print(re.fullmatch('super','super').group())
输出结果：
None
None
super
4.re.findall()
re.findall() 函数在字符串中找到正则表达式所匹配的所有子串，按顺序返回一个列表，如果没有找到匹配的，则返回空列表。
函数语法：
re.findall(pattern,string,flags=0)
参数说明如下：
| 参数 | 描述 |
|---|---|
| pattern | 匹配正则表达式 |
| string | 要匹配的字符串 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等 |
- 如果有且仅有一个组，则返回与该组匹配的字符串列表。
要求：匹配出所有的数字。
import re
print(re.findall(r"\d+","abafa 124ddwa56"))
输出结果：
[‘124’, ‘56’]
要求：匹配出f开头且左边是空字符串的单词。
import re
print(re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest'))
输出结果：
[‘foot’, ‘fell’, ‘fastest’]
- 如果有多个组，返回与这些匹配的字符串元组列表。
import re
print(re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10'))
输出结果：
[(‘width’, ‘20’), (‘height’, ‘10’)]
5.re.finditer()
re.finditer() 函数在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
函数语法：
re.finditer(pattern,string,flags=0)
参数说明如下：
| 参数 | 描述 |
|---|---|
| pattern | 匹配正则表达式 |
| string | 要匹配的字符串 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等 |
要求：匹配出所有的数字。
import re
it = re.finditer(r"\d+", "12a32bc43jf3")
for match in it:
print(match.group())
输出结果：
12
32
43
3
6.re.split()
re.split() 函数按照能够匹配子串将字符串分割后返回列表。
函数语法：
re.split(pattern, string[, maxsplit=0, flags=0])
参数说明如下：
| 参数 | 描述 |
|---|---|
| pattern | 匹配正则表达式 |
| string | 要匹配的字符串 |
| maxsplit | 分隔次数，maxsplit=1分隔一次，默认为0，不限制次数。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等 |
用pattern分隔开string。
要求：用非a-zA-Z0-9_字符切分字符串。
import re
re.split(r'\W+','Words, words, words.')
输出结果：
[‘Words’, ‘words’, ‘words’, ‘’]
- 如果maxsplit非零，最多进行maxsplit分隔，剩下的字符全部返回到列表的最后一个元素。
要求：用非a-zA-Z0-9_字符切分字符串且只分隔一次。
re.split(r'\W+', 'Words, words, words.', 1)
输出结果：
[‘Words’, ‘words, words.’]
- 如果pattern中捕获到括号，那么所有的组里的文字也会包含在列表里。
re.split(r'(\W+)', 'Words, words, words.')
输出结果：
[‘Words’, ', ', ‘words’, ', ', ‘words’, ‘.’, ‘’]
- 如果分隔符里有捕获组合，并且在匹配字符串的开始，那么结果将会以一个空字符串开始，对于结尾也是一样。
re.split(r'(\W+)', '...words, words...')
输出结果：
[‘’, ‘…’, ‘words’, ', ', ‘words’, ‘…’, ‘’]
- 用正则表达式切分字符串比用固定的字符更灵活。
正常的切分代码：
'a b c'.split(' ')
输出结果：
[‘a’, ‘b’, ‘’, ‘’, ‘c’]
无法识别连续的空格，用正则表达式试试：
import re
print(re.split(r'\s+','a b c'))
#无论多少个空格都可以正常分割。加入,
print(re.split(r'[\s\,]+', 'a,b, c d'))
#再加入;
print(re.split(r'[\s\,\;]+', 'a,b;; c d'))
输出结果：
[‘a’, ‘b’, ‘c’]
[‘a’, ‘b’, ‘c’, ‘d’]
[‘a’, ‘b’, ‘c’, ‘d’]
7.re.sub()
re.sub() 函数用于替换字符串中的匹配项。
函数语法：
re.sub(pattern, repl, string, count=0, flags=0)
参数说明如下：
| 参数 | 描述 |
|---|---|
| pattern | 匹配正则表达式 |
| repl | 替换的字符串，也可以是一个函数。 |
| string | 要被查找替换的原始字符串。 |
| count | 模式匹配后替换的最大次数，默认0表示替换所有的匹配。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等 |
前三个必选参数，后两个为可选参数。
要求：删除注释，移除非数字的内容。
import re
phone = "2004-959-559 # 这是一个电话号码"
# 删除注释
num = re.sub(r'#.*$', "", phone)
print("电话号码 : ", num)
# 移除非数字的内容
num = re.sub(r'\D', "", phone)
print("电话号码 : ", num)
输出结果：
电话号码 : 2004-959-559
电话号码 : 2004959559
- repl参数可以是一个函数，正则表达式使用了 (?P…) 语法，将匹配到的数字部分的字符串命名为value。
要求：将匹配的数字乘于 2。
import re
# 将匹配的数字乘于 2
def double(matched):
value = int(matched.group('value'))
return str(value * 2)
s = 'A23G4HFD567'
print(re.sub('(?P\d+)' , double, s))
输出结果：
A46G8HFD1134
8.re.compile()
re.compile() 函数将正则表达式的样式编译为一个正则表达对象（正则对象），可以用于匹配，通过这个对象的方法match()，search()以及其他。
这个表达式的行为可以通过指定标记的值来改变，值可以是以下任意变量。
prog=re.compile(pattern)
result=prog.match(string)
等价于
result=re.match(pattern,string)
如果需要多次使用这个正则表达式的话，使用re.compile()和保存这个正则对象以便利用，可以让程序更加高效。
正则对象的方法和属性
用compile编译后的正则表达式对象支持以下方法和属性：
-
pattern.search(string[, pos[, endpos]])
扫描整个string寻找第一个匹配的位置，并返回一个相应的匹配对象。如果没有匹配，就返回None。pos参数可以选择字符串开始搜索的位置索引，默认为0，它不完全等价于字符串切片，'^'样式字符匹配字符串真正的开关，和换行符后面的第一个字符，但不会匹配索引 规定开始的位置。
可选的参数endpos限定了字符串搜索的结束，它假定字符串长度到endpos,所以只有从pos到endpos-1的字符会被匹配，如果endpos小于pos,就不会有匹配产生，另个，如果rx是一个编译后的正则对象，rx.search(string,0,50) 等价于rx.search(string[:50],0)。
import re
pattern=re.compile("o")
print(pattern.search("dog"))
print(pattern.search("dog",2))
输出结果：
None
-
pattern.match(string[, pos[, endpos]])
如果 string 的 开始位置 能够找到这个正则样式的任意个匹配，就返回一个相应的 匹配对象。如果不匹配，就返回 None。pos参数可以选择字符串开始搜索的位置索引，默认为0，它不完全等价于字符串切片，'^'样式字符匹配字符串真正的开关，和换行符后面的第一个字符，但不会匹配索引 规定开始的位置。
import re
pattern=re.compile("o")
print(pattern.match("dog"))
print(pattern.match("dog",1))
输出结果：
None
-
pattern.fullmatch()
如果整个string匹配这个正则表达式，就返回一个相应的匹配对象。否则就返回None。可选参数 pos 和 endpos 与 search() 含义相同。
import re
pattern=re.compile("o[gh]")
print(pattern.fullmatch("dog"))
print(pattern.fullmatch("ogre"))
print(pattern.fullmatch("doggie",1,3))
输出结果：
None
None
-
pattern.findall(string[, pos[, endpos]])
类似函数 findall() ， 使用了编译后样式，但也可以接收可选参数 pos 和 endpos ，限制搜索范围，就像 search()。 -
pattren.finditer(string[, pos[, endpos]])
类似函数 finditer() ， 使用了编译后样式，但也可以接收可选参数 pos 和 endpos ，限制搜索范围，就像 search()。 -
pattern.split(string, maxsplit=0)
等价于 split() 函数，使用了编译后的样式。 -
pattern.sub(repl, string, count=0)
等价于 sub() 函数，使用了编译后的样式。
二、re模块下函数的匹配对象
正则表达式的函数一旦匹配成功，就是object对象，匹配对象支持以下方法和属性：
group() 返回被 RE 匹配的字符串
- 如果只有一个参数，结果就是一个字符串，如果没有参数，默认为0，相应的返回值就是整个匹配字符串。
m=re.match(r"(\w+) (\w+)", "I love you, Tom")
m.group()
m.group(0)
输出结果：
‘I love’
- 如果它是一个范围[1…99]，结果就是相应的括号组字符串。
m.group(1)
m.group(2)
输出结果：
‘I’
‘love’
- 如果有多个参数，结果就是一个元组，第个参数对应一个。
m.group(1,2)
输出结果：
(‘I’, ‘love’)
- 如果正则表达式使用了(?P…) 语法， groupN 参数就也可能是命名组合的名字。如果一个字符串参数在样式中未定义为组合名，就引发一个 IndexError 异常。
import re
m=re.match(r"(?P\w+) (?P\w+)" , "Malcolm Reynolds")
print(m.group("first_name"))
print(m.group("last_name"))
输出结果：
Malcolm
Reynolds
- 命名组合同样可以通过索引值引用
print(m.group(1))
print(m.group(2))
输出结果：
Malcolm
Reynolds
- 3.6版本后可以直接Match.getitem(g)，等价于m.group(g)。
print(m[1])
print(m[2])
print(m['first_name'])
print(m['last_name'])
输出结果：
Malcolm
Reynolds
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配 (开始,结束) 的位置
import re
result=re.match("hello","hello world")
print(result.start())
print(result.end())
print(result.span())
输出结果：
0
5
(0, 5)
匹配对象总是有一个布尔值 True。 所以可以简单的用 if 语句来判断是否匹配
import re
result=re.match("hello","hello world")
if result:
print(result.group())
else:
print("匹配失败!")
输出结果：
hello
参考文章：
https://docs.python.org/zh-cn/3/library/re.html#functions
https://www.cnblogs.com/CYHISTW/p/11363209.html
https://blog.csdn.net/weixin_38819889/article/details/93846579
https://blog.csdn.net/sodaloveer/article/details/128444428?spm=1001.2014.3001.5501