参考书籍：《正则指引》（1-3章）

---

以 Python 语言为学习工具，Python中常用的关于正则表达式的函数是 re.search()，需要引入对应的包

import re

用法：re.search(pattern, string)，pattern是字符串形式的正则表达式，string是需要匹配的字符串。

---

1. 普通字符组

在 pattern 两端加上 ^ 和 $，表示“定位到字符串的起始位置” 和 “定位到字符串的结束位置”，字符串前加 r 表示是原生字符串（Python特性）。

re.search(r"[0-9]", "2") != None    # True
re.search(r"^[0-9]$", "a2") != None # False

上边 [0-9] 等价于 [0123456789]，类似还有 [a-z]，[A-Z]。这些字符组可以混写在一起，比如匹配十六进制字符：

re.search(r"^[0-9a-zA-Z]$", "A") != None    # True

上例中 - 不能表示横线字符，包括 [ ] ^ $ 都成为元字符，有特殊的意义，如果要表示字符本身，用到转义字符 \ ，例如 [0\-9] 只表示字符 0 或 - 或 9，当然，如果 - 不在09之间 [-09]，就不用加转义字符，使用原则是，只有在表示特殊意义时使用转义字符才有效。
[ 需要转义，但 ] 不需要转义。

排除型字符组

在字符串最前方加脱字符 ^ 表示“在当前位置，匹配一个没有列出的字符”，[^0-9] 就表示0-9之外的字符，不包括空字符。

#匹配一个- 0 9之外的字符
re.search(r"^[^-09]$", "-") != None # True
re.search(r"^[^-09]$", "6") != None # False

字符组简记

\d 等价于 [0-9]

\w 等价于 [0-9a-zA-Z_]

\s 等价于 [ \t\r\n\v\f]

相对于 \d、\w、\s，\D、\W、\S是对应的排除型字符串。\s 能匹配的，\S 一定不能匹配，其他类似。

有趣的是，字符组 [\s\S] 匹配任意字符。

---

2. 量词

用 {m} 来表示匹配的字符重复个数，例如匹配6位邮政编码：

re.search(r"^\d{6}$", "101399") != None # True
re.search(r"^\d{6}$", "1013990") != None    # False
re.search(r"^\d{6}$", "1a1399") != None # False

如果长度不确定，通用形式是 {m,n}，需要注意的是：在 , 之后不能加空格！！！！

量词也有简记法，* 等价 {0,}， + 等价 {1,}，? 等价 {0,1}

量词	说明
{n}	之前的元素必须出现n次
{m,n}	之前的元素最少出现m次，最多出现n次
{m,}	之前的元素最少出现m次，出现次数无上限
{0,n}	之前的元素可以不出现，也可以出现，最多出现n次

点号

点号 . 可以匹配几乎所有的字符，换行符 \n 除外，如果要匹配所有的字符可以使用单行匹配模式或自制通配字符组：

#单行匹配模式
re.search(r"(?s)^.$", "\n") != None # True
#自制通配字符组
re.search(r"^[\s\S]$", "\n") != None    # True

点号 . 不能滥用，否则会很容易出现意外结果。（P23）
例如，要匹配双引号""字符串，应该使用 "[^"]*"，如果图省事使用 ".\*"

#字符串是 "hehehe"
print re.search(r"\".*\"", "\"hehehe\"").group(0)
"hehehe"
#字符串是 "aaa"bbb"
print re.search(r"\".*\"", "\"aaa\"bbb\"").group(0)
"aaa"bbb"

第二个出现错误！

忽略优先量词

用 <tr>[\s\S]<\tr> 匹配一段字符串中的所有的 <tr></tr>：

#字符串是 <tr>aaa</tr> hhh <tr>bbb</tr>
print re.findall(r"<tr>[\s\S]*</tr>", "<tr>aaa</tr> hhhh <tr>bbb</tr>")
['<tr>aaa</tr> hhhh <tr>bbb</tr>']

结果是，匹配了字符串最前的 <tr> 和最后的 </tr>，因为之前的量词都可归类为匹配优先量词（贪婪量词），而我们想要的结果是匹配两个 <tr> </tr>，就用到了忽略优先量词。

对 [\s\S]* 来说，把 * 改为 *? 就是使用了忽略优先量词：

#字符串是 <tr>aaa</tr> hhh <tr>bbb</tr>
print re.findall(r"<tr>[\s\S]*</tr>", "<tr>aaa</tr> hhhh <tr>bbb</tr>")
['<tr>aaa</tr>', '<tr>bbb</tr>']

匹配优先量词	忽略优先量词
*	*?
+	+?
?	??
{m,n}	{m,n}?
{m,}	{m,}?
{,n}	{,n}?

利用匹配优先量词拆解 Linux/Unix 路径 /usr/local/bin/python.py ：

print re.search(r"^.*/", "/usr/local/bin/python.py").group(0)
/usr/bin/

print re.search(r"[^//]*$", "/usr/local/bin/python.py").group(0)
python.py

量词的转义

量词	转义形式
{n}	{n}
{m,n}	{m,n}
{m,}	{m,}
*	*
+	+
?	?
*?	\*?
+?	\+?
??	??

应用：匹配IP地址，匹配模式是 ([0-9]{1,3}\.){3}[0-9]{1,3}

print re.search(r"^([0-9]{1,3}\.){3}[0-9]{1,3}$", "192.10.0.223") != None   # True

---

3. 括号

3.1 分组

其实，在上文匹配IP地址时，就已经使用了括号，很容易理解，就是把量词的作用范围扩展到括号内的所有表达式，而不仅仅是其前面的单个字符表达式。
例：匹配 E-mail 地址
E-mail由 @ 符号分成左右两部分，左边是用户名，右边是域名。用户名的匹配简单，主要由 [A-Z] [a-z] [0-9] _ . 组成，所以，左边的匹配字符组是 [\w\.]{1,64}。
右边的域名有可能是一级域名如 host.com，也有可能是多级域名，总之至少有一级。那么每多出的一级域名是有域名（由 [A-Z] [a-z] [0-9] -组成，可写为 [-\w]）和 . 组成，所以匹配字符组为[-\w]{1,63}\.，多出的域名有0个或多个可能，使用量词*限定。所以，完整的匹配表达式是 [\w\.]{1,64}@([-\w]{1,63}\.)*[-\w]{1,63}

re.search(r"^[-\w\.]{1,64}@([-a-zA-Z0-9]{1,63}\.)*[-a-zA-Z0-9]{1,63}$", "makai@ict.ac.cn") != None    #True

3.2 多选结构

多选结构的形式是 (...|...)，很好理解。
上文匹配IP的例子其实不准确，因为每一段的数字应该是在0-255之间，例子中如果大于255如998也会被匹配。此问题可以用多选结构解决。
匹配一段数值在0-255之间的文本，分下列几种情况：

说明	匹配
1位数	(00)?[0-9]
2位数	(0)?[0-9]{2}
3位数，第1位是1	1[0-9]{2}
3位数，第1位是2，第2位是0-4	2[0-4][0-9]
3位数，第1位是2，第2位是5	25[0-5]

所以，匹配一段数值在0-255之间的文本，表达式是 ((00)?[0-9]|(0)?[0-9]{2}|1[0-9]{2}|2[0-4][0-9]|25[0-5])
说明

1. (option1|option2)中如果么有出现括号()，则将整个表达式视为一个多选结构，所以ab|cd 等价于 (ab|cd)。但尽量还是加上括号()，以防意外。
2. 尽量不要出现既匹配 option1 又匹配 option2 的表达式。

3.3 引用分组

引用分组的作用是方便通过编号num的形式获取对应分组匹配的文本。
例如，诸如 205-04-28 这类表示日期的字符串，希望提取其中的年月日。

print re.search(r"(\d{4})-(\d{2})-(\d{2})", "2015-04-28").group(1)    # 2015
print re.search(r"(\d{4})-(\d{2})-(\d{2})", "2015-04-28").group(2)    # 04
print re.search(r"(\d{4})-(\d{2})-(\d{2})", "2015-04-28").group(3)    # 28

分组从1开始。分组0默认代表整个表达式匹配的文本。即：

print re.search(r"(\d{4})-(\d{2})-(\d{2})", "2015-04-28").group(0)    # 2015-04-28

如果存在括号的嵌套，编号的原则是：无论括号如何嵌套，分组的编号都是根据开括号出现顺序来基数；开括号是从左向右数第多少个开括号，整个括号分组的编号就是多少。

3.3.1 反向引用

形式：()\num ，num 表示所引用分组的编号
注意括号()不是一定与 \num挨着。

re.search(r"^([a-z])\1$", "aa") != None     # True
re.search(r"^([a-z])\1$", "ab") != None     # False

应用：可在解析HTML代码中匹配tag。比如匹配<bold class="class1">text</bold>或<h1>title</h1>中的内容。<(a-zA-Z0-9+)(\s[^>]+)?>[\s\S]*?</\1>