深入 Python :Dive Into Python 中文版

例 15.10. 编译正则表达式

>>> import re
>>> pattern = '^M?M?M?$'
>>> re.search(pattern, 'M')               
<SRE_Match object at 01090490>
>>> compiledPattern = re.compile(pattern) 
>>> compiledPattern
<SRE_Pattern object at 00F06E28>
>>> dir(compiledPattern)                  
['findall', 'match', 'scanner', 'search', 'split', 'sub', 'subn']
>>> compiledPattern.search('M')           
<SRE_Match object at 01104928>

	这是你看到过的 re.search 语法。把一个正则表达式作为字符串 (pattern) 并用这个字符串来匹配 ('M')。如果能够匹配，函数返回 一个 match 对象，可以用来确定匹配的部分和如何匹配的。
	这里是一个新的语法：re.compile 把一个正则表达式作为字符串参数接受并返回一个 pattern 对象。注意这里没去匹配字符串。编译正则表达式和以特定字符串 ('M') 进行匹配不是一回事，所牵扯的只是正则表达式本身。
	re.compile 返回的已编译的 pattern 对象有几个值得关注的功能：包括了几个 re 模块直接提供的功能 (比如：search 和 sub)。
	用 'M' 作参数来调用已编译的 pattern 对象的 search 函数与用正则表达式和字符串 'M' 调用 re.search 可以得到相同的结果，只是快了很多。 (事实上，re.search 函数仅仅将正则表达式编译，然后为你调用编译后的 pattern 对象的 search 方法。)

例 15.11. roman81.py 中已编译的正则表达式

这个文件可以在例子目录下的 py/roman/stage8/ 目录中找到。

如果您还没有下载本书附带的样例程序, 可以 下载本程序和其他样例程序。

# toRoman and rest of module omitted for clarity

romanNumeralPattern = \
    re.compile('^M?M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)(IX|IV|V?I?I?I?)$') 

def fromRoman(s):
    """convert Roman numeral to integer"""
    if not s:
        raise InvalidRomanNumeralError, 'Input can not be blank'
    if not romanNumeralPattern.search(s):                                    
        raise InvalidRomanNumeralError, 'Invalid Roman numeral: %s' % s

    result = 0
    index = 0
    for numeral, integer in romanNumeralMap:
        while s[index:index+len(numeral)] == numeral:
            result += integer
            index += len(numeral)
    return result

	看起来很相似，但实质却有很大改变。romanNumeralPattern 不再是一个字符串了，而是一个由 re.compile 返回的 pattern 对象。
	这意味着你可以直接调用 romanNumeralPattern 的方法。这比每次调用 re.search 要快很多。模块被首次导入 (import) 之时，正则表达式被一次编译并存储于 romanNumeralPattern。之后每次调用 fromRoman 时，你可以立刻以正则表达式匹配输入的字符串，而不需要在重复背后的这些编译的工作。

例 15.12. 用 romantest81.py 测试 roman81.py 的结果

.............          
----------------------------------------------------------------------
Ran 13 tests in 3.385s 

OK                     

	有一点说明一下：这里，我在运行单元测试时没有 使用 -v 选项，因此输出的也不再是每个测试完整的 doc string，而是用一个圆点来表示每个通过的测试。(失败的测试标用 F 表示，发生错误则用 E 表示，你仍旧可以获得失败和错误的完整追踪信息以便查找问题所在。)
	运行 13 个测试耗时 3.385 秒，与之相比是没有预编译正则表达式时的 3.685秒。这是一个 8% 的整体提速，记住单元测试的大量时间实际上花在做其他工作上。(我单独测试了正则表达式部分的耗时，不考虑单元测试的其他环节，正则表达式编译可以让匹配 search 平均提速 54%。)小小修改还真是值得。
	对了，不必顾虑什么，预先编译正则表达式并没有破坏什么，你刚刚证实这一点。

例 15.13. roman82.py

这个文件可以在例子目录下的 py/roman/stage8/ 目录中找到。

如果您还没有下载本书附带的样例程序, 可以 下载本程序和其他样例程序。

# rest of program omitted for clarity

#old version
#romanNumeralPattern = \
#   re.compile('^M?M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)(IX|IV|V?I?I?I?)$')

#new version
romanNumeralPattern = \
    re.compile('^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$') 

你已经将 M?M?M?M? 替换为 M{0,4}。它们的含义相同：“匹配 0 到 4 个 M 字符”。类似地，C?C?C? 改成了 C{0,3} (“匹配 0 到 3 个 C 字符”) 接下来的 X 和 I 也一样。

例 15.14. 以 romantest82.py 测试 roman82.py 的结果

.............
----------------------------------------------------------------------
Ran 13 tests in 3.315s 

OK                     

	总体而言，这种正则表达使单元测试提速 2%。这不太令人振奋，但记住 search 函数只是整体单元测试的一个小部分，很多时间花在了其他方面。(我另外的测试表明这个应用了新语法的正则表达式使 search 函数提速 11% 。) 通过预先编译和使用新语法重写可以使正则表达式的性能提升超过 60%，令单元测试的整体性能提升超过 10%。
	比任何的性能提升更重要的是模块仍然运转完好。这便是我早先提到的自由：自由地调整、修改或者重写任何部分并且保证在此过程中没有把事情搞得一团糟。这并不是给无休止地为了调整代码而调整代码以许可；你有很切实的目标 (“让 fromRoman 更快”)，而且你可以实现这个目标，不会因为考虑在改动过程中是否会引入新的 Bug 而有所迟疑。

例 15.15. roman83.py

该文件可以在例子目录下的 py/roman/stage8/ 目录中找到。

如果您还没有下载本书附带的样例程序, 可以 下载本程序和其他样例程序。

# rest of program omitted for clarity

#old version
#romanNumeralPattern = \
#   re.compile('^M{0,4}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$')

#new version
romanNumeralPattern = re.compile('''
    ^                   # beginning of string
    M{0,4}              # thousands - 0 to 4 M's
    (CM|CD|D?C{0,3})    # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 C's),
                        #            or 500-800 (D, followed by 0 to 3 C's)
    (XC|XL|L?X{0,3})    # tens - 90 (XC), 40 (XL), 0-30 (0 to 3 X's),
                        #        or 50-80 (L, followed by 0 to 3 X's)
    (IX|IV|V?I{0,3})    # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 I's),
                        #        or 5-8 (V, followed by 0 to 3 I's)
    $                   # end of string
    ''', re.VERBOSE) 

re.compile 函数的第二个参数是可选的，这个参数通过一个或一组标志 (flag) 来控制预编译正则表达式的选项。这里你指定了 re.VERBOSE 选项，告诉 Python 正则表达式里有内联注释。注释和它们周围的空白不 会被认做正则表达式的一部分，在编译正则表达式时 re.compile 函数会忽略它们。这个新 “verbose” 版本与老版本完全一样，只是更具可读性。

例 15.16. 用 romantest83.py 测试 roman83.py 的结果

.............
----------------------------------------------------------------------
Ran 13 tests in 3.315s 

OK                     

	新 “verbose” 版本和老版本的运行速度一样。事实上，编译的 pattern 对象也一样，因为 re.compile 函数会剔除掉所有你添加的内容。
	新 “verbose” 版本可以通过所有老版本通过的测试。什么都没有改变，但在六个月后重读该模块的程序员却有了理解功能如何实现的机会。