Python 研究(Dive Into Python)

lastwinner

例 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或者多个非数字字符”来跳过区号前面的字符。

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

lastwinner

例 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*)。 Aargh.

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

lastwinner

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

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

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

lastwinner

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

lastwinner

关于正则表达式的进一步阅读

• Regular Expression HOWTO 讲解正则表达式和如何在Python中使用正则表达式。
• Python Library Reference 概述了re module.

lastwinner

7.7. 小结
这只是正则表达式能够完成工作的很少一部分。换句话说，即使你现在备受打击，相信我，你也不是什么也没见过了。
现在，你应该熟悉下列技巧：

• ^ 匹配字符串的开始。
• $ 匹配字符串的结尾。
• \b 匹配一个单词的边界。
• \d 匹配任意数字。
• \D 匹配任意非数字字符。
• x? 匹配一个可选的x字符（换句话说，它匹配1次或者0次x 字符）。
• x* 匹配0次或者多次x字符。
• x+匹配1次或者多次x字符。
• x{n,m} 匹配x字符，至少n次，至多m次。
• (a|b|c)要么匹配a，要么匹配b，要么匹配c。
• (x) 一般情况下表示一个记忆组(remembered group). 你可以利用re.search函数返回对象的groups()函数获取它的值。

正则表达式非常强大，但是它并不能为每一个问题提供正确的解决方案。你应该学习足够多的知识，以辨别什么时候他们是合适的，什么时候他们会解决你的问题，什么时候他们产生的问题比要解决的问题还要多。

一些人，当遇到一个问题时，想“我知道，我将使用正则表达式。” 现在他有两个问题了。

--Jamie Zawinski, in comp.emacs.xemacs

lastwinner

第 8 章 HTML 处理
8.1. 概览
8.2. sgmllib.py 介绍
8.3. 从 HTML 文档中提取数据
8.4. BaseHTMLProcessor.py 介绍
8.5. locals 和 globals
8.6. 基于 dictionary 的字符串格式化
8.7. 给属性值加引号
8.8. dialect.py 介绍
8.9. 全部放在一起
8.10. 小结

lastwinner

8.1. 概览
我经常在 comp.lang.python 上看到关于如下的问题: “ 怎么才能从我的 HTML 文档中列出所有的 [头|图像|链接] 呢？” “怎么才能 [分析|解释|munge] 我的 HTML 文档的文本，但是不要标记呢？” “怎么才能一次给我所有的 HTML 标记 [增加|删除|加引号] 属性呢？” 本章将回答所有这些问题。

下面给出一个完整的，可工作的 Python 程序，它分为两部分。第一部分，BaseHTMLProcessor.py 是一个通用工具，它可以通过扫描标记和文本块来帮助您处理 HTML 文件。第二部分，dialect.py 是一个例子，演示了如何使用 BaseHTMLProcessor.py 来转化 HTML 文档，保留文本但是去掉了标记。阅读文档字符串 (doc string) 和注释来了解将要发生事情的概况。大部分内容看上去象巫术，因为任一个这些类的方法是如何调用的不是很清楚。不要紧，所有内容都会按进度被逐步地展示出来。

lastwinner

例 8.1. BaseHTMLProcessor.py
如果您还没有下载本书附带的例子程序, 可以 下载本程序和其他例子程序。


from sgmllib import SGMLParser
import htmlentitydefs

class BaseHTMLProcessor(SGMLParser):
    def reset(self):                       
        # extend (called by SGMLParser.__init__)
        self.pieces = []
        SGMLParser.reset(self)

    def unknown_starttag(self, tag, attrs):
        # called for each start tag
        # attrs is a list of (attr, value) tuples
        # e.g. for <pre class="screen">, tag="pre", attrs=[("class", "screen"]
        # Ideally we would like to reconstruct original tag and attributes, but
        # we may end up quoting attribute values that weren't quoted in the source
        # document, or we may change the type of quotes around the attribute value
        # (single to double quotes).
        # Note that improperly embedded non-HTML code (like client-side Javascript)
        # may be parsed incorrectly by the ancestor, causing runtime script errors.
        # All non-HTML code must be enclosed in HTML comment tags (<!-- code -->
        # to ensure that it will pass through this parser unaltered (in handle_comment).
        strattrs = "".join([' %s="%s"' % (key, value) for key, value in attrs])
        self.pieces.append("<%(tag)s%(strattrs)s>" % locals())

    def unknown_endtag(self, tag):         
        # called for each end tag, e.g. for </pre>, tag will be "pre"
        # Reconstruct the original end tag.
        self.pieces.append("</%(tag)s>" % locals())

    def handle_charref(self, ref):         
        # called for each character reference, e.g. for " ", ref will be "160"
        # Reconstruct the original character reference.
        self.pieces.append("&#%(ref)s;" % locals())

    def handle_entityref(self, ref):      
        # called for each entity reference, e.g. for "&copy;", ref will be "copy"
        # Reconstruct the original entity reference.
        self.pieces.append("&%(ref)s" % locals())
        # standard HTML entities are closed with a semicolon; other entities are not
        if htmlentitydefs.entitydefs.has_key(ref):
            self.pieces.append(";"

    def handle_data(self, text):           
        # called for each block of plain text, i.e. outside of any tag and
        # not containing any character or entity references
        # Store the original text verbatim.
        self.pieces.append(text)

    def handle_comment(self, text):        
        # called for each HTML comment, e.g. <!-- insert Javascript code here -->
        # Reconstruct the original comment.
        # It is especially important that the source document enclose client-side
        # code (like Javascript) within comments so it can pass through this
        # processor undisturbed; see comments in unknown_starttag for details.
        self.pieces.append("<!--%(text)s-->" % locals())

    def handle_pi(self, text):            
        # called for each processing instruction, e.g. <?instruction>
        # Reconstruct original processing instruction.
        self.pieces.append("<?%(text)s>" % locals())

    def handle_decl(self, text):
        # called for the DOCTYPE, if present, e.g.
        # <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
        #     "http://www.w3.org/TR/html4/loose.dtd">
        # Reconstruct original DOCTYPE
        self.pieces.append("<!%(text)s>" % locals())

    def output(self):              
        """Return processed HTML as a single string"""
        return "".join(self.pieces)

lastwinner

例 8.2. dialect.py

import re
from BaseHTMLProcessor import BaseHTMLProcessor

class Dialectizer(BaseHTMLProcessor):
    subs = ()

    def reset(self):
        # extend (called from __init__ in ancestor)
        # Reset all data attributes
        self.verbatim = 0
        BaseHTMLProcessor.reset(self)

    def start_pre(self, attrs):            
        # called for every <pre> tag in HTML source
        # Increment verbatim mode count, then handle tag like normal
        self.verbatim += 1                 
        self.unknown_starttag("pre", attrs)

    def end_pre(self):                     
        # called for every </pre> tag in HTML source
        # Decrement verbatim mode count
        self.unknown_endtag("pre"         
        self.verbatim -= 1                 

    def handle_data(self, text):                                       
        # override
        # called for every block of text in HTML source
        # If in verbatim mode, save text unaltered;
        # otherwise process the text with a series of substitutions
        self.pieces.append(self.verbatim and text or self.process(text))

    def process(self, text):
        # called from handle_data
        # Process text block by performing series of regular expression
        # substitutions (actual substitions are defined in descendant)
        for fromPattern, toPattern in self.subs:
            text = re.sub(fromPattern, toPattern, text)
        return text

class ChefDialectizer(Dialectizer):
    """convert HTML to Swedish Chef-speak
   
    based on the classic chef.x, copyright (c) 1992, 1993 John Hagerman
    """
    subs = ((r'a([nu])', r'u\1'),
            (r'A([nu])', r'U\1'),
            (r'a\B', r'e'),
            (r'A\B', r'E'),
            (r'en\b', r'ee'),
            (r'\Bew', r'oo'),
            (r'\Be\b', r'e-a'),
            (r'\be', r'i'),
            (r'\bE', r'I'),
            (r'\Bf', r'ff'),
            (r'\Bir', r'ur'),
            (r'(\w*?)i(\w*?)$', r'\1ee\2'),
            (r'\bow', r'oo'),
            (r'\bo', r'oo'),
            (r'\bO', r'Oo'),
            (r'the', r'zee'),
            (r'The', r'Zee'),
            (r'th\b', r't'),
            (r'\Btion', r'shun'),
            (r'\Bu', r'oo'),
            (r'\BU', r'Oo'),
            (r'v', r'f'),
            (r'V', r'F'),
            (r'w', r'w'),
            (r'W', r'W'),
            (r'([a-z])[.]', r'\1.  Bork Bork Bork!'))

class FuddDialectizer(Dialectizer):
    """convert HTML to Elmer Fudd-speak"""
    subs = ((r'[rl]', r'w'),
            (r'qu', r'qw'),
            (r'th\b', r'f'),
            (r'th', r'd'),
            (r'n[.]', r'n, uh-hah-hah-hah.'))

class OldeDialectizer(Dialectizer):
    """convert HTML to mock Middle English"""
    subs = ((r'i([bcdfghjklmnpqrstvwxyz])e\b', r'y\1'),
            (r'i([bcdfghjklmnpqrstvwxyz])e', r'y\1\1e'),
            (r'ick\b', r'yk'),
            (r'ia([bcdfghjklmnpqrstvwxyz])', r'e\1e'),
            (r'e[ea]([bcdfghjklmnpqrstvwxyz])', r'e\1e'),
            (r'([bcdfghjklmnpqrstvwxyz])y', r'\1ee'),
            (r'([bcdfghjklmnpqrstvwxyz])er', r'\1re'),
            (r'([aeiou])re\b', r'\1r'),
            (r'ia([bcdfghjklmnpqrstvwxyz])', r'i\1e'),
            (r'tion\b', r'cioun'),
            (r'ion\b', r'ioun'),
            (r'aid', r'ayde'),
            (r'ai', r'ey'),
            (r'ay\b', r'y'),
            (r'ay', r'ey'),
            (r'ant', r'aunt'),
            (r'ea', r'ee'),
            (r'oa', r'oo'),
            (r'ue', r'e'),
            (r'oe', r'o'),
            (r'ou', r'ow'),
            (r'ow', r'ou'),
            (r'\bhe', r'hi'),
            (r've\b', r'veth'),
            (r'se\b', r'e'),
            (r"'s\b", r'es'),
            (r'ic\b', r'ick'),
            (r'ics\b', r'icc'),
            (r'ical\b', r'ick'),
            (r'tle\b', r'til'),
            (r'll\b', r'l'),
            (r'ould\b', r'olde'),
            (r'own\b', r'oune'),
            (r'un\b', r'onne'),
            (r'rry\b', r'rye'),
            (r'est\b', r'este'),
            (r'pt\b', r'pte'),
            (r'th\b', r'the'),
            (r'ch\b', r'che'),
            (r'ss\b', r'sse'),
            (r'([wybdp])\b', r'\1e'),
            (r'([rnt])\b', r'\1\1e'),
            (r'from', r'fro'),
            (r'when', r'whan'))

def translate(url, dialectName="chef":
    """fetch URL and translate using dialect
   
    dialect in ("chef", "fudd", "olde""""
    import urllib                     
    sock = urllib.urlopen(url)         
    htmlSource = sock.read()           
    sock.close()                       
    parserName = "%sDialectizer" % dialectName.capitalize()
    parserClass = globals()[parserName]                    
    parser = parserClass()                                 
    parser.feed(htmlSource)
    parser.close()         
    return parser.output()

def test(url):
    """test all dialects against URL"""
    for dialect in ("chef", "fudd", "olde":
        outfile = "%s.html" % dialect
        fsock = open(outfile, "wb"
        fsock.write(translate(url, dialect))
        fsock.close()
        import webbrowser
        webbrowser.open_new(outfile)

if __name__ == "__main__":
    test("http://diveintopython.org/odbchelper_list.html"