PYTHON正则表达式re模块使用说明

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"""
&[[]]      #Startofanumericentityreference
(
[0-9]+[^0-9]      #Decimalform
|0[0-7]+[^0-7]  #Octalform
|x[0-9a-fA-F]+[^0-9a-fA-F]#Hexadecimalform
)
""",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-widthassertions）。它们并不会使引擎在处理字符串时更快;相反，它们根本就没有对应任何字符，只是简单的成功或失败。举个例子，\b是一个在单词边界定位当前位置的界定符（assertions），这个位置根本就不会被\b改变。这意味着零宽界定符（zero-widthassertions）将永远不会被重复，因为如果它们在给定位置匹配一次，那么它们很明显可以被匹配无数次。

|

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

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

^

匹配行首。除非设置MULTILINE标志，它只是匹配字符串的开始。在MULTILINE模式里，它也可以直接匹配字符串中的每个换行。

例如，如果你只希望匹配在行首单词"From"，那么RE将用^From。

#!python
>>>printre.search("^From","FromHeretoEternity")
<re.MatchObjectinstanceat80c1520>
>>>printre.search("^From","RecitingFromMemory")
None

$

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

#!python
>>>printre.search("}$","{block}")
<re.MatchObjectinstanceat80adfa8>
>>>printre.search("}$","{block}")
None
>>>printre.search("}$","{block}\n")
<re.MatchObjectinstanceat80adfa8>

匹配一个"$"，使用\$或将其包含在字符类中，如[$]。

\A

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

\Z

Matchesonlyattheendofthestring.
只匹配字符串尾。

\b

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

下面的例子只匹配"class"整个单词；而当它被包含在其他单词中时不匹配。

#!python
>>>p=re.compile(r"\bclass\b")
>>>printp.search("noclassatall")
<re.MatchObjectinstanceat80c8f28>
>>>printp.search("thedeclassifiedalgorithm")
None
>>>printp.search("onesubclassis")
None

当用这个特殊序列时你应该记住这里有两个微妙之处。第一个是Python字符串和正则表达式之间最糟的冲突。在Python字符串里，"\b"是反斜杠字符，ASCII值是8。如果你没有使用raw字符串时，那么Python将会把"\b"转换成一个回退符，你的RE将无法象你希望的那样匹配它了。下面的例子看起来和我们前面的RE一样，但在RE字符串前少了一个"r"。

#!python
>>>p=re.compile("\bclass\b")
>>>printp.search("noclassatall")
None
>>>printp.search("\b"+"class"+"\b")
<re.MatchObjectinstanceat80c3ee0>

第二个在字符类中，这个限定符（assertion）不起作用，\b表示回退符，以便与Python字符串兼容。

\B

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

分组

你经常需要得到比RE是否匹配还要多的信息。正则表达式常常用来分析字符串，编写一个RE匹配感兴趣的部分并将其分成几个小组。举个例子，一个RFC-822的头部用":"隔成一个头部名和一个值，这就可以通过编写一个正则表达式匹配整个头部，用一组匹配头部名，另一组匹配头部值的方式来处理。

组是通过"("和")"元字符来标识的。"("和")"有很多在数学表达式中相同的意思；它们一起把在它们里面的表达式组成一组。举个例子，你可以用重复限制符，象*,+,?,和{m,n}，来重复组里的内容，比如说(ab)*将匹配零或更多个重复的"ab"。

#!python
>>>p=re.compile("(ab)*")
>>>printp.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")

Thegroups()方法返回一个包含所有小组字符串的元组，从1到所含的小组号。

#!python
>>>m.groups()
("abc","b")

模式中的逆向引用允许你指定先前捕获组的内容，该组也必须在字符串当前位置被找到。举个例子，如果组1的内容能够在当前位置找到的话，\1就成功否则失败。记住Python字符串也是用反斜杠加数据来允许字符串中包含任意字符的，所以当在RE中使用逆向引用时确保使用raw字符串。

例如，下面的RE在一个字符串中找到成双的词。

#!python
>>>p=re.compile(r"(\b\w+)\s+\1")
>>>p.search("Parisinthethespring").group()
"thethe"

象这样只是搜索一个字符串的逆向引用并不常见--用这种方式重复数据的文本格式并不多见--但你不久就可以发现它们用在字符串替换上非常有用。

无捕获组和命名组

精心设计的REs也许会用很多组，既可以捕获感兴趣的子串，又可以分组和结构化RE本身。在复杂的REs里，追踪组号变得困难。有两个功能可以对这个问题有所帮助。它们也都使用正则表达式扩展的通用语法，因此我们来看看第一个。

Perl5对标准正则表达式增加了几个附加功能，Python的re模块也支持其中的大部分。选择一个新的单按键元字符或一个以"\"开始的特殊序列来表示新的功能，而又不会使Perl正则表达式与标准正则表达式产生混乱是有难度的。如果你选择"&"做为新的元字符，举个例子，老的表达式认为"&"是一个正常的字符，而不会在使用\&或[&]时也不会转义。

Perl开发人员的解决方法是使用(?...)来做为扩展语法。"?"在括号后面会直接导致一个语法错误，因为"?"没有任何字符可以重复，因此它不会产生任何兼容问题。紧随"?"之后的字符指出扩展的用途，因此(?=foo)

Python新增了一个扩展语法到Perl扩展语法中。如果在问号后的第一个字符是"P"，你就可以知道它是针对Python的扩展。目前有两个这样的扩展:(?P<name>...)定义一个命名组，(?P=name)则是对命名组的逆向引用。如果Perl5的未来版本使用不同的语法增加了相同的功能，那么re模块也将改变以支持新的语法，这是为了兼容性的目的而保持的Python专用语法。

现在我们看一下普通的扩展语法，我们回过头来简化在复杂REs中使用组运行的特性。因为组是从左到右编号的，而且一个复杂的表达式也许会使用许多组，它可以使跟踪当前组号变得困难，而修改如此复杂的RE是十分麻烦的。在开始时插入一个新组，你可以改变它之后的每个组号。

首先，有时你想用一个组去收集正则表达式的一部分，但又对组的内容不感兴趣。你可以用一个无捕获组:(?:...)来实现这项功能，这样你可以在括号中发送任何其他正则表达式。

#!python
>>>m=re.match("([abc])+","abc")
>>>m.groups()
("c",)
>>>m=re.match("(?:[abc])+","abc")
>>>m.groups()
()

除了捕获匹配组的内容之外，无捕获组与捕获组表现完全一样；你可以在其中放置任何字符，可以用重复元字符如"*"来重复它，可以在其他组（无捕获组与捕获组）中嵌套它。(?:...)对于修改已有组尤其有用，因为你可以不用改变所有其他组号的情况下添加一个新组。捕获组和无捕获组在搜索效率方面也没什么不同，没有哪一个比另一个更快。

其次，更重要和强大的是命名组；与用数字指定组不同的是，它可以用名字来指定。

命令组的语法是Python专用扩展之一：(?P<name>...)。名字很明显是组的名字。除了该组有个名字之外，命名组也同捕获组是相同的。`MatchObject`的方法处理捕获组时接受的要么是表示组号的整数，要么是包含组名的字符串。命名组也可以是数字，所以你可以通过两种方式来得到一个组的信息：

#!python
>>>p=re.compile(r"(?P<word>\b\w+\b)")
>>>m=p.search("((((Lotsofpunctuation)))")
>>>m.group("word")
"Lots"
>>>m.group(1)
"Lots"

命名组是便于使用的，因为它可以让你使用容易记住的名字来代替不得不记住的数字。这里有一个来自imaplib模块的RE示例：

#!python
InternalDate=re.compile(r"INTERNALDATE""
r"(?P<day>[123][0-9])-(?P<mon>[A-Z][a-z][a-z])-"
r"(?P<year>[0-9][0-9][0-9][0-9])"
r"(?P<hour>[0-9][0-9]):(?P<min>[0-9][0-9]):(?P<sec>[0-9][0-9])"
r"(?P<zonen>[-+])(?P<zoneh>[0-9][0-9])(?P<zonem>[0-9][0-9])"
r""")

很明显，得到m.group("zonem")要比记住得到组9要容易得多。

因为逆向引用的语法，象(...)\1这样的表达式所表示的是组号，这时用组名代替组号自然会有差别。还有一个Python扩展：(?P=name)，它可以使叫name的组内容再次在当前位置发现。正则表达式为了找到重复的单词，(\b\w+)\s+\1也可以被写成(?P<word>\b\w+)\s+(?P=word)：

#!python
>>>p=re.compile(r"(?P<word>\b\w+)\s+(?P=word)")
>>>p.search("Parisinthethespring").group()
"thethe"

前向界定符

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

(?=...)

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

(?!...)

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

通过示范在哪前向可以成功有助于具体实现。考虑一个简单的模式用于匹配一个文件名，并将其通过"."分成基本名和扩展名两部分。如在"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$).*$

修改字符串

到目前为止，我们简单地搜索了一个静态字符串。正则表达式通常也用不同的方式，通过下面的`RegexObject`方法，来修改字符串。

split(string[,maxsplit=0])

#!python
>>>p=re.compile(r"\W+")
>>>p.split("Thisisatest,shortandsweet,ofsplit().")
["This","is","a","test","short","and","sweet","of","split",""]
>>>p.split("Thisisatest,shortandsweet,ofsplit().",3)
["This","is","a","test,shortandsweet,ofsplit()."]

#!python
>>>p=re.compile(r"\W+")
>>>p2=re.compile(r"(\W+)")
>>>p.split("This...isatest.")
["This","is","a","test",""]
>>>p2.split("This...isatest.")
["This","...","is","","a","","test",".",""]

#!python
>>>re.split("[\W]+","Words,words,words.")
["Words","words","words",""]
>>>re.split("([\W]+)","Words,words,words.")
["Words",",","words",",","words",".",""]
>>>re.split("[\W]+","Words,words,words.",1)
["Words","words,words."]

sub(replacement,string[,count=0])

#!python
>>>p=re.compile("(blue|white|red)")
>>>p.sub("colour","bluesocksandredshoes")
"coloursocksandcolourshoes"
>>>p.sub("colour","bluesocksandredshoes",count=1)
"coloursocksandredshoes"

#!python
>>>p=re.compile("(blue|white|red)")
>>>p.subn("colour","bluesocksandredshoes")
("coloursocksandcolourshoes",2)
>>>p.subn("colour","nocoloursatall")
("nocoloursatall",0)

#!python
>>>p=re.compile("x*")
>>>p.sub("-","abxd")
"-a-b-"

#!python
>>>p=re.compile("section{([^}]*)}",re.VERBOSE)
>>>p.sub(r"subsection{\1}","section{First}section{second}")
"subsection{First}subsection{second}"

#!python
>>>p=re.compile("section{(?P<name>[^}]*)}",re.VERBOSE)
>>>p.sub(r"subsection{\1}","section{First}")
"subsection{First}"
>>>p.sub(r"subsection{\g<1>}","section{First}")
"subsection{First}"
>>>p.sub(r"subsection{\g<name>}","section{First}")
"subsection{First}"

#!python
>>>defhexrepl(match):
...    "Returnthehexstringforadecimalnumber"
...    value=int(match.group())
...    returnhex(value)
...
>>>p=re.compile(r"\d+")
>>>p.sub(hexrepl,"Call65490forprinting,49152forusercode.")
"Call0xffd2forprinting,0xc000forusercode."

#!python
>>>printre.match("super","superstition").span()
(0,5)
>>>printre.match("super","insuperable")
None

#!python
>>>printre.search("super","superstition").span()
(0,5)
>>>printre.search("super","insuperable").span()
(2,7)

#!python
>>>s="<html><head><title>Title</title>"
>>>len(s)
32
>>>printre.match("<.*>",s).span()
(0,32)
>>>printre.match("<.*>",s).group()
<html><head><title>Title</title>

#!python
>>>printre.match("<.*?>",s).group()
<html>

#!python
pat=re.compile(r"""
\s*                #Skipleadingwhitespace
(?P<header>[^:]+)  #Headername
\s*:              #Whitespace,andacolon
(?P<value>.*?)      #Theheader"svalue--*?usedto
#losethefollowingtrailingwhitespace
\s*$                #Trailingwhitespacetoend-of-line
""",re.VERBOSE)

#!python
pat=re.compile(r"\s*(?P<header>[^:]+)\s*:(?P<value>.*?)\s*$")