正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。
python中使用re
模块来实现
>>> import re
一、简单模式
1、字符串匹配
大多数字母和字符会匹配它们自身。举个例子,正则表达式 FishC将完全匹配字符串 "FishC"。当然这个规则也有例外。有少数特殊的字符我们称之为元字符(metacharacter),它们并不能匹配自身,它们定义了字符类、子组匹配和模式重复次数等。
元字符:. ^ $ * + ? { } [ ] \ | ( )
2、[ ] 字符类
它们指定一个字符类用于存放你需要匹配的字符集合。可以单独列出需要匹配的字符,也可以通过两个字符和一个横杆 - 指定匹配的范围。例如 [abc]
会匹配字符 a,b 或 c
;[a-c]
可以实现相同的功能。后者使用范围来表示与前者相同的字符集合。如果你想只匹配小写字母,你的 RE 可以写成 [a-z]
。
>>> re.search(r'[a-z]','I love 123 fishc.com!')
<re.Match object; span=(2, 3), match='l'>
>>> re.search(r'[0-9]','I love 123 fishc.com!')
<re.Match object; span=(7, 8), match='1'>
>>> re.search(r'[2-9]','I love 123 fishc.com!')
<re.Match object; span=(8, 9), match='2'>
元字符在方括号中不会触发“特殊功能”,在字符类中,它们只匹配自身。例如 [akm$]
会匹配任何字符'a','k','m' 或 '$'
,'$'
是一个元字符,但在方括号中它不表示特殊含义,它只匹配'$'
字符本身。
>>> re.search(r'[.]','fish.com')
<re.Match object; span=(4, 5), match='.'>
你还可以匹配方括号中未列出的所有其他字符。做法是在类的开头添加一个脱字符号 ^
,例如[^5]
会匹配除了 '5' 之外的任何字符。
>>> re.search(r'[aeiou]','i love 123 fishc.com!')
<re.Match object; span=(0, 1), match='i'>
>>> re.search(r'[aeiou]','I love 123 fishc.com!')
<re.Match object; span=(3, 4), match='o'> #正则表达式区分大小写
3、\
跟 Python 的字符串规则一样,如果在反斜杠后边紧跟着一个元字符,那么元字符的“特殊功能”也不会被触发。例如你需要匹配符号 [
或 \
,你可以在它们前面加上一个反斜杠,以消除它们的特殊功能:\[
,\\
反斜杠后边跟一些字符还可以表示特殊的意义,例如表示十进制数字,表示所有的字母或者表示非空白的字符集合。
\w
匹配任何单词字符。如果正则表达式以字节的形式表示,这相当于字符类[a-zA-Z0-9_]
;如果正则表达式是一个字符串,\w
会匹配所有Unicode
数据库(unicodedata 模块提供)中标记为字母的字符。你可以在编译正则表达式的时候,通过提供re.ASCII
表示进一步限制 \w
的定义。
re.ASCII 标志使得 \w 只能匹配 ASCII 字符,不要忘了,Python3 是 Unicode 的。
特殊字符 | 含义 |
---|---|
\d | 匹配任何十进制数字;相当于类 [0-9] |
\D | 与 \d 相反,匹配任何非十进制数字的字符;相当于类 [^0-9] |
\s | 匹配任何空白字符(包含空格、换行符、制表符等);相当于类 [ \t\n\r\f\v] |
\S | 与 \s 相反,匹配任何非空白字符;相当于类 [^ \t\n\r\f\v] |
\w | 匹配任何单词字符 |
\W | 于 \w 相反 |
\b | 匹配单词的开始或结束 |
\B | 与 \b 相反 |
>>> re.search(r'\d','i love 123 fishc.com!')
<re.Match object; span=(7, 8), match='1'>
>>> re.search(r'\d\d\d','i love 123 fishc.com!')
<re.Match object; span=(7, 10), match='123'>
它们可以包含在一个字符类中,并且一样拥有特殊含义。例如[\s,.]
是一个字符类,它将匹配任何空白字符(/s 的特殊含义),',' 或 '.'。
4、.
它匹配除了换行符以外的任何字符。如果设置了re.DOTALL
标志,.
将匹配包括换行符在内的任何字符。
>>> import re
>>> re.search('fishc','i love fishc.com')
<re.Match object; span=(7, 12), match='fishc'>
>>> re.search(r'.','i love fishc.com')
<re.Match object; span=(0, 1), match='i'>
>>> re.search(r'fish.','i love fishc.com!')
<re.Match object; span=(7, 12), match='fishc'>
>>> re.search(r'\.','i love fishc.com!')
<re.Match object; span=(12, 13), match='.'>
二、重复的事情
正则表达式有另一个强大的功能,就是你可以指定 RE 部分被重复的次数。
1、*
它用于指定前一个字符匹配零次或者多次。
例如 ca*t
将匹配 ct
(0 个字符 a),cat
(1 个字符 a),caaat
(3 个字符 a),等等。需要注意的是,由于受到 C 语言的 int 类型大小的内部限制,正则表达式引擎会限制字符 'a' 的重复个数不超过 20 亿个
正则表达式默认的重复规则是贪婪的,当你重复匹配一个 RE 时,匹配引擎会尝试尽可能多的去匹配。直到 RE 不匹配或者到了结尾,匹配引擎就会回退一个字符,然后再继续尝试匹配。
我们通过例子一步步的给大家讲解什么叫“贪婪”:先考虑一下表达式 a[bcd]*b
,首先需要匹配字符 'a'
,然后是零个到多个 [bcd]
,最后以'b'
结尾。那现在想象一下,这个 RE 匹配字符串 abcbd
会怎样?
步骤 | 匹配 | 说明 |
---|---|---|
1 | a | 匹配 RE 的第一个字符 'a' |
2 | abcbd | 引擎在符合规则的情况下尽可能地匹配 [bcd]*,直到该字符串的结尾 |
3 | 失败 | 引擎尝试匹配 RE 最后一个字符 'b',但当前位置已经是字符串的结尾,所以失败告终 |
4 | abcb | 回退,所以 [bcd]* 匹配少一个字符 |
5 | 失败 | 再一次尝试匹配 RE 最后一个字符 'b',但字符串最后一个字符是 'd',所以失败告终 |
6 | abc | 再次回退,所以 [bcd]* 这次只匹配 'bc' |
7 | abcb | 再一次尝试匹配字符 'b',这一次字符串当前位置指向的字符正好是 'b',匹配成功 |
*
== {0,无穷}
2、+
用于指定前一个字符匹配一次或者多次。
要特别注意 *
和+
的区别:*
匹配的是零次或者多次,所以被重复的内容可能压根儿不会出现;+
至少需要出现一次。例如 ca+t
会匹配 cat
和caaat
,但不会匹配 ct
。
+
== {1,无穷}
3、?
用于指定前一个字符匹配零次或者一次。你可以这么想,它的作用就是把某种东西标志位可选的。例如 小?甲鱼
可以匹配 小甲鱼
,也可以匹配 甲鱼
。
?
== {0,1}
4、{}
最灵活的应该是元字符 {m,n}
(m 和 n 都是十进制整数),它的含义是前一个字符必须匹配 m 次到 n 次之间。
例如a/{1,3}b
会匹配a/b
,a//b
和 a///b
。但不会匹配 ab
(没有斜杠);也不会匹配 a////b
(斜杠超过三个)。
你可以省略 m 或者 n,这样的话,引擎会假定一个合理的值代替。省略 m,将被解释为下限 0;省略 n 则会被解释为无穷大(事实上是上边我们提到的 20 亿)。
如果是 {,n}
相当于{0,n}
;如果是 {m,}
相当于 {m,+无穷}
;如果是 {n}
,则是重复前一个字符 n 次。
>>> re.search(r'ab{3}c','abbbc')
<re.Match object; span=(0, 5), match='abbbc'>
>>> re.search(r'ab{3,10}c','abbbbbc')
<re.Match object; span=(0, 7), match='abbbbbc'>
>>> re.search('(ab){3}','ababab')
<re.Match object; span=(0, 6), match='ababab'>
另外还有一个超容易出错的是写成 {m, n},看着挺美,但注意,正则表达式里边不能随意添加空格,不然会改变原来的含义。
tips:
1、如何取0-255之间的数字:
>>> re.search(r'[01]\d\d|2[0-4]\d|25[0-5]','188')
<re.Match object; span=(0, 3), match='188'>
先考虑百位,如果百位是1或0的话,后面两位可以是任意数字。如果百位是2,考虑十位,如果十位是0-4的话,个位可以是任意数字。最后考虑十位是5的情况,个位只能取0-5
2、正则表达式匹配IP地址
IP地址分为4段,以点号分隔。要对IP地址进行匹配,首先要对其进行分析,分成如下部分,分别进行匹配:
区间 | 表示 |
---|---|
0-9 | \d |
10-99 | [1-9]\d |
100-199 | [1]\d\d |
200-249 | 2[0-4]\d |
250-255 | 25[0-5] |
故每一段可以表示为:\d|[1-9]\d|[1]\d\d|2[0-4]\d|25[0-5]
前三段可以表示为:((\d|[1-9]\d|[1]\d\d|2[0-4]\d|25[0-5])\.){3}
加上最后一段,IP地址的表达式为 ((\d|[1-9]\d|[1]\d\d|2[0-4]\d|25[0-5])\.){3}(\d|[1-9]\d|[1]\d\d|2[0-4]\d|25[0-5])
但是该方法存在BUG,最后一段,如果匹配满足第一个\d,就会停止匹配
>>> import re
>>> res = re.compile('((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.){3}(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])')
>>> res.search('255.255.255.255')
<re.Match object; span=(0, 13), match='255.255.255.2'>
解决方法是:
1、把三位数移到前面
res = re.compile('((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.){3}(25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)')
>>> res.search('255.255.255.255')
<re.Match object; span=(0, 15), match='255.255.255.255'>
2、在末尾加上$
,$
表示匹配至字符串末尾
>>> res = re.compile('((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.){3}(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])$')
>>> res.search('255.255.255.255')
<re.Match object; span=(0, 15), match='255.255.255.255'>
>>> res.search('188.123.1.2')
<re.Match object; span=(0, 11), match='188.123.1.2'>
3、启用非贪婪模式
>>> s = '<html><title>love fishc </title></html>'
>>> re.search(r'<.+>',s)
<re.Match object; span=(0, 39), match='<html><title>love fishc </title></html>'>
>>> re.search(r'<.+?>',s)
<re.Match object; span=(0, 6), match='<html>'>
加上?
就可以启用非贪婪模式