python3 RE正则（正则表达式）
一、正则表达式
1.正则表达式概述
正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。正则表达式是烦琐的，但它是强大的，学会之后的应用会让你除了提高效率外，会给你带来绝对的成就感。
2.表达式列表
| 表达式 | 说明 | |
| 字符匹配 | [0-9] | 匹配0-9之间的任意1个数字。 |
| [a-z] |
表示某个范围内的字符。与指定区间内的任何字符匹配。例如，"[a-z]"匹配"a"与"z"之间的任何1个小写字母。 |
|
| [A-Z] | 表示某个范围内的字符。与指定区间内的任何字符匹配。例如，"[A-Z]"匹配"A"与"Z"之间的任何1个大写字母。 | |
| 元字符匹配 |
. |
匹配换行符以外的任何字符。 |
|
\w |
与任何单词字符匹配，包括下划线。等价于"[A-Za-z0-9_]"。 | |
|
\s |
与任何白字符匹配，包括空格、制表符、分页符等。等价于"[\f\n\r\t\v]"。 | |
|
\d |
与一个数字字符匹配。等价于[0-9]。 | |
|
\n |
与换行符字符匹配。 | |
|
\t |
与制表符匹配。 | |
|
\b |
与单词的边界匹配，即单词与空格之间的位置。例如，"er\b"与"never"中的"er"匹配，但是不匹配"verb"中的"er"。 | |
|
^ |
匹配输入的开始位置。 | |
|
$ |
匹配输入的结尾。 | |
|
\W |
与任何非单词字符匹配。等价于"[^A-Za-z0-9_]"。 | |
|
\D |
与非数字的字符匹配。等价于[^0-9]。 | |
|
\S |
与任何非空白的字符匹配。等价于"[^\f\n\r\t\v]"。 | |
|
x|y |
匹配x或y。例如"z|food"可匹配"z"或"food"。"(z|f)ood"匹配"zood"或"food"。 | |
|
() |
群组，与模式匹配并记住匹配。匹配的子字符串可以从作为结果的Matches集合中使用Item[0]... [n]取得。如果要匹配括号字符(和)，可使用"\("或"\)"。 | |
|
[xyz] |
一个字符集。与括号中字符的其中之一匹配。例如，"[abc]"匹配"plain"中的"a"。 | |
|
[^xyz] |
一个否定的字符集。匹配不在此括号中的任何字符。例如，"[^abc]"可以匹配"plain"中的"pl". | |
| 量词 |
* |
匹配前一个字符零次或几次。例如，"zo*"可以匹配"z"、"zoo"。 |
|
+ |
匹配前一个字符一次或多次。例如，"zo+"可以匹配"zoo",但不匹配"z"。 | |
|
? |
匹配前一个字符零次或一次。例如，"a?ve?"可以匹配"never"中的"ve"。 | |
|
{n} |
n为非负的整数。匹配恰好n次。例如，"o{2}"不能与"Bob中的"o"匹配，但是可以与"foooood"中的前两个o匹配。 | |
|
{n,} |
n为非负的整数。匹配至少n次。例如，"o{2,}"不匹配"Bob"中的"o"，但是匹配"foooood"中所有的o。"o{1,}"等价于"o+"。"o{0,}"等价于"o*"。 | |
|
{n,m} |
m和n为非负的整数。匹配至少n次，至多m次。例如，"o{1,3}"匹配"fooooood"中前三个o。"o{0,1}"等价于"o?"。 |
3.表达式的应用区别
（1）.^${}的区别
| 正则 | 待匹配字符 | 匹配 结果 |
说明 |
| 李.? | 李杰和李莲英和李二棍子 |
李杰 |
?表示重复零次或一次，即只匹配"李"后面一个任意字符
|
| 李.* | 李杰和李莲英和李二棍子 | 李杰和李莲英和李二棍子 |
*表示重复零次或多次，即匹配"李"后面0或多个任意字符
|
| 李.+ | 李杰和李莲英和李二棍子 | 李杰和李莲英和李二棍子 |
+表示重复一次或多次，即只匹配"李"后面1个或多个任意字符
|
| 李.{1,2} | 李杰和李莲英和李二棍子 |
李杰和 |
{1,2}匹配1到2次任意字符
|
注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，在一个量词后面加?号使其变成惰性匹配
| 正则 | 待匹配字符 | 匹配 结果 |
说明 |
| 李.*? | 李杰和李莲英和李二棍子 | 李 李 李 |
惰性匹配 |
（2）字符集[ ] [ ^ ]
| 正则 | 待匹配字符 | 匹配 结果 |
说明 |
| 李[杰莲英二棍子]* | 李杰和李莲英和李二棍子 |
李杰 |
表示匹配"李"字后面[杰莲英二棍子]的字符任意次
|
| 李[^和]* | 李杰和李莲英和李二棍子 |
李杰 |
表示匹配一个不是"和"的字符任意次
|
| [\d] | 456bdha3 |
4 |
表示匹配任意一个数字，匹配到4个结果
|
| [\d]+ | 456bdha3 |
456 |
表示匹配任意个数字，匹配到2个结果
|
（3）转移符\
在正则表达式中，有很多有特殊意义的是元字符，比如\d和\s等，如果要在正则中匹配正常的"\d"而不是"数字"就需要对"\"进行转义，变成'\\'。
在python中，无论是正则表达式，还是待匹配的内容，都是以字符串的形式出现的，在字符串中\也有特殊的含义，本身还需要转义。所以如果匹配一次"\d",字符串中要写成'\\d'，那么正则里就要写成"\\\\d",这样就太麻烦了。这个时候我们就用到了r'\d'这个概念，此时的正则是r'\\d'就可以了。
| 正则 | 待匹配字符 | 匹配 结果 |
说明 |
| \d | \d | False |
因为在正则表达式中\是有特殊意义的字符，所以要匹配\d本身，用表达式\d无法匹配
|
| \\d | \d | True |
转义\之后变成\\，即可匹配
|
| "\\\\d" | '\\d' | True |
如果在python中，字符串中的'\'也需要转义，所以每一个字符串'\'又需要转义一次
|
| r'\\d' | r'\d' | True |
在字符串之前加r，让整个字符串不转义
|
（4）贪婪匹配
贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配。
| 正则 | 待匹配字符 | 匹配 结果 |
说明 |
| <.*> |
<script>...<script> |
<script>...<script> |
默认为贪婪匹配模式，会匹配尽量长的字符串
|
| <.*?> | r'\d' |
<script> |
加上？为将贪婪匹配模式转为非贪婪匹配模式，会匹配尽量短的字符串
|
几个常用的非贪婪匹配模式
*? 重复任意次，但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复
.*?的用法
. 是任意字符 * 是取 0 至 无限长度 ? 是非贪婪模式。 何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在： .*?x 就是取前面任意长度的字符，直到一个x出现
二、RE模块
1.re函数方法总结
| 方法名称 | 格式 | 说明 |
| findall | re.findall(表达式,字符串) |
返回所有满足匹配条件的结果,放在列表里
|
| search | re.search(表达式,字符串).groups() |
函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
|
| match | re.match(表达式,字符串).groups() | 同search,不过尽在字符串开始处进行匹配 |
| split | re.split(表达式,字符串) | 按表达式对字符串分割，返回列表 |
| sub | re.sub(表达式,替换字符,字符串,count) |
按表达式类型替换成新的字符，返回字符串
|
| subn | re.subn(表达式,替换字符,字符串,count) |
按表达式类型替换成新的字符串，返回一个元组，存放这替换结果和替换次数 |
| compile | re.compile(表达式) |
将正则表达式编译成为一个 正则表达式对象
|
| finditer | re.finditer(表达式,字符串) |
finditer返回一个存放匹配结果的迭代器
|
2.常用方法实例
#（1）findall
import re
ret = re.findall('\d','adsf123456we7we') #匹配字符串中是数字的字符，并将匹配值返回到列表中
print(ret)
'''结果：
['1', '2', '3', '4', '5', '6', '7']
'''
#（2）search
ret = re.search('\d','adsf123456we7we').group() #按照表达式匹配到第一个值就返回
print(ret)
'''结果：
1
'''
#（3）match
ret = re.match('\w','adsf123456we7we').group() #按照表达式匹配开头第一个值，符合的话就返回，不符合就报错
print(ret)
'''结果：
a
'''
#（4）sub
ret = re.sub('\d','*','adsf123456we7we',0) #匹配字符串中的数字，并且替换成*号，0表示替换所有
print(ret)
'''结果：
adsf******we*we
'''
#（5）subn
ret = re.subn('\d','*','adsf123456we7we',0) #匹配字符串中的数字，并且替换成*号，返回一个元组，存放这替换结果和替换次数
print(ret)
'''结果：
('adsf******we*we', 7)
'''
#（6）compile
obj = re.compile('\d') #将正则表达式编译成一个正则表达式对象
ret = obj.search('ads123asd456').group()
print(ret)
'''结果：
1
'''
#（7）finditer
ret = re.finditer('\d','adsf451we15615adf16') #finditer返回一个存放匹配结果的迭代器
print(ret)
for i in ret:
print(i.group())
