Python 研究(Dive Into Python)

lastwinner

7.4. 使用{n,m} 语法
7.4.1. 校验十位数和个位数
在 前面的章节,你处理了相同字符可以重复三次的情况，在正则表达式中有另外一个方式来表达这种情况，并且使代码的可读性更好。首先来看我们在前面的例子中使用的方法。

例 7.5. 老方法：每一个字符都是可选的
>>> import re
>>> pattern = '^M?M?M?$'
>>> re.search(pattern, 'M')   
<_sre.SRE_Match object at 0x008EE090>
>>> pattern = '^M?M?M?$'
>>> re.search(pattern, 'MM')   
<_sre.SRE_Match object at 0x008EEB48>
>>> pattern = '^M?M?M?$'
>>> re.search(pattern, 'MMM')  
<_sre.SRE_Match object at 0x008EE090>
>>> re.search(pattern, 'MMMM')
>>>
  这个模式匹配串的开始，接着是第一个可选的字符M, 第二第三个M字符则被忽略，(这是可行的因为它们都是可选的),最后是字符串的结尾。
  这个模式匹配串的开始，接着是第一和第二个可选字符M ，而第三个M 字符被忽略(这是可行的因为它们都是可选的)，最后匹配字符串的结尾。
  这个模式匹配字符串的开始，接着匹配所有的三个可选字符 M, 最后匹配字符串的结尾。
  这个模式匹配字符串的开始，接着匹配所有的三个可选字符M，但是不能够匹配字符串的结尾(因为还有一个未匹配的字符M)，因此不能够匹配而返回一个None.

lastwinner

例 7.6. 一个新的方法：From n to m
>>> pattern = '^M{0,3}$'      
>>> re.search(pattern, 'M')   
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'MM')   
<_sre.SRE_Match object at 0x008EE090>
>>> re.search(pattern, 'MMM')  
<_sre.SRE_Match object at 0x008EEDA8>
>>> re.search(pattern, 'MMMM')
>>>
  这个模式意识是说：“匹配字符串的开始，接着匹配0到3个M字符，然后匹配字符串的结尾。” 可是是0到3之间的任何数字，如果你想要匹配至少1次，至多3次字符M，则可以写成 M{1,3}。
  这个模式匹配字符串的开始，接着匹配三个可选M字符中的一个，最后是字符串的结尾。
  这个模式匹配字符串的开始，接着匹配三个可选M字符中的两个，最后是字符串的结尾。
  这个模式匹配字符串的开始，接着匹配三个可选M字符中的三个，最后是字符串的结尾。
  这个模式匹配字符串的开始，接着匹配三个可选M字符中的三个，但是没有匹配字符串的结尾。正则表达式在字符串结尾之前最多只允许批评三次M字符，但是实际上有四个 M字符，因此模式没有匹配上这个字符串，返回一个None.


没有一个轻松的方法来确定两个正则表达式是否为等价的，你能采用的最好的办法就是列出很多的测试样例，确定这两个正则表达式对所有的相关输入都有相同的输出。在本书后面的章节，关于如何书写测试样例有更多的讨论。

lastwinner

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

例 7.7. 校验十位数
>>> pattern = '^M?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 不是一个有效的罗马数字。

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

>>> pattern = '^M?M?M?M?(CM|CD|D?C?C?C?)(XC|XL|L?X?X?X?)(IX|IV|V?I?I?I?)$'
用另一种{n,m}语法表达这个正则表达式会如何呢？这个例子展示新的语法。

lastwinner

例 7.8. 用{n,m}语法确认罗马数字
>>> pattern = '^M{0,4}(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, 'MMMMDCCCLXXXVIII')
<_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字符中所有字符，接着匹配字符串的结尾。MMMMDCCCLXXXVIII 表示罗马数字3888, 这个数字是不用扩展语法可以写出的最大的罗马数字。
  仔细看哪！(我象一个魔术师一样，“看仔细喽，孩子们，我将要从我的帽子中拽出一只兔子来啦！”) 这个模式匹配字符串的开始，接着匹配4个可选M字符的0个，接着匹配D?C{0,3}，此处，跳过可选字符D并匹配三个可选C字符的0个，接着匹配L?X{0,3}，此处，跳过可选字符L并匹配三个可选 X字符的0个，接着匹配V?I{0,3}，此处跳过可选字符 V并且匹配三个可选I字符的一个，最后匹配字符串的结尾。哇赛！


本章译者注：这个例子在正则表达式的匹配上没有问题，但是对于罗马数字的表示办法本身似乎有点问题，代表千位数的字符M，根据规定最多只能重复3次，但是在这个例子中重复了4次，但是这个罗马数字最后又表示3888，此处矛盾。不过，我们是为了搞清楚正则表达式的用法，罗马数字的表示法不是重点，因此从这个角度，这个例子没有问题。因此，在翻译的过程中保持了原文，大家在理解的时候需要注意一下这里。

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

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

lastwinner

7.5. 松散正则表达式
迄今为止，你只是处理过被我称之为“紧凑”类型的正则表达式。正如你曾看到的，它们难以阅读，即使你清楚正则表达式的含义，你也不能保证六个月以后你还能理解它。你真正所需的就是利用内联文档（inline documentation）。

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

忽略空白符。空格符，制表符，回车符不匹配它们自身，他们根本不参与匹配。(如果你想在松散正则表达式中匹配一个空格符，你必须在它前面添加一个反斜线符号对他进行转义)
忽略注释。在松散正则表达式中的注释和在普通Python代码中的一样：开始于一个#符号，结束于行尾。这种情况下，采用在一个多行字符串中注释，而不是在源代码中注释，他们以相同的方式工作。
用一个例子可以解释的更清楚。让我们重新来看前面的紧凑正则表达式，利用松散正则表达式重新表达。下面的例子显示实现方法。

lastwinner

例 7.9. 带有内联注释(Inline Comments)的正则表达式
>>> pattern = """
    ^                   # 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.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, 'MMMMDCCCLXXXVIII', re.VERBOSE)
<_sre.SRE_Match object at 0x008EEB48>
>>> re.search(pattern, 'M')                           
  当使用松散正则表达式是，请记住最重要的一件事情就是：必须传递另外一个参数re.VERBOSE，该参数是定义在re 模块中的一个常量，标志着待匹配的正则表达式是一个松散正则表达式。正如你看到的，这个模式中，有很多空格（所有的空格都被忽略），和几个注释（所有的注释也被忽略）。一旦你忽略所有的空格和注释，就和前面章节里的正则表达式完全相同，但是它具有更好的可读性。
  这个模式匹配字符串的开始，接着匹配四个可选M字符中的一个，接着匹配CM, 接着是字符L和三个可选X字符的所有字符，接着是IX，然后是字符串的结尾ie。
  这个模式匹配字符串的开始，接着是四个可选的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 默认每一个正则表达式都是紧凑类型的，除非你显式的标明一个正则表达式为松散类型。

lastwinner

7.6. 个案研究: 解析电话号码
迄今为止，你主要是匹配整个模式，不论是匹配上，还是没有匹配上。但是正则表达式还有比这更为强大的功能。当一个模式确实匹配上时，你可以获取模式中特定的片断，你可以发现具体匹配的位置。
这个例子来源于我遇到的另一个现实世界的问题，也是在以前的工作中遇到的。问题是：解析一个美国电话号码。客户要能（在一个单一的区域中）输入任何数字，然后存储区号，干线号，电话号和一个可选的独立的分机号到公司数据库里。为此，我通过网络找了很多正则表达式的例子，但是没有一个能够完全满足我的要求。
这里列举了我必须能够接受的电话号码:

• 800-555-1212
• 800 555 1212
• 800.555.1212
• (800) 555-1212
• 1-800-555-1212
• 800-555-1212-1234
• 800-555-1212x1234
• 800-555-1212 ext. 1234
• work 1-(800) 555.1212 #1234

格式可真够多的！我需要知道区号是800，干线号是555，电话号的其他数字为1212。对于那些有分机好的，我需要知道分机号我为 1234.
让我们完成电话号码解析这个工作，这个例子展示第一步。

lastwinner

例 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()函数。这个函数将返回一个元组，元组中的元素就是正则表达式中定义的组。在这个例子中，定义了三个组，第一个组有三个数字位，第二个组有三个数字位，第三个组有四个数字位。
  这个正则表达式不是最终的答案，因为它不能处理在电话号码结尾有分机号的情况，为此，我们需要扩展这个正则表达式。

lastwinner

例 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()现在返回一个有四个元素的元组，由于正则表达式中定义了四个记忆的组。
  不幸的是，这个正则表达式也不是最终的答案，因为它假设电话号码的不同部分是由连字符分割的。如果一个电话号码是由空格符、逗号或者点号分割呢？你需要一个更一般的解决方案来匹配几种不同的分割类型。
  啊呀！这个正则表达式不仅不能解决你想要的任何问题，反而性能更弱了，因为现在你甚至不能解析一个没有分机号的电话号码了。这根本不是你想要的，如果有分机号，你要知道分机号是什么，如果没有分机号，你仍然想要知道主电话号码的其他部分是什么。

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

lastwinner

例 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+ 代替-意味着现在你可以匹配中间是空格符分割的电话号码了。
  当然，用连字符分割的电话号码也能够被识别。
  不幸的是，这个正则表达式仍然不是最终答案，因为他假设电话号码一定有分隔符。如果电话号码中间没有空格符或者连字符的情况会怎样哪？
  我的天！这个正则表达式也没有达到我们对于分机号识别的要求。现在你共有两个问题，但是你可以利用相同的技术来解决他们。

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