一 正则表达式，又称规则表达式，英文名为Regular Expression，在代码中常简写为regex、regexp或RE，是计算机科学的一个概念。正则表通常被用来检索、替换那些符合某个模式(规则)的文本。实现过滤的功能。
1元字符
\w 匹配字母（包含汉字），数字，下划线
\d 匹配十进制数字
\s 匹配空白字符
\n 匹配换行符
\t 匹配制表符
^ 匹配字符串的开始
$匹配字符串的末尾
a|b 匹配a或者b
[ ]字符集，只能取其中的一个
[^.. ] 匹配除了字符集内所有的字符外的字符
2 量词
每个量词只控制前一个字符的出现次数
默认模式是贪婪匹配
量词后面加？，为非贪婪匹配
* 重复零次或多次
+ 重复一次或多次
？ 重复零次或一次
{n}重复n次
{n,m}重复n到m次
3 惰性匹配
？
4 ( ) 分组 对多个字符进行整体的量词约束
| 或
1、普通字符和11个元字符：
| 普通字符 |
匹配自身 |
abc |
abc |
|
. |
匹配任意除换行符"\n"外的字符(在DOTALL模式中也能匹配换行符 |
a.c |
abc |
|
\ |
转义字符，使后一个字符改变原来的意思 |
a\.c;a\\c |
a.c;a\c |
|
* |
匹配前一个字符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)haha\2‘,‘tinafeihahafei tinafeihahatina‘).group() print(a) 结果： tinafeihahafei
2、预定义字符集（可以写在字符集[...]中）
|
\d |
数字:[0-9] |
a\bc |
a1c |
|
\D |
非数字:[^\d] |
a\Dc |
abc |
|
\s |
匹配任何空白字符:[<空格>\t\r\n\f\v] |
a\sc |
a c |
| \S | 非空白字符:[^\s] |
a\Sc |
abc |
|
\w |
匹配包括下划线在内的任何字字符:[A-Za-z0-9_] |
a\wc |
abc |
|
\W |
匹配非字母字符，即匹配特殊字符 |
a\Wc |
a c |
|
\A |
仅匹配字符串开头,同^ | \Aabc |
abc |
|
\Z |
仅匹配字符串结尾，同$ |
abc\Z |
abc |
|
\b |
匹配\w和\W之间，即匹配单词边界匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b‘ 可以匹配"never" 中的 ‘er‘，但不能匹配 "verb" 中的 ‘er‘。 | \babc\b a\b!bc |
空格abc空格 a!bc |
|
\B |
[^\b] |
a\Bbc |
abc |
这里需要强调一下\b的单词边界的理解： w = re.findall(‘\btina‘,‘tian tinaaaa‘) print(w) s = re.findall(r‘\btina‘,‘tian tinaaaa‘) print(s) v = re.findall(r‘\btina‘,‘tian#tinaaaa‘) print(v) a = re.findall(r‘\btina\b‘,‘tian#[email protected]‘) 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)abc\1 |
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即可。