首先先对一些常用的匹配模式进行一下介绍及互相认识一下，当然了可能它认识我，但我绝对还不认识它。。。
********************************************
元字符 【 . ^ $ * + ? {} [] \ | () 】
********************************************
1、[.] 匹配任意1个字符，除了换行符（\n）。
要匹配包括‘\n‘在内的任何字符，就使用‘[.\n]‘的模式
例：
import re
print(re.findall(r‘a.‘,‘ab ac afbbbb‘))
>> [‘ab‘, ‘ac‘, ‘af‘]
2、[|] 或 匹配符号左边或右边的字符
例：
import re
str1=‘dit dot det,dct dit dot‘
print (re.findall(‘det|dct‘,str1))
>> [‘det‘, ‘dct‘]
3、[] 字符集合，匹配这个集合里面的任意一个就可以
[ic]表示i或c，‘d[ic]t‘表示dit和dct两者，和‘dit|dct‘等价
[^abc ] 代表反取,代表取abc之外的字符串
例：
import re
str1=‘dit dot det,dct dit dot‘
print (re.findall(‘d[ic]t‘,str1))
>> [‘dit‘, ‘dct‘, ‘dit‘]
4、^ 表示否定 [^ic]表示 除了i和c
例：
import re
str1=‘dit dot det,dct dit dot‘
print (re.findall(‘d[^ic]t‘,str1))
>> [‘dot‘, ‘det‘, ‘dot‘]
4-2 匹配字符串的开头 ^dit 表示子串dit在开头位置
例：
import re
str1=‘dit dot det,dct dit dot‘
print (re.findall(‘^dit‘,str1))
>> [‘dit‘]
5、$ 匹配字符串的末尾 ‘dot$‘ 表示子串dot要在末尾位置
import re
str1=‘dit dot det,dct dit dot‘
print (re.findall(‘dot$‘,str1))
>> [‘dot‘]
6、+ ‘di+t’ 表示d与t之间省略了一个或多个i
import re
str1=‘dit dot det,dct diit dot‘
print (re.findall(‘di+t‘,str1))
>> [‘dit‘, ‘diit‘]
7、* 匹配*号前的一个字符0次或多次
‘di*t’表示d与t之间省略了零个至多个i
import re
str1=‘dit dt det,dct diit dot‘
print (re.findall(‘di*t‘,str1))
>> [‘dit‘, ‘dt‘, ‘diit‘]
扩展 ‘.+’搭配使用，表示省略了一个至多个任意元素
‘.*’ 搭配使用，表示省略了零个至多个任意元素
import re
str1=‘d dt dit diit dot‘
print (re.findall(‘d.*t‘,str1))
print (re.findall(‘d.+t‘,str1))
>> [‘d dt dit diit dot‘]
>> [‘d dt dit diit dot‘]
8、? 匹配？前的一个字符0次或1次 ‘di?t’表示i可有可无，即dt，dit都满足条件
import re
str1=‘d dt dit diit det‘
print(re.findall(‘di?t‘,str1))
>> [‘dt‘, ‘dit‘]
8-2 ? 清除贪婪匹配
9、{} di{n}t 表示d和t之间有n个i
import re
str1=‘d dt dit diit det‘
print(re.findall(‘di{2}t‘,str1))
>> [‘diit‘]
9-2 {} di{n,m}t 表示d和t之间有n到m个i
import re
str1=‘d dt dit diit diiiit det‘
print(re.findall(‘di{2,4}t‘,str1))
>> [‘diit‘, ‘diiiit‘]
扩展：n和m都可以省略。{n,}表示n个到任意个；{,m}表示0到m个；{,}表示任意个
import re
str1=‘d dt dit diit diiit diiiit det‘
print(re.findall(‘di{3,}t‘,str1))
print(re.findall(‘di{,3}t‘,str1))
print(re.findall(‘di{,}t‘,str1))
>> [‘diiit‘, ‘diiiit‘]
[‘dt‘, ‘dit‘, ‘diit‘, ‘diiit‘]
[‘dt‘, ‘dit‘, ‘diit‘, ‘diiit‘, ‘diiiit‘]
10、\ 取消元字符，变成转义字符
就是说如果你想让特殊字符失去python语言赋予的意义变成普通字符，就在前面加上\
例：
import re
print(re.findall(r‘\?.‘,‘ab? ac af?bab?b‘))
>> [‘? ‘, ‘?b‘, ‘?b‘]
10-2、 \ 预定义字符
例：
import re
str1=‘12 abd 34 def‘
print(re.findall(‘\d‘,str1))
print(re.findall(‘\w‘,str1))
>> [‘1‘, ‘2‘, ‘3‘, ‘4‘]
[‘1‘, ‘2‘, ‘a‘, ‘b‘, ‘d‘, ‘3‘, ‘4‘, ‘d‘, ‘e‘, ‘f‘]
11、（） 在匹配字符串后，只输出匹配字串（）里面的内容
import re
str1=‘12abcd34‘
print(re.findall(‘12abcd34‘,str1))
print(re.findall(‘1(2a)bcd‘,str1))
print(re.findall(‘1(2a)bc(d3)4‘,str1))
>> [‘12abcd34‘]
[‘2a‘]
[(‘2a‘, ‘d3‘)]
***************************************************************
re模块的主要方法
findall() finditer() match() search() compile() aplit() sub() subn()
***************************************************************
1、re.match(1正则表达式，2要匹配的字符串，3标志位“用于控制正则表达式的匹配方式”)
开始位置：从第一个单词中匹配字符串，如果匹配到就返回一个结果，匹配不到就返回None
例:
import re
print (re.match(‘www‘,‘www.baidu.com‘).span())
print (re.match(‘baidu‘,‘www.baidu.com‘))
>> (0, 3)
None
2、re.search(1正则，2原字符串，3标志位)
匹配规则：扫描整个字符串并返回第一个成功匹配的结果，没有就返回None
例：
import re
print (re.search(‘www‘,‘www.baidu.com‘).span())
print (re.search(‘baidu‘,‘www.baidu.com.baidu‘).span())
>> (0, 3)
(4, 9)
3、re.findall()
匹配规则：从左往右搜索，结果1以list的形式返回，没有匹配到就返回空列表
例：
import re
print (re.findall(‘www‘,‘www.baidu.com.wwww‘))
print (re.findall(‘www‘,‘nishuosdhsds‘))
>>[‘www‘, ‘www‘]
[]
4、re.finditer()
匹配规则：从左往右搜索，但是结果以迭代器的形式返回
例：
import re
str1=‘ab cd e‘
istr1=re.finditer(‘\w+‘,str1)
for a in istr1:
print (a.group(),a.span())
扩展：a.group()返回满足匹配调节的子串，a.span()返回子串的起始位置 和末尾位置
>> (‘ab‘, (0, 2))
(‘cd‘, (3, 5))
(‘e‘, (6, 7))
5、re.compile()
匹配规则：对匹配格式先进行编译，返回一个实例对象。然后再使用它，可以加快匹配速度
例：
import re
str1=‘abcdeabfg‘
pre=re.compile(‘ab‘)
print (pre.findall(str1))
>> [‘ab‘, ‘ab‘]
6、re.split()
匹配规则：在string匹配正则表达式时进行分割
例：
import re
str1=‘abc.d.ea.bfg.rere‘
str2=‘12+34-56*78/90‘
print (re.split(‘\.‘,str1))
print (re.split(‘[\+\-\*/]‘,str2))
>> [‘abc‘, ‘d‘, ‘ea‘, ‘bfg‘, ‘rere‘]
[‘12‘, ‘34‘, ‘56‘, ‘78‘, ‘90‘]
7、re.sub(1正则，2替换的字符串，3原始字符串，4匹配后替换的最大次数)
匹配规则：用于替换字符串中的匹配项
例；
import re
str1=‘abcdefg‘
print (re.sub(‘b‘,‘123‘,str1))
>> a123cdefg
8、re.subn()
匹配规则：功能与sub相似，但返回结果多了一个数字，代表替换了多少次
例：
import re
str1=‘abcdebnfgcb‘
print (re.subn(‘b‘,‘123‘,str1))
>> (‘a123cde123nfgc123‘, 3)
****************************************************
还有一些关于字母的 \A \b\B \d\D \G \s\S \w\W \z\Z
#####[0-9] [a-z] [A-Z] [a-zA-Z0-9] [^0-9]
****************************************************
1、\A 匹配字符串开始，不能进行多行匹配（^）
例：
import re
print(re.findall(r‘\Ahttp://‘,‘http://www.baidu.com is good\nhttp://www.sohu.com‘,re.M))
>> [‘http://‘]
2、\Z 匹配字符串的结尾，不能进行多行匹配($)
例：
import re
print(re.findall(r‘\.jpge\Z|\.png\Z|\.gif\Z‘,‘touxiang.gif\nqq.png‘,re.M))
>> [‘.png‘]
3、\d 匹配一个数字
\w 匹配一个字母或数字
. 匹配任意字符
例：
‘00\d‘ 可以匹配‘007‘,不能匹配‘00A‘
‘\d\d\d‘可以匹配‘010‘
‘\w\w\d‘可以匹配‘py3
‘py.‘可以匹配‘py1‘‘pyc‘‘py!‘
* 匹配任意个字符（包括0个）
. 匹配1个字符
+ 匹配至少一个字符
？表示0个或1个字符
{n} 表示n个字符
{n,m}表示n-m个字符
4、\s 匹配任意空白字符
\S匹配任意非空字符
例：
\d{3}\s+\d{3,8}
>> \d{3} 表示匹配3个数字 如‘010‘
\s 可以匹配一个空格 \s+表示至少有一个空格 如‘ ‘,‘ ‘等
\d{3,8} 表示3-8个数字 如‘1234567‘
5、精确匹配
[0-9a-zA-Z\_] 可以匹配一个数字、字母或下划线
[0-9a-zA-Z\_]+ 可以匹配至少由一个数字、字母或下划线组成的字符串。如‘a100‘,‘0_z‘,‘Py003‘
[a-zA-Z\_][0-9a-zA-Z\_]*可以匹配由字母下划线开头，后接任意一个数字、字母下划线组成的字符串
[a-zA-Z\_][0-9a-zA-Z\_]{0,19}限制了变量的长度是1-20个字符（前面一个字符+后面最多19个字符）
^ 表示行的开头，^\d 表示必须以数字开头
$ 表示行的结束 \d$表示必须以数字结束
************************************************
分组
除了简单的判断是否匹配之外，正则表达式还有提取子串的强大功能。用（）表示的就是要提取的分组（group）
************************************************
1、group()或group(0)就是匹配正则表达式整体结果
例：
import re
test=‘010-12345‘
m= re.match(r‘^\d{3}\-\d{3,8}$‘,test)
print (m.span(),m.group())
>> ((0, 9), ‘010-12345‘)
2、group(1)列出第一个括号匹配的部分，group(2)列出第二个括号匹配的部分.
如果正则表达式中没有括号，group(1)肯定是不对的了。
例：
import re
a=‘123abc456‘
print (re.search(‘([0-9]*)([a-z]*)([0-9]*)‘,a).group())
print (re.search(‘([0-9]*)([a-z]*)([0-9]*)‘,a).group(1))
print (re.search(‘([0-9]*)([a-z]*)([0-9]*)‘,a).group(2))
print (re.search(‘([0-9]*)([a-z]*)([0-9]*)‘,a).group(3))
>> 123abc456
123
abc
456
3、groups() 返回一个包含所有小组字符串的元组，从1到所含的小组号
例：
import re
a=‘123abc456‘
print (re.search(‘([0-9]*)([a-z]*)([0-9]*)‘,a).group())
print (re.search(‘([0-9]*)([a-z]*)([0-9]*)‘,a).group(1))
print (re.search(‘([0-9]*)([a-z]*)([0-9]*)‘,a).group(2))
print (re.search(‘([0-9]*)([a-z]*)([0-9]*)‘,a).group(3))
print (re.search(‘([0-9]*)([a-z]*)([0-9]*)‘,a).groups())
>> 123abc456
123
abc
456
(‘123‘, ‘abc‘, ‘456‘) 重要看这条！！！
**********************************************
贪婪匹配
**********************************************
正则匹配默认是贪婪匹配，也就是匹配尽可能多的字符。
例：
import re
print (re.match(r‘^(\d+)(0*)$‘,‘1012300‘).groups())
>> (‘1012300‘, ‘‘)
此处\d+采用贪婪匹配，直接把后面的0也给匹配了，导致0*智能匹配空字符串
加个？就可以让\d+采用非贪婪匹配
例：
import re
print (re.match(r‘^(\d+?)(0*)$‘,‘1012300‘).groups())
>> (‘10123‘, ‘00‘)
原文地址：https://www.cnblogs.com/pf109/p/9896829.html