Python 正则表达式操作指南

简介

就其本质而言,正则表达式(或 RE)是一种小型的、高度专业化的编程语言,(在Python中)它内嵌在 Python 中,并通过 re 模块实现。
使用这个小型语言,你可以为想要匹配的相应字符串集指定规则;该字符串集可能包含英文语句、e-mail地址、TeX命令或任何你想搞定的东西。
然后你可以问诸如“这个字符串匹配该模式吗?”或“在这个字符串中是否有部分匹配该模式呢?”。
你也可以使用 RE 以各种方式来修改或分割字符串。

简单模式

字符匹配

  • 大多数字母和字符一般都会和自身匹配。
  • 元字符:. ^ $ * + ? { [ ] \ | ( )
  • 元字符是"[" 和 "]"。它们常用来指定一个字符类别,所谓字符类别就是你想匹配的一个字符集。字符可以单个列出,也可以用“-”号分隔的两个给定字符来表示一个字符区间。
    • 元字符在类别里并不起作用。例如,[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_]
  • 元字符 . 。它匹配除了换行字符外的任何字符,在 alternate 模式(re.DOTALL)下它甚至可以匹配换行。"." 通常被用于你想匹配“任何字符”的地方。

重复

  • * 匹配零或更多次,所以可以根本就不出现
  • + 则要求至少出现一次
  • ? 匹配一次或零次,可以认为它用于标识某事物是可选的
  • {m,n}(注意m,n之间不能有空格),其中 m 和 n 是十进制整数。该限定符的意思是至少有 m 个重复,至多到 n 个重复

考虑表达式 a[bcd]*b。它匹配字母 "a",零个或更多个来自类 [bcd] 中的字母,最后以 "b" 结尾。现在想一想该 RE 对字符串 "abcbd" 的匹配。

匹配引擎一开始会尽其所能进行匹配(贪婪匹配),如果没有匹配然后就逐步退回并反复尝试 RE 剩下来的部分。直到它退回尝试匹配 [bcd] 到零次为止,如果随后还是失败,那么引擎就会认为该字符串根本无法匹配 RE 。

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"

使用正则表达式

编译正则表达式

REs 被处理成字符串是因为正则表达式不是 Python 语言的核心部分,也没有为它创建特定的语法。(应用程序根本就不需要 REs,因此没必要包含它们去使语言说明变得臃肿不堪。)而 re 模块则只是以一个 C 扩展模块的形式来被 Python 包含,就象 socket 或 zlib 模块一样。将 REs 作为字符串以保证 Python 语言的简洁。

In [1]:
import re
p = re.compile('ab*')
p = re.compile('ab*', re.IGNORECASE)
print (p)
re.compile('ab*', re.IGNORECASE)

反斜杠

为了匹配一个反斜杠,不得不在 RE 字符串中写 '\\\\',因为正则表达式中必须是 "\\",而每个反斜杠在常规的 Python 字符串实值中必须表示成 "\\"。在 REs 中反斜杠的这个重复特性会导致大量重复的反斜杠,而且所生成的字符串也很难懂。

解决的办法就是为正则表达式使用 Python 的 raw 字符串表示;在字符串前加个 "r" 反斜杠就不会被任何特殊方式处理,所以 r"\n" 就是包含 "\" 和 "n" 的两个字符,而 "\n" 则是一个字符,表示一个换行。正则表达式通常在 Python 代码中都是用这种 raw 字符串表示。

常规字符串 Raw 字符串
"ab*" r"ab*"
"\\\\section" r"\\section"
"\\w+\\s+\\1" r"\w+\s+\1"

执行匹配

方法/属性 作用
match() 决定 RE 是否在字符串刚开始的位置匹配
search() 扫描字符串,找到这个 RE 匹配的位置
findall() 找到 RE 匹配的所有子串,并把它们作为一个列表返回
finditer() 找到 RE 匹配的所有子串,并把它们作为一个迭代器返回

如果没有匹配到的话,match() 和 search() 将返回 None。如果成功的话,就会返回一个 MatchObject 实例,其中有这次匹配的信息:它是从哪里开始和结束,它所匹配的子串等等。
findall() 在它返回结果时不得不创建一个列表。在 Python 2.2中,也可以用 finditer() 方法。

MatchObject 实例也有几个方法和属性;最重要的那些如下所示:

方法/属性 作用
group() 返回被 RE 匹配的字符串
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配 (开始,结束) 的位置

在实际程序中,最常见的作法是将 MatchObject 保存在一个变量里,然後检查它是否为 None,通常如下所示:

In [9]:
p = re.compile('[a-z]+')
m = p.match( 'tempo')
print(m)
if m:
    print ('Match found: ', m.group())
else:
    print ('No match')
<_sre.SRE_Match object; span=(0, 5), match='tempo'>
Match found:  tempo
In [5]:
m.group()
Out[5]:
'tempo'
In [6]:
m.start(), m.end()
Out[6]:
(0, 5)
In [7]:
m.span()
Out[7]:
(0, 5)
In [15]:
iterator = p.finditer('12 drummers drumming, 11 ... 10 ...')
for match in iterator:
    print(match.group())
    print(match.span())
drummers
(3, 11)
drumming
(12, 20)

编译标志

编译标志让你可以修改正则表达式的一些运行方式。在 re 模块中标志可以使用两个名字,一个是全名如 IGNORECASE,一个是缩写,一字母形式如 I。(如果你熟悉 Perl 的模式修改,一字母形式使用同样的字母;例如 re.VERBOSE的缩写形式是 re.X。)

多个标志可以通过按位 OR-ing 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志:

  • LOCALE 影响 \w, \W, \b, 和 \B,这取决于当前的本地化设置。
    locales 是 C 语言库中的一项功能,是用来为需要考虑不同语言的编程提供帮助的。举个例子,如果你正在处理法文文本,你想用 \w+ 来匹配文字,但 \w 只匹配字符类 [A-Za-z];它并不能匹配 "é" 或 "ç"。如果你的系统配置适当且本地化设置为法语,那么内部的 C 函数将告诉程序 "é" 也应该被认为是一个字母。当在编译正则表达式时使用 LOCALE 标志会得到用这些 C 函数来处理 \w 后的编译对象;这会更慢,但也会象你希望的那样可以用 \w+ 来匹配法文文本。
  • VERBOSE 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。当该标志被指定时,在 RE 字符串中的空白符被忽略,除非该空白符在字符类中或在反斜杠之后;这可以让你更清晰地组织和缩进 RE。它也可以允许你将注释写入 RE,这些注释会被引擎忽略;注释用 "#"号 来标识,不过该符号不能在字符串或反斜杠之后。
标志 含义
DOTALL, S 使 . 匹配包括换行在内的所有字符
IGNORECASE, I 使匹配对大小写不敏感
LOCALE, L 做本地化识别(locale-aware)匹配
MULTILINE, M 多行匹配,影响 ^$^$ 不会被解释
VERBOSE, X 能够使用 REs 的 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 模式里,它也可以直接匹配字符串中的每个换行。
  • $
    • 匹配行尾,行尾被定义为要么是字符串尾,要么是一个换行字符后面的任何位置
    • 匹配一个 "$",使用 \$ 或将其包含在字符类中,如 [$]
  • \A
    • 只匹配字符串首。
    • 当不在 MULTILINE 模式,\A^ 实际上是一样的。
    • 然而,在 MULTILINE 模式里它们是不同的;\A 只是匹配字符串首,而 ^ 还可以匹配在换行符之后字符串的任何位置。
  • \Z
    • Matches only at the end of the string.
    • 只匹配字符串尾。
  • \b
    • 单词边界。
    • 这是个零宽界定符(zero-width assertions)只用以匹配单词的词首和词尾。
    • 单词被定义为一个字母数字序列,因此词尾就是用空白符或非字母数字符来标示的。
  • \B
    • 另一个零宽界定符(zero-width assertions),它正好同 \b 相反,只在当前位置不在单词边界时匹配。
In [16]:
p = re.compile(r'\bclass\b')
print (p.search('no class at all'))
print (p.search('the declassified algorithm'))
print (p.search('one subclass is'))
<_sre.SRE_Match object; span=(3, 8), match='class'>
None
None

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

In [17]:
p = re.compile('\bclass\b')
print (p.search('no class at all'))
print (p.search('\b' + 'class' + '\b'))
None
<_sre.SRE_Match object; span=(0, 7), match='\x08class\x08'>

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

分组

  • 组是通过 "(" 和 ")" 元字符来标识的。 "(" 和 ")" 有很多在数学表达式中相同的意思;它们一起把在它们里面的表达式组成一组。举个例子,你可以用重复限制符,象 *, +, ?, 和 {m,n},来重复组里的内容,比如说 (ab)* 将匹配零或更多个重复的 "ab"。
  • 小组是从左向右计数的,从1开始。组可以被嵌套。计数的数值可以通过从左到右计算打开的括号数来确定。
  • The groups() 方法返回一个包含所有小组字符串的元组,从 1 到 所含的小组号。
  • 模式中的逆向引用允许你指定先前捕获组的内容,该组也必须在字符串当前位置被找到。举个例子,如果组 1 的内容能够在当前位置找到的话,\1 就成功否则失败。记住 Python 字符串也是用反斜杠加数据来允许字符串中包含任意字符的,所以当在 RE 中使用逆向引用时确保使用 raw 字符串。
    • 象这样只是搜索一个字符串的逆向引用并不常见 -- 用这种方式重复数据的文本格式并不多见 -- 但你不久就可以发现它们用在字符串替换上非常有用。
In [27]:
p = re.compile('(ab)*')
print (p.match('ababababab').span())
(0, 10)
In [21]:
p = re.compile('(a)b')
m = p.match('ab')
print(m.group())
print(m.group(0))
ab
ab
In [25]:
p = re.compile('(a(b)c)d')
m = p.match('abcd')
print(m.group(0))
print(m.group(1))
print(m.group(2))
print(m.group(2,1))
abcd
abc
b
('b', 'abc')
In [26]:
m.groups()
Out[26]:
('abc', 'b')
In [35]:
p = re.compile(r'(\b\w+)\s+\1')
p.findall('Paris in the the the spring')
#p.search('Paris in the the the spring').group()
Out[35]:
['the']

无捕获组和命名组

  • Python 新增了一个扩展语法到 Perl 扩展语法中。如果在问号后的第一个字符是 "P",你就可以知道它是针对 Python 的扩展。目前有两个这样的扩展:
    • (?P<name>...) 定义一个命名组
    • (?P=name) 则是对命名组的逆向引用
  • 首先,有时你想用一个组去收集正则表达式的一部分,但又对组的内容不感兴趣。你可以用一个无捕获组: (?:...) 来实现这项功能,这样你可以在括号中发送任何其他正则表达式。
    • 除了捕获匹配组的内容之外,无捕获组与捕获组表现完全一样;
    • 你可以在其中放置任何字符,可以用重复元字符如 "*" 来重复它,可以在其他组(无捕获组与捕获组)中嵌套它。
    • (?:...) 对于修改已有组尤其有用,因为你可以不用改变所有其他组号的情况下添加一个新组。
    • 捕获组和无捕获组在搜索效率方面也没什么不同,没有哪一个比另一个更快。
  • 其次,更重要和强大的是命名组;与用数字指定组不同的是,它可以用名字来指定。
    • 命令组的语法是 Python 专用扩展之一: (?P<name>...)。名字很明显是组的名字。
    • 除了该组有个名字之外,命名组也同捕获组是相同的。MatchObject 的方法处理捕获组时接受的要么是表示组号的整数,要么是包含组名的字符串。命名组也可以是数字,所以你可以通过两种方式来得到一个组的信息。
    • 命名组是便于使用的,因为它可以让你使用容易记住的名字来代替不得不记住的数字。
  • 因为逆向引用的语法,象 (...)\1 这样的表达式所表示的是组号,这时用组名代替组号自然会有差别。
    • 还有一个 Python 扩展:(?P=name),它可以使叫 name 的组内容再次在当前位置发现。
    • 正则表达式为了找到重复的单词,(\b\w+)\s+\1 也可以被写成 (?P<word>\b\w+)\s+(?P=word)
In [49]:
m = re.match("([abc])+", "abc")
print(m.groups())
('c',)
m = re.match("(?:[abc])+", "abc")
print(m.groups())
('c',)
()
In [51]:
p = re.compile(r'(?P<word>\b\w+\b)')
m = p.search( '(((( Lots of punctuation )))' )
print(m.groups('word'))
print(m.group(1))
('Lots',)
Lots
In [57]:
p = re.compile(r'(?P<word>\b\w+)\s+(?P=word)')
p.search('Paris in the the spring').group()
Out[57]:
'the the'

前向界定符

另一个零宽界定符(zero-width assertion)是前向界定符。前向界定符包括前向肯定界定符和前项否定界定符,如下所示:

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

考虑一个简单的模式用于匹配一个文件名,并将其通过 "." 分成基本名和扩展名两部分。如在 "news.rc" 中,"news" 是基本名,"rc" 是文件的扩展名。

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

现在,考虑把问题变得复杂点;如果你想匹配的扩展名不是 "bat" 的文件名?

  • .*[.](?!bat$).*$
  • 前向的意思:如果表达式 bat 在这里没有匹配,尝试模式的其余部分;如果 bat$ 匹配,整个模式将失败。
  • 后面的 $ 被要求是为了确保象 "sample.batch" 这样扩展名以 "bat" 开头的会被允许。
  • 将另一个文件扩展名排除在外现在也容易;简单地将其做为可选项放在界定符中。下面的这个模式将以 "bat" 或 "exe" 结尾的文件名排除在外。.*[.](?!bat$|exe$).*$
In [68]:
import re
twitter = re.compile(
    '''(?<[email protected])([\w\d_]+)''',re.UNICODE | re.VERBOSE)

text = '''This text includes two Twitter handles.
One for @ThePSF, and one for the author, @doughellmann.
'''

print (text)
for match in twitter.findall(text):
    print ('Handle:', match)
This text includes two Twitter handles.
One for @ThePSF, and one for the author, @doughellmann.

Handle: ThePSF
Handle: doughellmann
In [26]:
# 前向
# Isaac 前面有 Asimov 才能匹配
test = re.compile(r'Isaac(?=Asimov)')
test.findall("IsaacAsimov")
#test.findall("AsimovIsaac")
Out[26]:
['Isaac']
In [5]:
# 前向
# Isaac 前面有 Asimov 不能匹配
test = re.compile(r'Isaac(?!Asimov)')
test.findall("IsaacAsimov")
# test.findall("AsimovIsaac")
Out[5]:
[]
In [29]:
# 后向
# Isaac 后面有 Asimov 才能匹配
test = re.compile(r'(?<=Asimov)Isaac')
test.findall("AsimovIsaac")
#test.findall("IsaacAsimov")
Out[29]:
['Isaac']
In [30]:
# 后向
# Isaac 后面有 Asimov 不能匹配
test = re.compile(r'(?<!Asimov)Isaac')
test.findall("AsimovIsaac")
#test.findall("IsaacAsimov")
Out[30]:
[]
In [40]:
# 后向
m = re.search('(?<=abc)def', 'abcdef')
m.group(0)
Out[40]:
'def'
In [48]:
# 后向
m = re.search('(?<=-)\w+', 'spam-egg')
m.group(0)
Out[48]:
'egg'

修改字符串

方法/属性 作用
split() 将字符串在 RE 匹配的地方分片并生成一个列表,
sub() 找到 RE 匹配的所有子串,并将其用一个不同的字符串替换
subn() sub() 相同,但返回新的字符串和替换次数
  • re.compile().split(text, num): num 非 0 时,最多分成 num 段
  • p2 = re.compile(r'(\W+)'): 打印出定界符,如果不需要则为:p = re.compile(r'\W+')

将字符串分片

In [60]:
p = re.compile(r'\W+')
In [61]:
p.split('This is a test, short and sweet, of split().')
Out[61]:
['This', 'is', 'a', 'test', 'short', 'and', 'sweet', 'of', 'split', '']
In [69]:
# 最多分出 3 段(0 开始数)
p.split('This is a test, short and sweet, of split().', 3)
Out[69]:
['This', 'is', 'a', 'test, short and sweet, of split().']
In [71]:
p = re.compile(r'\W+')
p2 = re.compile(r'(\W+)')
In [72]:
p.split('This... is a test.')
Out[72]:
['This', 'is', 'a', 'test', '']
In [73]:
p2.split('This... is a test.')
Out[73]:
['This', '... ', 'is', ' ', 'a', ' ', 'test', '.', '']
In [76]:
re.split('[\W]+', 'Words, words, words.')
Out[76]:
['Words', 'words', 'words', '']
In [77]:
re.split('([\W]+)', 'Words, words, words.')
Out[77]:
['Words', ', ', 'words', ', ', 'words', '.', '']
In [78]:
re.split('[\W]+', 'Words, words, words.', 1)
Out[78]:
['Words', 'words, words.']

搜索和替换

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

  • 返回的字符串是在字符串中用 RE 最左边不重复的匹配来替换。如果模式没有发现,字符将被没有改变地返回。
    • 可选参数 count 是模式匹配后替换的最大次数;count 必须是非负整数。缺省值是 0 表示替换所有的匹配。
  • subn() 方法作用一样,但返回的是包含新字符串和替换执行次数的两元组。
  • 空匹配只有在它们没有紧挨着前一个匹配时才会被替换掉。
  • 还可以指定用 (?P<name>...) 语法定义的命名组。"\g<name>" 将通过组名 "name" 用子串来匹配,并且 "\g<number>" 使用相应的组号。所以 "\g<2>" 等于 "\2",但能在替换字符串里含义不清,如 "\g<2>0"。("\20" 被解释成对组 20 的引用,而不是对后面跟着一个字母 "0" 的组 2 的引用。)
  • 替换也可以是一个甚至给你更多控制的函数。如果替换是个函数,该函数将会被模式中每一个不重复的匹配所调用。在每次调用时,函数会被传入一个 MatchObject 的对象作为参数,因此可以用这个对象去计算出替换字符串并返回它。
In [80]:
p = re.compile('(blue|white|red)')
In [81]:
p.sub( 'colour', 'blue socks and red shoes')
Out[81]:
'colour socks and colour shoes'
In [83]:
p.sub('colour', 'blue socks and red shoes', count=1)
Out[83]:
'colour socks and red shoes'
In [89]:
p = re.compile('x*')
p.sub('-', 'abxd')
Out[89]:
'-a-b-d-'
In [107]:
p = re.compile('section{ ( [^}]* ) }', re.VERBOSE)
p = re.compile('section{(\w+)}')
p.sub(r'subsection{\1}','section{First} section{second}')
Out[107]:
'subsection{First} subsection{second}'
In [109]:
p = re.compile('section{ (?P<name> [^}]* ) }', re.VERBOSE)
p = re.compile('section{ (?P<name> \w+) }', re.VERBOSE)
p.sub(r'subsection{\1}','section{First}')
Out[109]:
'subsection{First}'
In [110]:
p.sub(r'subsection{\g<1>}','section{First}')
Out[110]:
'subsection{First}'
In [111]:
p.sub(r'subsection{\g<name>}','section{First}')
Out[111]:
'subsection{First}'
In [112]:
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.')
Out[112]:
'Call 0xffd2 for printing, 0xc000 for user code.'

常见问题

使用字符串方式

用一个固定字符串替换另一个 的例子,如:你可以把 "deed" 替换成 "word"。re.sub() 似乎正是胜任这个工作的函数,但还是考虑考虑 replace() 方法吧。注意 replace() 也可以在单词里面进行替换,可以把 "swordfish" 变成 "sdeedfish"。

另一个常见任务是从一个字符串中删除单个字符或用另一个字符来替代它。你也许可以用 re.sub('\n',' ', s) 这样来实现,但 translate() 能够实现这两个任务,而且比任何正则表达式操作起来更快。 (translate 需要配合 string.maketrans 使用。例如:import string 后 'a1b3'.translate(string.maketrans('ab', 'cd')) )

match() vs search()

match() 函数只检查 RE 是否在字符串开始处匹配,而 search() 则是扫描整个字符串。

贪婪 vs 不贪婪

不贪婪的限定符 *?、+?、?? 或 {m,n}?,尽可能匹配小的文本。

使用 re.VERBOSE

笔记

  • 大多数字母和字符一般都会和自身匹配
  • 元字符在类别里([] 里)并不起作用
  • 可以用补集来匹配不在区间范围内的字符。其做法是把"^"作为类别首个字符;其它地方的"^"只会简单匹配 "^"字符本身
  • 在字符串前加个 "r" 反斜杠就不会被任何特殊方式处理
  • 如果没有匹配到的话,match() 和 search() 将返回 None。如果成功的话,就会返回一个 MatchObject 实例,其中有这次匹配的信息:它是从哪里开始和结束,它所匹配的子串等等。findall() 在它返回结果时不得不创建一个列表。在 Python 2.2中,也可以用 finditer() 方法。
  • 多个标志可以通过按位 OR-ing 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志
  • 组可以被嵌套。计数的数值可以通过从左到右计算打开的括号数来确定。The groups() 方法返回一个包含所有小组字符串的元组,从 1 到 所含的小组号。
  • 模式中的逆向引用允许你指定先前捕获组的内容,该组也必须在字符串当前位置被找到。举个例子,如果组 1 的内容能够在当前位置找到的话,\1 就成功否则失败。

  • 无捕获组和命名组

    • (?P<name>...) 定义一个命名组,(?P=name) 则是对命名组的逆向引用;除了用数字指定组,它可以用名字来指定,如:(\b\w+)\s+\1 也可以被写成 (?P<word>\b\w+)\s+(?P=word)
    • 无捕获组: (?:...) ,对于修改已有组尤其有用,因为你可以不用改变所有其他组号的情况下添加一个新组。
  • 前向界定符

    • (?=...) 前向肯定界定符。如果所含正则表达式,以 ... 表示,在当前位置成功匹配时成功,否则失败。但一旦所含表达式已经尝试,匹配引擎根本没有提高;模式的剩余部分还要尝试界定符的右边。
    • (?!...) 前向否定界定符。与肯定界定符相反;当所含表达式不能在字符串当前位置匹配时成功,匹配不是 bat 或 exe 后缀的:.*[.](?!bat$|exe$).*$
  • split(string [, maxsplit = 0])

    • re.compile().split(text, num): num 非 0 时,最多分成 num 段
    • p2 = re.compile(r'(\W+)'): 打印出定界符,如果不需要则为:p = re.compile(r'\W+')
  • sub(replacement, string[, count = 0])

    • 可选参数 count 是模式匹配后替换的最大次数;count 必须是非负整数。缺省值是 0 表示替换所有的匹配。
    • 空匹配只有在它们没有紧挨着前一个匹配时才会被替换掉。
    • 还可以指定用 (?P<name>...) 语法定义的命名组。"\g<name>" 将通过组名 "name" 用子串来匹配,并且 "\g<number>" 使用相应的组号。
    • 替换也可以是一个函数,该函数将会被模式中每一个不重复的匹配所调用。
  • 更快的替换:replace
  • 从一个字符串中删除单个字符或用另一个字符来替代它
    • 可以用 re.sub('\n',' ', s) 这样来实现,但 translate() 能够实现这两个任务,而且比任何正则表达式操作起来更快。
    • translate 需要配合string.maketrans 使用。例如:import string'a1b3'.translate(string.maketrans('ab', 'cd'))
In [ ]: