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 5 6 3	表示匹配任意一个数字，匹配到4个结果
[\d]+	456bdha3	456 3	表示匹配任意个数字，匹配到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> <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())

 

转载于:https://www.cnblogs.com/jason-lv/p/8251904.html