正则表达式Re模块

正则表达式只有一个功能，对字符串提取的一套规则，用来模糊匹配，比如匹配字母开头为a的。。。

匹配规则

单字符匹配

字符	功能
.	匹配除(换行\n)以外任意1个字符
[ ]	匹配【】中列举的字符
\d	匹配数字，即0-9
\D	匹配非数字，即不是数字
\s	匹配空白，即空格，tab键
\S	匹配非空白
\w	匹配单词字符，即a-z、A-Z、0-9、
\W	匹配非 a-z、A-Z、0-9、即匹配特殊字符

代表数量的元字符

字符	功能
*	匹配前一个字符出现0次或者无限次，即可有可无
+	匹配前一个字符出现1次或者无限次，即至少有1次
？	匹配前一个字符出现1次或者0次，“a?”  匹配"a"
{m}	匹配前一个字符出现m次
{m,}	匹配前一个字符至少出现m次
{m,n}	匹配前一个字符出现从m到n次

表示边界的元字符

字符	功能
^	匹配字符串开头
$	匹配字符串结尾
\b	匹配一个单词的边界
\B	匹配非单词边界

分组匹配

字符	功能
|	匹配左右任意一个表达式
(XX)	将括号中字符作为一个分组

分组

(XX)一个括号为一组
print(re.search(r"(\d+)\.(\d+)", "24.1632").group())   #24.1632

m = re.match(r"(?P<first_name>\w+) (?P<last_name>\w+)", "Malcolm Reynolds")
print(m.groupdict())   #{'first_name': 'Malcolm', 'last_name': 'Reynolds'}

| 或  左右其中一个表达式
print(re.match(r"abc|ABC","ABCabc Py4t6H8on123").group())  #ABC

r = re.search("(?P<name>[a-zA-Z]+)(?P<id>[0-9]+)","Python123")
print(r.groupdict())  #{'name': 'Python', 'id': '123'}

re.search(pattern, string, flags=0) 从整个文本中搜索

a = re.search(r"P.+\D","Hello Python123")
print(a.group())
结果
Python

a = re.search(r"P[a-zA-Z]+n","Hello PytHon123")  
print(a.group())   #PytHon

re.match(pattern, string, flags=0) （格式，字符串，标志= 0）从字符串开头为起点匹配

从字符串开头为起点匹配，前面格式，后面字符串，如匹配，则返回相应的匹配对象，如不匹配则返回None

import re
a = re.match("匹配\D+","匹配字符串")
print(a)
print(a.group())   #匹配到了什么
print(a.span())    #返回匹配结果的位置
结果
<re.Match object; span=(0, 5), match='匹配字符串'>
匹配字符串
(0, 5)

re.split(pattern, string, maxsplit=0, flags=0) 对字符串进行拆分，返回列表

import re
print(re.split(r'[a-f]+', 'Words, words, words.',1))   #None
print(re.split('[a-f]', '0a3B9', flags=re.IGNORECASE))   #忽略大小写 IGNORECASE

结果
['Wor', 's, words, words.']
['0', '3', '9']

re.findall()  对象为所有字符，寻找所有能匹配到的字符,返回列表

print(re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest'))

结果
['foot', 'fell', 'fastest']

print(re.findall(r"[0-9]{2}","Hello Py4t6H8on123"))  #['12']
print(re.findall(r"[0-9]{2,}","Hello Py4t6H8on123")) #['123']
print(re.findall(r"[0-9]{1,3}","Hello Py4t6H8on123"))  #['4', '6', '8', '123']
print(re.findall(r"abc|ABC","ABCabc Py4t6H8on123"))  #['ABC', 'abc']

re.sub()  数据替换        re.subn() 返回的是元组

s = """<div>
<p>岗位职责:</p>
<p>完成推荐算法、数据统计、接口、后台等服务器端相关工作</p>
<p><br></p>
<P>必备要求:</p>
<p>良好的自我驱动力和职业素养，工作积极主动、结果导向</p>
<p>&nbsp;<br></p>
</div>"""
print(re.sub(r'<.*?>|&\w*.',"",s))   #替换成空字符串

re.escape(pattern) 转义pattern中的特殊字符

re.purge()  清除正则表达式缓存

re.fullmatch(pattern, string, flags=0)  只能全匹配，匹配不了返回none

import re
print(re.fullmatch("H.","Hello Python123"))   #None

flags=

re.I或(re.IGNORECASE) 忽略大小写
re.S或(re.DOTALL) 改变 . 不能匹配\n的行为

print(re.findall(r't.*123',"TESasf123",re.I))   #['TESasf123']
print(re.findall(r'test.*123',"testasf\n123",re.S))   #['testasf\n123']

表达式对象

pattern = re.compile("doga")
print(pattern.search("dogasfdasdfasdfasdf"))   #文本搜索
#结果<re.Match object; span=(0, 4), match='doga'>
pattern = re.compile("o")
print(pattern.match("daogasdf",2))             #从开头搜索
#结果<re.Match object; span=(2, 3), match='o'>

pattern = re.compile(".+[g]")
print(pattern.fullmatch("doggie", 0, 3))  #全匹配
#结果<re.Match object; span=(0, 3), match='dog'>
print(pattern.split("doggie"))            #分裂 与函数相同split()
#结果['', 'ie']
print(pattern.findall("doggie", 0, 3))    #搜索 区域 下标0-3，返回列表
#结果['dog']
print(pattern.finditer("doggie", 0, 3))   #搜索 区域 下标0-3，返回iter
#结果<callable_iterator object at 0x000002E1BC31FC10>
print(pattern.sub("add","doggie"))        #替换
#结果addie
print(pattern.subn("add","doggie"))       #替换，返回元组
#结果('addie', 1)
print(pattern.flags)       #标志
#结果32
print(pattern.groups)      #获取组的数量
#结果0
print(pattern.groupindex)  #组索引，没有组符号返回空
#结果{}
print(pattern.pattern)     #查看所用模式
#结果 .+[g]