python study - 正则表达式

现在我们来扩展一下关于罗马数字的正则表达式，以匹配十位数和个位数，下面的例子展示十位数的校验方法。

例 7.7. 校验十位数

>>> pattern = ‘^M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)$‘
>>> re.search(pattern, ‘MCMXL‘)    
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, ‘MCML‘)     
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, ‘MCMLX‘)    
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, ‘MCMLXXX‘)  
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, ‘MCMLXXXX‘) 
>>> 

	这个模式匹配字符串的开始，接着是第一个可选字符 M，接着是 CM，接着 XL，接着是字符串的结尾。请记住，(A|B|C) 这个语法的含义是“精确匹配 A、B 或者 C 其中的一个”。此处匹配了 XL，因此不再匹配 XC 和 L?X?X?X?，接着就匹配到字符串的结尾。MCML 表示罗马数字 1940。
	这个模式匹配字符串的开始，接着是第一个可选字符 M，接着是 CM，接着 L?X?X?X?。在模式 L?X?X?X? 中，它匹配 L 字符并且跳过所有可选的 X 字符，接着匹配字符串的结尾。MCML 表示罗马数字 1950。
	这个模式匹配字符串的开始，接着是第一个可选字符 M，接着是 CM，接着是可选的 L 字符和可选的第一个 X 字符，并且跳过第二第三个可选的 X 字符，接着是字符串的结尾。MCMLX 表示罗马数字 1960。
	这个模式匹配字符串的开始，接着是第一个可选字符 M，接着是 CM，接着是可选的 L 字符和所有的三个可选的 X 字符，接着匹配字符串的结尾。MCMLXXX 表示罗马数字 1980。
	这个模式匹配字符串的开始，接着是第一个可选字符M，接着是CM，接着是可选的 L字符和所有的三个可选的X字符，接着就未能匹配 字符串的结尾ie，因为还有一个未匹配的X 字符。所以整个模式匹配失败并返回一个 None. MCMLXXXX 不是一个有效的罗马数字。

对于个位数的正则表达式有类似的表达方式，我将省略细节，直接展示结果。

>>> pattern = ‘^M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)(IX|IV|V?I?I?I?)$‘

用另一种 {n,m} 语法表达这个正则表达式会如何呢？这个例子展示新的语法。

例 7.8. 用 {n,m} 语法确认罗马数字

>>> pattern = ‘^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$‘
>>> re.search(pattern, ‘MDLV‘)             
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, ‘MMDCLXVI‘)         
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, ‘MMMDCCCLXXXVIII‘)  
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, ‘I‘)                
<_sre.SRE_Match object at 0x008EEB48>

	这个模式匹配字符串的开始，接着匹配三个可选的 M 字符的一个，接着匹配 D?C{0,3}，此处，仅仅匹配可选的字符 D 和 0 个可选字符 C。继续向前匹配，匹配 L?X{0,3}，此处，匹配可选的 L 字符和 0 个可选字符 X，接着匹配 V?I{0,3}，此处，匹配可选的 V 和 0 个可选字符 I，最后匹配字符串的结尾。MDLV 表示罗马数字 1555。
	这个模式匹配字符串的开始，接着是三个可选的 M 字符的两个，接着匹配 D?C{0,3}，此处为一个字符 D 和三个可选 C 字符中的一个，接着匹配 L?X{0,3}，此处为一个 L 字符和三个可选 X 字符中的一个，接着匹配 V?I{0,3}，此处为一个字符 V 和三个可选 I 字符中的一个，接着匹配字符串的结尾。MMDCLXVI 表示罗马数字 2666。
	这个模式匹配字符串的开始，接着是三个可选的 M 字符的所有字符，接着匹配 D?C{0,3}，此处为一个字符 D 和三个可选 C 字符中所有字符，接着匹配 L?X{0,3}，此处为一个 L 字符和三个可选 X 字符中所有字符，接着匹配 V?I{0,3}，此处为一个字符 V 和三个可选 I 字符中所有字符，接着匹配字符串的结尾。MMMDCCCLXXXVIII 表示罗马数字3888，这个数字是不用扩展语法可以写出的最大的罗马数字。
	仔细看哪！(我像一个魔术师一样，“看仔细喽，孩子们，我将要从我的帽子中拽出一只兔子来啦！”) 这个模式匹配字符串的开始，接着匹配 3 个可选 M 字符的 0 个，接着匹配 D?C{0,3}，此处，跳过可选字符 D 并匹配三个可选 C 字符的 0 个，接着匹配 L?X{0,3}，此处，跳过可选字符 L 并匹配三个可选 X 字符的 0 个，接着匹配 V?I{0,3}，此处跳过可选字符 V 并匹配三个可选 I 字符的一个，最后匹配字符串的结尾。哇赛！

如果你在第一遍就跟上并理解了所讲的这些，那么你做的比我还要好。现在，你可以尝试着理解别人大规模程序里关键函数中的正则表达式了。或者想象着几个月后回头理解你自己的正则表达式。我曾经做过这样的事情，但是它并不是那么有趣。

在下一节里，你将会研究另外一种正则表达式语法，它可以使你的表达式具有更好的可维持性。

7.5. 松散正则表达式

Python 允许用户利用所谓的松散正则表达式 来完成这个任务。一个松散正则表达式和一个紧凑正则表达式主要区别表现在两个方面：

用一个例子可以解释得更清楚。让我们重新来看前面的紧凑正则表达式，利用松散正则表达式重新表达。下面的例子显示实现方法。

例 7.9. 带有内联注释 (Inline Comments) 的正则表达式

>>> pattern = """
    ^                   # beginning of string
    M{0,3}              # thousands - 0 to 3 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.search(pattern, ‘M‘, re.VERBOSE)                
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, ‘MCMLXXXIX‘, re.VERBOSE)        
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, ‘MMMDCCCLXXXVIII‘, re.VERBOSE)  
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, ‘M‘)                            

	当使用松散正则表达式时，最重要的一件事情就是：必须传递一个额外的参数 re.VERBOSE，该参数是定义在 re 模块中的一个常量，标志着待匹配的正则表达式是一个松散正则表达式。正如你看到的，这个模式中，有很多空格 (所有的空格都被忽略)，和几个注释 (所有的注释也被忽略)。如果忽略所有的空格和注释，它就和前面章节里的正则表达式完全相同，但是具有更好的可读性。
	这个模式匹配字符串的开始，接着匹配三个可选 M 字符中的一个，接着匹配 CM，接着是字符 L 和三个可选 X 字符的所有字符，接着是 IX，然后是字符串的结尾。
	这个模式匹配字符串的开始，接着是三个可选的 M 字符的所有字符，接着匹配 D?C{0,3}，此处为一个字符 D 和三个可选 C 字符中所有字符，接着匹配 L?X{0,3}，此处为一个 L 字符和三个可选 X 字符中所有字符，接着匹配 V?I{0,3}，此处为一个字符 V 和三个可选 I 字符中所有字符，接着匹配字符串的结尾。
	这个没有匹配。为什么呢？因为没有 re.VERBOSE 标记，所以 re.search 函数把模式作为一个紧凑正则表达式进行匹配。Python 不能自动检测一个正则表达式是为松散类型还是紧凑类型。Python 默认每一个正则表达式都是紧凑类型的，除非你显式地标明一个正则表达式为松散类型。

7.6. 个案研究：解析电话号码

这个例子来源于我遇到的另一个现实世界的问题，也是在以前的工作中遇到的。问题是：解析一个美国电话号码。客户要能 (在一个单一的区域中) 输入任何数字，然后存储区号、干线号、电话号和一个可选的独立的分机号到公司数据库里。为此，我通过网络找了很多正则表达式的例子，但是没有一个能够完全 满足我的要求。

这里列举了我必须能够接受的电话号码：

格式可真够多的！我需要知道区号是 800，干线号是 555，电话号的其他数字为 1212。对于那些有分机号的，我需要知道分机号为 1234。

让我们完成电话号码解析这个工作，这个例子展示第一步。

例 7.10. 发现数字

>>> phonePattern = re.compile(r‘^(\d{3})-(\d{3})-(\d{4})$‘) 
>>> phonePattern.search(‘800-555-1212‘).groups()            
(‘800‘, ‘555‘, ‘1212‘)
>>> phonePattern.search(‘800-555-1212-1234‘)                
>>> 

	我们通常从左到右阅读正则表达式。这个正则表达式匹配字符串的开始，接着匹配 (\d{3})。\d{3} 是什么呢？好吧，{3} 的含义是“精确匹配三个数字”；这是曾在前面见到过的 {n,m} 语法的一种变形。\d 的含义是 “任何一个数字” (0 到 9)。把它们放大括号中意味着要“精确匹配三个数字位，接着把它们作为一个组保存下来，以便后面的调用”。接着匹配一个连字符，接着是另外一个精确匹配三个数字位的组，接着另外一个连字符，接着另外一个精确匹配四个数字为的组，接着匹配字符串的结尾。
	为了访问正则表达式解析过程中记忆下来的多个组，我们使用 search 函数返回对象的 groups() 函数。这个函数将返回一个元组，元组中的元素就是正则表达式中定义的组。在这个例子中，定义了三个组，第一个组有三个数字位，第二个组有三个数字位，第三个组有四个数字位。
	这个正则表达式不是最终的答案，因为它不能处理在电话号码结尾有分机号的情况，为此，我们需要扩展这个正则表达式。

例 7.11. 发现分机号

>>> phonePattern = re.compile(r‘^(\d{3})-(\d{3})-(\d{4})-(\d+)$‘) 
>>> phonePattern.search(‘800-555-1212-1234‘).groups()             
(‘800‘, ‘555‘, ‘1212‘, ‘1234‘)
>>> phonePattern.search(‘800 555 1212 1234‘)                      
>>> 
>>> phonePattern.search(‘800-555-1212‘)                           
>>> 

	这个正则表达式和上一个几乎相同，正像前面的那样，匹配字符串的开始，接着匹配一个有三个数字位的组并记忆下来，接着是一个连字符，接着是一个有三个数字位的组并记忆下来，接着是一个连字符，接着是一个有四个数字位的组并记忆下来。不同的地方是你接着又匹配了另一个连字符，然后是一个有一个或者多个数字位的组并记忆下来，最后是字符串的结尾。
	函数 groups() 现在返回一个有四个元素的元组，由于正则表达式中定义了四个记忆的组。
	不幸的是，这个正则表达式也不是最终的答案，因为它假设电话号码的不同部分是由连字符分割的。如果一个电话号码是由空格符、逗号或者点号分割呢？你需要一个更一般的解决方案来匹配几种不同的分割类型。
	啊呀！这个正则表达式不仅不能解决你想要的任何问题，反而性能更弱了，因为现在你甚至不能解析一个没有分机号的电话号码了。这根本不是你想要的，如果有分机号，你要知道分机号是什么，如果没有分机号，你仍然想要知道主电话号码的其他部分是什么。

下一个例子展示正则表达式处理一个电话号码内部，采用不同分隔符的情况。

例 7.12. 处理不同分隔符

>>> phonePattern = re.compile(r‘^(\d{3})\D+(\d{3})\D+(\d{4})\D+(\d+)$‘) 
>>> phonePattern.search(‘800 555 1212 1234‘).groups()                   
(‘800‘, ‘555‘, ‘1212‘, ‘1234‘)
>>> phonePattern.search(‘800-555-1212-1234‘).groups()                   
(‘800‘, ‘555‘, ‘1212‘, ‘1234‘)
>>> phonePattern.search(‘80055512121234‘)                               
>>> 
>>> phonePattern.search(‘800-555-1212‘)                                 
>>> 

	当心啦！你首先匹配字符串的开始，接着是一个三个数字位的组，接着是 \D+，这是个什么东西？好吧，\D 匹配任意字符，除了 数字位，+ 表示“1 个或者多个”，因此 \D+ 匹配一个或者多个不是数字位的字符。这就是你替换连字符为了匹配不同分隔符所用的方法。
	使用 \D+ 代替 - 意味着现在你可以匹配中间是空格符分割的电话号码了。
	当然，用连字符分割的电话号码也能够被识别。
	不幸的是，这个正则表达式仍然不是最终答案，因为它假设电话号码一定有分隔符。如果电话号码中间没有空格符或者连字符的情况会怎样哪？
	我的天！这个正则表达式也没有达到我们对于分机号识别的要求。现在你共有两个问题，但是你可以利用相同的技术来解决它们。

下一个例子展示正则表达式处理没有 分隔符的电话号码的情况。

例 7.13. 处理没有分隔符的数字

>>> phonePattern = re.compile(r‘^(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$‘) 
>>> phonePattern.search(‘80055512121234‘).groups()                      
(‘800‘, ‘555‘, ‘1212‘, ‘1234‘)
>>> phonePattern.search(‘800.555.1212 x1234‘).groups()                  
(‘800‘, ‘555‘, ‘1212‘, ‘1234‘)
>>> phonePattern.search(‘800-555-1212‘).groups()                        
(‘800‘, ‘555‘, ‘1212‘, ‘‘)
>>> phonePattern.search(‘(800)5551212 x1234‘)                           
>>> 

	和上一步相比，你所做的唯一变化就是把所有的 + 变成 *。在电话号码的不同部分之间不再匹配 \D+，而是匹配 \D* 了。还记得 + 的含义是“1 或者多个”吗? 好的，* 的含义是“0 或者多个”。因此，现在你应该能够解析没有分隔符的电话号码了。
	你瞧，它真的可以胜任。为什么？首先匹配字符串的开始，接着是一个有三个数字位 (800) 的组，接着是 0 个非数字字符，接着是一个有三个数字位 (555) 的组，接着是 0 个非数字字符，接着是一个有四个数字位 (1212) 的组，接着是 0 个非数字字符，接着是一个有任意数字位 (1234) 的组，最后是字符串的结尾。
	对于其他的变化也能够匹配：比如点号分隔符，在分机号前面既有空格符又有 x 符号的情况也能够匹配。
	最后，你已经解决了长期存在的一个问题：现在分机号是可选的了。如果没有发现分机号，groups() 函数仍然返回一个有四个元素的元组，但是第四个元素只是一个空字符串。
	我不喜欢做一个坏消息的传递人，此时你还没有完全结束这个问题。还有什么问题呢？当在区号前面还有一个额外的字符时，而正则表达式假设区号是一个字符串的开始，因此不能匹配。这个不是问题，你可以利用相同的技术“0或者多个非数字字符”来跳过区号前面的字符。

下一个例子展示如何解决电话号码前面有其他字符的情况。

例 7.14. 处理开始字符

>>> phonePattern = re.compile(r‘^\D*(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$‘) 
>>> phonePattern.search(‘(800)5551212 ext. 1234‘).groups()                 
(‘800‘, ‘555‘, ‘1212‘, ‘1234‘)
>>> phonePattern.search(‘800-555-1212‘).groups()                           
(‘800‘, ‘555‘, ‘1212‘, ‘‘)
>>> phonePattern.search(‘work 1-(800) 555.1212 #1234‘)                     
>>> 

	这个正则表达式和前面的几乎相同，但它在第一个记忆组 (区号) 前面匹配 \D*，0 或者多个非数字字符。注意，此处你没有记忆这些非数字字符 (它们没有被括号括起来)。如果你发现它们，只是跳过它们，接着只要匹配上就开始记忆区号。
	你可以成功地解析电话号码，即使在区号前面有一个左括号。(在区号后面的右括号也已经被处理，它被看成非数字字符分隔符，由第一个记忆组后面的 \D* 匹配。)
	进行仔细的检查，保证你没有破坏前面能够匹配的任何情况。由于首字符是完全可选的，这个模式匹配字符串的开始，接着是 0 个非数字字符，接着是一个有三个数字字符的记忆组 (800)，接着是 1 个非数字字符 (连字符)，接着是一个有三个数字字符的记忆组 (555)，接着是 1 个非数字字符 (连字符)，接着是一个有四个数字字符的记忆组 (1212)，接着是 0 个非数字字符，接着是一个有 0 个数字位的记忆组，最后是字符串的结尾。
	此处是正则表达式让我产生了找一个硬东西挖出自己的眼睛的冲动。为什么这个电话号码没有匹配上？因为在它的区号前面有一个 1，但是你认为在区号前面的所有字符都是非数字字符 (\D*)。唉！

让我们往回看一下。迄今为止，正则表达式总是从一个字符串的开始匹配。但是现在你看到了，有很多不确定的情况需要你忽略。与其尽力全部匹配它们，还不如全部跳过它们，让我们采用一个不同的方法：根本不显式地匹配字符串的开始。下面的这个例子展示这个方法。

例 7.15. 电话号码，无论何时我都要找到它

>>> phonePattern = re.compile(r‘(\d{3})\D*(\d{3})\D*(\d{4})\D*(\d*)$‘) 
>>> phonePattern.search(‘work 1-(800) 555.1212 #1234‘).groups()        
(‘800‘, ‘555‘, ‘1212‘, ‘1234‘)
>>> phonePattern.search(‘800-555-1212‘)                                
(‘800‘, ‘555‘, ‘1212‘, ‘‘)
>>> phonePattern.search(‘80055512121234‘)                              
(‘800‘, ‘555‘, ‘1212‘, ‘1234‘)

	注意，在这个正则表达式的开始少了一个 ^ 字符。你不再匹配字符串的开始了，也就是说，你需要用你的正则表达式匹配整个输入字符串，除此之外没有别的意思了。正则表达式引擎将要努力计算出开始匹配输入字符串的位置，并且从这个位置开始匹配。
	现在你可以成功解析一个电话号码了，无论这个电话号码的首字符是不是数字，无论在电话号码各部分之间有多少任意类型的分隔符。
	仔细检查，这个正则表达式仍然工作的很好。
	还是能够工作。

看看一个正则表达式能够失控得多快？回头看看前面的例子，你还能区别它们么？

当你还能够理解这个最终答案的时候 (这个正则表达式就是最终答案，即使你发现一种它不能处理的情况，我也真的不想知道它了)，在你忘记为什么你这么选择之前，让我们把它写成松散正则表达式的形式。

例 7.16. 解析电话号码 (最终版本)

>>> phonePattern = re.compile(r‘‘‘
                # don‘t match beginning of string, number can start anywhere
    (\d{3})     # area code is 3 digits (e.g. ‘800‘)
    \D*         # optional separator is any number of non-digits
    (\d{3})     # trunk is 3 digits (e.g. ‘555‘)
    \D*         # optional separator
    (\d{4})     # rest of number is 4 digits (e.g. ‘1212‘)
    \D*         # optional separator
    (\d*)       # extension is optional and can be any number of digits
    $           # end of string
    ‘‘‘, re.VERBOSE)
>>> phonePattern.search(‘work 1-(800) 555.1212 #1234‘).groups()        
(‘800‘, ‘555‘, ‘1212‘, ‘1234‘)
>>> phonePattern.search(‘800-555-1212‘)                                
(‘800‘, ‘555‘, ‘1212‘, ‘‘)

	除了被分成多行，这个正则表达式和最后一步的那个完全相同，因此它能够解析相同的输入一点也不奇怪。
	进行最后的仔细检查。很好，仍然工作。你终于完成了这件任务。