以下是各章修订清单的汇总。
  1. ../2007-06-08

  2. ../2007-06-27

  3. ../2007-06-28

  4. ../2007-07-01

  5. ../2007-07-07

  6. ../2007-07-11

  7. ../2007-07-14

  8. ../2007-07-23

  9. ../2007-07-25

  10. ../2007-07-29

  11. ../2007-08-01

  12. ../2007-08-03

  13. ../2007-08-05

  14. ../2007-08-06

  15. ../2007-08-07

  16. ../2007-08-09

  17. ../2007-08-17

  18. ../2007-08-18

6-8<X1> install.xml 安装 Python

1.1 哪一种 Python 适合您?

  1. Para 2:……大多数Linux发布版本 <!> (./) 发行版

  2. Para -1无论哪一个已经安装再您的计算机上的均可。
    (!) 表达似乎有些别扭,
    (./) 无论哪一个——只要已经安装在您计算机上——均可。

1.2 Windows 上的 Python

  1. Para 2ActiveState 制作了一个 Windows 上的 Python安装程序称为 ActivePython
    (!) 表达很别扭,
    (./) ActiveState 发布 Windows 上的 Python 安装程序,叫做 ActivePython

  2. Para 2附加了 <!> 一些 Windows 扩展 (./) 以及

  3. Para 3曾经 {X} 学习 Python 时

  4. Para 3:新的 Python 版本出来 <!> 几个月 (./) 发布

  5. 过程1.1, 5:……执行一个 {X} 定制安装

  6. 过程1.1, 6Start->Programs
    (!) 能翻译为什么不翻译呢?
    (./) 开始->程序

1.3 Mac OS X 上的 Python

  1. 过程1.4, 2挂装 <!> 到桌面 (./) 挂载

  2. 例1.1上:那您需要知道正在使用 {i} 的是 哪一个版本的 Python。

1.4 Mac OS 9 上的 Python

pass

1.5 RedHat Linux 上的 Python

  1. Para 1:如果你想在像 Linux 一样的 UNIX 兼容的操作系统上……
    (./) 在类 UNIX 的操作系统(如 Linux)上

  2. Para 2:下载最新的 Python RPM {i}

  3. 例1.2, (3):这是我们刚 <!> 的 Python (./) 安装

1.6 Debian GNU/Linux 上的 Python

  1. Para 1:如果您碰巧 {X} 运行在……

1.7 从源代码安装 Python

pass

1.8 使用 Python 的交互 Shell

  1. Para 3:让我们深入下去做这些操作
    (!) 不管原文如何,这里不符合上下文(下文不过是做了1 + 1print 'hello world'这样的简单操作)
    (./) 让我们尝试着做这些操作

6-27<X2> odbchelper.xml 第一个 Python 程序

  1. Para 1: 大家都很清楚,其它书籍是如何…… {i} 还是让我们跳过这个部分吧

2.1 概览

pass

2.2 函数声明

  1. Para 3:Python 不需要提定 <!> 明显typo 返回值的数据类型 (./) 指定

2.2.1 Python 和其他编程语言数据类型的比较

  1. “xx类型定义语言”,这样的表达太罗嗦,按照一般的表达,改为“xx类型语言”
  2. Para 3A language in which types are fixed at compile time
    一种在编译期间数据类型固定的语言
    (!) 明显,原文的被动式在这里应该是表示单纯的被动动作而非状态
    (./) 一种在编译期间就确定数据类型的语言

  3. Para 3Most statically typed languages enforce this by requiring you to declare all variables with their datatypes before using them.
    大多数静态类型语言是通过要求在使用所有变量之前声明它们的数据类型来保证这一点的。
    (!) 很有意思的是,原来的英文读起来很正常,但如实翻译成中文后明显有了逻辑问题。鉴于中英文表达习惯不同,“所有”改为“任一”。相应地,“它们的”改为“其”。
    (./) 大多数静态类型语言是通过要求在使用任一变量之前声明数据类型来保证这一点的。

  4. Para -1:因为只要一个变量具有一个数据类型
    (!) 此处采用更加动态的表达方式似乎更好
    (./) 因为只要一个变量获得了一个数据类型

2.3 文档化函数

  1. Para 1:可以通过给出一个 doc string(文档字符串) {i} 文档化一个 Python 函数

  2. 例2.2下, Para 1, Line -1:但是您可能会发现它们经常定义 doc string 的情况

  3. (!) 怎么就没人嫌别扭呢 (./) 但是您可能会发现它们经常被用于定义 doc string。

2.4 万物皆对象

  1. Para 1如果 <!> 您没在意,我刚才的意思是…… (./) 可能

  2. 例2.3, (1)...a module -- a chunk of code that you can use interactively, or from a larger Python program.
    模块是指……或者来自一个大规模的 Python 程序
    (!) 此处原译太死,不符合中文习惯,语法上也说不过去
    (./) 或者一个大规模的 Python 程序的片段

2.4.1 模块导入的搜索路径

  1. 它会按所有定义在 sys.path 中的目录进行搜索
    (./) 它会按定义在 sys.path 中的目录逐个进行搜索

  2. 例2.4, (2):sys.path 是一个组成 <!> 当前搜索路径的目录列表。 (./) 指定

  3. 例2.4, (3)有一些,像 sys 模块,是……
    (./) 有一些模块(像 sys)

2.5 代码缩进

  1. Para 1:没有花括号,用于标函数的开始和结束
    (!) 改为相对简单的语法结构
    (./) 没有标明函数的开始和结束的花括号

  2. 例2.5, Para 1:代码块 {i} 通过它们的缩进来定义的

  3. 例2.5, Para 1, Line -1:不一定非要是 4 {i} ,只要一致就可以了。没有缩进的第一行则 {i} 被视为 在函数体之外。

  4. 例2.6, (2):包括字符串、整数和其它如字典和列表(我们将在下一章学习)等类型
    (./) 包括字符串、整数和其它类型,如字典和列表(我们将在下一章学习)

  5. 例2.6, (2)通过使用以逗号分割的值列表把几个东西输出到一行上
    (!) 此处表达太罗嗦,且与下文重复了
    (./) 只需用逗号隔开

  6. 例2.6, (3):如果 if 表达式计算为 true,{i} 紧跟着的 缩进块 {i} 被执行

2.6 测试模块

  1. Para 1:您可以使用这些属性方便地测试您所书写 <!> 的模块。 (./) 编写

  2. Para 2:有几 <!> 重要的观察结果 (./)

  3. Para 3:一个模块的 __name__ 的值要看 <!> 您如何应用模块 (./) 取决于

2.-1 反馈

6-28<X3> odbchelper.xml 内置数据类型

3.1 Dictionary 介绍

  1. 例3.2, (2)括号内Yes, this will annoy you someday when you think you are adding new values but are actually just modifying the same value over and over because your key isn't changing the way you think it is.
    是的,它可能某天会给您带来麻烦,您可能以为加入了新值,但实际上只是一次又一次地修改了同一个值,这是因为您的 key 没有按照您的想法进行改变。
    (!) 说实话,不论英文和中文我都花了不少时间才彻底理解Mark是什么意思。翻译得很勉强,我调整了一下语序,添加了一些字词。
    (./) 是的,它可能某天会给您带来麻烦。设想你一次次地修改一个 dictionary,但其间您使用的 key 并未按照您的想法进行改变。您可能以为加入了新值,但实际上只是一次又一次地修改了同一个值。

  2. 例3.4, (2):……可以是字符串、整数 <!> 几种其它的类型 (./)

  3. 例3.4, (2), Line -1:也可以在一个 dictionary 中混用和配匹 明显typo <!> key 的数据类型 (./) 匹配

  4. 进一步阅读, Line -1:……总结了所有 {i} dictionary 方法

3.2 List 介绍

  1. 例3.11, (1), Line -1:并且添加这个 list 中的每个元素到原 list 中 (./) 并且这个 list 中的每个元素添加到原 list 中

  2. 例3.12下, 注解:为了弥补这一点 <!> (./) 这一个缺陷

3.3 Tuple 介绍

  1. 例3.15, (1)A tuple is defined in the same way as a list, except that the whole set of elements is enclosed in parentheses instead of square brackets.
    定义 tuple 与定义 list 的方式相同,除了整个元素集是用小括号包围的而不是方括号。
    (!) 翻译得太死,难道except非要翻译为“除了”吗
    (./) 定义 tuple 与定义 list 的方式相同,整个元素集是用小括号包围的,而不是方括号。

3.4 变量声明

  1. 3.4.1上:幸运的是,与 VBScript 不同的是 {X} ,Python 不允许您引用一个未被赋值的变量,试图这样做会引发一个异常。

  2. 进一步阅读上, Para -1: ……包括os模块, {i} 我们 将在 第 6 章 中讨论

3.5 格式化字符串

  1. 例3.21, (1)The whole expression evaluates to a string.
    整个表达式计算结果为一个字符串。
    (!) 是的,原文中的“evaluates to”的确是“计算结果为”的意思。但明显,中文在此处采用静态意义的表达法更加自然。
    (./) 整个表达式的值为一个字符串。

  2. 同上:在字符串中所有其它的字符
    (./) 字符串中的所有其它字符

  3. 例3.22下, Para 1:不同的格式化格式符和可选的修正符 {i} 用于不同的数据类型

  4. 例3.23, (1):格式符选项被认为是 <!> 一个十进制浮点数 (!) 有点逻辑问题 (./) 映射

3.6 映射 list

  1. 例3.24下, Para 1Here are the list comprehensions in the buildConnectionString function that you declared in Chapter 2:
    声明位于 第 2 章 的函数 buildConnectionString 对 list 的解析:
    (!) 此处翻译得很勉强,不妨罗嗦一点,意思反而更清楚。
    (./) 让我们回过头来看看位于 第 2 章 的函数 buildConnectionString 对 list 的解析:

  2. 例3.25, (1):keys 方法返回一个 {i} 包含 所有键的 list

  3. 例3.25, (2):values 方法返回一个 {i} 包含 所有值的 list

  4. 例3.25, (2):这个 list 以 keys 返回的 list 顺序输出 (./) 它同 keys 方法返回的 list 输出顺序相同

  5. 例3.25, (3):items 方法返回 {i} 一个形如 (key, value) 的 tuple {i} 组成 的 list

  6. 例3.25下, Para 1:这个新 list 将拥有与 params.items 相同的元素数量,在新 list 中的每个元素都将包含从 dictionary.params 来的一个键和与其关联值的字符串
    (!) 翻译得很勉强
    (./) 这个新 list 将与 params.items 一一对应:新 list 中的每个元素都是 dictionary.params 中的一个键-值对构成的的字符串

  7. 进一步阅读:Python Tutorial 展示了如何 {i} 嵌套 list 的 list {i} 进行 解析

3.7 连接 list 与分割字符串

  1. Para 4:总之, {i} 这里的 join 方法将 list 中的元素连接成单个字符串……

  2. Para 4下, 提示:它不进行任何的类型强制转换 <!> (./) 强制类型转换

  3. 进一步阅读上:……在您想要搜索一个子串,然后处理字串前面的东西 <!> (即 list 中第一个元素) 和其后的东西 <!> (即 list 中第二个元素) 时…… (./) 前半部分 后半部分

3.7.1 字符串方法的历史注解

  1. I use the new join method exclusively, but you will see code written either way...
    我只使用新的 join 方法,但是您将会看到代码的其它写法,并且如果它真的使您……
    (./) 我只使用新的 join 方法,但是您还是会看到其它写法。如果它真的使您……

3.8 小结

  1. Line -1:分割字符串 成为 list 和 连接 list 成为字符串
    (./) 把字符串分割为list 和把 list 连接为字符串

3.-1 反馈

7-1<X4> apihelper.xml 自省的威力

  1. Para 1:……Python 中任何东西都是对象 <!> ,…… (!) 为了和前面章节的用词统一, (./) 万物皆对象

4.1 概览

  1. 例4.2上:……它可以使用 <!> 任何……作为参数…… (./) 接受

  2. 例4.2, Para 1:缺省地,程序输出进行了格式化处理 {i} ,以使其易于阅读

4.2 使用可选参数和命名参数

  1. 例4.4下, 提示:调用函数时唯一需要 <!> 做的事情就是为每一个必备参数指定值…… (./) 必须

4.3 使用 type、str、dir 和其它内置函数

  1. Para 1...This was actually a conscious design decision,...
    ……其实这是一个非常明智的设计决策……
    (!) decision固然是“决策”的意思,但我想此处Mark的意思应该是“策略”而不是“决策”。
    (./) ……其实这是一个非常明智的设计策略……

  2. Para 2:添加了脚注:
    这对于处理多种数据类型的帮助者函数 <footnote><para>帮助者函数,原文是 helper function,也就是我们在前文所看到的诸如 <literal>odbchelper</literal>、<literal>apihelper</literal> 这样的函数。——译注</para></footnote> 非常有用。
    (!) helper function这个术语的出现对于英文阅读者十分自然(helper已经出现在函数名中了),但中文版应该予以说明。

4.3.1 type 函数

pass

4.3.2 str 函数

  1. Para 1The str coerces data into a string. Every datatype can be coerced into a string.
    str 将数据强制转型 <!> 为字符串。每种数据类型都可以强制转型为字符串。
    (!) coerce在国内不是通译为“强制转换”吗,我真不知道YuLin是怎么会想到用“转型”这个词的。(台湾译风的影响?)
    (./) 转换

  2. 例4.6, (4)You'll use this to your advantage in the info function...
    你将会使用这一点来提高你的 info 函数
    (./) 你将会使用这一点来改进你的 info 函数

  3. 例4.7, (1):li 是一个列表,所以 dir(li) 返回 {i} 一个包含所有列表方法的一个 {X} 列表。

  4. 例4.8上:如果参数对象是可调用的那么返回 true否则返回 false。
    (./) 如果参数对象是可调用的,返回 true;否则返回 false。

  5. 例4.8, (1)...but the module contains a lot of useful constants like this string.punctuation, which contains all the standard punctuation characters.
    但是在这个模块中包含了许多有用的变量比如 string.punctuation,这个模块包含了所有标准的标点符号字符。
    (!) 估计是一个which把译者给搞懵了,竟然稀里糊涂地翻译成了“模块”
    (./) 但是在这个模块中包含了许多有用的变量,例如 string.punctuation,这个字符串包含了所有标准的标点符号字符。

4.3.3 内置函数

  1. Para 2:像这样考虑的好处是,是你可以获取 __builtin__ 模块信息的…… (!) 估计是typo (./) 你是

  2. Para 2:猜到什么了吗, {i} 现在我们的 Python 有一个称为 info 的函数。 (!) 从上下文来看,info函数明显是作者自己写的,而不是Python原有的。

  3. Para 2, Line -1:……应该看上去已经 {i} 熟悉了。 (!) 这里是为了中文表达的顺畅

4.4 通过getattr获取对象引用

  1. 例4.10, (3):如果不深信它是多么的有用 (./) 确信

  2. 例4.12, (3):现在你可以简单地调用输出函数就像调用其它函数一样
    (./) 现在你可以简单地调用输出函数就像调用其它函数一样。

4.5 过滤列表

  1. Para 3A filter expression can be any expression that evaluates true or false (which in Python can be almost anything)
    过滤器表达式可以是返回值为真或者假(在 Python 中是 几乎任何东西)的任何表达式。
    (!) 又一次没有把握语序,括号里面的内容解说的是expression而非false。况且大多数 Python 表达式的值是真,而不是假。
    (./) 过滤器表达式可以是返回值为真或者假的任何表达式(在 Python 中是 几乎任何东西)

  2. 同上:任何经过滤器表达式演算值为元素的真都可以包含在映射中。
    (./) 任何经过滤器表达式演算值为真的元素都可以包含在映射中。

  3. 进一步阅读上,整段部件 <!> 一律改为更常见的术语, (./) 成员。(不再列出全文,还请自己参看)

  4. 进一步阅读:Python Tutorial 讨论了 使用内置过滤器 <!> 函数……
    (!) 过度翻译,Python里可没有叫做“过滤器”的函数,只有filter函数
    (./) filter

4.6 and 和 or 的特殊性质

  1. 为了和前面章节的用词一致,布尔上下文 <!> 一律改为前文中使用的,也是更好的术语, (./) 布尔环境。顺便说一句,我发现几乎所有被翻译为“上下文”的术语都是指“环境”,不知道 programming 资料的第一批译者是怎么想的

  2. 例4.18上不只 <!> 一次 (./) 不止

  3. 例4.18下:and-or技巧, {i} 也就是bool and a or b表达式……

4.7 使用 lambda 函数

  1. 例4.20, (2)你可以使用 lambda 函数甚至不需要将它赋值给一个变量。
    (./) 使用 lambda 函数甚至不需要将它赋值给一个变量。

  2. 例4.21, (2)split without any arguments splits on whitespace.
    不带参数的 split 按照空格 <!> 进行分割。 (!) 翻译错误 (./) 空白

4.8 全部放在一起

  1. Para 2This is the meat of apihelper.py:
    下面是 apihelper.py 的根本 <!>(./) 关键

  2. Para 4
    Now, let's take it from the end and work backwards. The
    for method in methodList
    现在,让我们从后向前分析。这个
    for method in methodList
    ……
    (!) 从下文看来,这里的“这个”画蛇添足,宁肯去掉。况且“the”翻译为“这个”也不甚妥当。

  3. 例4.23, (1)Confusingly, if you evaluate the __doc__ attribute directly, the Python IDE prints nothing at all, which makes sense if you think about it, but is still unhelpful.
    令人迷惑的是,如果你直接演算 __doc__ 属性的值,Python IDE 什么都不会打印,如果你只是考虑它,是有意义的,但是却没有什么用。
    (!) 翻译有些生硬。if you think about it不译也不会对句子的意思产生多大影响,宁肯不译。
    (./) 这是有意义的,但是却没有什么用。

  4. 例4.25, (1)This is also a useful debugging trick when you're working with lists. And in Python, you're always working with lists.
    在你处理列表时,这确实是一个有用的调试技巧。还有一点在 Python 中,你总是在操纵列表。
    (!) 此处翻译不太灵活,让人费解。
    (./) 在 Python 中,你会十分频繁地操作列表。

4.9 小结

  • pass

4.-1 反馈

7-7<X5> fileinfo.xml 对象和面向对象

5.1 概览

pass

5.2 使用 from module import 导入模块

  1. Para 3:添加了译注,指出文中的错误(和 Mark 联系上后移除)

5.3 类的定义

  1. 例5.4, (1):把原来的译注移到脚注<footnote>里面去了

  2. 例5.4下, 提示:不像在 Java 中有一个特殊的 extends {X} 关键字。

  3. 例5.5:初始化 FileInfo Class (!) 没有翻译?! (./)

  4. 例5.5, (2), Line -1:……但 __init__ 是在 Python 中你可以得到的最接近构造函数的东西,并且它也扮演着非常相同 <!> 的角色。 (./) 相似

  5. 例5.5, (4)__init__ 方法可以接受任意个数的参数,就像函数一样,参数可以用缺省值定义,可以设置成对于调用者可选。
    (./) __init__ 方法可以接受任意数目的参数,就像函数一样,参数可以用缺省值定义,可以设置成对于调用者可选。

  6. 例5.6, (1):Python 不是这样,你必须显示地调用在父类中的适合 <!> 方法。 (./) 合适

5.4 类的实例化

  1. Para 1:……为了对类进行实例化,只要调用类,好像它是一个函数……
    (./) 对类进行实例化,只要调用类(就好像它是一个函数)……

  2. 例5.7, (4):修正一处格式化错误(不再列出)。

  3. 例5.8, (1):然后函数结束 {i} 没有释放 f

5.5 探索 UserDict:一个封装类

  1. Para 1:如你所见,FileInfo 是一个像字典一样动作的类。
    (./) 如你所见,FileInfo 是一个有着像字典一样的行为方式的类。

  2. 例5.9, (5), Line -1:你可以用这种语法,或者可以在后面的行拥有缩近代码…… (./) 写下

  3. 例5.9下, Para 1:一个类可以有同名的多个方法,但这些方法或者是参数个数不同, <!> 参数的类型不同。 (!) 为保持一致, (./) 或者是

  4. 例5.9下, Para 2Guido, the original author of Python, explains method overriding this way: "Derived classes may override methods of their base classes. Because methods have no special privileges when calling other methods of the same object, a method of a base class that calls another method defined in the same base class, may in fact end up calling a method of a derived class that overrides it. (For C++ programmers: all methods in Python are effectively virtual.)" If that doesn't make sense to you (it confuses the hell out of me), feel free to ignore it. I just thought I'd pass it along.
    Python 的原作者 Guido 是这样解释方法覆盖的 “子类可以覆盖父类中的方法。因为方法没有特殊的优先级设置,在调用同一对象的另外方法时,父类中一个方法对另一个同类中的方法的调用,可能其实调用到的却是一个子类中覆盖父类同名方法的方法。(对于 C++ 程序员,所有的 Python 方法都非常有效)” 如果你不明白(它另我颇感困惑),不必在意。我想我要跳过它。
    (!) 明显这位兄台没有理解 Guido 的话,也不懂 C++。
    (./) Python 的原作者 Guido 是这样解释方法覆盖的:“子类可以覆盖父类中的方法。因为方法没有特殊的优先级设置,父类中的一个方法在调用同类中的另一方法时,可能其实调用到的却是一个子类中覆盖父类同名方法的方法。(C++ 程序员可能会这样想:所有的 Python 方法都是虚函数。)”如果你不明白(它另我颇感困惑),不必在意。我想我要跳过它。
    (./) 同时添加了一段译注,帮助读者理解。

  5. 例5.10, (1), Line -1在你忘记的情况下 <!> ,字典的 clear 方法删除它的所有关键字和关键字相应的值。 (./) 你可能已经忘了

  6. 例5.10, (3):我们使用 __class__ 属性来查看是否 self 是 <!> 一个 UserDict…… (./) self 是否是

  7. 例5.10, (4), Line -1是否你想到要自已研究它了呢? (./) 你是否已经

  8. 例5.10下, Para 1UserDict出色于模仿字典。 (./) UserDict能十分出色地模仿字典。

5.6 专用类方法

  1. Para 1:除了普通的类方法,还有一些对于 Python 类可以定义的专用方法。
    (./) 除了普通的类方法,对于 Python 类还有一些可以定义的专用方法。

  2. 例5.14上, Para -1, Line -1:它还要在文件自身内进行搜索 MP3 的标记然后填充一整套关键字集合 {X} 。下面的例子将展示其如何工作(./) 工作方式

  3. 例5.14, (1):注意我们的 __setitem__ 方法严格按照 父类方法相同的形式进行定义。

  4. 例5.14, (4):注意,我们在调用直接父类,FileInfo,尽管它没有一个 {X} __setitem__ 方法。没问题,因为 Python 将会沿着父类树走,直到它找到一个有着 <!> 我们正在调用方法的类,…… (./) 拥有

  5. 例5.15, (2):关键字触发了 MP3FileInfo 上的 __setitem__ 方法( 不是 UserDict

5.7 高级专用类方法

  1. 例5.16下, 注解:关于 Java 的技术评注翻译了两次。合并为一次。

  2. 注解下, Para 2:任何类可以表现得像一个序列,只要通过 {X} 定义 __getitem__ 方法。

  3. 同上:并且如果你的类表现 拥有类似长度的东西……

  4. 进一步阅读上:允许你在类实例上进行加,减, <!> 执行其它算数操作。 (./) 以及

5.8 类属性介绍

  1. 例5.17, (2):它 {X} 在创建任何类实例之前就有效了。

  2. 例5.17下:在 Java 中,静态变量和实例变量两者 {i} 是紧跟在类定义之后定义的……

  3. 同上:到后面 <!> ,它只会把你(或其它人)搞乱。 (./) 最后

5.9 私有函数

pass

5.10 小结

  1. 子类化 UserDict 来定义作为 <!> 像字典的类 (./) 行为

5.-1 反馈

7-11<X6> fileinfo.xml 异常和文件处理

本章的修订参考了某人放在项目主页上的反馈。请看到此页后在此加上自己的名字,谢谢!

6.1 异常处理

  1. 列举下:在这些情况下,我们都在简单使用 Python IDE:一个错误发生了,异常被打印出来(根据你的 IDE,有意地以一种刺眼的红色形式表示)
    (./) 在这些情况下,我们都在简单使用 Python IDE:一个错误发生了,异常被打印出来 (取决于你的 IDE,可能会有意地以一种刺眼的红色形式表示)

  2. 下一段:但是许多时候,一个异常是可以预计 <!> 的…… (./) 预见

  3. 例 6.1 下, Para 1Would you rather get back an unusable file object to a non-existent file?
    希望获得一个没有用的文件对象而不是一个不存在的文件吧?
    (!) 注意这里的to,不是表比较,而是引导object的定语,表指向(这样的用法很常见,eg. a pointer to an integer)
    (./)该不会希望获得一个指向不存在的文件的对象吧

  4. 例6.2, (1):termios 是一个 UNIX 特定模块
    (./) termios 是一个特定的 UNIX 模块

  5. 例6.2, (2):……它是一个 Windows 特定模块
    (./) 它是一个特定的 Windows 模块

  6. 例6.2, (3):它是一个 Mac OS 特定模块
    (./) 它是一个特定的 Mac OS 模块

  7. 例6.2, (4):……注意我们在这里做的:…… (./) 注意我们在这里做的:……

  8. 例6.2, (5):一处样式错误。还请参见源文件。

  9. 例6.2, (5), Line -1
    Each of the other try...except blocks has similar else clauses to bind getpass to the appropriate function when you find an import that works.
    其它每个 try...except 块有着相似的 else 子句,当我们找到一个 import 可用时,来绑定 getpass 到适合的函数。
    (./) 其它每个 try...except 块有着相似的 else 子句,当我们发现一个 import 可用时,绑定 getpass 到适合的函数。

6.2 与文件对象共事

  1. 作名词短语的打开文件 <!> 一律改为 (./) 被打开文件

6.2.1 读取文件

  1. Para 1:……正如下一个例子所显示 <!> 的。 (./) 展示

  2. 例6.4, (2):0 表示移动到一个绝对位置(从文件开始算起),0 表示移到一个相对位置(从当前位置算起),还有 2 表示对于文件尾的一个相对位置。
    0 表示移动到一个绝对位置(从文件起始处算起),1 表示移到一个相对位置(从当前位置算起),还有 2 表示相对于文件尾的位置。

  3. 同上:添加了译注,说明了“文件尾”指的是文件的结束标记,而不是最后一个字节。

  4. 例6.4, (3):tell 方法确认了已经移到当前文件位置
    (!) 有必要和 例6.4, (5) 里面的用词保持一致(原文可是一致的)。
    (./) tell 方法确认了当前位置已经移动了

  5. 例6.4, (4):我们本可以在这里简单地说一下 {X} read(),……

6.2.2 关闭文件

  1. Para 1:打开文件消耗系统资源,并且依赖于文件模式,其它程序或许不能访问它们
    (./) 打开文件消耗系统资源,并且其间其它程序可能无法访问它们(取决于文件模式)

  2. 例6.5, (1):……打开文件要消耗系统资源,并且根据文件模式,其它程序可能不能使用它们。……
    %^$#`?!!原文可没有把上文重复一次啊
    (./) 删去!

  3. 例6.5, (2):刷新被缓冲的系统确实 {X} 还未写入的输出(如果有的话),……

  4. 例6.5, (4)只是因为文件被关闭,并不意味着文件对象停止存在。
    (./) 文件被关闭但这并不意味着文件对象不再存在。

6.2.3 处理 I/O 错误

  1. 例6.6, (5):一旦文件通过 open 函数被成功地打开,我们应该绝对保证把它关闭,甚至由于 seek 或 read 方法引发了一个异常。
    (./) ……即使是在 seek 或 read 方法引发了一个异常

  2. 例6.6, (6), Line -1:……并且处理将正常继续,从 tryexcept 块的下一行代码 {i} 开始

6.2.4 写入文件

  1. Para 2, 3:"Append" 模式将数据追加到文件尾。
    "write" 模式将覆盖文件的原有内容。
    (!) 有必要交代一下中文含义。
    (./) 追加(Append)模式将数据追加到文件尾。
    写入(write)模式将覆盖文件的原有内容。

  2. 例6.7, (1):你可以大胆地开始创建任何的 {X} 新文件 test.log 或覆盖现有文件,……

  3. 例6.7, (3):file 是 open 的同义语。它用一行打开文件,读取内容,并打印它们。
    (./) ……这一行语句打开文件,读取内容,并打印它们。

  4. 例6.7, (5):……同时注意回车符并没包含进来
    (!) 意思不是很清晰
    (./) 同时注意两行之间并没包含回车符

6.3 for 循环

  1. 例6.8, (2):for 循环可以在它里面有任意条数的代码行。
    (!) 前者不符合中文表达习惯;“条数”和“代码行”有重复之嫌。
    (./) for 循环可以包含任意数目的代码行。

  2. 例6.8, (3):这就是为什么你以前没看到过 for 循环的原因:…… (!) 与后面的“原因”重复了。 (./) 删去

  3. 例6.10, (3):使用 多变量赋值 和 list 解析,你可以使用单行语句来替换整个 for 循环。在实际的编码中是否这样做只是个人风格问题;我喜欢它是因为,可以使得 {X} 将一个 dictionary 映射到一个 list,然后将 list 合并成一个字符串,这一过程显得很清晰。

  4. 例6.11, (1)一旦我们读出文件最后 128 个字节,第 3 到 32 字节总是歌曲的名字,……
    (./) 只要我们读出文件最后 128 个字节,那么第 3 到 32 字节总是歌曲的名字,……

  5. 例6.11, (2)这个 <!> for 变量结构…… (./) 这里的

  6. 例6.11, (3):……,接着将 parseFunc {i} 的返回值 作为值赋值给伪字典 self 中的键字 tag。
    (!) 根据上下文来看,这里指的是返回值。

6.4 使用 sys.modules

  1. 例6.12, (1)这个 {X} sys 模块包含了系统级的信息,……

  2. 例6.14, (1):每个 python 类 {i} 拥有一个内置的 类属性 __module__,……

  3. 例6.15, (3):hasattr 是一个补充性的函数,用来检查是否一个对象具有一个特别的属性;……
    (./) 用来检查一个对象是否具有一个特定的属性……

6.5 与 Directory 共事

  1. 例6.16, (2):ospath 的 join 函数一个或多个部分路径名构造成一个路径名。
    (./) ospath 的 join 函数一个或多个部分路径名连接成一个路径名。

  2. 例6.16, (3):当 {X} 发现这一点时我高兴极了,……

  3. 例6.16, (5):将这些技术 <!> 在一起,…… (./) 组合

  4. 例6.18, (1):listdir 函数接收一个路径名,返回那个目录的内容的一个 list。
    (./) listdir 函数接收一个路径名,返回那个目录的内容的 list。

  5. 例6.18, (3):在这里,我们使用 ospath.join 来确保一个全路径名,但 isfile 对一个相对于当前工作目录的部分路径也是有效的。你可以使用 os.getcwd() 来得到当前的工作目录
    (./) 在这里,我们使用 ospath.join 来确保得到一个全路径名,但 isfile 对部分路径(相对于当前目录)也是有效的。你可以使用 os.getcwd() 来得到当前目录

  6. 例6.19, (4):我们查看是否扩展名在我们关心的文件扩展名 list 中……
    (./) 我们查看扩展名是否在我们关心的文件扩展名 list 中……

  7. 例6.19下, 提示:只要有可能,你应该使用在 os 和 ospath 中的函数进行文件目录和路径的操作。
    (./) 只要有可能,你应该使用在 os 和 ospath 中的函数进行文件、目录和路径的操作。

  8. 例6.20上:还有一种获得 directory <!> 内容的方法。 (./) 目录

  9. 例6.20, 标题Listing Directories with glob (./) 使用 glob 列出目录

  10. 例6.20, (1):正如你前面看到的,os.listdir 简单地取出一个目录路径,目录中的所有文件和子目录。
    (./) 正如你前面看到的,os.listdir 简单地一个目录路径,返回目录中的所有文件和子目录。

  11. 例6.20, (2):glob 模块,另一方面,选取 <!> 一个通配符…… (./) 接受

  12. 例6.20, (4)你可以用两个通配符仅仅调用 glob 一次立刻获得所有这些文件的一个 list。
    (./) 使用两个通配符仅仅调用 glob 一次就可以立刻获得所有这些文件的一个 list。

6.6 全部放在一起

  1. 例6.21, (1):listdirectory 是整个模块主要的引吸 <!> 之处。 (./) 有趣

  2. 例6.21, (2):……这行代码得到一个全路径名的列表,它们 <!> 是在 directory 中…… (./) 它的元素

  3. 例6.21, (6):接着我们创建这个类(不管它是什么)的一个实例,传入文件名(又是 f)给 {X} init 方法。

  4. Para -1:请注意 listdirectory 完全是通用的。它事先不知道将得到文件哪种类型或者哪些定义好的类能够处理这些文件。
    (./) ……它事先不知道将得到哪种类型的文件也不知道哪些定义好的类能够处理这些文件。

6.7 小结

  1. Para -1动态地 实例化未知类型的类 通过将类看成对象并传入参数
    (./) 通过将类看成对象并传入参数,动态地 实例化未知类型的类

6.-1 反馈

7-14<X7> re.xml 正则表达式

re.xml 中不知为何不少 XML tag 和 entity 都被破坏了,都逐一修复了~~
本章 typo 太多,故均不列出。
  1. Para 1:……它们的语法非常相似,那么你仅仅阅读一下 re 模块的摘要,大致了解其中可用的函数和参数就可以了。
    (./) 由于它们的语法非常相似,你仅仅阅读一下 re 模块的摘要,大致了解其中可用的函数和参数就可以了。

7.1 概览

  1. Para 2If what you're trying to do can be accomplished with string functions, you should use them. They're fast and simple and easy to read, and there's a lot to be said for fast, simple, readable code.
    如果你要解决的问题利用字符串函数能够完成,你应该使用它们。它们快速、简单且容易阅读,而对于快速、简单、可读性强的代码等方面有很多内容
    (./) ……它们快速、简单且容易阅读,而快速、简单、可读性强的代码可以说出很多好处

7.2 个案研究:街道地址

  1. 例7.1下, Para 1很快,我发现上面的例子,仅仅匹配地址末尾的……
    (./) 很快我发现,在上面的例子中,……

  2. 例7.2, (1):你利用 \b,……在 python 中,由于字符'\'在一个字符串中必须转义这个事实,从而变得非常麻烦。
    (./) 由于字符 '\' 在一个字符串中必须转义,这会变得非常麻烦。

7.3 个案研究:罗马字母

  1. 确定了几个术语的使用:“fives character”翻译为“含五字符”(原译“被5整除的字符”),同样地,“tens character”翻译为“含十字符”(原译“被10整除的字符”)。原译注删去。
  2. Para 1:这是一个表示数字的系统,它能够真正回溯到远古的罗马帝国(因此而得名)。 (./) 它实际上能够追溯到远古的罗马帝国

  3. 列举, 最后一条:罗马数字经常 <!> 从高位到低位书写,…… (./) 一般

7.3.1 校验千位数

  1. Para 1:……由于罗马数字经常 <!> 是从高位到低位书写,…… (./) 一般

  2. 例7.3, (1)^表示仅仅 <!> 在一个字符串的开始匹配其后的字符串内容。 (./)

  3. 同上:M?可选地匹配单个字符 M,由于它 {i} 重复出现三次,…… (!) 根据上文 (./) 最多

  4. 例7.3, (2):re 模块的本质是一个 search 函数
    (!) 模块的本质是函数??
    (./) 模块的关键是一个 search 函数

  5. 同上:你此刻关注的唯一事情,就是模式是否匹配上,可以利用 search 函数的返回值弄清这个事实。
    (./) ……于是我们利用 search 函数的返回值了解这个事实。

  6. 例7.3, (3):'MM' {i} 匹配上是因为…… (./)

  7. 例7.3, (4):'MMM' {i} 匹配上是因为…… (./)

  8. 例7.3, (5):'MMMM' 没有匹配上。因为所有的三个 M 都匹配上,但是正则表达式还有字符串尾部的限制(由于字符 $),然而字符串没有结束……
    (./) 'MMMM' 没有匹配上。因为所有的三个 M 都匹配完了,但是正则表达式还有字符串尾部的限制(由于字符 $),字符串又没有结束

7.3.2 检验百位数

  1. 标题检验百位数 (!) 为和上一节标题“校验千位数”一致, (./) 校验百位数

  2. 文中多次出现了X位数位置 <!> ,实际上指的就是 (./) X位数,一律修正。

  3. Para 1:……,具体用那种方式表达和具体的数值相关
    (./) 具体用那种方式表达和具体的数值有关

  4. 第二次列举:零到三次出现 C 字符(如果是零,表示百位数为 0(./) 出现零次表示百位数为 0

  5. 例7.4, (2):因此 CD 和 D?C?C?C? 两个模式甚至 {X} 不再考虑

  6. Para -1吆!来看正则表达式能够多快变得难以理解?
    (!) 这个语气叹词我可没见过(字典里也找不到这一义项,只能解释为动词,不能做语气词)。
    (./) 哎呀!来看正则表达式能够多快变得难以理解?

7.4 使用 {n,m} 语法

  1. Para 1:在 前面的章节,你处理了相同字符可以重复三次的情况,在正则表达式中有另外一个方式来表达这种情况,并且使代码的可读性更好
    (./) 在前面的章节,你处理了相同字符可以重复三次的情况在正则表达式中有另外一个方式来表达这种情况,并且能提高代码的可读性

  2. 例7.6, (1)The 0 and 3 can be any numbers; if you want to match at least one but no more than three M characters, you could say M{1,3}.
    可是是 0 到 3 之间的任何数字,如果你想要匹配至少 1 次,至多 3 次字符 M,则可以写成 M{1,3}。
    (./) 这里的 0 和 3 可以改成其它任何数字;如果你想要匹配至少 1 次,至多 3 次字符 M,则可以写成 M{1,3}。
    (!) 对照原文,不难判定孰正孰误。

  3. 例7.6, (5):但是 没有匹配 <!> 字符串的结尾。 (!) 根据上文,这里应当是 (./) 没有匹配上

  4. 例7.6下, 注解:没有一个轻松的方法来确定两个正则表达式是否为等价的,……在本书后面的章节,关于如何书写测试样例有更多的讨论
    (./) 没有一个轻松的方法来确定两个正则表达式是否等价。……在本书后面的章节,将更多地讨论如何编写测试样例

7.4.1 校验十位数和个位数

  1. Para 1:现在我们来扩展扩展关于罗马数字的正则表达式,……
    (./) 现在我们来扩展一下关于罗马数字的正则表达式,……

  2. 7.4 Para -2:……我曾经做过这样的事情,但是它并不是那么好看 <!>(./) 有趣

7.5 松散正则表达式

  1. 例7.9, (1):当使用松散正则表达式时,请记住 {X} 最重要的一件事情就是:……

7.6 个案研究:解析电话号码

  1. 例7.10, (1)通常是从左到右阅读正则表达式,……
    (./) 我们通常从左到右阅读正则表达式

  2. 为了用词的统一,后文的分割符 <!> 一律改为 (./) 分隔符

  3. 例7.14, (1):这个正则表达式和前面的几乎相同,除了在第一个记忆组(区号)前面匹配……
    (./) 这个正则表达式和前面的几乎相同,但它在第一个记忆组(区号)前面匹配……

  4. 例7.14, (4):但是你认为在区号前面的所有字符都是非数字字符(\D*)。Aargh.
    (!) 没有翻译??!!
    (./) ……唉!

  5. 例7.15, (2):……,不论这个电话号码的首字符是数字还是不是数字还是在电话号码不同部分之间加上任意数目的任意类型的分隔符。,……
    (./) ……,无论这个电话号码的首字符是不是数字无论在电话号码各部分之间有多少任意类型的分隔符。

7.7 小结

  1. x? 匹配一个可选的 x 字符(换句话说,它匹配 1 次或者 0 次 x 字符)。 (./) 换言之

  2. Para -1:一些人,当遇到一个问题时,想“……”
    (./) 一些人,遇到一个问题时就想:“……”

7.-1 反馈

7-23<X8>dialect.xml HTML 处理

  • 感谢 zhangfance。

    本章频繁 typo:显示显式混用。

8.1 概览

  1. Para 1How do I parse/translate/munge the text of my HTML document but leave the tags alone?
    怎么才能 [分析|解释|munge] 我的 HTML 文档的文本,但是不要标记呢
    (!) “leave alone”的意思是“不惊动,不涉及”,而非“不要”。
    (./) 怎么才能 [分析|解释|munge] 我的 HTML 文档的文本,但是又要保留标记呢

8.2 sgmllib.py 介绍

  1. Para 5:开始标记(Start tag)是一个 {X} 开始一个块的 HTML 标记,像……

  2. 警示, Line -1在这 <!> 错误在 python 2.1 中改正了。 (./) 这个

8.3 从 HTML 文档中提取数据

  1. Para 2If you have some HTML lying around on your hard drive, you can use file functions to read it,... 如果在您的硬盘里存放着 HTML 文件,您可以使用 file 函数 将它读出来,……
    (!) 就链接的指向来看,file functions 指的是 (./) 处理文件的函数

  2. 例8.6, (1), Line -1:……当某人重用一个分析器实例时, <!> 正确地重新初始化 (./) 可以

  3. 例8.6, (3):我们可以通过一个简单的 多变量 list 映射来查找是否这个 <a> 标记拥有一个 href 属性。
    (./) 我们可以通过一个简单的 多变量 list 映射来查找这个 <a> 标记是否拥有一个 href 属性。

  4. 例8.7, (1), 脚注:……也许因为这就选择了 feed 这个名字。 (!) 汉语博大精深的词汇怎么不好好利用啊 (./) 因此

  5. 整节 Line -1{i} 如果 当您读到此处发现输出结果不一样,那是因为下载了本书的更新版本。

8.4 BaseHTMLProcessor.py 介绍

  1. Para 1:您可以通过将 SGMLParser 子类化来定义一个类,……
    (./) 您可以定义 SGMLParser 的子类,……

  2. Para 2SGMLParser 子类化 BaseHTMLProcessor (./) BaseHTMLProcessor 子类化 SGMLParser

8.5 locals 和 globals

  1. ……一会 {i} 我们就会看到

  2. 例8.10上, Para 1, Line 1:您是否为此而感到困惑?不要绝望(!) 汗……哪这么容易绝望
    (./) 您是否为此而感到困惑?不要灰心

  3. 例8.10下, Para 1不仅仅是模块的名字空间包含了模块级的变量和常量,它还包括了所有在模块中定义的函数和类。再加上,它包括了任何被导入到模块中的东西。
    (./) 模块的名字空间不仅仅包含了模块级的变量和常量,包括了所有在模块中定义的函数和类。除此以外,它包括了任何被导入到模块中的东西。

  4. 下一段:这就是为什么您可以直接访问它们却不需要引用它们所来源的模块的原因 {X}
    (!) 原句明显病句(句式杂糅)。

  5. 例8.11, 样例输出:原文最后的“rest of output omitted for brevity”翻译为“略”是正确的。但是这段输出是放在<programlisting>里面的,在语法着色的时候会把中文分解成XML标记,显示出来也是XML标记而不是中文。改回“rest of output omitted for brevity”。

  6. 例8.11, 样例输出, (1)SGMLParser 使用了 from module import 从 sgmllib 中被导入。
    (!) 中文的表达采用主动式更自然。
    (./) 我们使用了 from module import SGMLParser 从 sgmllib 中导入。

  7. 例8.11, 样例输出, (2):对比这个和 htmlentitydefs,它是用 import 被导入的。也就是说 htmlentitydefs 模块本身也在名字空间中,但是 entitydefs 变量定义在 htmlentitydefs 之外。
    (!) 上下文无法全部列出,还请参看原文。
    (./) 把上面的例子和 htmlentitydefs 对比一下,它是用 import 被导入的。也就是说 htmlentitydefs 模块本身被导入了名字空间,但是定义在 htmlentitydefs 之中的 entitydefs 变量却没有

  8. 例8.11, 样例输出, (4):当运行一个模块时 ( <!> 从另外一个模块中导入而言) (./) 相对于

  9. 例8.12上, Line -1It will bite you anyway, but at least then you'll remember learning it.
    它无论如何都会困扰您的,但至少您还记得了解过它。
    (./) 它无论如何都会困扰您的,但至少您还会记得曾经学习过它。

  10. 例8.12, (1):locals 是一个返回 dictionary 的函数,并且 {i} 在 dictionary 中设置 {i} 一个值。

8.6 基于 dictionary 的字符串格式化

  1. 例8.13, (1):这个名字是 params dictionary 中的一个键字,并且将 %(pwd)s 标记所在的地方替换成相应的值 secret。
    (./) 所以 %(pwd)s 标记所在的地方替换成相应的值 secret。

  2. 例8.13, (3)You can even specify the same key twice; each occurrence will be replaced with the same value.
    您甚至可以两次指定同一键字,每个键字发生之处将被同一个值所替换。
    (./) 您甚至可以两次指定同一键字,每个键字出现之处将被同一个值所替换。

  3. 例8.14上Well, it does seem like overkill to set up a dictionary of keys and values simply to do string formatting in the next line;
    好,在下面一行中,仅为了进行字符串格式化就需要创建一个有键字和值的 dictionary 看上去的确有些小题大作。
    (./) 的确,仅为了进行字符串格式化,就事先创建一个有键字和值的 dictionary 看上去的确有些小题大作。
    (!) 看看原文就不难知道孰正孰误。“下一行”这个意思没有保留。原文的next line也只是笼统的概念,不一定创建了这样一个 dictionary 后就非得在下一行进行字符串格式化。

  4. 例8.15, (1), b:在这个列表理解 <!> 的第一轮循环中,…… (./) 解析

  5. 例8.15, (1), c:这个字符串就作为这个列表理解 <!> 返回值的第一个元素。 (./) 解析

8.7 给属性值加引号

  1. Para 2:即使它们可能以大写字母开始或是大小写的混和 <!> 形式。 (./) 混合 (!) 连我自己起初都不相信,但这确实是错别字。

  2. 例8.16, 标题:Quoting attribute values (!) 又一次没有翻译 (./) 给属性值加引号

8.8 dialect.py 介绍

  1. 例8.17, (1)每次 SGMLParser 在 HTML 源代码中…… (!) 此处的“每次”改为 (./) 每当。后面相似的句型作一样的修改,不再列出。

  2. 例8.17, (2):我们可以将它作为一个标志,并且把它设为 1 或重置为 0,但这样做……
    (./) 我们本可以把它实现为一个标志,即或把它设为 1,重置为 0,

  3. 例8.18, (1)The only thing left to do is figure out whether there is a specific handler method for this tag, or whether you should fall back on the default method.
    唯一要做的事情就是找到对于这个标记是否存在一个特别的处理方法,或者是否我们应该求助于缺省方法。
    (./) 唯一要做的事情就是检查对于这个标记是否存在一个特别的处理方法,否则我们应该求助于缺省方法。

  4. 例8.18, (2):您以前可能还没注意到的是 getattr 将查找定义在一个对象的继承者中或对象自身的方法。
    (./) 您以前可能还没注意到 getattr 将查找定义在一个对象的继承者中或对象自身的方法。

  5. 例8.18, (4):正如您看一 <!> 的,…… (!) typo (./) 看到

  6. 例8.18, (5):……来调用 getattr 实败 <!> 了。 (./) 失败

  7. 例8.18, (8)start_xxx and do_xxx methods are not called directly; the tag, method, and attributes are passed to this function, handle_starttag, so that descendants can override it and change the way all start tags are dispatched. You don't need that level of control, so you just let this method do its thing, which is to call the method (start_xxx or do_xxx) with the list of attributes.
    start_xxx 和 do_xxx 方法并不被直接调用标记名、方法和属性被传给 handle_starttag 这个方法,以便继承者可以覆盖它,并改变 全部 开始标记分发的方式。我们不需要控制层,所以我们只让这个方法做它自已的事,就是用属性属性 {X} 的 list 来调用方法 (start_xxx 或 do_xxx) 。
    (!) that level of controlcontrol而非level是中心语 (./) start_xxx 和 do_xxx 方法并不被直接调用标记名、方法和属性被传给 handle_starttag 这个方法,以便继承者可以覆盖它,并改变 全部 开始标记分发的方式。我们不需要控制这个层面上,所以……

  8. 例8.19上:当我们跑题时,我们正在定义 <!> 特别的处理方法来处理…… (./) 定义了

8.9 全部放在一起

  1. Para 1:到了 {X} 将迄今为止我们已经学过并用得不错的东西放在一起的时候了。

  2. 例8.20, (3)Now you get the source of the given URL.
    现在我们得到了给定的URL的原始资料了(./) 现在我们得到了给定的 URL 源文件了

  3. 例8.21, (1)Combined with some string formatting, you've taken the name of a dialect and transformed it into the name of the corresponding Dialectizer class.
    与某个字符串格式化合在一起使用后,我们就得到了一种方言的名字,接着将它转化为相应的方言变换器类的名字。
    (./) 再使用字符串格式化,我们就得到了一种方言的名字,将它转化为相应的方言变换器类的名字。

  4. 例8.21, (2):我们有了一个字符串形式 (parserName) 的类名称,还有一个 dictionary (globals()) 形式的全局名字空间。合起来后,我们可以得到一个以前面字符串 <!> 命名的类的引用。 (./) 前者

  5. 例8.21, (3):……像函数一样调用类。这个类保存在一个局部变量中的事实完全不会有什么影响;……
    (./) 这个类保存在一个局部变量中,但这个事实完全不会有什么影响

  6. 例8.21下, Para 1Why bother?
    怎么这么麻烦?
    (./) 何必这么麻烦?

  7. 例8.22, (1)After all that imagining, this is going to seem pretty boring, but the feed function is what does the entire transformation.
    毕竟那只是假设,这个似乎会非常令人讨厌,但这个 feed 函数执行了全部的转换工作。
    (./) 剩下的工作似乎会非常无聊,但实际上,feed 函数执行了全部的转换工作。

  8. 进一步阅读:您可能会认为我正在拿服务端脚本编程开玩笑。在我发现这个 基于 web 的方言转换器 之前,的确是这样认为的。
    (./) 您可能会认为我的服务端脚本编程的想法是开玩笑。在我发现这个 基于 web 的方言转换器 之前,的确是这样的。

8.10 小结

  1. 汇集结果,如 URL lister (!) 根据 URL lister 的实际用途,改为 (./) 摘录结果

  2. 按结构的方式对其进行修改,如 属性引用
    (./) 在处理过程中顺便调整结构,如 给属性值加引号

8.-1 反馈

7-25<X9>kpg.xml XML 处理

  • 为了术语的一致,把file-like object 统一译为“类文件对象”。

9.1 概览

  1. Para 1:下面两章是关于 Python 中 XML 处理的。如果你已经知道一个 XML 文档的样子,……
    (./) 如果你已经对 XML 文档有了一个大概的了解

  2. Para 3:Being a philosophy major is not required, although if you have ever had the misfortune of being subjected to the writings of Immanuel Kant, you will appreciate the example program a lot more than if you majored in something useful, like computer science. (!) 又一次没有翻译
    (./) 如果你在大学里主修哲学(而不是像计算机科学这样的实用专业),并且曾不幸地被伊曼努尔·康德的著作折磨地够呛,那么你会非常欣赏本章的样例程序。(这当然不意味着你必须修过哲学。)

  3. 例9.3, 标题:Sample output of kgp.py (./) kgp.py 的样例输出

  4. 例9.3下, Para 1, Line -1:但所有内容都 {X} 符合康德的风格。

  5. 例9.4上The interesting thing about this program is that there is nothing Kant-specific about it. 关于这个程序的有趣之处在于没有一点内容是属于康德的。
    (./) 有趣之处在于,这个程序中没有一点内容是属于康德的。

9.2 包

  1. 例9.5, (1):这个语法你之前没有见过。它看上去很像我们所知并且喜欢的 from module import,但是……
    (./) 这个语法你之前没有见过。它看上去很像我们熟知的 from module import,但是……

  2. 例9.6下Python 认为它的意思是:“在 xml 目录中查找 dom 目录,然后在中查找 minidom 模块,……”
    (!) 原文即为斜体
    (./) 在 xml 目录中查找 dom 目录,然后在 这个目录 中查找 minidom 模块

  3. 例9.7, (1):……为了能够引用 minidom 模块中的类(比如 Element),你必须在它们的类名前面加上模块名。
    (./) 引用 minidom 模块中的类(比如 Element),你必须在它们的类名前面加上模块名。

  4. 例9.7, (3)Here you are importing the dom package (a nested package of xml) as a module in and of itself.
    这里你正在导入 dom 包(xml 的一个嵌套包),并将其作为自己或者内部的 {X} 一个模块。
    (!) in and of 只是对itself 的强调

9.3 XML 解析

  1. 例9.8, (1):正如在上一 {X} 节看到的,……

  2. 例9.8, (2):它只是我本地磁盘上一个 XML 文档的文件名。(为了继续执行, {X} 你需要将路径改为指向下载的例子所在的目录。)

  3. 例9.12, 标题:Drilling down all the way to text (./) 把文本挖出来

  4. 例9.12, (2)The ref element has its own set of child nodes, one for the carriage return, a separate one for the spaces, one for the p element, and so forth.
    ref元素有它自己的子节点集合,一个表示硬回车,一个独立表示空格的,一个用于p元素的,诸如此类。
    (./) ref 元素有它自己的子节点集合,一个表示硬回车,一个表示空格,一个表示 p 元素,诸如此类。

  5. 例9.12, (3):你甚至可以在这里使用 toxml 方法, {i} 尽管它深深嵌套在文档中。

  6. 例9.12, (3):p 元素只有一个子节点(在这个例子中,你无法知道这一点,……)
    (./) p 元素只有一个子节点(在这个例子中无法看出……)

9.4 Unicode

  1. 历史注解, Para 1:……在系统之间进行文档交流是困难的,因为对于一台计算机来说,没有方法可以识别出文档的作者使用了哪种编码模式;计算机看到的只是数字,并且这些数字可以表示不同的东西。接着考虑到试图将这些 {i} (采用不同编码的)文档存放到同一个地方(比如在同一个数据库表中);……比较有代表性的是使用转义符来进行模式切换; <!> ,我们处于俄语 koi8-r 模式,所以字符 241 表示这个;,现在我们处于 Mac 希腊语模式,…… (./)
    (!) 原文太长,不能全部列出。

  2. 历史注解, Para 3, Line -1:Unicode使用同7位 ASCII 码一样的字符表示0到127同ISO-8859-1一样的字符表示128到255,接着使用剩余的数字,256到65535,扩展到表示其它语言的字符。
    (./) Unicode 在 0 到 127 上使用了同 7 位 ASCII 码一样的字符表在 128 到 255上同 ISO-8859-1 一样,接着使用剩余的数字,256 到 65535,扩展到表示其它语言的字符。

  3. 历史注解, Para 4:……或将数据打印输出到一个非unicode识别终端或打印机。
    (./) 或将数据打印输出到一个不识别 unicode 的终端或打印机。

  4. 例9.13上, Para -1:从2.0版本开始,Python 在整个语言的基础上已经支持unicode。
    (./) 从 2.0 开始,Python 整个语言都已经支持 unicode。

  5. 例9.14, (2):还记得我说过 print 函数会尝试将unicode字符串转换为 ASCII,这样就可以打印它了吗?
    (./) 还记得我说过 print 函数会尝试将 unicode 字符串转换为 ASCII 从而打印它吗?

  6. 例9.14, (3):……我们使用 latin-1(也就是大家知道的 iso-8859-1)
    (./) 我们使用 latin-1(也叫 iso-8859-1)

  7. 例9.15, (2):Python 会在任何需要自动将unicode字符串强制转换为正规字符串的地方,使用这个编码模式。
    (./) Python 会在任何需要将 unicode 字符串自动转换为正规字符串的地方,使用这个编码模式。

  8. 例9.15, (1)The default encoding can only be changed during Python startup; you can't change it later. (Due to some wacky programming tricks that I won't get into right now, you can't even call sys.setdefaultencoding after Python has started up.
    默认的编码只会在 Python 启动的时候改变;之后就不能改变了。(由于一些古怪的编程技巧,我没有马上深入,你甚至不能在 Python 启动之后调用sys.setdefaultencoding函数。……)
    (./) 由于一些我们现在不会仔细研究的古怪的编程技巧,你甚至不能在 Python 启动之后调用 sys.setdefaultencoding 函数。

  9. 例9.18上:现在,想想 XML 中的编码应该是怎样的呢?不错的是 {X} ,每一个 XML 文档都有指定的编码。

  10. 例9.19, (3):打印title是不可能的,因为这个unicode字符串包哈了非 ASCII 字符,……
    (./) 直接打印 title 是不可能的,因为这个 unicode 字符串包含了非 ASCII 字符,……

  11. 例9.19, (4)你能够,但是,显式将它转换为koi8-r,……
    (./) 但是,你能够显式将它转换为 koi8-r,……

  12. 进一步阅读:PEP 263 涉及了何时、如何在你的 .py 文件中定义字符 {i} 编码的更多细节。

9.5 搜索元素

  1. Para 1:在这部分,将使用 binary.xml 语法文件,它看上去是这样的
    (./) 在这部分,将使用 binary.xml 语法文件,它的内容如下

  2. 例9.20上:它有两个 ref,'bit' {i} (位)和 'byte' {i} (字节)

  3. 例9.22, (3):在本例中,你有两个,每“位”使用一个。
    (./) 在本例中,你有两个元素,每“位”各占一个。
    (!) 还请参见原文

9.6 访问元素属性

  1. Para 3:这部分由于某个涵义 <!> 重叠的术语可能让人有点糊涂。 (./) 含义 (!) 这不是错别字,但属于非推荐词形1

  2. 例9.24, (1):每个 Element 对象都有一个称为 attributes {X} 属性

  3. 例9.24, (5):……那些非常认真的读者将已经知道 NamedNodeMap 类是如何实现这一技巧的:通过定义一个 __getitem__ 特殊方法
    (!) 为和前面的术语一致,改为 (./) 专用方法

  4. 同上{i} 它的读者可能乐意接受这一事实:……

  5. 例9.25, (1):与你在 bitref.attributes NamedNodeMap {X} 伪目录中寻找的对象同名

9.7 Segue

  1. 标题:有必要解释一下标题的含义。加入了脚注:
    “Segue”是音乐术语,意为“继续演奏”。

  2. Para 1OK,that's it for the hard-core XML stuff. (!) 又一次……
    (./) 以上就是 XML 的核心内容。

9.-1 反馈

7-29<X10>kpg.xml 脚本和流

  1. “接收……作为参数”一律改为“接受……作为参数”
  2. 本章标题Scrips 和 Streams (./) 脚本和流

10.1 抽象输入源

  1. Para 1:Python 的最强大力量之一是它的动态绑定,并且动态绑定最强大的用法之一是类文件(file-like)对象。
    (./) Python 的最强大力量之一是它的动态绑定,动态绑定最强大的用法之一是类文件(file-like)对象。

  2. 例10.1上, Para -2:只要你将一个类文件对象传递给函数,函数只是调用对象的 read 方法,函数可以处理任何类型的输入源,而不需要处理每种类型的特定代码
    (./) 只要你将一个类文件对象传递给函数,函数只是调用对象的 read 方法,就可以处理任何类型的输入源,而不需要为处理每种类型分别编码

  3. 例10.1上, Para -1:你可能纳闷这和 XML 处理有什么关系,…… (./) 你可能纳闷……

  4. 例10.1, (3):确保处理完 {X} 文件后调用 close 方法。

  5. 例10.2上:哦,所有这些看上去象是在浪费大量的时间。毕竟,你已经看过 minidom.parse 可以只接收文件名,并自动执行所有打开文件和关闭无用文件的行为。不错,如果你知道正要解析的是一个本地文件,你可以传递文件名而且 minidom.parse 可以足够聪明的做正确的事情™,这一切都不会有问题。但是请注意,使用类文件分析直接从Internet上来的 XML 文档是多么相似和容易的事情
    (./) 哦,所有这些看上去像是在浪费大量的时间。毕竟,你已经看到,minidom.parse 可以只接收文件名,并自动执行所有打开文件和关闭无用文件的行为。不错,如果你知道正要解析的是一个本地文件,你可以传递文件名而且 minidom.parse 可以足够聪明地做正确的事情(Do The Right Thing™),这一切都不会有问题。但是请注意,使用类文件,会使分析直接从 Internet 上来的 XML 文档变得多么相似和容易
    (!) 我就纳闷了,怎么“做正确的事情”也成了 trademark。顺便加了个注释 {i} 这是一部著名的电影。——译注

  6. 例10.2, (1){i} 前一章中所看到的,……

  7. 例10.2, (4)By the way, this URL is real, and it really is XML. It's an XML representation of the current headlines on Slashdot, a technical news and gossip site.
    顺便提一句,这个 URL 是真实的,它真的是一个 XML。它是Slashdot站点(这是一个技术新闻和随笔站点)上当前标题的 XML 表示。
    (./) 顺便提一句,这个 URL 是真实的,它真的是一个 XML。它是 Slashdot 站点(一个技术新闻和随笔站点)上当前新闻提要的 XML 表示。

  8. 例10.3下OK,所以你可以使用 minidom.parse 函数来解析本地文件和远端 URL,但对于解析字符串,你使用……一个不同的函数。
    (./) 好吧,所以你可以使用 minidom.parse 函数来解析本地文件和远端 URL,但对于解析字符串,你使用……另一个函数。

  9. 例10.4上:如果有一个方法可以把字符串转换成类文件对象,那么你可以只把 <!> 这个对象传递给 minidom.parse 就可以了。 (./) 只要

  10. 例10.4, (1):StringIO 模块只包含了单个 <!> 类,也叫 StringIO,它允许你将一个字符串转换为一个类文件对象。这个 {X} StringIO 类在创建实例的时候接收字符串作为参数。 (./) 一个

  11. 例10.4, (4):任何时候,read 都将返回字符串的未读剩余 {X} 部分。

  12. 例10.5, (1):……它将调用对象的 read 方法并高兴的开始解析,绝不会知道它的输入源 {X} 自一个硬编码的字符串。

  13. 例10.5下:那么现在你知道了如何使用单个 <!> 函数,minidom.parse,来解析一个保存在 web 页面上、本地文件中或硬编码字符串中的 XML 文档。 (./) 同一个

  14. 例10.6, (1):……source 是某种类型的字符串;它可能是一个 URL(例如 'http://slashdot.org/slashdot.rdf' ),一个本地文件的完整或者部分路径名(例如 'binary.xml'),或者是一个包含了需要解析 <!> XML 数据的字符串。待解析

  15. 例10.6, (2)This is actually elegant in the sense that, if urllib ever supports new types of URLs in the future, you will also support them without recoding.
    这里通过强制方式进行:尝试把它当作一个 URL 打开并静静地忽略打开非 URL 引起的错误。感觉上 {X} 这样做非常好,因为如果 urllib 将来支持更多的 URL 类型,不用重新编码就可以支持它们。

  16. 例10.6, (3):再一次,你不用做任何特别的事来检查 source 是否是一个有效的文件名(总之在不同的平台上,判断文件名有效性的规则变化很大,那么不管怎样做都可能会判断错)。
    (./) 再一次,你不用做任何特别的事来检查 source 是否是一个有效的文件名(在不同的平台上,判断文件名有效性的规则变化很大,因此不管怎样做都可能会判断错)。

  17. 例10.6, (4):到这里,你需要假设 source 是一个其中有硬编码数据的字符串(因为没有什么可以判断的了),所以你可以使用 StringIO 从中创建一个类文件对象并将它返回。(实际上,由于使用了 str 函数,所以 source 没有必要一定是字符串;它可以是任何对象,你可以使用它的字符串表示形式,通过它的定义的 __str__ 特殊方法。) (./) 到这里,你需要假设 source 是一个其中有硬编码数据的字符串(因为没有别的可以判断的了),所以你可以使用 StringIO 从中创建一个类文件对象并将它返回。(实际上,由于使用了 str 函数,所以 source 没有必要一定是字符串;它可以是任何对象,你可以使用它的字符串表示形式,只要定义了它的 __str__ 专用方法。)

  18. 例10.6下:……构造一个函数,接收一个指向 XML 文档的 source,而且无需知道这个 source 的含义, <!> 解析它。 (./) 然后

10.2 标准输入、输出和错误

  1. Para 2:……当你 print 某些东西时,结果前往 stdout 管道;当你的程序崩溃并打印出调试信息(类似于 <!> Python 中的 {i} traceback(错误跟踪))的时候,信息前往 stderr 管道。 (./) 例如

  2. 例10.8, (1):正如 {i} 例 6.9, “简单计数”中看到的,……

  3. 例10.8, (3)像 stdout <!> ,stderr 并不为你添加硬回车;如果需要,要自己加上。 (./) 和 stdout 一样

  4. 例10.8下:……然而,它们仍然是类文件对象,并且你可以将其它任何文件或者类文件对象赋值给它们来重定向它们的输出。
    (./) 然而,它们仍然是类文件对象,因此你可以将其它任何(类)文件对象赋值给它们来重定向其输出。

  5. 例10.9:在 Windows 上,你可以使用 type 来代替 cat 显示文件的内容。
    (./) 在 Windows 上,你使用 type 来代替 cat 显示文件的内容。

  6. 例10.9, (4)所有后续的输出重定向到刚才打开的新文件上。
    (./) 所有后续的输出都会被重定向到刚才打开的新文件上。

  7. 例10.9, (5):这样只会将输出结果“printed <!> ”到日志文件中;…… (./) 打印

  8. 例10.10上:重定向 stderr 以完全相同的方式进行,用 sys.stderr 代替 sys.stdout。
    (./) 重定向 stderr 以完全相同的方式进行,只要把 sys.stdout 改为 sys.stderr

  9. 例10.10, (4)Also note that you're not explicitly closing your log file, nor are you setting stderr back to its original value. This is fine, since once the program crashes (because of the exception), Python will clean up and close the file for us, and it doesn't make any difference that stderr is never restored, since, as I mentioned, the program crashes and Python ends. Restoring the original is more important for stdout, if you expect to go do other stuff within the same script afterwards.
    还要注意你既没有显式关闭日志文件,也没有将 stderr 设回最初的值。这样挺好,因为一旦程序崩溃(由于引发的异常),Python 将替我们清理并关闭文件,这和永远不恢复 stderr 不会造成什么不同,因为,我提到过,一旦程序崩溃,则 Python 结束如果你希望在同一个脚本的后面去做其它的事情,恢复初始值对 stdout 更为重要。
    (./) 还要注意你既没有显式关闭日志文件,也没有将 stderr 设回最初的值。这样挺好,因为一旦程序崩溃(由于引发的异常),Python 将替我们清理并关闭文件,因此永远不恢复 stderr 不会造成什么影响。然而对于 stdout,恢复初始值相对更为重要——你可能会在后面再次操作标准输出(!) 原文比较长,所以 Mark 反复强调了程序崩溃后 Python 的行为。译文相对简洁,就没有这个必要了。

  10. 例10.11上:向标准错误写入错误信息是很常见的,所以有一种较快的语法可以立刻信息导出 <!>(./) 导出信息

  11. 例10.11, (1)This shorthand syntax of the print statement can be used to write to any open file, or file-like object. In this case, you can redirect a single print statement to stderr without affecting subsequent print statements. print 语句的快捷语法可以用于向任何打开的文件写入,或者是类文件对象在这种情况下,你可以将单个 print 语句重定向到 stderr 而且不用影响后面的 print 语句。
    (./) print 语句的快捷语法可以用于写入任何打开的文件(或者是类文件对象)在这里,你可以将单个 print 语句重定向到 stderr 而且不用影响后面的 print 语句。 (!) in this case 指上文的那一行语句。

  12. 例10.11下:标准输出,另一方面,只是一个只读文件对象,它表示从前一个程序到这个程序的数据流。这个对于老的 Mac OS 用户和 Windows 用户可能不太容易理解,除非你受到过 MS-DOS 命令行的影响。它工作的方式是你可以在单个命令行中构造一个命令的链,……
    (./) 另一方面,标准输入是一个只读文件对象,它表示从前一个程序到这个程序的数据流。这个对于老的 Mac OS 用户和 Windows 用户可能不太容易理解,除非你受到过 MS-DOS 命令行的影响。在 MS-DOS 命令行中,你可以使用一行指令构造一个命令的链,……

  13. 例10.12, (3):该处打印 binary.xml 的内容,但是“|”字符,称为“管道”符,说明内容不会打印到屏幕上。而且,它们会成为下一个命令的标准输入,在这个例子中是你调用的 Python 脚本。 (./) 该处打印 binary.xml 的内容,但是“|”字符,称为“管道”符,说明内容不会打印到屏幕上它们会成为下一个命令的标准输入,在这个例子中是你调用的 Python 脚本。

  14. 例10.12, (4):但是想想这里的扩展性。代替cat binary.xml,你可以通过运行一个脚本动态生成语法,然后你可以通过管道将它导入你的脚本。它可以来源于任何地方:数据库,或者是生成语法