Python正則表達式：怎样使用正則表達式
正則表達式被编译到一系列的字节码，然后被C语言实现的匹配引擎运行。
在一些高级应用场景，必须关注引擎怎么运行一个RE，以依据引擎的特征编写RE提高字节码的处理效率。这篇文章不包括优化，优化须要对匹配引擎的内部实现有好的理解。
正則表達式相对小而且存在限制，所以不是全部的字符串处理任务都能用正則表達式解决。也存在有些任务能够用正則表達式做，但表达式很复杂。在这些情况下，更好的选择是使用Python代码处理，但Python代码相对正則表達式会更慢。但却可能更好理解。
正則表達式简述
匹配字符串
这个规则存在例外，一些字符是特殊元字符。不匹配他们自身。他们暗示一些不平常的事将被匹配，或者他们影响RE的其他部分，比如反复他们或者改变他们的含义。文章的其余部分都主要讨论各种元字符和他们的含义。
以下是元字符的列表，后面将介绍他们的含义：
. ^ $ * + ? { } [ ] \ | ( )首先我们看[和]，他们被用于指定一个字符类。表示你希望匹配的一套字符集。字符能被单独列出，或者使用'-'来指示字符的范围，比如：[abc]将匹配字符a、b或c的随意一个；[a-c]也是匹配a、b或c中的随意一个。假设你想匹配仅小写字母。那么RE应该为[a-z]。
在类中（[ ]内）的元字符不是激活的，比如：[akm$]将匹配'a'、'k'、'm'或'$'中的随意一个，'$'是一个元字符，可是在字符类中它作为普通字符使用。
你也能排除类中列出的字符集，通过将'^'作为类的第一个字符，注意在类之外的'^'将只匹配'^'字符，比如：[^5]将匹配除了5之外的不论什么字符。
也许最重要的元字符是反斜杠\。在Python中，反斜杠能被各种字符尾随作为各种特殊序列使用。它也能被用于取出元字符的特殊性将其作为本身匹配。比如：假设你须要匹配一个[或者\。你能在它们之前带上一个反斜杠移除它们的特殊含义，即\[或者\\。
以'\'開始的特殊序列中的一些表示了常常被使用的提前定义字符集。比如数字集合、字符集合、或者非空白的随意字符集合。
让我们看一个样例：\w匹配不论什么字母数字。
假设正則表達式模式以字节为单位，这等价于类[a-zA-Z0-9_]。
假设正則表達式模式是字符串。则\w将匹配全部被unicodedata模块提供的在Unicode数据库总的字符。当编译正則表達式时，你能加入re.ASCII标志给\w更严格的限制。
以下提供了部分特殊序列供參考：
\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_]。
这些序列能够被包括到字符类中，比如：[\s,.]是一个字符类。将匹配随意的空白字符，或者','，或者'.'。
在这节中最后的元字符是'.'，它匹配除了新行字符之外的不论什么字符，使用交替模式（re.DOTALL）它将匹配包含新行的全部字符，'.'通常被用于须要匹配“随意字符”的场景。
处理反复
处理反复的第一个元字符是'*'。'*'不会匹配字符'*'，它表示先前的字符能被匹配0次或者多次。
比如：ca*t将匹配ct（0个a）、cat（1个a）、caaat（3个a）、等等。RE引擎内部会限制a的匹配的数量，但通常足够了。
反复（比如*）算法是贪婪的，对于反复的RE，匹配引擎将尝试尽可能多的反复次数，假设模式的后面部分不匹配，则匹配引擎将回退并再次尝试更少的反复次数。
比如，考虑表达式a[bcd]*b。这匹配单词'a'。0个或者多个来自类[bcd]的字母，最后以'b'结束。以下是RE匹配abcbd的过程：
1、匹配a：RE匹配a成功；
2、匹配abcbd：引擎匹配[bcd]*。因为尽可能的匹配很多其它，所以匹配了整个字符串；
3、匹配失败：引擎试着匹配b，可是已经到达字符串结尾，因此失败。
4、匹配abcb：回退，[bcd]*匹配降低一个字符；
5、匹配失败：再次尝试b，但当前位置的字符为d；
6、匹配abc：继续回退。以至于[bcd]*仅匹配bc。
7、匹配abcb：再次尝试b。这次当前位置的字符为b，匹配成功，结束。
RE终于匹配abcb，整个过程演示了匹配引擎的匹配过程。首先匹配尽可能多的字符，假设不匹配。则不断回退再次尝试。它将回退直到[bcd]*匹配0个字符，假设任然失败，则引擎得出结论“字符串不匹配RE”。
还有一个反复的元字符是+。匹配一次或者多次。小心*和+之间的不同。*匹配0次或者多次。即能够匹配空；+则须要至少出现一次。
比如：ca+t将匹配cat(1个a)，caaat(3个a)，但不匹配ct。
另外还有两个反复限定符。其一是问号'?'，表示匹配一次或者0次，比如：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表示无限制。
你可能已经注意到，使用最后一个限定符能够代替前面3个限定符：{0,}等价于*；{1,}等价于+；{0,1}等价于?。
为什么使用*、+或者?
呢？主要在于，更简短的表达式更利于阅读和理解。
使用正則表達式
re模块提供了使用正則表達式的接口，同意你编译RE到对象。然后使用它们。
编译正則表達式
>>> import re
>>> p = re.compile('ab*')
>>> p
re.compile('ab*')re.compile()也提供了一个可选的flags參数。用于激活各种特征。后面将具体介绍，以下是一个简单的样例：>>> p = re.compile('ab*', re.IGNORECASE)RE作为一个字符串传给re.compile()。RE被作为字符串处理是由于正則表達式不是Python语言核心的一部分，没有特定的语言用于创建它们。re模块不过Python包括的一个C语言扩展模块，就像socket和zlib模块一样。
将RE作为字符串保持了Python语言的简单，但也存在不利，比例如以下一节将讲述的内容。
反斜杠问题
你假设想写一个RE匹配字符串\section。我们看看怎么构造一个正則表達式对象：首先。我们使用整个字符串作为正則表達式；其次。找出反斜杠和其他元字符，在它们前面加入反斜杠，变为\\section；最后，字符串被传入到re.compile()。因为传入的必须为\\section。结合Python语法，每一个\的前面必须再次加入一个\，因此，终于在Python中传入的字符串为"\\\\section"。
简而言之。为了匹配一个反斜杠。在Python中你须要写'\\\\'作为RE字符串。这导致了非常多反复的反斜杠，使语法非常难于理解。
解决方式是为正則表達式使用Python的原生字符串凝视。当字符串带有前缀'r'时。反斜杠将不以特殊字符处理，于是r"\n"是包括'\'和'n'的两个字符的字符串，而"\n"是包括换行符的一个字符的字符串。在Python中正則表達式将常常採用这样的方式编写。
运行匹配
1）match()
确定RE是否匹配字符串的开头。
2）search()
扫描字符串，查找和RE匹配的不论什么位置。
3）findall()
找到全部RE匹配的子字符串，并作为一个列表返回。
4）finditer()
发现全部RE匹配的子字符串，并作为一个iterator返回。
假设找到匹配。match()和search()返回None；假设匹配成功。则返回一个匹配对象实例，包括匹配的信息：開始和结束点、匹配的子字符串、等等。
以下来看看Python中怎么使用正則表達式。
首先。执行Python解释器，导入re模块，而且编译一个RE：
>>> import re
>>> p = re.compile('[a-z]+')
>>> p
re.compile('[a-z]+')如今。你能尝试匹配各种字符串，一个空字符串将根本不匹配，因为+意味着‘一个或者很多其它’，match()将返回None，你能直接打印结果：>>> p.match("")
>>> print(p.match(""))
None接下来。我们尝试一个匹配的字符串，这时。match()将返回一个匹配对象，因此你应该存储结果在一个变量中以供后面使用：>>> m = p.match('tempo')
>>> m
<_sre.SRE_Match object; span=(0, 5), match='tempo'>如今你能询问匹配对象关于匹配字符串的信息。匹配对象也有几个方法和属性，最重要的几个是：1）group()
返回被RE匹配的字符串
2）start()
返回匹配的開始位置
3）end()
返回匹配的结束位置
4）span()
返回包括匹配位置的元组（開始，结束）
以下是一些使用这些方法的样例：
>>> m.group() 'tempo' >>> m.start(), m.end() (0, 5) >>> m.span() (0, 5)因为match()仅检查RE是否匹配字符串的開始，start()将总是返回0。然而，search()方法扫描整个字符串。因此開始位置不一定为0：
>>> print(p.match('::: message'))
None
>>> m = p.search('::: message'); print(m)
<_sre.SRE_Match object; span=(4, 11), match='message'>
>>> m.group()
'message'
>>> m.span()
(4, 11)在实际编程汇总，通常将匹配对象存入一个变量中，然后检查它是否为None。比如：p = re.compile( ... )
m = p.match( 'string goes here' )
if m:
print('Match found: ', m.group())
else:
print('No match')findall()返回匹配字符串的列表：>>> p = re.compile('\d+')
>>> p.findall('12 drummers drumming, 11 pipers piping, 10 lords a-leaping')
['12', '11', '10']findall()在返回结果前必须创建完整的列表，而finditer()则返回匹配对象实例作为一个iterator：>>> iterator = p.finditer('12 drummers drumming, 11 ... 10 ...')
>>> iterator
<callable_iterator object at 0x...>
>>> for match in iterator:
... print(match.span())
...
(0, 2)
(22, 24)
(29, 31)
模块级函数
这些函数採用和相应的模式方法相同的參数，也相同返回None或者匹配对象实例：
>>> print(re.match(r'From\s+', 'Fromage amk')) None >>> re.match(r'From\s+', 'From amk Thu May 14 19:12:10 1998') <_sre.SRE_Match object; span=(0, 5), match='From '>这些函数创建一个模式对象，并调用它上面的方法。它们也存储编译后的对象到缓存中，以至于未来使用相同的RE将不须要又一次编译。
你应该用这些模块及的函数。还是应该通过模块对象来调用呢？假设你正在做一个正則表達式的循环，则预编译将节省很多函数调用，否则。两个方式没有太大差别。
编译标志
在re模块中标志能够使用两种名称，长名称。比如IGNORECASE。和短名称，比如I。通过位或运算，多个标志能被指定，比如re.I | re.M设置I和M标志。
以下是可用标志的列表和每一个标志的解释：
1）ASCII, A
当使用\w、\b、\s和\d时仅匹配ASCII字符；
2）DOTALL, S
使'.'匹配不论什么字符，包含新行；
3）IGNORECASE, I
忽略大写和小写匹配。
4）LOCALE, L
做地域相关匹配。
5）MULTILINE, M
多行匹配，影响^和$。
6）VERBOSE, X (for ‘extended’)
启动具体的RE，能更清晰的组织和更好理解。
比如。以下使用了re.VERBOSE。使RE更easy阅读：
charref = re.compile(r"""
&[#] # Start of a numeric entity reference
(
0[0-7]+ # Octal form
| [0-9]+ # Decimal form
| x[0-9a-fA-F]+ # Hexadecimal form
)
; # Trailing semicolon
""", re.VERBOSE)假设没有使用re.VERBOSE，则RE将是这样：charref = re.compile("&#(0[0-7]+"
"|[0-9]+"
"|x[0-9a-fA-F]+);")在上面的样例中，Python的自己主动字符串串联被用于将RE分化到多个片段，可是它任然比使用re.VERBOSE更难理解。正則表達式的很多其它特性
很多其它元字符
1）|
表示‘或’操作，假设A和B都是正則表達式，则A|B表示匹配A或者匹配B。为了能有效的工作，|有非常低的优先级，比如：Crow|Servo将匹配Crow或者Servo。而不是Cro。一个‘w’或者一个‘S’。再接上ervo。
为了匹配字符'|'，你须要使用\|，或者封装它到一个字符类中。作为[|]。
2）^
匹配行的開始。
除非设置了MULTILINE标志。这将仅匹配字符串的開始。
在MULTILINE模式下。这也匹配每一个新行的開始。
比如：假设你希望匹配在行的開始匹配单词From，RE中将使用^From。
>>> print(re.search('^From', 'From Here to Eternity'))
<_sre.SRE_Match object; span=(0, 4), match='From'>
>>> print(re.search('^From', 'Reciting From Memory'))
None 3）$匹配行的结尾。
能够是字符串的结尾，或者是被新行符尾随的部分。
>>> print(re.search('}$', '{block}'))
<_sre.SRE_Match object; span=(6, 7), match='}'>
>>> print(re.search('}$', '{block} '))
None
>>> print(re.search('}$', '{block}\n'))
<_sre.SRE_Match object; span=(6, 7), match='}'> 为了匹配字符'$'，须要使用\$或者将它分装到字符类中，作为[$]。4）\A
仅匹配字符串的開始。当不使用MULTILINE模式时，\A和^是同样的；在MULTILINE模式，他们是不同的：\A任然仅匹配字符串的開始。而^能够匹配每一个新行的開始。
5）\Z
匹配仅在字符串末尾。
6）\b
单词边界。这是一个零宽度断言，仅匹配单词的開始和结束。
一个单词被定义为字母的序列。以至于单词的结束被表示为空白或者一个非字母字符。
以下是一个样例。匹配单词class，但它位于一个单词内部时将不被匹配：
>>> p = re.compile(r'\bclass\b')
>>> print(p.search('no class at all'))
<_sre.SRE_Match object; span=(3, 8), match='class'>
>>> print(p.search('the declassified algorithm'))
None
>>> print(p.search('one subclass is'))
None 在使用时有两点须要注意：首先，在Python中，\b表示退格字符。ASCII值是8，假设你不用原始字符串，那么Python将转换\b到一个退格字符，你的RE将不按你的设想匹配。以下的样例和我们上面的样例相似。仅有的差别是RE字符串少了'r'前缀：>>> p = re.compile('\bclass\b')
>>> print(p.search('no class at all'))
None
>>> print(p.search('\b' + 'class' + '\b'))
<_sre.SRE_Match object; span=(0, 7), match='\x08class\x08'> 第二，在字符类里，\b表示退格字符，和Python中的含义表示一致。7）\B
还有一个零宽度断言。和\b相反，仅匹配当前位置不是单词边界。
分组
比如。(ab)*将匹配0个或者多个ab。
>>> p = re.compile('(ab)*')
>>> print(p.match('ababababab').span())
(0, 10)组也能获取它们匹配的字符串的開始和结束点。通过传递一个參数到group()、start()、end()和span()。组的编号从0開始，组0总是存在的，他就是整个RE，因此匹配对象方法将组0作为他们的默认參数。
>>> p = re.compile('(a)b')
>>> m = p.match('ab')
>>> m.group()
'ab'
>>> m.group(0)
'ab'子组从左到右编号，从1開始。组能是嵌套的。为了确定编号，从左向右仅仅算开放括号字符。
>>> p = re.compile('(a(b)c)d')
>>> m = p.match('abcd')
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'group()一次能被传递多个组编号。这样的情况下它将返回一个元组：>>> m.group(2,1,2)
('b', 'abc', 'b')groups()方法返回包括全部子组匹配的字符串的元组，子组从1開始：>>> m.groups()
('abc', 'b')在模式中的反向应用同意你指定一个先前组的内容，比如，\1表示在当前位置的内容和组1匹配的内容同样。注意在Python中必须使用原始字符串表示。
比如，以下的RE探測同一时候出现两个同样单词的情况：
>>> p = re.compile(r'(\b\w+)\s+\1')
>>> p.search('Paris in the the spring').group()
'the the'这样的匹配方式在搜索中非常少使用。但在字符串替换时却非常实用。非捕获和命名组
有两个方法能够解决问题，我们首先看第一个。
有时你将想要使用一个组表示正則表達式的一部分，可是不想要获取该组的内容。
这时，你能使用非捕获组：(?
:...)，将...替换为不论什么正則表達式。
>>> m = re.match("([abc])+", "abc")
>>> m.groups()
('c',)
>>> m = re.match("(?:[abc])+", "abc")
>>> m.groups()
()除了你不能获取组匹配的内容，一个非捕获组的行为和捕获组的行为全然一致。你能放不论什么内容在它里面，能够使用反复元字符（比如*）反复它，或者嵌套其他组（捕获或者非捕获）。当改动一个已经存在的模式时(?:...)是特别实用的，由于你能够添加新的组而不改变已有的组的编号。但须要注意，使用非捕获组和捕获组在匹配上没有不论什么效率上的不同。
还有一个更有意义的特征是命名组：代替为组编号，改为使用为组指定一个名称。
命名组是Python特定扩展之中的一个，语法为：(?
P<name>...)，name是组的名称。
匹配对象方法能够接受组的编号或者组的名称，因此你能使用两种方法得到组的匹配信息：
>>> p = re.compile(r'(?P<word>\b\w+\b)')
>>> m = p.search( '(((( Lots of punctuation )))' )
>>> m.group('word')
'Lots'
>>> m.group(1)
'Lots'命名组是便利的。由于名称比编号更easy记忆。以下是一个来自imaplib模块的RE的样例：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获取匹配值的方式更加easy使用。
对于向后应用的语法。比如(...)\1，引用了组的编号，使用组名取代编号语法有一些改变。这是还有一个Python扩展：(?P=name)。表示组名为name的内容应该和当前点的内容匹配。为发现2个连续反复单词的正則表達式，(\b\w+)\s+\1能被写为(?P<word>\b\w+)\s+(?
P=word)：
>>> p = re.compile(r'(?P<word>\b\w+)\s+(?P=word)') >>> p.search('Paris in the the spring').group() 'the the'
预測先行断言
1）(?
=...)
正预測先行断言。
假设包括...表示的正則表達式在当前位置被成功匹配，则成功，否则失败。可是，尽管包括的正則表達式被尝试。但匹配引擎并不会前进，模式的其余部分还是从断言開始的地方開始匹配。
2）(?!...)
负预測先行断言。和正预測先行断言相反，假设它包括的正則表達式不匹配当前位置的字符串，则成功。
为了使描写叙述更加详细，我们看一个样例说明预測先行的作用。考虑一个简单的模式，用于匹配一个文件名称，并将它拆分为文件名称和扩展名。比如。news.rc中，news表示文件名称，rc表示扩展名。
匹配的模式非常easy：
.*[.].*$
注意.须要放到字符类中。由于它是一个元字符；也注意$，用于确保全部字符串的其余部分被包括在扩展中。这个正則表達式能够匹配foo.bar、autoexec.bat、sendmail.cf和printers.conf。
如今，考虑一个稍复杂点的情况，假设你想匹配扩展名不是bat的文件名称该怎么做？以下是一些不对的尝试：
1）.*[.][^b].*$
这个尝试要求扩展名的第一个字符不是b来排除bat。这时错误的。由于该模式也不匹配foo.bar。
2）.*[.]([^b]..|.[^a].|..[^t])$
这个比上一个更复杂一点，要求：扩展的第一个字符不匹配b，或者第二个字符不匹配a，或者第三个字符不匹配t。
这个模式匹配foo.bar，不匹配autoexec.bat，可是它要求扩展名必须为3个字符。将不匹配带有2个字符扩展名的文件，比如sendmail.cf。我们将继续完好它。
3）.*[.]([^b].?.?
|.[^a]?.?|..?
[^t]?)$
在这个尝试中，第二个和第三个字符都是可选的，为了匹配的扩展名小于三个字符的情况，比如sendmail.cf。
如今模式開始复杂起来了，開始难于阅读和理解。
更糟的是，假设问题改变。你想同一时候排除扩展名bat和exe，模式将变得更为复杂和难于理解。
一个负预測先行断言能够解决问题。
.*[.](?!bat$).*$
含义为：假设当前点表达式bat不匹配，则尝试模式的其余部分。假设bat$匹配。整个模式将失败。
结尾的$用于防止出现sample.batch的情况。
排除还有一个文件扩展名如今也easy了，简单的添加它作为断言的二选一。以下的模式同一时候排除bat和exe：
.*[.](?
!bat$|exe$).*$
改动字符串
1）split()
从RE匹配的地方将字符串分解为字符串列表。
2）sub()
找到RE匹配的全部子字符串。并使用不同的字符串代替它们；
3）subn()
和sub做的事同样，可是返回新字符串和替换的次数。
分解字符串
它和字符串的split()方法是类似的。可是提供了更为通用的分隔符。字符串的split()方法仅支持空格或者固定的字符串。
re也提供了一个模块级的re.split()函数。
split(string[, maxsplit=0])
通过正則表達式的匹配分解字符串。
假设在RE中使用了括号，则正則表達式的匹配也将出如今结果列表中。
假设maxsplit值大于0。则最多做maxsplit次分解。
你能通过设置maxsplit的值限制分解的数量。当maxsplit大于0时，最多进行maxsplit次分解，字符串的剩余部分被作为列表的最后一个元素返回。在以下的样例中，分隔符时不论什么非字符或数字的字符组合：
>>> p = re.compile(r'\W+')
>>> p.split('This is a test, short and sweet, of split().')
['This', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']
>>> p.split('This is a test, short and sweet, of split().', 3)
['This', 'is', 'a', 'test, short and sweet, of split().']有时你不仅对分隔符之间是什么感兴趣，并且须要知道哦分隔符是什么。假设在RE中使用了括号。那么他们的值也将出如今返回列表中。比較以下的调用：>>> p = re.compile(r'\W+')
>>> p2 = re.compile(r'(\W+)')
>>> p.split('This... is a test.')
['This', 'is', 'a', 'test', '']
>>> p2.split('This... is a test.')
['This', '... ', 'is', ' ', 'a', ' ', 'test', '.', '']模块级的函数re.split()添加了RE作为第一个參数，其余的同样：>>> 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])
返回替换后的字符串，替换採用从左到右而且非重叠的方式。
假设模式未被发现。返回未改变的字符串。
可选參数count用于指定替换的最大次数。count必须非负。
默认值0意味着替换全部。
以下是一个简单的样例。
它使用colour替换全部匹配的颜色名：
>>> p = re.compile( '(blue|white|red)') >>> p.sub( 'colour', 'blue socks and red shoes') 'colour socks and colour shoes' >>> p.sub( 'colour', 'blue socks and red shoes', count=1) 'colour socks and red shoes'subn()方法做相同的事，可是返回一个长度为2的元组，包括新字符串和替换的次数：
>>> p = re.compile( '(blue|white|red)')
>>> p.subn( 'colour', 'blue socks and red shoes')
('colour socks and colour shoes', 2)
>>> p.subn( 'colour', 'no colours at all')
('no colours at all', 0)空匹配仅仅有当不和前一个匹配相邻时才做替换：>>> p = re.compile('x*')
>>> p.sub('-', 'abxd')
'-a-b-d-'假设replacement是一个字符串。在它里面的不论什么反斜杠转义符都会被处理。即，\n会被转换为一个新行字符。\r被转换为回车符，等等。未知的转义符比如\j被遗留。
反向引用，比如\6，被RE中的相应组匹配的子字符串代替。
这让你在替换后的结果字符串中能合并原始字符串的部分。
以下的样例匹配单词section。被一个{}包括的字符串尾随，而且改变section到subsection：
>>> p = re.compile('section{ ( [^}]* ) }', re.VERBOSE)
>>> p.sub(r'subsection{\1}','section{First} section{second}')
'subsection{First} subsection{second}'也能够使用(?P<name>...)命名的组。\g<name>将通过组名来匹配，\g<number>将通过组编号来匹配。因此\g<2>等价于\2，当能够避免歧义，比如\g<2>0表示匹配组2。而\20则会被解释为匹配组20。以下替换的样例都是等价的，可是使用了3种不同的方式：
>>> 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}'
replacement也能够是一个函数，能够给你很多其它的控制。假设replacement是一个函数。函数会处理每个模式匹配的非重叠的子字符串。在每次调用。函数被传递一个匹配对象作为參数。函数能够使用这个信息计算替换字符串并返回它。在以下的样例中。replacement函数转换10进制数到16进制：
>>> def hexrepl(match): ... "Return the hex string for a decimal number" ... value = int(match.group()) ... return hex(value) ... >>> p = re.compile(r'\d+') >>> p.sub(hexrepl, 'Call 65490 for printing, 49152 for user code.') 'Call 0xffd2 for printing, 0xc000 for user code.'当使用模块级别的re.sub()函数时。模式作为第一个參数传入。模式能够为一个对象或者字符串；假设你须要指定正則表達式标志，你必须使用一个模式对象作为第一个參数，或者在模式字符串中用嵌入的修饰语，比如：sub("(?i)b+", "x", "bbbb BBBB")返回'x x'。
常见问题
用String方法
一个常见的样例是替换一个固定的字符串为还有一个。比如，你想替换word为deed，re.sub()似乎能够用于这样的场景，可是你应该考虑replace()方法。注意replace()也将替换单词内的word，比如改动swordfish为sdeedfish，可是简单的RE word也将做那。（为了避免单词内的替换，模式将必须是\bword\b，为了要求word是一个独立的单词。这一点超出了replace()的能力。）
还有一个常见任务是探測字符串中某个字符的位置，或者使用还有一个字符替换它。
你能够使用类似这种操作来实现：re.sub('\n', ' ', S)。可是translate()也能够完毕这种任务。而且比不论什么正則表達式的操作都更快。
总之。使用re模块之前，考虑你的问题能否使用更快、更简单的字符串方法解决。
match() VS search()
>>> print(re.match('super', 'superstition').span())
(0, 5)
>>> print(re.match('super', 'insuperable'))
None还有一个方面，search()将扫描整个字符串，报告发现的第一个成功匹配。>>> print(re.search('super', 'superstition').span())
(0, 5)
>>> print(re.search('super', 'insuperable').span())
(2, 7)有时你会被引诱使用re.match()，只添加.*到你的RE之前。你应该拒绝这个诱惑。转而使用re.search()。正則表達式编译器会做一些RE的分析。为了加速查找匹配的处理。一个如此的分析是分析出匹配的首字符必然是什么。比如。一个以Crow開始的模式必须匹配首字符'C'。这个分析使引擎高速扫描字符串查询開始字符，当'C'被发现时才继续向下匹配。
添加.*将使这个优化无效，要求扫描到字符串的结尾。在回溯发现RE其余部分的一个匹配。因此，优先使用re.search()。
贪婪 VS 非贪婪
这一点常常会导致一些问题，当你尝试匹配一对对称的限定符时，比如包括HTML标签的尖括号，因为.*的贪婪特性，简单的匹配一个HTML标签的模式不工作：
>>> s = '<html><head><title>Title</title>'
>>> len(s)
32
>>> print(re.match('<.*>', s).span())
(0, 32)
>>> print(re.match('<.*>', s).group())
<html><head><title>Title</title>RE在<html>中匹配'<'。然后.*消费字符串其余的全部部分，因为RE最后的>不能匹配。于是正則表達式引擎不得不回溯字符直到它为>找到一个匹配。最后的匹配就是从<html>的'<'到</title>的'>'。并非你想要的。
在这样的场景，应该使用非贪婪限制符*?、+?、?
?
、或者{m,n}?，他们将匹配尽可能少的字符。
在上面的样例中，在第一个'<'匹配之后，'>'将被马上尝试，假设失败，引擎每次前进一个字符，再次尝试。最后得到正确的结果：
>>> print(re.match('<.*?>', s).group())
<html>（注意使用正則表達式解析HTML或者XML是痛苦的。由于写一个能处理全部场景的正則表達式是很复杂的，使用HTML或者XML解析器来完毕这种任务。）使用re.VERBOSE
为如此的RE，当编译正則表達式时指定re.VERBOSE标志是有帮助的。由于它同意你格式化正則表達式使其更清晰。
re.VERBOSE标志有几个影响。在正則表達式中但不在字符类中的空格将被忽略。这意味着一个表达式比如dog | cat将等价于dog|cat，可是[a b]任然匹配字符'a'、'b'和空格。此外，你也能放凝视在一个RE中。凝视从一个#字符到下一行。当用三引號字符串时。RE被格式化的更加清晰：
pat = re.compile(r""" \s* # Skip leading whitespace (?P<header>[^:]+) # Header name \s* : # Whitespace, and a colon (?P<value>.*?) # The header's value -- *?和以下的表达式比起来。这是更可读的：used to # lose the following trailing whitespace \s*$ # Trailing whitespace to end-of-line """, re.VERBOSE)
pat = re.compile(r"\s*(?P<header>[^:]+)\s*:(?P<value>.*?)\s*$")
posted on 2017-05-03 17:35 gavanwanggw 阅读(278) 评论(0) 编辑 收藏 举报
