目录
1、re.match()函数和re.search()函数，实现字符串的正则匹配
3、re.compile() 函数,生成一个正则表达式（ Pattern ）对象
4、re.compile() 供 match() 和 search() 这两个函数的使用
6、re.finditer()使用，匹配的所有子串，迭代器返回
扫描二维码关注公众号，回复：
8677452 查看本文章
正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。它能帮助你方便的检查一个字符串是否与某种模式匹配。最常见的邮箱规则模式：[a-zA-Z0-9_-]+@[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)，什么意思呢？做数据清洗的时候想查出一些特定的字符，批量替换一些指定的字符怎么做？...等等，在python中，这些都可以用正则表达式处理函数进行处理。
re 模块使 Python 语言拥有全部的正则表达式功能。使用前导入该模块：import re
常用的正则表达式处理函数。
1、re.match()函数和re.search()函数，实现字符串的正则匹配
match 和 search 只匹配一次，当正则表达式在字符串中匹配到多个结果时，在不指定全部返回的情况下，只返回最先匹配到的第一个结果。
- re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
- 函数语法：re.match(pattern, string, [flags])
- re.search 扫描整个字符串从任意位置匹配并返回第一个成功的匹配。
- 函数语法：re.search(pattern, string, [flags])
- re.match与re.search的区别:
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。所以实际应用往往使用re.search()函数。
参数：
- pattern：匹配的正则表达式(参考后面的正则表达式匹配模式附件)。
- string：要匹配的字符串。
- flags：标志位，用于控制正则表达式的匹配方式（参考后面的flags匹配模式模块）
结果获取：
- span()：获取所匹配元素的起止位置
- start() ：返回匹配开始的位置
- end() ：返回匹配结束的位置
- group(num) / groups() ：我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
group(num=0)
匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。 groups() 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
re.match函数案例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import re
line = "This is a regular expression for python"
matchObj = re.match(r'(.*) is (.*?) .*', line, re.M | re.I)
if matchObj:
print("matchObj.span() :",matchObj.span())
print("matchObj.group() : ", matchObj.group())
print("matchObj.group(1) : ", matchObj.group(1))
print("matchObj.group(2) : ", matchObj.group(2))
print("matchObj.groups()) :", matchObj.groups())
else:
print("No match!!")
结果：
matchObj.span() : (0, 39)
matchObj.group() : This is a regular expression for python
matchObj.group(1) : This
matchObj.group(2) : a
matchObj.groups()) : ('This', 'a')re.search函数案例：
#re.search()函数，扫描整个字符串从任意位置匹配并返回第一个成功的匹配。
line = "This is a regular expression for python"
searchObj = re.search(r"a (.*) for (p.*n$)",line,re.M | re.I)
print("searchObj.span() :",searchObj.span())
print("searchObj.group() : ", searchObj.group())#重点使用
print("searchObj.group(1) : ", searchObj.group(1))
print("searchObj.groups() : ", searchObj.groups())
输出：
searchObj.span() : (8, 39)
searchObj.group() : a regular expression for python
searchObj.group(1) : regular expression
searchObj.groups() : ('regular expression', 'python')#re.mactch()函数和re.search()函数对比
import re
line = "This is a regular expression for python"
matchObj = re.match(r"python",line,re.M | re.I)
if matchObj:
print(matchObj.group())
else:
print("No match!!")
searchObj = re.search(r"python",line,re.M | re.I)
if searchObj:
print(searchObj.group())
else:
print("No search!!")
输出：
No match!!
python2、re.sub()函数,用于 检索和替换
Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。
语法：re.sub(pattern, repl, string, [count=0], [flags=0])
参数：
- pattern : 正则中的模式字符串。
- repl : 替换的字符串，也可为一个函数。
- string : 要被查找替换的原始字符串。
- count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
- flags：标志位，用于控制正则表达式的匹配方式，默认flags=0表示不进行特殊指定（参考后面的flags匹配模式模块）
案例：
#re.sub()函数 检索和替换
import re
line = "112-568-774" # 结果：==> 112568774
subObj = re.sub(r"\D","",line, count=0, flags=0)
print(subObj)
#repl 参数是一个函数.将匹配的数字乘以 2
line= 'A23G4HFD567' # 结果：==> A46G8HFD1134
def double(x):
x = int(x.group('value'))*2
return str(x)
print(re.sub('(?P<value>\d+)',double,line))
# ?P<value>的意思就是命名一个名字为value的组，匹配规则符合后面的/d+3、re.compile() 函数,生成一个正则表达式（ Pattern ）对象
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 、search() 、sub()、findall()、finditer()、split()等函数使用。
语法：
- pattern = re.compile(pattern[, flags])
- m = pattern.match()/pattern.search()/.... #函数参数与re.match()/re.search()/... 对比少写一个pattern参数即可,其他不变
re.compile(参数)：
- pattern : 一个字符串形式的正则表达式
- flags : 可选，表示匹配模式，比如忽略大小写，多行模式等
4、re.compile() 供 match() 和 search() 这两个函数的使用
语法：
- string = "字符串"
- pattern = re.compile(pattern [,flags])
- m = pattern.match(string [, pos[, endpos]]) 或者 m = pattern.seach(string [, pos[, endpos]])
- result = m.group()
参数：
- string : 待匹配的字符串。
- pos : 可选参数，指定字符串的起始位置，默认为 0。
- endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。
#编辑器：ipython
In [1]: import re
In [2]: pattern = re.compile(r"\d")
In [3]: m = pattern.match("abc123def456") #查找头部是否有数字
In [4]: print(m)
None
In [5]: m1 = pattern.search("abc123edf456")#查询字符串中的数字
In [6]: print(m1)
<re.Match object; span=(3, 4), match='1'>
In [7]: m2 = pattern.match("abc123456dfe",3,8) #指定起止位置的查找
In [8]: print(m2)
<re.Match object; span=(3, 4), match='1'>
In [9]: m3 = pattern.search("asd123456789gh",3,8) #指定起止位置的查找
In [10]: print(m3)
<re.Match object; span=(3, 4), match='1'>
In [11]: print(m3.group()) #返回结果
1
In [12]: #返回多值的正则表达式
In [13]: pattern = re.compile(r"\d+")
In [14]: m = pattern.search("asd123456789gh",3,8) #指定起止位置的查找
In [15]: print(m.group())
12345
In [16]: print(m.start(),m.end(),m.span())
3 8 (3, 8)5、findall()使用，匹配的所有子串，列表返回
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次，使用group()调用结果， findall 匹配所有，返回结果列表。
语法：
- pattern = re.compile(pattern [,flags])
- result = pattern.findall(string[, pos[, endpos]])
- 或者
- result = re.findall(pattern,string[, pos[, endpos]])
参数：
- string : 待匹配的字符串。
- pos : 可选参数，指定字符串的起始位置，默认为 0。
- endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。
import re
#re.compile() 供findall(string[, pos[, endpos]])使用
s = "a12b12c12d12"
parttern = re.compile(r"\d+")
result1 = parttern.findall(s)
print(result1) # ['12', '12', '12', '12']
result2 = parttern.findall(s,0,5)
print(result2) # ['12', '1']
#单独使用indall(string[, pos[, endpos]])
result3 = re.findall(r"\d+","20a20b20-20.20c2")
print(result3) #['20', '20', '20', '20', '20', '2']6、re.finditer()使用，匹配的所有子串，迭代器返回
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
语法：
- m = re.finditer(pattern, string, flags=0)
- 或者
- pattern = re.compile(pattern [,flags])
- m = pattern.finditer(string[, flags=0])
- #调用结果
- for i in m:
- v= i.group()
参数：
- pattern：匹配的正则表达式(参考后面的正则表达式匹配模式附件)。
- string：要匹配的字符串。
- flags：标志位，用于控制正则表达式的匹配方式（参考后面的flags匹配模式模块）
import re
pattern = re.compile(r"\d+")
it = pattern.finditer("12a32bc43jf3")
s = []
for i in it:
s.append(i.group()) #将结果转化为列表
print(s) #['12', '32', '43', '3']7、re.split()使用，将字符串分割后返回列表
split 方法按照能够匹配的子串将字符串分割后返回列表，
语法：re.split(pattern, string[, maxsplit=0, flags=0])
参数：
- pattern：匹配的正则表达式
- string：要匹配的字符串。
- maxsplit：分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
- flags：标志位，用于控制正则表达式的匹配方式
import re
s ="广东-广州-天河-2020-01-16"
pattern = re.compile(r"-")
s1 = pattern.split(s,maxsplit=3)
print(s1) #['广东', '广州', '天河', '2020-01-16']8、'(?P...)' 分组匹配
import re
s = '4225281994xxxxxxxx'
res = re.search('(?P<province>\d{3})(?P<city>\d{3})(?P<born_year>\d{4})',s)
print(res.groupdict())
#{'province': '422', 'city': '528', 'born_year': '1994'}附件1、flags匹配模式规则表
| 修饰符flags | 描述 |
| re.I | 忽略大小写 |
| re.L | 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境 |
| re.M | 多行模式 |
| re.S | 即为 . 并且包括换行符在内的任意字符（. 不包括换行符） |
| re.U | 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库 |
| re.X | 了增加可读性，忽略空格和 # 后面的注释 |
| 0 | flags=0表示不进行特殊指定 |
附件2、pattern正则表达式匹配模式规则表
| 模式pattern | 描述说明 |
| ^ | 匹配字符串的开头 |
| $ | 匹配字符串末尾 |
| . | 匹配任意字符，除了换行符[可以用flag=re.S解决换行] |
| [...] | 用来表示一组字符，单独列出：[jxr12] 表示匹配 'j'或'x'或'r'或1或2，[0-9]<=>[0123456789]，[A-Z]表示任意大写字母，[a-z]表示所有小写字母 |
| [^...] | 不在[]内的其他字符，如：[^abc]匹配除abc的其他字符 |
| re* | 0个或者多个表达式 |
| re+ | 1个或者多个表达式 |
| re? | 匹配0个或者1个由前面的正则式定义的片段，非贪婪方式。 |
| .* | .* 代表匹配除换行符之外的所有字符。 |
| .*? | .*? 后面多个问号，代表非贪婪模式，也就是说只匹配符合条件的最少字符 |
| re{n} | 精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。 |
| re{n,} | 匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*" 。 |
| re{n,m} | 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式 |
| x| y | 匹配x或者y |
| (re) | 匹配括号内的表达式，也表示一个组 |
| (?imx) | 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域 。 |
| (?-imx) | 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。 |
| (?: re) | 类似 (...), 但是不表示一个组 |
| (?imx: re) | 在括号中使用i, m, 或 x 可选标志 |
| (?-imx: re) | 在括号中不使用i, m, 或 x 可选标志 |
| (?#...) | 注释. |
| (?= re) | 前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。 |
| (?! re) | 前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功 |
| (?> re) | 匹配的独立模式，省去回溯。 |
| \w | 匹配字母数字及下划线 |
| \W | 匹配非字母数字及下划线 |
| \s | 匹配任意空白字符，等价于 [\t\n\r\f]. |
| \S | 匹配任意非空字符 |
| \d | 匹配任意数字，等价于 [0-9]. |
| \D | 匹配任意非数字 |
| \A | 匹配字符串开始 |
| \Z | 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。 |
| \z | 匹配字符串结束 |
| \G | 匹配最后匹配完成的位置。 |
| \b | 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。 |
| \B | 匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。 |
| \n, \t, 等. | 匹配一个换行符。匹配一个制表符。等 |
| \1...\9 | 匹配第n个分组的内容。 |
| \10 | 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。 |
| \ | 转义字符。如：\. 、\?、\* 转义为本身的意思 |
最后理解一下：[a-zA-Z0-9_-]+@[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)
表示a到z或A到Z或0到9任意1个或多个@a到z或A到Z或0到9任意1个或多个.a到z或A到Z或0到9任意1个或多个，
即：xx···x@xx···x.xx···x，如：[email protected]
