一 正则表达式，又称规则表达式，英文名为Regular Expression，在代码中常简写为regex、regexp或RE，是计算机科学的一个概念。正则表通常被用来检索、替换那些符合某个模式(规则)的文本。实现过滤的功能。
1元字符
w 匹配字母（包含汉字），数字，下划线
d 匹配十进制数字
s 匹配空白字符
匹配换行符
匹配制表符
^ 匹配字符串的开始
$匹配字符串的末尾
a|b 匹配a或者b
[ ]字符集，只能取其中的一个
[^.. ] 匹配除了字符集内所有的字符外的字符
2 量词
每个量词只控制前一个字符的出现次数
默认模式是贪婪匹配
量词后面加？，为非贪婪匹配
* 重复零次或多次
+ 重复一次或多次
？ 重复零次或一次
{n}重复n次
{n,m}重复n到m次
3 惰性匹配
？
4 ( ) 分组 对多个字符进行整体的量词约束
| 或
1、普通字符和11个元字符：
| 普通字符 |
匹配自身
|
abc
|
abc
|
|
.
|
匹配任意除换行符" "外的字符(在DOTALL模式中也能匹配换行符 |
a.c
|
abc
|
|
转义字符，使后一个字符改变原来的意思
|
a.c;a\c
|
a.c;ac
|
|
|
*
|
匹配前一个字符0或多次
|
abc*
|
ab;abccc
|
|
+
|
匹配前一个字符1次或无限次
|
abc+
|
abc;abccc
|
|
?
|
匹配一个字符0次或1次
|
abc?
|
ab;abc
|
|
^
|
匹配字符串开头。在多行模式中匹配每一行的开头 | ^abc |
abc
|
|
$
|
匹配字符串末尾，在多行模式中匹配每一行的末尾 | abc$ |
abc
|
| | | 或。匹配|左右表达式任意一个，从左到右匹配，如果|没有包括在()中，则它的范围是整个正则表达式 |
abc|def
|
abc
def
|
| {} | {m}匹配前一个字符m次，{m,n}匹配前一个字符m至n次，若省略n，则匹配m至无限次 |
ab{1,2}c
|
abc
abbc
|
|
[]
|
字符集。对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，如[abc]或[a-c]。[^abc]表示取反，即非abc。 所有特殊字符在字符集中都失去其原有的特殊含义。用反斜杠转义恢复特殊字符的特殊含义。 |
a[bcd]e
|
abe
ace
ade
|
|
()
|
被括起来的表达式将作为分组，从表达式左边开始没遇到一个分组的左括号“（”，编号+1. 分组表达式作为一个整体，可以后接数量词。表达式中的|仅在该组中有效。 |
(abc){2} a(123|456)c |
abcabc
a456c
|
这里需要强调一下反斜杠的作用：
- 反斜杠后边跟元字符去除特殊功能；（即将特殊字符转义成普通字符）
- 反斜杠后边跟普通字符实现特殊功能；（即预定义字符）
- 引用序号对应的字组所匹配的字符串。
a=re.search(r'(tina)(fei)haha2','tinafeihahafei tinafeihahatina').group() print(a) 结果： tinafeihahafei
2、预定义字符集（可以写在字符集[...]中）
|
d
|
数字:[0-9] |
ac
|
a1c
|
|
D
|
非数字:[^d] |
aDc
|
abc
|
|
s
|
匹配任何空白字符:[<空格> fv] |
asc
|
a c
|
| S | 非空白字符:[^s] |
aSc
|
abc
|
|
w
|
匹配包括下划线在内的任何字字符:[A-Za-z0-9_] |
awc
|
abc
|
|
W
|
匹配非字母字符，即匹配特殊字符 |
aWc
|
a c
|
|
A
|
仅匹配字符串开头,同^ | Aabc |
abc
|
| 仅匹配字符串结尾，同$ |
abc
|
abc
|
|
| 匹配w和W之间，即匹配单词边界匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。 | abc a!bc |
空格abc空格 a!bc |
|
|
B
|
[^] |
aBbc
|
abc
|
这里需要强调一下的单词边界的理解： w = re.findall('tina','tian tinaaaa') print(w) s = re.findall(r'tina','tian tinaaaa') print(s) v = re.findall(r'tina','tian#tinaaaa') print(v) a = re.findall(r'tina','tian#tina@aaa') print(a) 执行结果如下： [] ['tina'] ['tina'] ['tina']
3、特殊分组用法：
|
(?P<name>)
|
分组，除了原有的编号外再指定一个额外的别名 | (?P<id>abc){2} |
abcabc
|
|
(?P=name)
|
引用别名为<name>的分组匹配到字符串 | (?P<id>d)abc(?P=id) |
1abc1
5abc5
|
|
<number>
|
引用编号为<number>的分组匹配到字符串 | (d)abc1 |
1abc1
5abc5
|
二 re模块的方法
1 findall，返回列表， 在findall中优先显示( )内的东西。（？：）取消优先级。
import re ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com') print(ret) # ['oldboy'] 这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可 ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com') print(ret) # ['www.oldboy.com']
2 match ，如果没有找到，返回值是None。如果不为空，调用返回值的group( )方法。
ret = re.match('a', 'abc').group() # 同search,不过尽在字符串开始处进行匹配 print(ret) #结果 : 'a'
*注：match和search一旦匹配成功，就是一个match object对象，而match object对象有以下方法：
- group() 返回被 RE 匹配的字符串
- start() 返回匹配开始的位置
- end() 返回匹配结束的位置
- span() 返回一个元组包含匹配 (开始,结束) 的位置
- group() 返回re整体匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串。
a. group（）返回re整体匹配的字符串，
b. group (n,m) 返回组号为n，m所匹配的字符串，如果组号不存在，则返回indexError异常
c.groups（）groups() 方法返回一个包含正则表达式中所有小组字符串的元组，从 1 到所含的小组号，通常groups()不需要参数，返回一个元组，元组中的元就是正则表达式中定义的组。
3 search ,如果没有找到，返回值是None。如果不为空，调用返回值的group( )方法。
针对match，seach，一般是这样用。
ret = re.search('a', 'eva egon yuan').group() print(ret) #结果 : 'a' # 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以 # 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
4 split，切割。加上( ) ，保留被分割的对象。
print(re.split('d','abc123qwe')) print(re.split('(d)','abc123qwe')) 输出结果 ['abc', '', '', 'qwe'] ['abc', '1', '', '2', '', '3', 'qwe']
5 sub，替换，与字符串的replace方法一样，默认全部替换，同样也可以指定替换的个数。
import re print(re.sub('d','A','123abc',1)) print(re.sub('d','A','123abc',)) 输出结果 A23abc AAAabc
6 compile 将正则表达式编译成一个正则表达式对象。后面直接用正则表达式对象调用re模块方法，就可以了。
import re obj=re.compile('d+') print(obj.match('123abv').group()) 输出结果 123
7 finditer 返回的结果是一个迭代的。for循环遍历得到的元素，本质上是调用match方法得到的，所以然后调用元素的group( )方法。
import re res=re.finditer('d','abc123qwe') print(res,type(res)) for i in res: print(type(i),i.group()) 输出结果 <callable_iterator object at 0x000001C573FE6DA0> <class 'callable_iterator'> <class '_sre.SRE_Match'> 1 <class '_sre.SRE_Match'> 2 <class '_sre.SRE_Match'> 3
三 举例
匹配小数 点是特殊字符，必须转义
import re print(re.findall('d+.d+','2.14')) 输出结果 ['2.14']
匹配整数
import re res=re.findall('d+.d+|(d+)','2.14,50,12') while '' in res: res.remove('') print(res) 输出结果 ['50', '12']
四、一些注意点
1、re.match与re.search与re.findall的区别：
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
a=re.search('[d]',"abc33").group() print(a) p=re.match('[d]',"abc33") print(p) b=re.findall('[d]',"abc33") print(b) 执行结果： None ['3', '3']
2、贪婪匹配与非贪婪匹配
*?,+?,??,{m,n}? 前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配
a = re.findall(r"a(d+?)",'a23b') print(a) b = re.findall(r"a(d+)",'a23b') print(b) 执行结果： ['2'] ['23'] a = re.match('<(.*)>','<H1>title<H1>').group() print(a) b = re.match('<(.*?)>','<H1>title<H1>').group() print(b) 执行结果： <H1>title<H1> <H1>
a = re.findall(r"a(d+)b",'a3333b') print(a) b = re.findall(r"a(d+?)b",'a3333b') print(b) 执行结果如下： ['3333'] ['3333'] ####################### 这里需要注意的是如果前后均有限定条件的时候，就不存在什么贪婪模式了，非匹配模式失效。
3、用flags时遇到的小坑
print(re.split('a','1A1a2A3',re.I))#输出结果并未能区分大小写 这是因为re.split(pattern，string，maxsplit,flags)默认是四个参数，当我们传入的三个参数的时候，系统会默认re.I是第三个参数，所以就没起作用。如果想让这里的re.I起作用，写成flags=re.I即可。