Python-正则表达式详解-快速掌握正则表达式核心函数

正则表达式为为高级的文本模式匹配、抽取或文本形式的搜索和替换功能提供了基础。本文主要介绍python正则表达式的一些基础功能，掌握它也可以使得在python编程中处理字符串游刃有余。

---

1.简介

正则表达式是一些由字符和特殊符号组成的字符串，匹配一系列有相似特征的字符串。Python 通过标准库中的 re 模块来支持正则表达式。

2.特殊符号和字符

表示法	描述	示例	实例解释
literal	匹配文本字符串的字面值	this	匹配this
re1|re2	匹配正则表达式re1 或者 re2	foo|bar	foo或者bar
.	匹配任何字符（除了\n 之外）(一个.一个字符)	b.b	bsb,b1b...
^	匹配字符串起始部分	^Dear	匹配所有Dear开头的字符
$	匹配字符串终止部分	txt$	匹配以txt结尾的字符串
*	匹配0 次或者多次前面出现的正则表达式	5*	0个或多个5
+	匹配1 次或者多次前面出现的正则表达式	5+	1个或多个5
?	匹配0 次或者 1 次前面出现的正则表达式	5?	0个或1个5
{N}	匹配N 次前面出现的正则表达式（精准）	X{3}	3个X
{N，}	匹配N 次前面出现的正则表达式	X{3}	3个及以上X
{M,N}	匹配M～N 次前面出现的正则表达式	X{2,5}	2到5个X
[…]	匹配来自字符集的任意单一字符	[aeiou]	a,e,i,o,u的任一个
[..x−y..]	匹配x～y 范围中的任意单一字符	[2-5], [D-F]	2,3,4,5任一个，D，E，F任一个
[^…]	不匹配此字符集中出现的任何一个字符，包括某一范围的字符	[^aeiou]，[^0-9]	不匹配a,e,i,o,u任何一个字母，不匹配任一个数字

表一常见正则表达式符号

表示法	描述	示例	实例解释
\d	匹配任何十进制数字，与[0-9]一致	\d{11}	表示11位数字
\D	非数字字符，与\d 相反	\D{5}	5个非数字字符
\w	匹配任何字母数字字符，与[A-Za-z0-9_]相同	\w+	数字和字符构成的字符串均可匹配到
\W	匹配非数字字母
\s,\n, \t, \r, \v, \f, 等	匹配任何空格字符,匹配一个换行符,匹配一个制表符,匹配回车，匹配垂直制表符，匹配换页符
\S	匹配非空白符号
\b	匹配任何单词边界	er\b	可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'
\B	匹配非单词边界（要包含）	er\B	能匹配"verb" 中的 'er'，但不能匹配 "never" 中的 'er'
\A	匹配整个字符串的开始，不支持多行模式	\Aabc	整个字符串abc开头匹配不上xyz\nabc
\Z（大写）	匹配字符串的结束，如果是存在换行，只匹配到换行前的结束字符串。	def\Z	整个字符串匹配以def结尾。匹配不上def\nxyz
\z（小写）	匹配字符串结束	xyz\Z	整个字符串匹配以xyz结尾。可以匹配def\nxyz
\G	匹配最后匹配完成的位置

表二常见正则表达式特殊字符

表示法	描述	示例	实例解释
(?#…)	表示注释，所有内容都被忽略
(?=…)	前向肯定断言 1、表达式一(?<=子组表达式)表达式二 2、表达式一可选，对前向肯定断言没有影响。首先匹配后面的表达式二捕获内容二，然后用子组表达式从开始位置匹配内容二（相当于子组表达式前面固定添加^），如果匹配成功，则断言成功，否则断言失败。断言成功整条表达式返回成功。断言失败整条表达式返回失败。 3、避免没有表达式二	1、re.search(r'(?=abc)abc',"fishc@abcch") 2、re.search(r'@(?=abc)abcch',"fishc@abcch") 3、re.search(r'(?=abc)@abc',"fishc@abcch") 4、re.search(r'fishc@abc(?=abc)ch',"fishc@abcch") 5、re.search(r'(?=.abc)@abc',"fishc@abcch") 6、re.search(r'fishc@(?=abc)',"fishc@abcch") 7、re.search(r'fish(?=abc)',"fishc@abcch") 8、re.search(r'(?=abc)',"fishc@abcch")	1、span=(6, 9), match='abc' 2、span=(5, 11), match='@abcch' 3、None 4、None 5、span=(5, 9), match='@abc' 6、span=(0, 6), match='fishc@' 7、None 8、span=(6, 6), match=''
(?!…)	前向否定断言 1、表达式一(?<=子组表达式)表达式二 2、表达式一可选，对前向否定断言没有影响。首先匹配后面的表达式二捕获内容二，然后用子组表达式从开始位置匹配内容二（相当于子组表达式前面固定添加^），如果匹配成功，则断言失败，否则断言成功。断言成功整条表达式返回成功。断言失败整条表达式返回失败。 3、避免没有表达式二	1、re.search(r'(?!abc)@abc',"fishc@abcch") 2、re.search(r'fishc@abc(?=abc)ch',"fishc@abcch") 3、re.search(r'(?!abc)abc',"fishc@abcch") 4、re.search(r'@(?!abc)abcch',"fishc@abcch") 5、re.search(r'fishc@(?!abc)',"fishc@abcch") 6、re.match(r'fishc@(?!abc)',"fishc@abcch") 7、re.search(r'(?!abc)',"fishc@abcch")	1、span=(5, 9), match='@abc' 2、span=(0, 11), match='fishc@abcch' 3、None 4、None 5、None 6、None 7、span=(0, 0), match=''
(?<=…)	后向肯定断言 1、表达式一(?<=子组表达式)表达式二 2、首先匹配表达式一捕获内容一，然后用子组表达式从结束位置匹配内容一（相当于子组表达式后面固定添加$），如果匹配成功，则断言成功，否则断言失败。断言成功如果有表达式二则执行表达式二，如果没有整条表达式返回成功。如果断言失败，则整条表达式返回失败。 3、避免没有表达式一	1、re.search(r'fishc@abc(?<=abc)',"fishc@abcch") 2、re.search(r'fishc@abcch(?<=abc)',"fishc@abcch" 3、re.search(r'fishc@(?<=abc)abc',"fishc@abcch") 4、re.search(r'fishc@abc(?<=abc)ch',"fishc@abcch" 5、re.search(r'(?<=abc)abc',"fishc@abcch") 6、re.search(r'(?<=abc)ch',"fishc@abcch") 7、re.search(r'(?<=abc)',"fishc@abcch")	1、span=(0, 9), match='fishc@abc' 2、None 3、None 4、span=(0, 11), match='fishc@abcch' 5、None 6、span=(9, 11), match='ch' 7、span=(9, 9), match=''
(?<!…)	后向否定断言 1、表达式一(?<=子组表达式)表达式二 2、首先匹配表达式一捕获内容一，然后用子组表达式从结束位置匹配内容一（相当于子组表达式后面固定添加$），如果匹配成功，则断言失败，否则断言成功。断言成功如果有表达式二则执行表达式二，如果没有整条表达式返回成功。如果断言失败，则整条表达式返回失败。 3、避免没有表达式一	1、re.search(r'fishc@abcch(?<!abc)',"fishc@abcch") 2、re.search(r'fishc@(?<!abc)abc',"fishc@abcch") 3、re.search(r'fishc@abc(?<!abc)',"fishc@abcch") 4、re.search(r'fishc@abc(?<!abc)ch',"fishc@abcch") 5、re.search(r'(?<!abc)abcch',"fishc@abcch") 6、re.search(r'(?<!abc)shc',"fishc@aabcch") 7、re.search(r'(?<!abc)',"fishc@abcch")	1、span=(0, 11), match='fishc@abcch' 2、span=(0, 9), match='fishc@abc' 3、None 4、None 5、span=(6, 11), match='abcch' 6、span=(2, 5), match='shc' 7、span=(0, 0), match=''

表三常见正则表达式扩展表示法

优先级	符号
最高	“\”
高	“()” “(?:)” “(?=)” “[]”
中	“*”“+” “?”“{n}” “{n,}” “{n,m}”
低	“^” “$” “中介字符”
次最低	串接，即相邻字符连接在一起
最低	“|”

表四正则表达式特殊字符的优先级

正则表达式中有些字符具有特殊的含义，如果在匹配中要用到它本来的含义，需要进行转义，使用转义符'\'。而上述表二，可以看出有些字符自带反斜杠，如\d匹配数字。因此我们可以直接理解为： 如果'\'后面跟的字符不是ASCII数字或者ASCII字母，那么正则样式将直接匹配后面跟的字符，例如，.*\$$匹配任何以美元符号结尾的字符串。

3.正则表达式核心函数

Python 当前如何通过使用 re 模块来支持正则表达式，表五列出了来自 re 模块的更多常见函数。下面将介绍常用的函数

函数	描述
compile(pattern，flags = 0)	使用任何可选的标记来编译正则表达式的模式，然后返回一个正则表达式对象
match(pattern，string，flags=0)	尝试使用带有可选的标记的正则表达式的模式来匹配字符串。如果匹配成功，就返回匹配对象；如果失败，就返回None
search(pattern，string，flags=0)	使用可选标记搜索字符串中第一次出现的正则表达式模式。如果匹配成功，则返回匹配对象；如果失败，则返回None
findall(pattern，string [, flags] )	查找字符串中所有（非重复）出现的正则表达式模式，并返回一个匹配列表
finditer(pattern，string [, flags] )	与findall()函数相同，但返回的不是一个列表，而是一个迭代器。对于每一次匹配，迭代器都返回一个匹配对象
split(pattern，string，max=0)	根据正则表达式的模式分隔符，split 函数将字符串分割为列表，然后返回成功匹配的列表，分隔最多操作 max 次（默认分割所有匹配成功的位置）
sub(pattern，repl，string，count=0)	使用repl 替换所有正则表达式的模式在字符串中出现的位置，除非定义 count，否则就将替换所有出现的位置（另见 subn()函数，该函数返回替换操作的数目）
purge()	清除隐式编译的正则表达式模式
group(num=0)	返回整个匹配对象，或者编号为num 的特定子组
groups(default=None)	返回一个包含所有匹配子组的元组（如果没有成功匹配，则返回一个空元组）
groupdict(default=None)	返回一个包含所有匹配的命名子组的字典，所有的子组名称作为字典的键（如果没有成功匹配，则返回一个空字典）

表五常用的函数

3.1 compile()

当我们在Python中使用正则表达式时，re模块内部会干两件事情：①编译正则表达式，如果正则表达式的字符串本身不合法，会报错；②用编译后的正则表达式去匹配字符串。

那么如果一个正则表达式要重复使用几千次，出于效率的考虑，是不是应该先把这个正则先预编译好，接下来重复使用时就不再需要编译这个步骤了，直接匹配，提高效率，compile()就事干这个的，在模式匹配发生之前，正则表达式模式必须编译成正则表达式。

re.compile(pattern,flags )

pattern为一个字符串形式的正则表达式，

flag可选，表示匹配模式，见表六。

re.I、re.IGNORECASE	不区分大小写的匹配
re.L、re.LOCALE	根据所使用的本地语言环境通过\w、\W、\b、\B、\s、\S 实现匹配
re.M、re.MULTILINE	^和$分别匹配目标字符串中行的起始和结尾，而不是严格匹配整个字符串本身的起始和结尾
re.S、rer.DOTALL	“.”（点号）通常匹配除了\n（换行符）之外的所有单个字符；该标记表示 “.”（点号能够匹配全部字符
re.X、re.VERBOSE	通过反斜线转义，否则所有空格加上#（以及在该行中所有后续文字）都被忽略，除非在一个字符类中或者允许注释并且提高可读性

表六常用的模块属性

例子：

import re

m_token=r'\d+'

pattern=re.compile(m_token)

m = pattern.match('12twothree34four')

print(m)

输出结果：

<_sre.SRE_Match object; span=(0, 2), match='12'>

3.2 match()

match() 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 none。

re.match(pattern,string,flags)

pattern 匹配的正则表达式

string 要匹配的字符串。

flags 可选，表示匹配模式，见表六。

例子：

import re

m_token=r'\d+'

pattern=re.compile(m_token)

m1 = pattern.match('12twothree34four')

m2 = pattern.match('abc12twothree34four')

print(m1)

print(m2)

输出结果：

<_sre.SRE_Match object; span=(0, 2), match='12'>

None

说明，只有字符串起始开始匹配成功，才不返回None。

3.3 search()

其实，想要搜索的模式出现在一个字符串中间部分的概率，远大于出现在字符串起始部分的概率。这也就是search()派上用场的时候了。search()的工作方式与 match()完全一致，不同之处在于 search()会用它的字符串参数，在任意位置对给定正则表达式模式搜索第一次出现的匹配情况。如果搜索到成功的匹配，就会返回一个匹配对象；否则，返回 None。

re.search(pattern,string,flags)

pattern 匹配的正则表达式

string 要匹配的字符串。

flags 可选，表示匹配模式，见表六。

例子：

import re

m_token=r'\d+'

pattern=re.compile(m_token)

m1 = pattern.search('12twothree34four')

m2 = pattern.search('abc12twothree34four')

print(m1)

print(m2)

输出结果：

<_sre.SRE_Match object; span=(0, 2), match='12'>

<_sre.SRE_Match object; span=(3, 5), match='12'>

说明：通过比较match(),发现search()只要整个字符串有匹配成功就返回。

3.4 group()和 groups()

成功调用match()或者search()返回的对象为匹配对象，匹配对象有两个主要的方法：group()和groups()。group()方法用于获得一个或多个分组匹配的字符串，要么返回整个匹配对象，要么根据要求返回特定子组。当要获得整个匹配的子串时，可直接使用 group() 或 group(0)。groups()则仅返回一个包含 唯一或者全部子组的元组，等价于(m.group(1), m.group(2), ...)。

例子：

import re

line = "Cats are smarter than dogs"

matchObj1 = re.match(r'(.*) are (.*?) .*', line, re.M | re.I)

matchObj2 = re.match(r'(.*) are (.*?) (.*)', line, re.M | re.I)

print("matchObj1.group() : ", matchObj1.group())

print("matchObj2.group() : ", matchObj2.group())

print("matchObj1.groups() : ", matchObj1.groups())

print("matchObj2.groups() : ", matchObj2.groups())

输出结果：

matchObj1.group() : Cats are smarter than dogs

matchObj2.group() : Cats are smarter than dogs

matchObj1.groups() : ('Cats', 'smarter')

matchObj2.groups() : ('Cats', 'smarter', 'than dogs')

说明：matchObj1和matchObj2的区别在于.*是否为要求返回的特定子组，

因此matchObj1.groups() 只有两个元素 ('Cats', 'smarter')，

matchObj1.groups() 有三个元素 ('Cats', 'smarter', 'than dogs')。

3.5 findall()

findall()在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。

match()和 search()的不同之处在于，match 和 search 是匹配一次 findall 匹配所有。

re.findall(string,pos,endpos)

string : 待匹配的字符串。

pos : 可选参数，指定字符串的起始位置，默认为 0。

endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。

例子：

import re

pattern = re.compile(r'\d+') # 查找数字

result1 = pattern.findall('runoob 123 google 456')

result2 = pattern.findall('run88oob123google456', 0, 10)

print(result1)

print(result2)

输出结果：

['123', '456']

['88', '12']

例子：

import re

result = re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')

print(result)

输出结果：

[('width', '20'), ('height', '10')]

说明：实例2为多个匹配模式，返回元组列表。

finditer()函数是一个与 findall()函数类似但是更节省内存的变体，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

例子：

mport re

it = re.finditer(r"\d+","12a32bc43jf3")

print(it)

for a in it:

print(a)

输出结果：

<callable_iterator object at 0x0000021ED9214978>

<_sre.SRE_Match object; span=(0, 2), match='12'>

<_sre.SRE_Match object; span=(3, 5), match='32'>

<_sre.SRE_Match object; span=(7, 9), match='43'>

<_sre.SRE_Match object; span=(11, 12), match='3'>

说明：可以看出，it返回的是一个迭代器，可以提取匹配的内容。

3.6 sub()

sub()是将某字符串中所有匹配正则表达式的部分进行某种形式的替换。

re.sub(replacement, string, count)

replacement是被替换成的文本

string是需要被替换的文本

count是一个可选参数，指最大被替换的数量

例子：

import re

p = re.compile('(blue|white|red)')

print(p.sub('colour','blue socks and red shoes'))

print(p.sub('colour','blue socks and red shoes', count=1))

输出结果：

colour socks and colour shoes

colour socks and red shoes

说明：当添加了count=1只将blue替换成了colour，red没有被替换。

subn()方法执行的效果跟sub()一样，不过它会返回一个二维数组，包括替换后的新的字符串和总共替换的数量。

例子：

import re

p = re.compile('(blue|white|red)')

print(p.subn('colour','blue socks and red shoes'))

print(p.subn('colour','blue socks and red shoes', count=1))

输出结果：

('colour socks and colour shoes', 2)

('colour socks and red shoes', 1)

4.分组

分组就是用一对圆括号“()”括起来的正则表达式，匹配出的内容就表示一个分组。从正则表达式的左边开始看，看到的第一个左括号“(”表示第一个分组，第二个表示第二个分组，依次类推，需要注意的是，有一个隐含的全局分组（就是0），就是整个正则表达式。分完组以后，要想获得某个分组的内容，直接使用group(num)和groups()函数去直接提取就行。

例子：

import re

msg = '<html><h1>hello</h1></html>'

result = re.match(r'<([0-9a-zA-Z]+)><([0-9a-zA-Z]+)>(.+)</([0-9a-zA-Z]+)></([0-9a-zA-Z]+)>$', msg)

#result = re.match(r'<([0-9a-zA-Z]+)>(.+)</\1>$', msg)

print(result)

print(result.group(0))

print(result.group(1))

print(result.group(2))

print(result.group(3))

print(result.group(4))

print(result.group(5))

print(result.groups())

输出结果：

<_sre.SRE_Match object; span=(0, 27), match='<html><h1>hello</h1></html>'>

<html><h1>hello</h1></html>

html

h1

hello

h1

html

('html', 'h1', 'hello', 'h1', 'html')

说明：上述正则表达式中出现了5对（），因此分成了5组，通过groups（）中5个元素也可看出。

命名分组：

(?P<name>正则表达式)#name是一个合法的标识符

引用分组：

(?P=name)

注意：P为大写！

例子：

import re

msg = '<html><h1>hello</h1></html>'

result = re.match(r'<(?P<fenzu>[0-9a-zA-Z]+)><([0-9a-zA-Z]+)>(.+)</([0-9a-zA-Z]+)></([0-9a-zA-Z]+)>', msg)

print(result)

print(result.groups())

输出结果：

<_sre.SRE_Match object; span=(0, 27), match='<html><h1>hello</h1></html>'>

('html', 'h1', 'hello', 'h1', 'html')

说明：（[0-9a-zA-Z]+）写成(?P<fenzu>[0-9a-zA-Z]+)，命名了一个分组fenzu，且仍是5个分组。

例子：

import re

msg = '<html><h1>hello</h1></html>'

result = re.match(r'<(?P<fenzu>[0-9a-zA-Z]+)><([0-9a-zA-Z]+)>(.+)</([0-9a-zA-Z]+)></(?P=fenzu)>', msg)

print(result)

print(result.groups())

输出结果：

<_sre.SRE_Match object; span=(0, 27), match='<html><h1>hello</h1></html>'>

('html', 'h1', 'hello', 'h1')

说明：将后面的([0-9a-zA-Z]+)写成了(?P=fenzu)，引用了分组。但是此时，之前的第五个分组'html'因引用了第一个分组，因此只有4个分组。

5.贪婪和非贪婪

“贪婪”，尽可能多的匹配；“非贪婪”，尽可能少的匹配。默认情况下，正则表达式将进行贪婪匹配，加上？为将贪婪匹配模式转为非贪婪匹配模式。

例子：

import re

sentence = """You said "why?" and I say "I don't know"."""

print(re.findall(r'"(.*)"', sentence))

print(re.findall(r'"(.*?)"', sentence))

输出结果：

['why?" and I say "I don\'t know']

['why?', "I don't know"]

说明:贪婪匹配，从sentence中尽可能长的匹配两个””之间的内容，因此打印出整个字符串；加上了？，变成了非贪婪匹配，因此从sentence中尽可能短的匹配两个””之间的内容，匹配到了就输出，因此打印出两个匹配内容。