正则表达式是一种通用的工具&＃xff0c;并不只属于Python语言&＃xff0c;基本大部分语言都封装好了这个工具。

引子

正则表达式&＃xff08;Regular Expression&＃xff09;是一种用于做字符串匹配的工具&＃xff0c;它能够非常方便地从一段文本中找到/匹配出符合一定要求/规律的目标字符串。

但是我们什么情况下要做字符串匹配呢&＃xff1f;而且为什么要用正则表达式做呢&＃xff0c;直接用一对一的去对不行吗&＃xff1f;举一个简单的例子来回答上面的问题。

比如说&＃xff0c;我们有如下一段文本&＃xff0c;假设这是你写的一段日记&＃xff1a;

我昨天认识了一个女孩A&＃xff0c;她给了我她的邮箱girlA&＃64;163.com&＃xff0c;和她道别后&＃xff0c;又遇到另一个女孩B&＃xff0c;她也给了我她的邮箱girlB&＃64;qq.com&＃xff0c;没想到&＃xff0c;我之后又遇见了第三个女孩C......


那么&＃xff0c;现在&＃xff0c;你肯定想做的事情就是给这些遇见的女孩子们群发约会的邀请信息&＃xff0c;但是想偷懒的你不想手动一个个地去从上述文本里肉眼查找&＃xff0c;然后复制粘贴每个女孩的邮箱&＃xff08;数量少时&＃xff0c;你手动做肯定没问题&＃xff09;。于是&＃xff0c;你想能不能用一个工具自动提取出所有日记里面的邮箱地址出来。

然后你也想到&＃xff0c;首先每个人邮箱的名字都不一样&＃xff0c;可能是各种数字与字母的组合&＃xff0c;其次邮箱所属的机构名&＃xff08;163, sina, qq, gmail, outlook&＃xff09;也可能不一样&＃xff0c;域名(.com, .net, .cn)也可能不一样&＃xff0c;那么这可怎么匹配&＃xff1f;

但是&＃xff0c;聪明的你总结出了一条规律&＃xff1a;邮箱不过就是【若干个字符&＃xff08;邮箱名&＃xff09;&＃43;&＃64;&＃43;若干个字符&＃xff08;机构名&＃xff09;&＃43;.&＃43;若干个字符&＃xff08;域名&＃xff09;】&＃xff0c;如果程序能够懂这个模式就能挑选出字符串了&＃xff01;

现在告诉你&＃xff0c;正则表达式就可以做到&＃xff0c;它就可以按照【若干个字符&＃xff08;邮箱名&＃xff09;&＃43;&＃64;符号&＃43;若干个字符&＃xff08;机构名&＃xff09;&＃43;.&＃43;若干个字符&＃xff08;域名&＃xff09;】的模式去从文本里把所有符合这个模式的字符串全部找出来。

用python3具体做法如下&＃xff1a;

import re
pattern&＃61;re.compile(r&＃39;[0-9a-zA-Z_]{0,19}&＃64;[0-9a-zA-Z]{1,13}\.[com,cn,net]{1,3}&＃39;)
text&＃61;&＃39;&＃39;&＃39;我昨天认识了一个女孩A&＃xff0c;她给了我她的邮箱girlA&＃64;163.com&＃xff0c;
和她道别后&＃xff0c;又遇到另一个女孩B&＃xff0c;她也给了我她的邮箱girlB&＃64;qq.com&＃xff0c;
没想到&＃xff0c;我之后又遇见了第三个女孩C......&＃39;&＃39;&＃39;
match &＃61; pattern.findall(text)
for email in match:print(email)
# girlA&＃64;163.com
# girlB&＃64;qq.com

搞定&＃xff01;

目前你看不懂上面的代码没关系&＃xff0c;下面我们来一一讲解。

语法

要想用好正则表达式&＃xff0c;首先要学习正则表达式的使用语法/使用规则。

图来自Python正则表达式指南

我们按照图里面的顺序来分别讲解不同正则表达式不同部分的语法&＃xff1a;

字符

• 一般字符

如”a”,”b”,”g”,”4”,”,”等这种比较常用的字符&＃xff0c;在正则表达式中都是一对一地匹配和自身相同的字符&＃xff0c;没什么特别。

import re
text&＃61;&＃39;abcdefg&＃39;
match&＃61;re.search(&＃39;cd&＃39;,text)
if match:print(match.group())
# cd 匹配到cd

• .(点)

.&＃xff08;一个点&＃xff09;用于匹配任意除了换行符”\n”以外的字符。

import re
text&＃61;&＃39;ab3defg&＃39;
match&＃61;re.search(&＃39;b..&＃39;,text)
if match:print(match.group())
# b3d 匹配到b及其后紧跟的两个任意字符

• \&＃xff08;反斜杠&＃xff09;

反斜杠表示转义字符&＃xff0c;它将使得紧跟在它后面的字符转变成特殊的含义&＃xff0c;或者消除特殊字符本身的特殊含义。&＃xff08;注意&＃xff0c;后面的\d 和\w等正则本身包含的元字符中的反斜杠不属于此类转义作用&＃xff0c;而是正则中规定好的组合&＃xff0c;元字符里的反斜杠就是普通的反斜杠字符。这一点目前看不懂没关系&＃xff0c;结合后面的注意事项部分理解&＃xff09;

比如当\与.&＃xff08;点&＃xff09;结合在一起&＃xff0c;点就不再是匹配任意单个字符&＃xff0c;而是确实地匹配一个点&＃xff08;消除特殊含义&＃xff09;。

• […]

中括号中放上任意多的字符&＃xff0c;则这些字符会构成一个字符集合&＃xff0c;这个模式将会在遇到集合中的任意一个字符时都认定为匹配。

import re
text&＃61;&＃39;abc345def&＃39;
match&＃61;re.search(&＃39;[345]&＃39;,text)
if match:print(match.group())
# bc3 由于匹配到了(3,4,5)中的3&＃xff0c;不再继续向后匹配。match&＃61;re.search(&＃39;[b5aef]&＃39;,text)
if match:print(match.group())
# a 由于匹配到了(b,5,a,e,f)中的a&＃xff0c;不再继续向后匹配

预定义字符集

• \d \D 数字字符

d是decimal&＃xff08;十进位的&＃xff09;首字母&＃xff0c;代表数字。w

\d用来匹配任意单个数字&＃xff08;0到9&＃xff09;&＃xff0c;而\D则是匹配任意的非数字&＃xff08;大写就是反过来&＃xff0c;比较好记&＃xff09;

import re
text&＃61;&＃39;abc345def&＃39;
match&＃61;re.search(&＃39;\d\d&＃39;,text)
if match:print(match.group())
# 34 匹配到连续的两个数字match&＃61;re.search(&＃39;\D\D&＃39;,text)
if match:print(match.group())
# ab 匹配到连续的两个非数字字符

• \s \S 空白字符

s代表space&＃xff08;空格&＃xff0c;空白&＃xff09;&＃xff0c;可以匹配空格&＃xff0c;\t制表符&＃xff0c;\r,\n换行符&＃xff0c;\f,\v这几个不会在屏幕上输出可见字符的字符。

import re
text&＃61;&＃39;abc3 45def&＃39;
match&＃61;re.search(&＃39;\d\s\d&＃39;,text)
if match:print(match.group())
# 3 4 匹配到数字&＃43;空格&＃43;数字的三个连续字符的组合

• \w \W 单词字符

w代表word&＃xff08;单词&＃xff09;&＃xff0c;能构成word的字符包括大小写的字母&＃xff08;a-z和A-Z&＃xff09;&＃xff0c;也包括数字&＃xff08;0-9&＃xff09;&＃xff0c;还包括下划线_。

import re
text&＃61;&＃39;_a3%sdef&＃39;
match&＃61;re.search(&＃39;\w\w\w\w&＃39;,text)
if match:print(match.group())
# sdef 匹配到连续的四个单词字符&＃xff0c;但不能匹配"_a3%"&＃xff0c;因为%是非单词字符

数量词

首先明白&＃xff0c;数量词不能单独使用&＃xff0c;是配合前面的字符使用&＃xff0c;用以描述对前面的字符进行什么数量的匹配。

• *&＃xff08;星号&＃xff09;

星号*表示对前面的字符串进行0次或多次匹配&＃xff08;多次即大于等于1次&＃xff09;。

import re
text&＃61;&＃39;_a34534%1sdef&＃39;
match&＃61;re.search(&＃39;a\d*&＃39;,text)
if match:print(match.group())
# a34534 匹配到a与其后的多个数字&＃xff0c;直到遇到第一个非数字的%号停止匹配。match&＃61;re.search(&＃39;a\s*\d*&＃39;,text)
if match:print(match.group())
# a34534 依然是匹配到a与其后的多个数字。虽然在字符a与数字之间没有任何空白字符&＃xff0c;但是由于星号允许匹配0个&＃xff08;即没有&＃xff09;&＃xff0c;所以也算匹配。

简而言之&＃xff0c;星号是有则匹配&＃xff0c;没有也不要紧&＃xff0c;继续往后走。

• • &＃xff08;加号&＃xff09;

加号相对星号就“真的很严格~~”&＃xff0c;因为它要求前面的字符至少匹配一次&＃xff0c;多次也ok。

承接上面星号中的例子&＃xff0c;只是把”\s*”改成了”\s&＃43;”&＃xff1a;

import re
text&＃61;&＃39;_a34534%1sdef&＃39;
match&＃61;re.search(&＃39;a\s&＃43;\d*&＃39;,text)
if match:print(match.group())

输出为空白&＃xff0c;因为字符a和后面的数字之间根本没有空白字符&＃xff0c;于是匹配不成功&＃xff0c;返回空。

import re
text&＃61;&＃39;_a34534%1sdef&＃39;
match&＃61;re.search(&＃39;a\d&＃43;&＃39;,text)
if match:print(match.group())
# a34534 这样就还是能匹配到字符a及后面的数字。

• ? &＃xff08;问号&＃xff09;

问号就是确认一下有木有&＃xff0c;有或没有都行&＃xff0c;但是你有的话&＃xff0c;就只能有一个&＃xff0c;不准多了&＃xff0c;多了它不负责匹配。

import re
text&＃61;&＃39;_a34534%1sdef&＃39;
match&＃61;re.search(&＃39;a\d?&＃39;,text)
if match:print(match.group())
# a3 匹配到a及后面紧接的一个数字&＃xff0c;不再继续向后匹配。match&＃61;re.search(&＃39;a\d*!?&＃39;,text)
if match:print(match.group())
# a34534 匹配到a及后面的数字&＃xff0c;又尝试匹配数字后的感叹号&＃xff0c;发现没有&＃xff08;实际是百分号&＃xff09;&＃xff0c;于是停止匹配。

• {m}

这个就比较简单&＃xff0c;就是匹配前一个字符m次。

import re
text&＃61;&＃39;_a34534%1sdef&＃39;
match&＃61;re.search(&＃39;\d{3}&＃39;,text)
if match:print(match.group())
# 345 匹配数字字符三次。

• {m,n}

这个也很简单&＃xff0c;就是匹配n到m次&＃xff0c;即大于等于n&＃xff0c;小于等于m的任一次数都可以。不过会尽量往多的次数匹配。

import re
text&＃61;&＃39;_a34534%1sdef&＃39;
match&＃61;re.search(&＃39;\d{1,4}&＃39;,text)
if match:print(match.group())
# 3453 匹配数字1-4次&＃xff0c;因为尽量往多的匹配&＃xff0c;匹配了4个数字match&＃61;re.search(&＃39;\d{1,3}s&＃39;,text)
if match:print(match.group())
# 1s 匹配数字1-3次及后面的s字符

• *? &＃43;? ?? {m,n}?

注意&＃xff0c;这里的问号不是前面讲的“匹配字符0或1次”的那个问号的作用&＃xff0c;而是用于声明使用懒惰模式&＃xff08;或者叫非贪婪模式&＃xff09;来进行匹配。

什么叫贪婪模式&＃xff1f;即默认情况下&＃xff0c;凡是涉及到数量词的匹配&＃xff0c;正则表达式的匹配工具都是尽可能地往次数多的去匹配的&＃xff08;例子见上面讲{m,n}时的第一个示例代码&＃xff09;&＃xff0c;这就是贪婪模式&＃xff08;尽可能多就是很“贪婪”嘛~&＃xff09;。而非贪婪模式/懒惰模式就是相反地做尽可能少的匹配。

两种情况下&＃xff0c;星号、加号、问号、{m,n}实际上就分别成了以下作用&＃xff1a;

举个简单的例子&＃xff1a;

import re
text&＃61;&＃39;_a34534%1sdef&＃39;
match&＃61;re.search(&＃39;\d{2,3}&＃39;,text)
if match:print(match.group())
# 345 匹配到连续的三个数字&＃xff08;贪婪模式&＃xff09;match&＃61;re.search(&＃39;\d{2,3}?&＃39;,text)
if match:print(match.group())
# 34 匹配到连续的两个数字&＃xff08;非贪婪模式&＃xff09;

边界匹配

• ^ $

^代表匹配字符串的开头&＃xff08;在多行模式中匹配每一行的开头&＃xff09;。$代表匹配字符串的末尾&＃xff08;在多行模式中匹配每一行的末尾&＃xff09;。

这两个符号主要是针对只想匹配文本的开头或结尾部分的情况使用的。而当一个正则表达式同时使用两个符号”^XXXXXX$”时&＃xff0c;意思就是对字符串进行从头到尾的整体匹配。

比如我们在任意网站注册账号时要求填入邮箱信息&＃xff0c;那么网站的后台一般会对邮箱做合法性检验&＃xff0c;那么就会对我们输入的邮箱地址做从头到尾的正则匹配&＃xff0c;看是否符合要求。

import re
text&＃61;&＃39;%a1234&＃39;
match&＃61;re.search(&＃39;a\d{4}&＃39;,text)
if match:print(match.group())
# a1234 匹配到a和连续的4个数字match&＃61;re.search(&＃39;^a\d{4}&＃39;,text)
if match:print(match.group())
# 输出空白&＃xff0c;因为从头开始匹配&＃xff0c;而开头是百分号&＃xff0c;不是a&＃xff0c;匹配失败。

• \A \Z

\A和^的作用相同&＃xff0c;\Z和$的作用相同。

逻辑、分组

• &＃xff08;…&＃xff09;分组

圆括号会将包含在里面的所有内容作为一个分组的整体&＃xff0c;我们可以在分组加数量词来匹配分组若干次。

import re
text&＃61;&＃39;_a34a534b123%1sdef&＃39;
match&＃61;re.search(&＃39;(a\d{2,3})&＃43;&＃39;,text)
if match:print(match.group())
# a34a534 匹配分组[字符a&＃43;2-3个数字]一次或多次

• |&＃xff08;竖线&＃xff09;

竖线本身会将正则表达式切分成左右两个部分&＃xff0c;而竖线的作用就是&＃xff1a;优先匹配左边的部分&＃xff0c;如果匹配到了&＃xff0c;就完成匹配&＃xff1b;如果未匹配到&＃xff0c;再匹配右边的部分&＃xff0c;如果匹配到了&＃xff0c;就完成匹配&＃xff0c;否则&＃xff0c;匹配失败。

import re
text&＃61;&＃39;_a34a524b1234%1sdef&＃39;
match&＃61;re.search(&＃39;[a-z]\d{5}|[a-z]\d{4}&＃39;,text)
if match:print(match.group())
# b1234 竖线左边小写字母和5个数字的匹配未成功&＃xff0c;转而匹配右边小写字母和4个数字的匹配成功。

常用的正则语法也就是上面这些&＃xff0c;其它的大家可以再需要用到时再回来看和理解&＃xff0c;这里就先不详细讲解了。

注意事项

正则表达式前的r是什么

r表示raw&＃xff08;原生的&＃xff0c;未加工的&＃xff09;&＃xff0c;放在字符串前&＃xff0c;表示这个字符串为原生字符串&＃xff0c;而原生字符串指的是区别于正则表达式的一般字符串。

强调原生字符串这种概念的主要原因是针对反斜杠&＃xff08;\&＃xff09;的问题。因为反斜杠在一般编程语言的字符串里的含义是转义符&＃xff0c;转义符的作用在前面也有提到过&＃xff0c;就是转换或消除后面紧跟的一个字符的特殊含义。即单个的反斜杠出现时&＃xff0c;就会被认为是在对紧跟在它后面的一个字符进行转义操作。

但是问题是&＃xff0c;有时候我们可能想匹配的文本就是一个包含有反斜杠字符的字符串&＃xff0c;那么我们在正则里面就需要把反斜杠的转义的作用给消除掉&＃xff0c;而表达出我们就是要匹配一个反斜杠字符的意思。

首先&＃xff0c;我们要明白的是&＃xff0c;如果我们想在一个普通字符串里面表达一个反斜杠字符&＃xff0c;而非转义符时&＃xff0c;应该这么做&＃xff1a;

string&＃61;&＃39;abc\ndef&＃39;
print(string)
# abc
# def
# 会分两行输出abc和def&＃xff0c;因为\n中的反斜杠被认为成转义符&＃xff0c;和n结合时就成了换行符。# 第一种方法&＃xff1a;反斜杠&＃43;反斜杠
string&＃61;&＃39;abc\\ndef&＃39;
print(string)
# abc\ndef
# 只输出一行&＃xff0c;因为\\n中的第一个反斜杠作为转义符&＃xff0c;将后面的第二个反斜杠给转义了&＃xff0c;使其成为了普通的反斜杠字符&＃xff08;消除特殊含义&＃xff09;。# 第二种方法&＃xff1a;声明原生字符串
string&＃61;r&＃39;abc\ndef&＃39;
print(string)
# abc\ndef
# 只输出一行&＃xff0c;因为被声明成原生字符串的字符串&＃xff0c;其里面所有的字符都将被消除特殊含义&＃xff0c;于是单个的反斜杠也不是转义符了&＃xff0c;而成了普通的反斜杠字符。

好&＃xff0c;回到我们的正则表达式&＃xff0c;正则表达式里如果我们想写一个能匹配反斜杠的表达式&＃xff0c;怎么写呢&＃xff1f;

import re
text&＃61;r&＃39;%abc\ndef&＃39;
match&＃61;re.search(&＃39;\\\\&＃39;,text)
if match:print(match.group())
# \

对&＃xff0c;没有错&＃xff0c;你得写四个反斜杠才行&＃xff01;&＃xff01;&＃xff01;原因是&＃xff0c;一般的字符串里你想表达一个反斜杠字符得用两个反斜杠(\)&＃xff0c;但是在正则表达式里规定了&＃xff1a;表达一个普通字符串里的反斜杠字符需要用两个反斜杠字符&＃xff08;很绕很奇怪我知道- -&＃xff01;&＃xff09;&＃xff0c;于是这代表着&＃xff0c;你需要组合两个反斜杠字符(\)&＃xff0c;即四个反斜杠一起&＃xff0c;才能在正则表达式里面表达出一个反斜杠字符的含义。

于是&＃xff0c;为了简化这个问题&＃xff0c;防止在正则表达式里面写反斜杠写到晕厥&＃xff0c;我们可以用原生字符串的方法来减少麻烦&＃xff1a;

import re
text&＃61;r&＃39;%abc\ndef&＃39;
match&＃61;re.search(r&＃39;\\&＃39;,text) # 不是转义
if match:print(match.group())
# \

即&＃xff0c;当你把正则表达式声明为原生字符串时&＃xff0c;里面所有的反斜杠也不再具备转义含义&＃xff0c;而是纯粹的反斜杠字符&＃xff0c;于是只用写两个就可以表示普通字符串里面的一个反斜杠字符了。&＃xff08;所以追根溯源&＃xff0c;这个坑就是因为正则里面规定了表达式里的两个反斜杠字符才能算普通字符串里的一个反斜杠字符&＃xff09;。

总结&＃xff1a;一般情况下&＃xff0c;我们也提倡在正则表达式的前面加个r声明这是原生字符串&＃xff0c;因为可以减少匹配反斜杠字符时候的麻烦&＃xff08;写两个反斜杠就够了&＃xff09;&＃xff0c;也不影响其它正则元字符的正常使用&＃xff08;\d,\s,\w等&＃xff09;&＃xff0c;该咋写咋写。

这个部分比较绕&＃xff0c;不过实际情况中也并没有很多需要做反斜杠字符匹配的地方&＃xff0c;所以不太理解此部分问题也不大&＃xff0c;能够顺畅使用正则表达式里的上述其它语法也已经可以应对绝大多数匹配问题了。

另外&＃xff0c;字符串前面有时还有带一个u字母的&＃xff0c;意思是表示该字符串是一个unicode编码的字符串。详情参见python字符串前缀 u和r的区别。

Python3正则工具