Python 研究(Dive Into Python)

lastwinner

9.7. Segue
OK，that's it for the hard-core XML stuff. 下一章将继续使用相同的示例程序，但是焦点在于能使程序更加灵活的其它方面：使用输入流处理，使用 getattr 进行方法分发，并使用命令行标识允许用户重新配置程序而无需修改代码。

在进入下一章前，你应该没有困难的完成这些事情：

使用 minidom 解析 XML 文档 ，搜索已解析文档，并以任意顺序访问元素属性和元素子元素
将复杂的库组织为包
将unicode字符串转换为不同的字符编码

lastwinner

第 10 章 Scripts 和 Streams
10.1. 抽象输入源
10.2. 标准输入、输出和错误
10.3. 缓冲节点查询
10.4. 查找节点的直接子节点
10.5. 通过节点类型创建独立的处理句柄 Creating separate handlers by node type
10.6. 处理命令行参数
10.7. 全部放在一起
10.8. 小结
10.1. 抽象输入源
Python 的最强大力量之一是它的动态绑定，并且动态绑定最强大的用法之一是类文件(file-like)对象。

许多需要输入源的函数可以只接收一个文件名，并以读方式打开文件，读取文件，处理完成后关闭它。其实它们不是这样的，而是接收一个类文件对象。

在最简单的例子中，类文件对象是任意一个带有 read 方法的对象，这个方法带有一个可选的size参数，并返回一个字符串。调用时如果没有size参数，它从输入源中读取所有东西并将所有数据作为单个字符串返回。调用时如果指定了size参数，它将从输入源中读取size大小的数据并返回这些数据；再次调用的时候，它从余下的地方开始并返回下一块数据。

这就是从真实文件读取数据的工作方式；区别在于你不用把自己局限于真实的文件。输入源可以是任何东西：磁盘上的文件，甚至是一个硬编码的字符串。只要你将一个类文件对象传递给函数，函数只是调用对象的 read 方法，函数可以处理任何类型的输入源，而不需要处理每种类型的特定代码。

你可能纳闷过这和 XML 处理有什么关系，其实 minidom.parse 就是一个可以接收类文件对象的函数。

例 10.1. 从文件中解析 XML
>>> from xml.dom import minidom
>>> fsock = open('binary.xml')   
>>> xmldoc = minidom.parse(fsock)
>>> fsock.close()                 
>>> print xmldoc.toxml()         
<?xml version="1.0" ?>
<grammar>
<ref id="bit">
  <p>0</p>
  <p>1</p>
</ref>
<ref id="byte">
  <p><xref id="bit"/><xref id="bit"/><xref id="bit"/><xref id="bit"/>\
<xref id="bit"/><xref id="bit"/><xref id="bit"/><xref id="bit"/></p>
</ref>
</grammar>  首先，你要打开一个磁盘上的文件。这会提供给你一个文件对象。
  将文件对象传递给 minidom.parse ，它调用fsock的 read 方法并从磁盘上的文件读取 XML 文档。
  确保处理完成文件后调用 close 方法。minidom.parse不会替你做这件事。
  在返回的 XML 文档上调用toxml()方法，打印出整个文档的内容。

哦，所有这些看上去象是在浪费大量的时间。毕竟，你已经看过 minidom.parse 可以只接收文件名，并自动执行所有打开文件和关闭无用文件的行为。不错，如果你知道正要解析的是一个本地文件，你可以传递文件名而且 minidom.parse 可以足够聪明的做正确的事情™，这一切都不会有问题。但是请注意，使用类文件分析直接从Internet上来的 XML 文档是多么相似和容易的事情！

lastwinner

例 10.2. 解析来自 URL 的 XML
>>> import urllib
>>> usock = urllib.urlopen('http://slashdot.org/slashdot.rdf')
>>> xmldoc = minidom.parse(usock)                              
>>> usock.close()                                             
>>> print xmldoc.toxml()                                       
<?xml version="1.0" ?>
<rdf:RDF xmlns="http://my.netscape.com/rdf/simple/0.9/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">

<channel>
<title>Slashdot</title>
<link>http://slashdot.org/</link>
<description>News for nerds, stuff that matters</description>
</channel>

<image>
<title>Slashdot</title>
<url>http://images.slashdot.org/topics/topicslashdot.gif</url>
<link>http://slashdot.org/</link>
</image>

<item>
<title>To HDTV or Not to HDTV?</title>
<link>http://slashdot.org/article.pl?sid=01/12/28/0421241</link>
</item>

[...snip...]  如前一章，urlopen 接收一个web页面的 URL 作为参数并返回一个类文件对象。最重要的是，这个对象有一个 read 方法可以返回web页面的 HTML 源代码。
  现在把类文件对象传递给 minidom.parse ，它顺从地调用对象的 read 方法并解析 read 方法返回的 XML 数据。这与 XML 数据现在直接来源于web页面的事实毫不相干。minidom.parse 并不知道web页面，它也不关心web页面；它只知道类文件对象。
  到这里已经处理完毕了，确保将 urlopen 提供给你的类文件对象关闭。
  顺便提一句，这个 URL 是真实的，它真的是一个 XML。它是Slashdot站点（这是一个技术新闻和随笔站点）上当前标题的 XML 表示。

例 10.3. 解析字符串 XML (容易但不灵活的方式)
>>> contents = "<grammar><ref id='bit'><p>0</p><p>1</p></ref></grammar>"
>>> xmldoc = minidom.parseString(contents)
>>> print xmldoc.toxml()
<?xml version="1.0" ?>
<grammar><ref id="bit"><p>0</p><p>1</p></ref></grammar>  minidom 有一个方法，parseString，它接收一个字符串形式的完整 XML 文档作为参数并解析这个参数。如果你已经将整个 XML 文档放入一个字符串，你可以使用它代替minidom.parse。

OK，所以你可以使用 minidom.parse 函数来解析本地文件和远端 URL，但对于解析字符串，你使用...一个不同的函数。这就是说，你要从文件，URL 或者字符串接收输入，你需要特别的逻辑来判断参数是否是字符串，然后调用 parseString。多不让人满意。

如果有一个方法可以把字符串转换成类文件对象，那么你可以只把这个对象传递给 minidom.parse 就可以了。事实上，有一个模块专门设计用来做这件事：StringIO。

lastwinner

例 10.4. StringIO 介绍
>>> contents = "<grammar><ref id='bit'><p>0</p><p>1</p></ref></grammar>"
>>> import StringIO
>>> ssock = StringIO.StringIO(contents)   
>>> ssock.read()                          
"<grammar><ref id='bit'><p>0</p><p>1</p></ref></grammar>"
>>> ssock.read()                          
''
>>> ssock.seek(0)                        
>>> ssock.read(15)                        
'<grammar><ref i'
>>> ssock.read(15)
"d='bit'><p>0</p"
>>> ssock.read()
'><p>1</p></ref></grammar>'
>>> ssock.close()                           StringIO 模块只包含了单个类，也叫 StringIO，它允许你将一个字符串转换为一个类文件对象。这个 StringIO 类在创建实例的时候接收字符串作为参数。
  现在你有了一个类文件对象，你可用它做类文件的所有事情。比如 read 可以返回原始字符串。
  再次调用 read 返回空字符串。真实文件对象的工作方式也是这样的；一旦你读取了整个文件，如果不显式定位到文件的开始位置，就不可能读取到任何其他数据。StringIO 对象以相同的方式进行工作。
  使用 StringIO 对象的 seek 方法，你可以显式的定位到字符串的开始位置，就像在文件中定位一样。
  将一个size参数传递给 read 方法，你还可以以块的形式读取字符串。
  任何时候，read 都将返回字符串的未读剩余部分。所有这些严格地按文件对象的方式工作；，这就是术语类文件对象的来历。

例 10.5. 解析字符串 XML （类文件对象方式）
>>> contents = "<grammar><ref id='bit'><p>0</p><p>1</p></ref></grammar>"
>>> ssock = StringIO.StringIO(contents)
>>> xmldoc = minidom.parse(ssock)
>>> ssock.close()
>>> print xmldoc.toxml()
<?xml version="1.0" ?>
<grammar><ref id="bit"><p>0</p><p>1</p></ref></grammar>  现在你可以把类文件对象（实际是一个 StringIO）传递给 minidom.parse，它将调用对象的 read 方法并高兴的开始解析，绝不会知道它的输入源源自一个硬编码的字符串。

那么现在你知道了如何使用单个函数，minidom.parse，来解析一个保存在web页面上，本地文件中或硬编码字符串中的 XML 文档。对于一个web页面，使用 urlopen 得到类文件对象；对于本地文件，使用 open ；对于字符串，使用 StringIO。现在让我们进一步并总结一下这些 不同。

lastwinner

例 10.6. openAnything

def openAnything(source):                  
    # try to open with urllib (if source is http, ftp, or file URL)
    import urllib                        
    try:                                 
        return urllib.urlopen(source)      
    except (IOError, OSError):            
        pass                              

    # try to open with native open function (if source is pathname)
    try:                                 
        return open(source)               
    except (IOError, OSError):            
        pass                              

    # treat source as string
    import StringIO                       
    return StringIO.StringIO(str(source))    openAnything 函数接收单个参数，source，并返回类文件对象。source是某种类型的字符串；它可能是一个 URL （例如'http://slashdot.org/slashdot.rdf'），一个本地文件的完整或者部分路径名（例如'binary.xml'），或者是一个包含了需要解析 XML 数据的字符串。
  首先，查看source是否是一个 URL 。这里通过强制方式进行：尝试把它当作一个 URL 打开并静静地忽略打开非 URL 引起的错误。感觉上这样做非常好，如果 urllib 将来支持更多的 URL 类型，不用重新编码就可以支持它们。如果 urllib 能够打开source，那么 return 可以立刻把你踢出函数，下面的try语句将不会执行。
  另一方面，如果 urllib 向你呼喊并告诉你source不是一个有效的 URL，你假设它是一个磁盘文件的路径并尝试打开它。再一次，你不用做任何特别的事来检查source是否是一个有效的文件名（总之在不同的平台上，判断文件名有效性的规则变化很大，那么不管怎样做都可能会判断错）。反而，只要盲目地打开文件并静静地捕获任何错误就可以了。
  到这里，你需要假设source是一个其中有硬编码数据的字符串（因为没有什么可以判断的了），所以你可以使用 StringIO 从中创建一个类文件对象并将它返回。（实际上，由于使用了 str 函数，所以source没有必要一定是字符串；它可以是任何对象，你可以使用它的字符串表示形式，通过它的 __str__ 定义的特殊方法。）

现在你可以使用这个 openAnything 函数联合 minidom.parse 构造一个函数，接收一个指向 XML 文档的source，而且无需知道这个source的含义（可以是一个 URL 或是一个本地文件名，或是一个硬编码 XML 文档的字符串形式），并解析它。

例 10.7. 在 kgp.py 中使用 openAnything

class KantGenerator:
    def _load(self, source):
        sock = toolbox.openAnything(source)
        xmldoc = minidom.parse(sock).documentElement
        sock.close()
        return xmldoc

lastwinner

10.2. 标准输入、输出和错误
UNIX 用户已经对标准输入，标准输出和标准错误的概念非常熟悉了。这一节是为其他不熟悉的人准备的。

标准输入和标准错误（通常缩写为 stdout 和 stderr）是內建在每一个 UNIX 系统中的管道。当你 print 某些东西时，结果前往 stdout 管道；当你的程序崩溃并打印出调试信息（类似于 Python 中的错误跟踪）的时候，信息前往 stderr 管道。通常这两个管道只与你正在工作的终端窗口相联，所以当一个程序打印时，你可以看到输出，而当一个程序崩溃时，你可以看到调式信息。（如果你正在一个基于窗口的 Python IDE 上工作时，stdout 和 stderr 缺省为你的“交互窗口”。）

例 10.8. stdout 和 stderr 介绍
>>> for i in range(3):
...     print 'Dive in'            
Dive in
Dive in
Dive in
>>> import sys
>>> for i in range(3):
...     sys.stdout.write('Dive in')
Dive inDive inDive in
>>> for i in range(3):
...     sys.stderr.write('Dive in')
Dive inDive inDive in  正如例 6.9 “简单计数”中看到的，你可以使用 Python 内置的 range 函数来构造简单的计数循环，即重复某物一定的次数。
  stdout 是一个类文件对象；调用它的 write 函数可以打印出你给定的任何字符串。实际上，这就是 print 函数真正做的事情；它在你打印的字符串后面加上一个硬回车，然后调用sys.stdout.write函数。
  在最简单的例子中，stdout 和 stderr 把它们的输出发送到相同的地方：Python IDE （如果你在一个 IDE 中的话），或者终端（如果你从命令行运行 Python 的话）。像 stdout，stderr 并不为你添加硬回车；如果需要，要自己加上。

stdout 和 stderr 都是类文件对象，就像在第 10.1 节 “抽象输入源”中讨论的一样，但是它们都是只写的。它们都没有 read 方法，只有 write 方法。然而，它们仍然是类文件对象，并且你可以将其它任何文件或者类文件对象赋值给它们来重定向它们的输出。

例 10.9. 重定向输出
[you@localhost kgp]$ python stdout.py
Dive in
[you@localhost kgp]$ cat out.log
This message will be logged instead of displayed(在Windows上，你可以使用type来代替cat显式文件的内容。)

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

#stdout.py
import sys

print 'Dive in'                                          
saveout = sys.stdout                                    
fsock = open('out.log', 'w')                             
sys.stdout = fsock                                       
print 'This message will be logged instead of displayed'
sys.stdout = saveout                                    
fsock.close()                                            
  打印输出到 IDE “交互窗口”（或终端，如果从命令行运行脚本的话）。
  始终在重定向前保存 stdout ，这样的话之后你还可以将其设回正常。
  打开一个新文件用于写入。如果文件不存在，将会被创建。如果文件存在，将被覆盖。
  将所有后续的输出重定向到刚才打开的新文件上。
  这样只会将输出结果“printed”到日志文件中；在 IDE 窗口中或在屏幕上不会看到输出结果。
  在我们将 stdout 搞乱之前，让我们把它设回原来的方式。
  关闭日志文件。

重定向 stderr 完全以相同的方式进行，用 sys.stderr 代替 sys.stdout。

lastwinner

例 10.10. 重定向错误信息
[you@localhost kgp]$ python stderr.py
[you@localhost kgp]$ cat error.log
Traceback (most recent line last):
  File "stderr.py", line 5, in ?
    raise Exception, 'this error will be logged'
Exception: this error will be logged如果您还没有下载本书附带的例子程序, 可以 下载本程序和其他例子程序。

#stderr.py
import sys

fsock = open('error.log', 'w')               
sys.stderr = fsock                           
raise Exception, 'this error will be logged'  
  打开你要存储调试信息的日志文件。
  将新打开的日志文件的文件对象赋值给 stderr 以重定向标准错误。
  引发一个异常。从屏幕输出上可以注意到这个行为没有在屏幕上打印出任何东西。所有正常的跟踪信息已经写进 error.log。
  还要注意你既没有显式关闭日志文件，也没有将 stderr 设回最初的值。这样挺好，因为一旦程序崩溃（由于引发的异常），Python 将替我们清理并关闭文件，这和永远不恢复 stderr 不会造成什么不同，因为，我提到过，一旦程序崩溃，则 Python 结束。如果你希望在同一个脚本的后面去做其它的事情，恢复初始值对 stdout 更为重要。

向标准错误写入错误信息是很常见的，所以有一种较快的语法可以立刻信息导出。

例 10.11. 打印到 stderr
>>> print 'entering function'
entering function
>>> import sys
>>> print >> sys.stderr, 'entering function'
entering function
  print 语句的快捷语法可以用于向任何打开的文件写入，或者是类文件对象。在这种情况下，你可以将单个print 语句重定向到stderr 而且不用影响后面的print 语句。

标准输出，另一方面，只是一个只读文件对象，它表示从前一个程序到这个程序的数据流。这个对于老的Mac OS用户和Windows用户可能不太容易理解，除非你受到过 MS-DOS 命令行的影响。它工作的方式是你可以在单个命令行中构造一个命令的链，这样的话一个程序的输出就可以成为下一个程序的输入。第一个程序只是简单的输出到标准输出上（其本身没有做任何特别的重定向，只是执行了普通的 print 语句），然后，下一个程序从标准输入中读取，操作系统只是关注将一个程序的输出连接到一个程序的输入。

lastwinner

例 10.12. 链接命令
[you@localhost kgp]$ python kgp.py -g binary.xml         
01100111
[you@localhost kgp]$ cat binary.xml                     
<?xml version="1.0"?>
<!DOCTYPE grammar PUBLIC "-//diveintopython.org//DTD Kant Generator Pro v1.0//EN" "kgp.dtd">
<grammar>
<ref id="bit">
  <p>0</p>
  <p>1</p>
</ref>
<ref id="byte">
  <p><xref id="bit"/><xref id="bit"/><xref id="bit"/><xref id="bit"/>\
<xref id="bit"/><xref id="bit"/><xref id="bit"/><xref id="bit"/></p>
</ref>
</grammar>
[you@localhost kgp]$ cat binary.xml | python kgp.py -g -  
10110001  正如你在第 9.1 节 “概览”中看到的，该命令将只打印一个随机的八位字符串，其中只有0 或者 1。
  该处只是简单的打印出整个binary.xml文档的内容。（Windows用户应该用type代替cat。)
  该处打印binary.xml的内容，但是“|”字符，称为“管道”符，说明内容不会打印到屏幕上。而且，它们会成为下一个命令的标准输入，在这个例子中是你调用的Python 脚本。
  为了不用指定一个模块(例如binary.xml)，你需要指定“-”，它会使得你的脚本从标准输入载入脚本而不是从磁盘上的特定文件。（下一个例子更多地说明了这是如何实现的）。所以效果和第一种语法是一样的，在那里你要直接指定语法文件，但是想想这里的扩展性。代替cat binary.xml，你可以通过运行一个脚本动态生成语法，然后你可以通过管道将它导入你的脚本。它可以来源于任何地方：数据库，或者是生成语法的元脚本，或者其他。你根本不需要修改你的kgp.py 脚本就可以混合使用这个功能。所有你要作的仅仅是从标准输入取得一个语法文件，然后你就可以将其他的逻辑分离出来放到另一程序中去了。

那么脚本是如何“知道”在语法文件是“-”时从标准输入读取? 其实不神奇；它只是代码。

例 10.13. 在kgp.py中从标准输入读取

def openAnything(source):
    if source == "-":   
        import sys
        return sys.stdin

    # try to open with urllib (if source is http, ftp, or file URL)
    import urllib
    try:

[... snip ...]  这是toolbox.py 中的openAnything函数，以前在第 10.1 节 “抽象输入源”中你已经检视过了。所有你要做的就是在函数的开始加入3行代码来检测源是否是“-”; 如果是，返回sys.stdin。实际上，that's it! 记住，stdin 是一个拥有read方法的类文件对象，所以剩下的代码（在kgp.py中，在那里你调用了openAnything) 一点都不需要改动。

lastwinner

10.3. 缓冲节点查询
kgp.py 使用了多种技巧，对你进行 XML 处理而言它们或许有用。第一个就是，使用输入文档的结构稳定特征来构建节点缓冲。

一个语法文件定义了一系列的 ref 元素。每个 ref 包含了一个或者多个 p 元素，p 元素可以包含很多不同的东西，包括 xref。无论何时你遇到一个 xref ，都可以通过相同的 id 属性找到相对应的 ref 元素，并选择 ref 元素的子元素之一进行解析。（在下一部分中你将看到是如何进行这种随机选择的。）

如何构建语法：为最小的片段定义 ref 元素，然后通过 xref 定义“包含”第一个 ref 元素的 ref 元素，等等。然后，解析“最大的”引用并跟在每个 xref 后面，最后输出真实的文本。输出的文本依赖于你每次填充 xref 所做的（随机）决策，所以每次的输出都是不同的。

这种方式非常灵活，但是有一个不好的地方：性能。当你找到一个 xref 并需要找到相应的 ref 元素时，会遇到一个问题。 xref 有 id 属性，而你要找拥有相同 id 属性的 ref 元素，但是没有简单的方式做到这件事。较慢的方式是每次获取所有 ref 元素的完整列表，然后手动遍历并检视每一个 id 属性。较快的方式是只做一次然后以字典形式构建一个缓冲。

例 10.14. loadGrammar
    def loadGrammar(self, grammar):                        
        self.grammar = self._load(grammar)                  
        self.refs = {}                                       
        for ref in self.grammar.getElementsByTagName("ref":
            self.refs[ref.attributes["id"].value] = ref         从创建一个空字典 self.refs 开始。
  正如你在第 9.5 节 “搜索元素”中看到的，getElementsByTagName 返回所有特定名称元素的一个列表。你可以很容易的得到所有 ref 元素的一个列表，然后仅仅是遍历这个列表
  正如你在第 9.6 节 “访问元素属性”中看到的，使用标准的字典语法，你可以通过名称来访问个别元素。所以，self.refs 字典的键将是每个 ref 元素的 id 属性值。
  self.refs 字典的值将是 ref 元素本身。如你在第 9.3 节 “XML 解析”中看到的，已解析 XML 文档中的每个元素，每个节点，每个注释，每个文本片段都是一个对象。

一旦你构建了这个缓冲，无论何时你遇到一个 xref 并且需要找到具有相同 id 属性的 ref 元素，你只要在 self.refs 中查找它。

例 10.15. 使用 ref 元素缓冲
    def do_xref(self, node):
        id = node.attributes["id"].value
        self.parse(self.randomChildElement(self.refs[id]))你将在下一部分探究 randomChildElement 函数。

lastwinner

10.4. 查找节点的直接子节点
解析 XML 文档时，另一个有用的己技巧是查找某个特定元素的所有直接子元素。例如，在语法文件中，一个 ref 元素可以有数个 p 元素，其中每一个都可以包含很多东西，包括其他的 p 元素。你只要查找作为 ref 孩子的 p 元素，不用查找其他 p 元素的孩子 p 元素。

你可能认为你只要简单的使用 getElementsByTagName 来实现这点就可以了，但是你不可以这么做。 getElementsByTagName 递归搜索并返回所有找到的元素的单个列表。由于 p 元素可以包含其他的 p 元素，你不能使用 getElementsByTagName ，因为它会返回你不要的嵌套 p 元素。为了只找到直接子元素，你要自己进行处理。

例 10.16. 查找直接子元素
    def randomChildElement(self, node):
        choices = [e for e in node.childNodes
                   if e.nodeType == e.ELEMENT_NODE]   
        chosen = random.choice(choices)            
        return chosen                                正如你在例 9.9 “获取子节点”中看到的， childNodes 属性返回元素所有子节点的一个列表。
  However, 正如你在例 9.11 “子节点可以是文本”中看到的，childNodes 返回的列表包含了所有不同类型的节点，包括文本节点。这并不是你在这里要查找的。你只要元素形式的孩子。
  每个节点都有一个nodeType属性，它可以是元素节点, 文本节点, 注释节点，或者任意数量的其它值。可能值的完整列表在xml.dom包的__init__.py文件中。（关于包更多的，参见第 9.2 节 “包”。）但你只是对元素节点有兴趣，所以你可以过滤出一个列表，其中只包含nodeType是元素节点的节点。
  一旦你拥有了一个真实元素的列表，选择任意一个都很容易。Python 有一个叫 random 的模块，它包含了好几个有用的函数。random.choice函数接收一个任意数量条目的列表并随机返回其中的一个条目。比如，如果 ref 元素包含了多个 p 元素，那么choices将会是 p 元素的一个列表，并且chosen将以被赋予其中的一个确切值而结束,而这个值是随即选择的。