正则表达式的学习

正则表达式已经成为处理文本的利器。

之前在PHP/PYthon/PERL中使用过一些，但是没有进行深入的学习， 最近有时间就来好好看看吧。

 

简单模式 我们将从最简单的正则表达式学习开始

 

字符匹配

大多数字母和字符一般都会和自身匹配。例如，正则表达式 test 会和字符串“test”完全匹配。（你也可以使用大小写不敏感模式，它还能让这个 RE 匹配“Test”或“TEST”；稍后会有更多解释。）

这个规则当然会有例外；有些字符比较特殊，它们和自身并不匹配，而是会表明应和一些特殊的东西匹配，或者它们会影响到 RE 其它部分的重复次数。本文很大篇幅专门讨论了各种元字符及其作用。

这里有一个元字符的完整列表；其含义会在本指南余下部分进行讨论。

. ^ $ * + ? { [ ] / | ( )

我们首先考察的元字符是"[" 和 "]"。它们常用来指定一个字符类别，所谓字符类别就是你想匹配的一个字符集。字符可以单个列出，也可以用“-”号分隔的两个给定字符来表示一个字符区间。例如，[abc] 将匹配"a", "b", 或 "c"中的任意一个字符；也可以用区间[a-c]来表示同一字符集，和前者效果一致。如果你只想匹配小写字母，那么 RE 应写成 [a-z].

元字符在类别里并不起作用。例如，[akm$]将匹配字符"a", "k", "m", 或 "$" 中的任意一个；"$"通常用作元字符，但在字符类别里，其特性被除去，恢复成普通字符。

你可以用补集来匹配不在区间范围内的字符。其做法是把"^"作为类别的首个字符；其它地方的"^"只会简单匹配 "^"字符本身。例如，[^5] 将匹配除 "5" 之外的任意字符。

也许最重要的元字符是反斜杠"/"。 做为 Python 中的字符串字母，反斜杠后面可以加不同的字符以表示不同特殊意义。它也可以用于取消所有的元字符，这样你就可以在模式中匹配它们了。举个例子，如果你需要匹配字符 "[" 或 "/"，你可以在它们之前用反斜杠来取消它们的特殊意义： /[ 或 //。

一些用 "/" 开始的特殊字符所表示的预定义字符集通常是很有用的，象数字集，字母集，或其它非空字符集。下列是可用的预设特殊字符：

/d  匹配任何十进制数；它相当于类 [0-9]。
/D  匹配任何非数字字符；它相当于类 [^0-9]。
/s  匹配任何空白字符；它相当于类  [ /t/n/r/f/v]。
/S  匹配任何非空白字符；它相当于类 [^ /t/n/r/f/v]。
/w  匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。
/W  匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]。

表1.常用的元字符

代码	说明
.	匹配除换行符以外的任意字符
/w	匹配字母或数字或下划线或汉字
/s	匹配任意的空白符
/d	匹配数字
/b	匹配单词的开始或结束
^	匹配字符串的开始
$	匹配字符串的结束

 

这样特殊字符都可以包含在一个字符类中。如，[/s,.]字符类将匹配任何空白字符或","或"."。

本节最后一个元字符是 . 。它匹配除了换行字符外的任何字符，在 alternate 模式（re.DOTALL）下它甚至可以匹配换行。"." 通常被用于你想匹配“任何字符”的地方。

 

重复

正则表达式第一件能做的事是能够匹配不定长的字符集，而这是其它能作用在字符串上的方法所不能做到的。 不过，如果那是正则表达式唯一的附加功能的话，那么它们也就不那么优秀了。它们的另一个功能就是你可以指定正则表达式的一部分的重复次数。

我们讨论的第一个重复功能的元字符是 *。* 并不匹配字母字符 "*"；相反，它指定前一个字符可以被匹配零次或更多次，而不是只有一次。

举个例子，ca*t 将匹配 "ct" (0 个 "a" 字符), "cat" (1 个 "a"), "caaat" (3 个 "a" 字符)等等。RE 引擎有各种来自 C 的整数类型大小的内部限制，以防止它匹配超过20亿个 "a" 字符；你也许没有足够的内存去建造那么大的字符串，所以将不会累计到那个限制。

象 * 这样地重复是“贪婪的”；当重复一个 RE 时，匹配引擎会试着重复尽可能多的次数。如果模式的后面部分没有被匹配，匹配引擎将退回并再次尝试更小的重复。

一步步的示例可以使它更加清晰。让我们考虑表达式 a[bcd]*b。它匹配字母 "a"，零个或更多个来自类 [bcd]中的字母，最后以 "b" 结尾。现在想一想该 RE 对字符串 "abcbd" 的匹配。

Step	Matched	Explanation
1	a	a 匹配模式
2	abcbd	引擎匹配 [bcd]*，并尽其所能匹配到字符串的结尾
3	Failure	引擎尝试匹配 b，但当前位置已经是字符的最后了，所以失败
4	abcb	退回，[bcd]*尝试少匹配一个字符。
5	Failure	再次尝次b，但在当前最后一位字符是"d"。
6	abc	再次退回，[bcd]*只匹配 "bc"。
7	abcb	再次尝试 b ，这次当前位上的字符正好是 "b"

RE 的结尾部分现在可以到达了，它匹配 "abcb"。这证明了匹配引擎一开始会尽其所能进行匹配，如果没有匹配然后就逐步退回并反复尝试 RE 剩下来的部分。直到它退回尝试匹配 [bcd] 到零次为止，如果随后还是失败，那么引擎就会认为该字符串根本无法匹配 RE 。

另一个重复元字符是 +，表示匹配一或更多次。请注意 * 和 + 之间的不同；＊ 匹配零或更多次，所以根本就可以不出现，而 + 则要求至少出现一次。用同一个例子，ca+t 就可以匹配 "cat" (1 个 "a")， "caaat" (3 个 "a")， 但不能匹配 "ct"。

还有更多的限定符。问号 ? 匹配一次或零次；你可以认为它用于标识某事物是可选的。例如：home-?brew 匹配 "homebrew" 或 "home-brew"。

最复杂的重复限定符是 {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亿，但这也许同无穷大一样。

细心的读者也许注意到其他三个限定符都可以用这样方式来表示。 {0,} 等同于 *，{1,} 等同于 +，而{0,1}则与 ? 相同。如果可以的话，最好使用 *，+，或?。很简单因为它们更短也更容易懂。

 

表2.常用的限定符

代码/语法	说明
*	重复零次或更多次
+	重复一次或更多次
?	重复零次或一次
{n}	重复n次
{n,}	重复n次或更多次
{n,m}	重复n到m次

 

有时需要查找不属于某个能简单定义的字符类的字符。比如想查找除了数字以外，其它任意字符都行的情况，这时需要用到反义 ：

表3.常用的反义代码

代码/语法	说明
/W	匹配任意不是字母，数字，下划线，汉字的字符
/S	匹配任意不是空白符的字符
/D	匹配任意非数字的字符
/B	匹配不是单词开头或结束的位置
[^x]	匹配除了x以外的任意字符
[^aeiou]	匹配除了aeiou这几个字母以外的任意字符

例子：/S+ 匹配不包含空白符的字符串 。

<a[^>]+> 匹配用尖括号括起来的以a开头的字符串 。

 

剩下来要讨论的一部分元字符是零宽界定符（zero-width assertions）。它们并不会使引擎在处理字符串时更快;相反，它们根本就没有对应任何字符，只是简单的成功或失败。举个例子， /b 是一个在单词边界定位当前位置的界定符（assertions），这个位置根本就不会被 /b 改变。这意味着零宽界定符（zero-width assertions）将永远不会被重复，因为如果它们在给定位置匹配一次，那么它们很明显可以被匹配无数次。

|

可选项，或者 "or" 操作符。如果 A 和 B 是正则表达式，A|B 将匹配任何匹配了 "A" 或 "B" 的字符串。| 的优先级非常低，是为了当你有多字符串要选择时能适当地运行。Crow|Servo 将匹配"Crow" 或 "Servo", 而不是 "Cro", 一个 "w" 或 一个 "S", 和 "ervo"。

为了匹配字母 "|"，可以用 /|，或将其包含在字符类中，如[|]。

 

^

匹配行首。

 

$

匹配行尾，行尾被定义为要么是字符串尾，要么是一个换行字符后面的任何位置。

 

/A

只匹配字符串首。当不在 MULTILINE 模式，/A 和 ^ 实际上是一样的。然而，在 MULTILINE 模式里它们是不同的；/A 只是匹配字符串首，而 ^ 还可以匹配在换行符之后字符串的任何位置。

/Z

Matches only at the end of the string.
只匹配字符串尾。

/b

单词边界。这是个零宽界定符（zero-width assertions）只用以匹配单词的词首和词尾。单词被定义为一个字母数字序列，因此词尾就是用空白符或非字母数字符来标示的。

 

 

B

另一个零宽界定符（zero-width assertions），它正好同 /b 相反，只在当前位置不在单词边界时匹配。

 

 

 

前向界定符

 

另一个零宽界定符（zero-width assertion）是前向界定符。前向界定符包括前向肯定界定符和前项否定界定符，所下所示：

(?=...) 前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。

(?!...)

前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功

通过示范在哪前向可以成功有助于具体实现。考虑一个简单的模式用于匹配一个文件名，并将其通过 "." 分成基本名和扩展名两部分。如在 "news.rc" 中，"news" 是基本名，"rc" 是文件的扩展名。

匹配模式非常简单：

.*[.].*$

注意 "." 需要特殊对待，因为它是一个元字符；我把它放在一个字符类中。另外注意后面的 $; 添加这个是为了确保字符串所有的剩余部分必须被包含在扩展名中。这个正则表达式匹配 "foo.bar"、"autoexec.bat"、 "sendmail.cf" 和 "printers.conf"。

现在，考虑把问题变得复杂点；如果你想匹配的扩展名不是 "bat" 的文件名？一些不正确的尝试：

.*[.][^b].*$

上面的第一次去除 "bat" 的尝试是要求扩展名的第一个字符不是 "b"。这是错误的，因为该模式也不能匹配 "foo.bar"。

.*[.]([^b]..|.[^a].|..[^t])$

当你试着修补第一个解决方法而要求匹配下列情况之一时表达式更乱了：扩展名的第一个字符不是 "b"; 第二个字符不是 "a"；或第三个字符不是 "t"。这样可以接受 "foo.bar" 而拒绝 "autoexec.bat"，但这要求只能是三个字符的扩展名而不接受两个字符的扩展名如 "sendmail.cf"。我们将在努力修补它时再次把该模式变得复杂。

.*[.]([^b].?.?|.[^a]?.?|..?[^t]?)$

在第三次尝试中，第二和第三个字母都变成可选，为的是允许匹配比三个字符更短的扩展名，如 "sendmail.cf"。

该模式现在变得非常复杂，这使它很难读懂。更糟的是，如果问题变化了，你想扩展名不是 "bat" 和 "exe"，该模式甚至会变得更复杂和混乱。

前向否定把所有这些裁剪成：

.*[.](?!bat$).*$

前向的意思：如果表达式 bat 在这里没有匹配，尝试模式的其余部分；如果 bat$ 匹配，整个模式将失败。后面的 $ 被要求是为了确保象 "sample.batch" 这样扩展名以 "bat" 开头的会被允许。

将另一个文件扩展名排除在外现在也容易；简单地将其做为可选项放在界定符中。下面的这个模式将以 "bat" 或 "exe" 结尾的文件名排除在外。

.*[.](?!bat$|exe$).*$

后向引用

使用小括号指定一个子表达式后，匹配这个子表达式的文本 (也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下，每个分组会自动拥有一个组号 ，规则是：从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推

呃……其实,组号分配还不像我刚说得那么简单：

• 分组0对应整个正则表达式
• 实际上组号分配过程是要从左向右扫描两遍的：第一遍只给未命名组分配，第二遍只给命名组分配－－因此所有命名组的组号都大于未命名的组号
• 你可以使用(?:exp) 这样的语法来剥夺一个分组对组号分配的参与

后向引用 用于重复搜索前面某个分组匹配的文本。例如，/1 代表分组1匹配的文本 。难以理解？请看示例：

/b(/w+)/b/s+/1/b 可以用来匹配重复的单词 ，像go go , 或者kitty kitty 。这个表达式首先是一个单词 ，也就是单词开始处和结束处之间的多于一个的字母或数字 (/b(/w+)/b )，这个单词会被捕获到编号为1的分组中，然后是1个或几个空白符 (/s+ )，最后是分组1中捕获的内容（也就是前面匹配的那个单词） (/1 )。

你也可以自己指定子表达式的组名 。要指定一个子表达式的组名，请使用这样的语法：(?<Word>/w+) (或者把尖括号换成' 也行：(?'Word'/w+) ),这样就把/w+ 的组名指定为Word 了。要反向引用这个分组捕获 的内容，你可以使用/k<Word> ,所以上一个例子也可以写成这样：/b(?<Word>/w+)/b/s+/k<Word>/b 。

使用小括号的时候，还有很多特定用途的语法。下面列出了最常用的一些：

表4.常用分组语法

分类	代码/语法	说明
捕获	(exp)	匹配exp,并捕获文本到自动命名的组里
	(?<name>exp)	匹配exp,并捕获文本到名称为name的组里，也可以写成(?'name'exp)
	(?:exp)	匹配exp,不捕获匹配的文本，也不给此分组分配组号
零宽断言	(?=exp)	匹配exp前面的位置
	(?<=exp)	匹配exp后面的位置
	(?!exp)	匹配后面跟的不是exp的位置
	(?<!exp)	匹配前面不是exp的位置
注释	(?#comment)	这种类型的分组不对正则表达式的处理产生任何影响，用于提供注释让人阅读

我们已经讨论了前两种语法。第三个(?:exp) 不会改变正则表达式的处理方式，只是这样的组匹配的内容不会像前两种那样被捕获到某个组里面，也不会拥有组号 。“我为什么会想要这样做？”——好问题，你觉得为什么呢？

零宽断言

接下来的四个用于查找在某些内容(但并不包括这些内容)之前或之后的东西，也就是说它们像/b ,^ ,$ 那样用于指定一个位置，这个位置应该满足一定的条件(即断言)，因此它们也被称为零宽断言 。最好还是拿例子来说明吧：

断言用来声明一个应该为真的事实。正则表达式中只有当断言为真时才会继续进行匹配。

(?=exp) 也叫零宽度正预测先行断言 ，它断言自身出现的位置的后面能匹配表达式exp 。比如/b/w+(?=ing/b) ，匹配以ing结尾的单词的前面部分(除了ing以外的部分) ，如查找I'm singing while you're dancing. 时，它会匹配sing 和danc 。

(?<=exp) 也叫零宽度正回顾后发断言 ，它断言自身出现的位置的前面能匹配表达式exp 。比如(?<=/bre)/w+/b 会匹配以re开头的单词的后半部分(除了re以外的部分) ，例如在查找reading a book 时，它匹配ading 。

假如你想要给一个很长的数字中每三位间加一个逗号(当然是从右边加起了)，你可以这样查找需要在前面和里面添加逗号的部分：((?<=/d)/d{3})+/b ，用它对1234567890 进行查找时结果是234567890 。

下面这个例子同时使用了这两种断言：(?<=/s)/d+(?=/s) 匹配以空白符间隔的数字(再次强调，不包括这些空白符) 。

负向零宽断言

 

前面我们提到过怎么查找不是某个字符或不在某个字符类里 的字符的方法(反义)。但是如果我们只是想要确保某个字符没有出现，但并不想去匹配它 时怎么办？例如，如果我们想查找这样的单词--它里面出现了字母q,但是q后面跟的不是字母u,我们可以尝试这样：

/b/w*q[^u]/w*/b 匹配包含后面不是字母u的字母q 的单词 。但是如果多做测试(或者你思维足够敏锐，直接就观察出来了)，你会发现，如果q出现在单词的结尾的话，像Iraq ,Benq ，这个表达式就会出错。这是因为[^u] 总要匹配一个字符，所以如果q是单词的最后一个字符的话，后面的[^u] 将会匹配q后面的单词分隔符(可能是空格，或者是句号或其它的什么)，后面的/w*/b 将会匹配下一个单词，于是/b/w*q[^u]/w*/b 就能匹配整个Iraq fighting 。负向零宽断言 能解决这样的问题，因为它只匹配一个位置，并不消费 任何字符。现在，我们可以这样来解决这个问题：/b/w*q(?!u)/w*/b 。

零宽度负预测先行断言 (?!exp) ，断言此位置的后面不能匹配表达式exp 。例如：/d{3}(?!/d) 匹配三位数字，而且这三位数字的后面不能是数字 ；/b((?!abc)/w)+/b 匹配不包含连续字符串abc的单词 。

同理，我们可以用(?<!exp) ,零宽度负回顾后发断言 来断言此位置的前面不能匹配表达式exp ：(?<![a-z])/d{7} 匹配前面不是小写字母的七位数字 。

请详细分析表达式(?<=<(/w+)>).*(?=<///1>) ，这个表达式最能表现零宽断言的真正用途。

一个更复杂的例子：(?<=<(/w+)>).*(?=<///1>) 匹配不包含属性的简单HTML标签内里的内容 。(?<=<(/w+)>) 指定了这样的前缀 ：被尖括号括起来的单词 (比如可能是<b>)，然后是.* (任意的字符串),最后是一个后缀 (?=<///1>) 。注意后缀里的// ，它用到了前面提过的字符转义；/1 则是一个反向引用，引用的正是捕获的第一组 ，前面的(/w+) 匹配的内容，这样如果前缀实际上是<b>的话，后缀就是</b>了。整个表达式匹配的是<b>和</b>之间的内容(再次提醒，不包括前缀和后缀本身)。

 

贪婪与懒惰

当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多 的字符。以这个表达式为例：a.*b ，它将会匹配最长的以a开始，以b结束的字符串 。如果用它来搜索aabab 的话，它会匹配整个字符串aabab 。这被称为贪婪 匹配。

有时，我们更需要懒惰 匹配，也就是匹配尽可能少 的字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号? 。这样.*? 就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复 。现在看看懒惰版的例子吧：

a.*?b 匹配最短的，以a开始，以b结束的字符串 。如果把它应用于aabab 的话，它会匹配aab（第一到第三个字符） 和ab（第四到第五个字符） 。

为什么第一个匹配是aab（第一到第三个字符）而不是ab（第二到第三个字符）？简单地说，因为正则表达式有另一条规则，比懒惰／贪婪规则的优先级更高：最先开始的匹配拥有最高的优先权——The match that begins earliest wins。

表5.懒惰限定符

代码/语法	说明
*?	重复任意次，但尽可能少重复
+?	重复1次或更多次，但尽可能少重复
??	重复0次或1次，但尽可能少重复
{n,m}?	重复n到m次，但尽可能少重复
{n,}?	重复n次以上，但尽可能少重复

 

处理选项

上面介绍了几个选项如忽略大小写，处理多行等，这些选项能用来改变处理正则表达式的方式。下面是.Net中常用的正则表达式选项：

表6.常用的处理选项

名称	说明
IgnoreCase(忽略大小写)	匹配时不区分大小写。
Multiline(多行模式)	更改^ 和$ 的含义，使它们分别在任意一行的行首和行尾匹配，而不仅仅在整个字符串的开头和结尾匹配。(在此模式下,$ 的精确含意是:匹配/n之前的位置以及字符串结束前的位置.)
Singleline(单行模式)	更改. 的含义，使它与每一个字符匹配（包括换行符/n）。
IgnorePatternWhitespace(忽略空白)	忽略表达式中的非转义空白并启用由# 标记的注释。
ExplicitCapture(显式捕获)	仅捕获已被显式命名的组。

 

 

 

平衡组/递归匹配

 

有时我们需要匹配像( 100 * ( 50 + 15 ) )这样的可嵌套的层次性结构 ，这时简单地使用/(.+/) 则只会匹配到最左边的左括号和最右边的右括号之间的内容(这里我们讨论的是贪婪模式，懒惰模式也有下面的问题)。假如原来的字符串里的左括号和右括号出现的次数不相等，比如( 5 / ( 3 + 2 ) ) ) ，那我们的匹配结果里两者的个数也不会相等。有没有办法在这样的字符串里匹配到最长的，配对的括号之间的内容呢？

为了避免( 和/( 把你的大脑彻底搞糊涂，我们还是用尖括号代替圆括号吧。现在我们的问题变成了如何把xx <aa <bbb> <bbb> aa> yy 这样的字符串里，最长的配对的尖括号内的内容捕获出来？

这里需要用到以下的语法构造：

• (?'group') 把捕获的内容命名为group,并压入堆栈(Stack)
• (?'-group') 从堆栈上弹出最后压入堆栈的名为group的捕获内容，如果堆栈本来为空，则本分组的匹配失败
• (?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分
• (?!) 零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败

如果你不是一个程序员（或者你自称程序员但是不知道堆栈是什么东西），你就这样理解上面的三种语法吧：第一个就 是在黑板上写一个"group"，第二个就是从黑板上擦掉一个"group"，第三个就是看黑板上写的还有没有"group"，如果有就继续匹配yes部 分，否则就匹配no部分。

我们需要做的是每碰到了左括号，就在压入一个"Open",每碰到一个右括号，就弹出一个，到了最后就看看堆栈是否为空－－如果不为空那就证明左括号比右括号多，那匹配就应该失败。正则表达式引擎会进行回溯(放弃最前面或最后面的一些字符)，尽量使整个表达式得到匹配。

<                         #最外层的左括号
    [^<>]*                #最外层的左括号后面的不是括号的内容
    (
        (
            (?'Open'<)    #碰到了左括号，在黑板上写一个"Open"
            [^<>]*       #匹配左括号后面的不是括号的内容
        )+
        (
            (?'-Open'>)   #碰到了右括号，擦掉一个"Open"
            [^<>]*        #匹配右括号后面不是括号的内容
        )+
    )*
    (?(Open)(?!))         #在遇到最外层的右括号前面，判断黑板上还有没有没擦掉的"Open"；如果还有，则匹配失败

>                         #最外层的右括号

平衡组的一个最常见的应用就是匹配HTML,下面这个例子可以匹配嵌套的<div>标签 ：<div[^>]*>[^<>]*(((?'Open'<div[^>]*>)[^<>]*)+((?'-Open'</div>)[^<>]*)+)*(?(Open)(?!))</div> .