就其本质而言，正则表达式（或 re）是一种小型的、高度专业化的编程语言，（在python中）它内嵌在python中，并通过 re 模块实现。使用这个小型语言，你可以为想要匹配的相应字符串集指定规则；该字符串集可能包含英文语句、e-mail地址、tex命令或任何你想搞定的东西。然後你可以问诸如“这个字符串匹配该模式吗？”或“在这个字符串中是否有部分匹配该模式呢？”。你也可以使用 re 以各种方式来修改或分割字符串。
正则表达式模式被编译成一系列的字节码，然後由用 c 编写的匹配引擎执行。在高级用法中，也许还要仔细留意引擎是如何执行给定 re ，如何以特定方式编写 re 以令生产的字节码运行速度更快。本文并不涉及优化，因为那要求你已充分掌握了匹配引擎的内部机制。
正则表达式语言相对小型和受限（功能有限），因此并非所有字符串处理都能用正则表达式完成。当然也有些任务可以用正则表达式完成，不过最终表达式会变得异常复杂。碰到这些情形时，编写 python 代码进行处理可能反而更好；尽管 python 代码比一个精巧的正则表达式要慢些，但它更易理解。
简单模式 我们将从最简单的正则表达式学习开始。由于正则表达式常用于字符串操作，那我们就从最常见的任务：字符匹配 下手。
有关正则表达式底层的计算机科学上的详细解释（确定性和非确定性有限自动机），你可以查阅编写编译器相关的任何教科书。
字符匹配 大多数字母和字符一般都会和自身匹配。例如，正则表达式 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  匹配任何空白字符；它相当于类  [ tnrfv]。
\s  匹配任何非空白字符；它相当于类 [^ tnrfv]。
\w  匹配任何字母数字字符；它相当于类 [a-za-z0-9_]。
\w  匹配任何非字母数字字符；它相当于类 [^a-za-z0-9_]。
这样特殊字符都可以包含在一个字符类中。如，[s,.]字符类将匹配任何空白字符或,或.。
本节最後一个元字符是 . 。它匹配除了换行字符外的任何字符，在 alternate 模式（re.dotall）下它甚至可以匹配换行。. 通常被用于你想匹配“任何字符”的地方。
重复 正则表达式第一件能做的事是能够匹配不定长的字符集，而这是其它能作用在字符串上的方法所不能做到的。 不过，如果那是正则表达式唯一的附加功能的话，那么它们也就不那么优秀了。它们的另一个功能就是你可以指定正则表达式的一部分的重复次数。
我们讨论的第一个重复功能的元字符是 *。* 并不匹配字母字符 *；相反，它指定前一个字符可以被匹配零次或更多次，而不是只有一次。
举个例子，ca*t 将匹配 ct (0 个 a 字符), cat (1 个 a), caaat (3 个 a 字符)等等。re 引擎有各种来自 c 的整数类型大小的内部限制，以防止它匹配超过2亿个 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 的结果将是上边界为无穷大 -- 实际上是先前我们提到的 2 兆，但这也许同无穷大一样。
细心的读者也许注意到其他三个限定符都可以用这样方式来表示。 {0,} 等同于 *，{1,} 等同于 +，而{0,1}则与 ? 相同。如果可以的话，最好使用 *，+，或?。很简单因为它们更短也再容易懂。
使用正则表达式 现在我们已经看了一些简单的正则表达式，那么我们实际在 python 中是如何使用它们的呢？ re 模块提供了一个正则表达式引擎的接口，可以让你将 res 编译成对象并用它们来进行匹配。
编译正则表达式 正则表达式被编译成 `regexobject` 实例，可以为不同的操作提供方法，如模式匹配搜索或字符串替换。
#!python
>>> import re
>>> p = re.compile('ab*')
>>> print p
re.regexobject instance at 80b4150>
re.compile() 也接受可选的标志参数，常用来实现不同的特殊功能和语法变更。我们稍後将查看所有可用的设置，但现在只举一个例子：
#!python
>>> p = re.compile('ab*', re.ignorecase)
re 被做为一个字符串发送给 re.compile()。res 被处理成字符串是因为正则表达式不是 python 语言的核心部分，也没有为它创建特定的语法。（应用程序根本就不需要 res，因此没必要包含它们去使语言说明变得臃肿不堪。）而 re 模块则只是以一个 c 扩展模块的形式来被 python 包含，就象 socket 或 zlib 模块一样。
将 res 作为字符串以保证 python 语言的简洁，但这样带来的一个麻烦就是象下节标题所讲的。
反斜杠的麻烦 在早期规定中，正则表达式用反斜杠字符 () 来表示特殊格式或允许使用特殊字符而不调用它的特殊用法。这就与 python 在字符串中的那些起相同作用的相同字符产生了冲突。
让我们举例说明，你想写一个 re 以匹配字符串 section，可能是在一个 latex 文件查找。为了要在程序代码中判断，首先要写出想要匹配的字符串。接下来你需要在所有反斜杠和元字符前加反斜杠来取消其特殊意义。
字符 阶段
\section 要匹配的字符串
\\section 为 re.compile 取消反斜杠的特殊意义
\\\\section 为字符串取消反斜杠
简单地说，为了匹配一个反斜杠，不得不在 re 字符串中写 '\\'，因为正则表达式中必须是 \\，而每个反斜杠按 python 字符串字母表示的常规必须表示成 \\。在 res 中反斜杠的这个重复特性会导致大量重复的反斜杠，而且所生成的字符串也很难懂。
解决的办法就是为正则表达式使用 python 的 raw 字符串表示；在字符串前加个 r 反斜杠就不会被任何特殊方式处理，所以 r\n 就是包含\ 和 n 的两个字符，而 \n 则是一个字符，表示一个换行。正则表达式通常在 python 代码中都是用这种 raw 字符串表示。
常规字符串 raw 字符串
ab* rab*
\\\\section r\\section
\\w+\\s+\\1 r\w+\s+\1
执行匹配 一旦你有了已经编译了的正则表达式的对象，你要用它做什么呢？`regexobject` 实例有一些方法和属性。这里只显示了最重要的几个，如果要看完整的列表请查阅 python library reference
方法/属性 作用
match() 决定 re 是否在字符串刚开始的位置匹配
search() 扫描字符串，找到这个 re 匹配的位置
findall() 找到 re 匹配的所有子串，并把它们作为一个列表返回
finditer() 找到 re 匹配的所有子串，并把它们作为一个迭代器返回
如果没有匹配到的话，match() 和 search() 将返回 none。如果成功的话，就会返回一个 `matchobject` 实例，其中有这次匹配的信息：它是从哪里开始和结束，它所匹配的子串等等。
你可以用采用人机对话并用 re 模块实验的方式来学习它。如果你有 tkinter 的话，你也许可以考虑参考一下 tools/scripts/redemo.py，一个包含在 python 发行版里的示范程序。
首先，运行 python 解释器，导入 re 模块并编译一个 re：
#!python
python 2.2.2 (#1, feb 10 2003, 12:57:01)
>>> import re
>>> p = re.compile('[a-z]+')
>>> p
_sre.sre_pattern object at 80c3c28>
现在，你可以试着用 re 的 [a-z]+ 去匹配不同的字符串。一个空字符串将根本不能匹配，因为 + 的意思是 “一个或更多的重复次数”。 在这种情况下 match() 将返回 none，因为它使解释器没有输出。你可以明确地打印出 match() 的结果来弄清这一点。
#!python
>>> p.match()
>>> print p.match()
none
现在，让我们试着用它来匹配一个字符串，如 tempo。这时，match() 将返回一个 matchobject。因此你可以将结果保存在变量里以便后面使用。
#!python
>>> m = p.match( 'tempo')
>>> print m
_sre.sre_match object at 80c4f68>
现在你可以查询 `matchobject` 关于匹配字符串的相关信息了。matchobject 实例也有几个方法和属性；最重要的那些如下所示：
方法/属性 作用
group() 返回被 re 匹配的字符串
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配 (开始,结束) 的位置
试试这些方法不久就会清楚它们的作用了：
#!python
>>> m.group()
'tempo'
>>> m.start(), m.end()
(0, 5)
>>> m.span()
(0, 5)
group() 返回 re 匹配的子串。start() 和 end() 返回匹配开始和结束时的索引。span() 则用单个元组把开始和结束时的索引一起返回。因为匹配方法检查到如果 re 在字符串开始处开始匹配，那么 start() 将总是为零。然而， `regexobject` 实例的 search 方法扫描下面的字符串的话，在这种情况下，匹配开始的位置就也许不是零了。
#!python
>>> print p.match('::: message')
none
>>> m = p.search('::: message') ; print m
re.matchobject instance at 80c9650>
>>> m.group()
'message'
>>> m.span()
(4, 11)
在实际程序中，最常见的作法是将 `matchobject` 保存在一个变量里，然后检查它是否为 none，通常如下所示：
#!python
p = re.compile(  )
m = p.match( 'string goes here' )
if m:
print 'match found: ', m.group()
else:
print 'no match'
两个 `regexobject` 方法返回所有匹配模式的子串。findall()返回一个匹配字符串行表：
#!python
>>> p = re.compile('d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']
findall() 在它返回结果时不得不创建一个列表。在 python 2.2中，也可以用 finditer() 方法。
#!python
>>> iterator = p.finditer('12 drummers drumming, 11  10 ')
>>> iterator
callable-iterator object at 0x401833ac>
>>> for match in iterator:
print match.span()
(0, 2)
(22, 24)
(29, 31)
模块级函数 你不一定要产生一个 `regexobject` 对象然後再调用它的方法；re 模块也提供了顶级函数调用如 match()、search()、sub() 等等。这些函数使用 re 字符串作为第一个参数，而後面的参数则与相应 `regexobject` 的方法参数相同，返回则要么是 none 要么就是一个 `matchobject` 的实例。
#!python
>>> print re.match(r'froms+', 'fromage amk')
none
>>> re.match(r'froms+', 'from amk thu may 14 19:12:10 1998')
re.matchobject instance at 80c5978>
under the hood, 这些函数简单地产生一个 regexoject 并在其上调用相应的方法。它们也在缓存里保存编译後的对象，因此在将来调用用到相同 re 时就会更快。
你将使用这些模块级函数，还是先得到一个 `regexobject` 再调用它的方法呢？如何选择依赖于怎样用 re 更有效率以及你个人编码风格。如果一个 re 在代码中只做用一次的话，那么模块级函数也许更方便。如果程序包含很多的正则表达式，或在多处复用同一个的话，那么将全部定义放在一起，在一段代码中提前编译所有的 res 更有用。从标准库中看一个例子，这是从 xmllib.py 文件中提取出来的：
#!python
ref = re.compile(  )
entityref = re.compile(  )
charref = re.compile(  )
starttagopen = re.compile(  )
我通常更喜欢使用编译对象，甚至它只用一次，but few people will be as much of a purist about this as i am。
编译标志 编译标志让你可以修改正则表达式的一些运行方式。在 re 模块中标志可以使用两个名字，一个是全名如 ignorecase，一个是缩写，一字母形式如 i。（如果你熟悉 perl 的模式修改，一字母形式使用同样的字母；例如 re.verbose的缩写形式是 re.x。）多个标志可以通过按位 or-ing 它们来指定。如 re.i | re.m 被设置成 i 和 m 标志：
这有个可用标志表，对每个标志後面都有详细的说明。
标志 含义
dotall, s 使 . 匹配包括换行在内的所有字符
ignorecase, i 使匹配对大小写不敏感
locale, l 做本地化识别（locale-aware）匹配
multiline, m 多行匹配，影响 ^ 和 $
verbose, x 能够使用 res 的 verbose 状态，使之被组织得更清晰易懂
i
ignorecase
使匹配对大小写不敏感；字符类和字符串匹配字母时忽略大小写。举个例子，[a-z]也可以匹配小写字母，spam 可以匹配 spam, spam, 或 spam。这个小写字母并不考虑当前位置。
l
locale
影响 w, w, b, 和 b，这取决于当前的本地化设置。
locales 是 c 语言库中的一项功能，是用来为需要考虑不同语言的编程提供帮助的。举个例子，如果你正在处理法文文本，你想用 w+ 来匹配文字，但 w 只匹配字符类 [a-za-z]；它并不能匹配 é 或 ç。如果你的系统配置适当且本地化设置为法语，那么内部的 c 函数将告诉程序 é 也应该被认为是一个字母。当在编译正则表达式时使用 locale 标志会得到用这些 c 函数来处理 w 後的编译对象；这会更慢，但也会象你希望的那样可以用 w+ 来匹配法文文本。
m
multiline
(此时 ^ 和 $ 不会被解释; 它们将在 4.1 节被介绍.)
使用 ^ 只匹配字符串的开始，而 $ 则只匹配字符串的结尾和直接在换行前（如果有的话）的字符串结尾。当本标志指定後， ^ 匹配字符串的开始和字符串中每行的开始。同样的， $ 元字符匹配字符串结尾和字符串中每行的结尾（直接在每个换行之前）。
s
dotall
使 . 特殊字符完全匹配任何字符，包括换行；没有这个标志， . 匹配除了换行外的任何字符。
x
verbose
该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。当该标志被指定时，在 re 字符串中的空白符被忽略，除非该空白符在字符类中或在反斜杠之後；这可以让你更清晰地组织和缩进 re。它也可以允许你将注释写入 re，这些注释会被引擎忽略；注释用 #号 来标识，不过该符号不能在字符串或反斜杠之後。
举个例子，这里有一个使用 re.verbose 的 re；看看读它轻松了多少？
#!python
charref = re.compile(r
&[[]]             # start of a numeric entity reference
(
[0-9]+[^0-9]      # decimal form
| 0[0-7]+[^0-7]   # octal form
| x[0-9a-fa-f]+[^0-9a-fa-f] # hexadecimal form
)
, re.verbose)
没有 verbose 设置， re 会看起来象这样：
#!python
charref = re.compile(([0-9]+[^0-9]
|0[0-7]+[^0-7]
|x[0-9a-fa-f]+[^0-9a-fa-f]))
在上面的例子里，python 的字符串自动连接可以用来将 re 分成更小的部分，但它比用 re.verbose 标志时更难懂。
更多模式功能 到目前为止，我们只展示了正则表达式的一部分功能。在本节，我们将展示一些新的元字符和如何使用组来检索被匹配的文本部分。
更多的元字符 还有一些我们还没展示的元字符，其中的大部分将在本节展示。
剩下来要讨论的一部分元字符是零宽界定符（zero-width assertions）。它们并不会使引擎在处理字符串时更快;相反，它们根本就没有对应任何字符，只是简单的成功或失败。举个例子， b 是一个在单词边界定位当前位置的界定符（assertions），这个位置根本就不会被 b 改变。这意味着零宽界定符（zero-width assertions）将永远不会被重复，因为如果它们在给定位置匹配一次，那么它们很明显可以被匹配无数次。
|
可选项，或者 or 操作符。如果 a 和 b 是正则表达式，a|b 将匹配任何匹配了 a 或 b 的字符串。| 的优先级非常低，是为了当你有多字符串要选择时能适当地运行。crow|servo 将匹配crow 或 servo, 而不是 cro, 一个 w 或 一个 s, 和 ervo。
为了匹配字母 |，可以用 |，或将其包含在字符类中，如[|]。
^
匹配行首。除非设置 multiline 标志，它只是匹配字符串的开始。在 multiline 模式里，它也可以直接匹配字符串中的每个换行。
例如，如果你只希望匹配在行首单词 from，那幺 re 将用 ^from。
#!python
>>> print re.search('^from', 'from here to eternity')
re.matchobject instance at 80c1520>
>>> print re.search('^from', 'reciting from memory')
none
$
匹配行尾，行尾被定义为要么是字符串尾，要么是一个换行字符後面的任何位置。
#!python
>>> print re.search('}$', '{block}')
re.matchobject instance at 80adfa8>
>>> print re.search('}$', '{block} ')
none
>>> print re.search('}$', '{block}n')
re.matchobject instance at 80adfa8>
匹配一个 $，使用 $ 或将其包含在字符类中，如[$]。
a
只匹配字符串首。当不在 multiline 模式，a 和 ^ 实际上是一样的。然而，在 multiline 模式里它们是不同的；a 只是匹配字符串首，而 ^ 还可以匹配在换行符之後字符串的任何位置。
z
matches only at the end of the string.
只匹配字符串尾。
b
单词边界。这是个零宽界定符（zero-width assertions）只用以匹配单词的词首和词尾。单词被定义为一个字母数字序列，因此词尾就是用空白符或非字母数字符来标示的。
下面的例子只匹配 class 整个单词；而当它被包含在其他单词中时不匹配。
#!python
>>> p = re.compile(r'bclassb')
>>> print p.search('no class at all')
re.matchobject instance at 80c8f28>
>>> print p.search('the declassified algorithm')
none
>>> print p.search('one subclass is')
none
当用这个特殊序列时你应该记住这里有两个微妙之处。第一个是 python 字符串和正则表达式之间最糟的冲突。在 python 字符串里，b 是反斜杠字符，ascii值是8。如果你没有使用 raw 字符串时，那幺 python 将会把 b 转换成一个回退符，你的 re 将无法象你希望的那样匹配它了。下面的例子看起来和我们前面的 re 一样，但在 re 字符串前少了一个 r 。
#!python
>>> p = re.compile('bclassb')
>>> print p.search('no class at all')
none
>>> print p.search('b' + 'class' + 'b')
re.matchobject instance at 80c3ee0>
第二个在字符类中，这个限定符（assertion）不起作用，b 表示回退符，以便与 python 字符串兼容。
b
另一个零宽界定符（zero-width assertions），它正好同 b 相反，只在当前位置不在单词边界时匹配。
分组 你经常需要得到比 re 是否匹配还要多的信息。正则表达式常常用来分析字符串，编写一个 re 匹配感兴趣的部分并将其分成几个小组。举个例子，一个 rfc-822 的头部用 : 隔成一个头部名和一个值，这就可以通过编写一个正则表达式匹配整个头部，用一组匹配头部名，另一组匹配头部值的方式来处理。
组是通过 ( 和 ) 元字符来标识的。 ( 和 ) 有很多在数学表达式中相同的意思；它们一起把在它们里面的表达式组成一组。举个例子，你可以用重复限制符，象 *, +, ?, 和 {m,n}，来重复组里的内容，比如说(ab)* 将匹配零或更多个重复的 ab。
#!python
>>> p = re.compile('(ab)*')
>>> print p.match('ababababab').span()
(0, 10)
组用 ( 和 ) 来指定，并且得到它们匹配文本的开始和结尾索引；这就可以通过一个参数用 group()、start()、end() 和 span() 来进行检索。组是从 0 开始计数的。组 0 总是存在；它就是整个 re，所以 `matchobject` 的方法都把组 0 作为它们缺省的参数。稍後我们将看到怎样表达不能得到它们所匹配文本的 span。
#!python
>>> p = re.compile('(a)b')
>>> m = p.match('ab')
>>> m.group()
'ab'
>>> m.group(0)
'ab'
小组是从左向右计数的，从1开始。组可以被嵌套。计数的数值可以能过从左到右计算打开的括号数来确定。
#!python
>>> p = re.compile('(a(b)c)d')
>>> m = p.match('abcd')
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'
group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
#!python
>>> m.group(2,1,2)
('b', 'abc', 'b')
the groups() 方法返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
#!python
>>> m.groups()
('abc', 'b')
模式中的逆向引用允许你指定先前捕获组的内容，该组也必须在字符串当前位置被找到。举个例子，如果组 1 的内容能够在当前位置找到的话，1 就成功否则失败。记住 python 字符串也是用反斜杠加数据来允许字符串中包含任意字符的，所以当在 re 中使用逆向引用时确保使用 raw 字符串。
例如，下面的 re 在一个字符串中找到成双的词。
#!python
>>> p =