Python 2.0 有什麼新功能
***********************

作者:
   A.M. Kuchling 和 Moshe Zadka


簡介
====

A new release of Python, version 2.0, was released on October 16,
2000. This article covers the exciting new features in 2.0, highlights
some other useful changes, and points out a few incompatible changes
that may require rewriting code.

Python 的开发工作在版本发布之间绝不会完全停止，总是会有错误修复和改进
被持续地提交。 2.0 中包含了大量的小问题修正、一些性能优化、额外的文档
字符串和更完善的错误消息；要列出所有这些是不可能的，但它们确实带来了明
显的变化。 如果你想查看完整清单可以参阅公开的 CVS 日志。 这些进展归功
于为 PythonLabs 工作的五位开发者，他们现在可以付出时间修复问题并获得报
酬，同时也归功于迁移到 SourceForge 后在沟通方面的改善。


Python 1.6 将会怎样？
=====================

Python 1.6 可以被视为继续履行合同义务的 Python 发布版。 在核心开发团队
于 2000 年 5 月离开 CNRI 之后，CNRI 要求创建一个 1.6 发布版，其中包含
CNRI 在 Python 项目上已完成的所有工作。 因此 Python 1.6 代表了截至
2000 年 5 月的 CVS 树的状态，其中最重要的新特性是 Unicode 支持。 当然
，5 月之后开发工作仍在继续，因此 1.6 树接受了一些修正以确保它对 Python
2.0 向上兼容。 所以 1.6 仍是 Python 演化过程的组成部分，而不是一个旁支
。

那么，你应该对 Python 1.6 保持更多关注吗？也许不必。 1.6final 和
2.0beta1 是在同一天（2000 年 9 月 5 日）发布的，计划在一个月左右的时间
内完成 Python 2.0 正式版。 如果你有应用程序需要维护，那么迁移到 1.6 破
坏兼容性，修复它们，然后在一个月内又迁移到 2.0 再进行新一轮的兼容性修
复的做法似乎没有什么意义；你最好直接迁移到 2.0。 本文档中介绍的大多数
真正值得关注的特性都只出现在 2.0 中，因为很多工作都是在 5 月到 9 月之
间完成的。


新开发流程
==========

Python 2.0 中最重要的变化可能根本不是代码，而是 Python 的开发方式：在
2000 年 5 月，Python 开发者开始使用 SourceForge 提供的工具来存储源代码
、跟踪错误报告以及管理补丁提交队列。 要报告 Python 2.0 的错误或提交补
丁，请使用位于 https://sourceforge.net/projects/python/ 的 Python项目
页上的错误跟踪和补丁管理器工具。

现在托管在SourceForge的最重要的服务是Python CVS树，这是一个包含Python
源代码的版本控制库。以前，大约有7个左右的人可以写入CVS树，所有的补丁都
必须由这个短名单上的一个人检查和签到。很明显，这并不是非常可扩展的。通
过将CVS树转移到SourceForge，有可能向更多的人授予写访问权；截至2000年9
月，有27人能够检查变化，增加了4倍。这使得大规模的改变成为可能，如果它
们必须通过一小群核心开发者来过滤，就不会被尝试。例如，有一天Peter
Schneider-Kamp想到了放弃K&R C的兼容性，将Python的C源转换为ANSI C。在获
得python-dev邮件列表的批准后，他发起了一连串的签到，持续了大约一周，其
他开发人员加入了进来帮忙，工作就完成了。如果只有5个人可以接触到写作，
那么这项任务可能会被视为 "不错，但不值得花费时间和精力，而且它永远不会
完成。

转向使用 SourceForge 的服务显著提高了开发速度。 补丁现在由原提交者以外
的人提交、评论、修改，并在不同人员之间来回传递，直到补丁被认为值得检入
。 程序错误在一个中心位置被跟踪，并可以分配给特定人员进行修复，我们还
可以统计未解决程序错误的数量来衡量进度。 这并不是没有代价的：开发人员
现在需要处理更多的电子邮件，关注更多的邮件列表，并且需要为新环境编写专
门的工具。 例如，SourceForge 发送的默认补丁和错误通知电子邮件完全无用
，所以 Ka-Ping Yee 编写了一个 HTML 屏幕抓取器以便发送更有用的信息。

添加代码的便利性引发了一些初期的成长痛苦，比如代码在准备好之前或未经开
发者团队明确同意就被检入。 现在形成的审批流程有点类似于 Apache 团队所
使用的流程。 开发者可以对补丁投票：+1、+0、-0 或 -1；+1 和 -1 表示接受
或拒绝，而 +0 和 -0 则表示开发者对变更大多持无所谓的态度，但略有正面或
负面的倾向。 与 Apache 模型最显著的变化是投票本质上是咨询性的，让拥有
终身仁慈独裁者地位的 Guido van Rossum 了解总体意见。 他仍然可以忽略投
票结果，并批准或拒绝变更，即使社区不同意他的决定。

实际产生补丁是添加新功能的最后一步，与之前指定一个好的设计相比，这通常
比较容易。 对于新功能的讨论往往会变成冗长的邮件列表帖子，使讨论难以跟
踪，并且没有人能够阅读每一条发给 python-dev 的帖子。 因此，建议了一个
相对正式的流程来编写 Python 增强提案（PEP），该流程借鉴了互联网 RFC 流
程。 PEP 是描述拟议新特性的草案文件，并不断修改，直到社区达成共识，接
受或拒绝该提案。 引用自 **PEP 1** 的介绍部分 "PEP Purpose and
Guidelines"：

   PEP 是 Python Enhancement Proposal 的缩写。 一个 PEP 就是一份设计文
   档，用来向 Python 社区提供信息，或描述一个 Python 新增特性。 PEP 应
   当提供对所提议特性的精确的技术规格和原理说明。

   我们打算将 PEP 作为提出新特性建议、收集社区对特定问题意见以及为必须
   加入 Python 的设计决策编写文档的首选机制。 PEP 的作者有责任在社区内
   部建立共识，并应将对立的观点也记入文档。

Read the rest of **PEP 1** for the details of the PEP editorial
process, style, and format.  PEPs are kept in the Python CVS tree on
SourceForge, though they're not part of the Python 2.0 distribution,
and are also available in HTML form from
https://www.python.org/dev/peps/.  As of September 2000, there are 25
PEPS, ranging from **PEP 201**, "Lockstep Iteration", to PEP 225,
"Elementwise/Objectwise Operators".


Unicode
=======

Python 2.0 中最大的新特性是引入了一种新的基本数据类型：Unicode 字符串
。 Unicode 使用 16 位二进制数表示字符，而不是 ASCII 所使用的 8 位，这
意味着可以支持 65,536 个不同的字符。

Unicode 支持的最终接口是通过在 python-dev 邮件列表上无数次激烈的讨论达
成的，主要由 Marc-André Lemburg 基于 Fredrik Lundh 的 Unicode 字符串类
型实现来完成。 详细的接口说明被写成了 **PEP 100** "Python Unicode
Integration"。 这篇文章只简单地涵盖关于 Unicode 接口的最重要信息。

In Python source code, Unicode strings are written as "u"string"".
Arbitrary Unicode characters can be written using a new escape
sequence, "\uHHHH", where *HHHH* is a 4-digit hexadecimal number from
0000 to FFFF.  The existing "\xHHHH" escape sequence can also be used,
and octal escapes can be used for characters up to U+01FF, which is
represented by "\777".

Unicode 字符串和常规字符串一样，是一种不可变的序列类型。 它们可以被索
引和切片，但不能原地修改。 Unicode 字符串有一个 "encode( [encoding] )"
方法，该方法返回一个以所需编码格式表示的 8 位字符串。 编码格式通过字符
串命名，如 "'ascii'"、"'utf-8'"、"'iso-8859-1'" 等等。 为实现和注册新
的编码格式定义了一个编解码器 API，这些编码格式随后可在整个 Python 程序
中使用。 如果未指定编码格式，默认编码格式通常是 7 位 ASCII，不过这可以
通过在自定义版本的 "site.py" 模块中调用
"sys.setdefaultencoding(encoding)" 函数来更改。

将 8 比特位和 Unicode 的字符串结合使用时将总是会使用默认 ASCII 编码格
式强制转换到 Unicode；"'a' + u'bc'" 的结果将为 "u'abc'"。

新增了一批内置函数，现有的内置函数也被修改为支持 Unicode：

* "unichr(ch)" 将返回长度为 1 个字符的 Unicode 字符串，其中包含字符
  *ch*。

* "ord(u)"，其中 *u* 是长度为 1 个字符的常规或 Unicode 字符串，将以整
  数形式返回该字符的码位值。

* 函数 "unicode(string [, encoding] [, errors] )" 从 8 位字符串创建一
  个 Unicode 字符串。 "encoding" 是一个指定使用编码格式的字符串。
  "errors" 参数指定如何处理当前编码格式中无效的字符；传入 "'strict'"
  作为参数值会在有任何编码错误时引发异常，而 "'ignore'" 会静默忽略错误
  ，"'replace'" 则在出现问题时使用 U+FFFD 即官方的替换字符。

* "exec" 语句，以及各种内置函数如 "eval()"，"getattr()" 和 "setattr()"
  也会接受 Unicode 字符串和普通字符串。 （修复过程中可能会遗漏一些内置
  函数；如果你发现一个接受字符串但完全不接受 Unicode 字符串的内置函数
  ，请报告此错误。）

一个新的模块 "unicodedata" 提供了对 Unicode 字符属性的接口。 例如，
"unicodedata.category(u'A')" 返回 2 个字符的字符串 'Lu'，其中 'L' 表示
这是一个字母，'u' 表示这是一个大写字母。
"unicodedata.bidirectional(u'\u0660')" 返回 'AN'，表示 U+0660 是一个阿
拉伯数字。

"codecs" 模块包含查找现有编码格式和注册新编码格式的函数。 除非你想实现
一个新的编码格式，否则你最常使用的是 "codecs.lookup(encoding)" 函数，
它返回一个 4 元素的元组: "(encode_func, decode_func, stream_reader,
stream_writer)"。

* *encode_func* 是一个接受 Unicode 字符串的函数，并返回一个 2 元组
  "(string, length)"。 *string* 是一个包含部分（可能是全部） Unicode
  字符串转换为指定编码的 8 位字符串，*length* 告诉你转换了多少 Unicode
  字符串。

* *decode_func* 与 *encode_func* 相反，它接受一个 8 位字符串并返回一个
  2 元组 "(ustring, length)"，其中 *ustring* 是转换得到的 Unicode 字符
  串，*length* 是一个整数，表示消耗了多少 8 位字符串。

* *stream_reader* is a class that supports decoding input from a
  stream. *stream_reader(file_obj)* returns an object that supports
  the "read()", "readline()", and "readlines()" methods.  These
  methods will all translate from the given encoding and return
  Unicode strings.

* *stream_writer*, similarly, is a class that supports encoding output
  to a stream.  *stream_writer(file_obj)* returns an object that
  supports the "write()" and "writelines()" methods.  These methods
  expect Unicode strings, translating them to the given encoding on
  output.

例如，以下的代码将 Unicode 字符串写入一个 UTF-8 编码的文件:

   import codecs

   unistr = u'\u0660\u2000ab ...'

   (UTF8_encode, UTF8_decode,
    UTF8_streamreader, UTF8_streamwriter) = codecs.lookup('UTF-8')

   output = UTF8_streamwriter( open( '/tmp/output', 'wb') )
   output.write( unistr )
   output.close()

以下的代码则可以从文件中读取 UTF-8 输入:

   input = UTF8_streamreader( open( '/tmp/output', 'rb') )
   print repr(input.read())
   input.close()

支持 Unicode 的正则表达式可以通过 "re" 模块使用，该模块有一个新的底层
实现称为 SRE，由 Secret Labs AB 的 Fredrik Lundh 编写。

添加了一个 "-U" 命令行选项，使 Python 编译器将所有字符串字面量解释为
Unicode 字符串字面量。 这用于测试和为你的 Python 代码提供未来保障，因
为未来某个版本的 Python 可能会取消对 8 位字符串的支持，只提供 Unicode
字符串。


串列綜合運算（List Comprehension）
==================================

列表是 Python 中的一种主力数据类型，许多程序在某个时候都会处理列表。
对列表的两种常见操作是遍历它们，并筛选出符合某个条件的元素，或对每个元
素应用某个函数。 例如，给定一个字符串列表，你可能想要提取出所有包含特
定子字符串的字符串，或去掉每行的尾随空白。

现有的 "map()" 和 "filter()" 函数可以用于此目的，但它们需要一个函数作
为参数之一。 如果有一个现有的内置函数可以直接传递，这是很好的，但如果
没有，你必须创建一个小函数来完成所需的工作。 而 Python 的作用域规则会
使结果变得丑陋，特别是如果这个小函数需要额外的信息。 以上一段中的第一
个例子为例，找到列表中所有包含给定子字符串的字符串。 你可以写如下代码
来实现:

   # Given the list L, make a list of all strings
   # containing the substring S.
   sublist = filter( lambda s, substring=S:
                        string.find(s, substring) != -1,
                     L)

由于 Python 的作用域规则，将会使用默认参数以使由 "lambda" 表达式创建的
匿名函数知道正在搜索哪个子字符串。 列表推导能使这个过程更简洁:

   sublist = [ s for s in L if string.find(s, S) != -1 ]

列表推导式的形式如下:

   [ expression for expr in sequence1
                for expr2 in sequence2 ...
                for exprN in sequenceN
                if condition ]

"for"...:keyword:*!in* 子句包含要迭代的序列。 这些序列不必具有相同的长
度，因为它们 *不是* 并行迭代的，而是从左到右依次迭代；这一点将在以下段
落中更清楚地解释。 生成列表的元素将是 *表达式* 的连续值。 最后的 "if"
子句是可选的；如果存在，只有当 *condition* 为真时，*表达式* 才会被求值
并添加到结果中。

为了使语义更为清晰，列表推导相当于以下 Python 代码:

   for expr1 in sequence1:
       for expr2 in sequence2:
       ...
           for exprN in sequenceN:
                if (condition):
                     # Append the value of
                     # the expression to the
                     # resulting list.

这意味着当有多个 "for"...:keyword:*!in* 子句时，生成的列表将等于所有序
列长的的乘积。 如果你有两个长度为 3 的列表，输出列表将有 9 个元素:

   seq1 = 'abc'
   seq2 = (1,2,3)
   >>> [ (x,y) for x in seq1 for y in seq2]
   [('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2), ('b', 3), ('c', 1),
   ('c', 2), ('c', 3)]

为了避免在 Python 的语法中引入歧义，如果 *表达式* 创建的是一个元组，它
必须用括号括起来。 下面的第一个列表推导式有语法错误，而第二个则是正确
的:

   # Syntax error
   [ x,y for x in seq1 for y in seq2]
   # Correct
   [ (x,y) for x in seq1 for y in seq2]

列表推导的概念最初来自函数式编程语言 Haskell (https://www.haskell.org)
。 Greg Ewing 最有力地提出了将其添加到 Python 中的建议，并编写了最初的
列表推导式补丁，然后在 python-dev 邮件列表上进行了看似无休止的讨论，并
由 Skip Montanaro 保持更新。


增强赋值
========

增强赋值运算符，另一个长期以来要求添加的功能，已经被加入到 Python 2.0
中。 增强赋值运算符包括 "+="，"-="，"*=" 等。例如，语句 "a += 2" 将变
量 "a" 的值增加 2，等同于稍长一些的 "a = a + 2"。

The full list of supported assignment operators is "+=", "-=", "*=",
"/=", "%=", "**=", "&=", "|=", "^=", ">>=", and "<<=".  Python classes
can override the augmented assignment operators by defining methods
named "__iadd__()", "__isub__()", etc.  For example, the following
"Number" class stores a number and supports using += to create a new
instance with an incremented value.

   class Number:
       def __init__(self, value):
           self.value = value
       def __iadd__(self, increment):
           return Number( self.value + increment)

   n = Number(5)
   n += 3
   print n.value

The "__iadd__()" special method is called with the value of the
increment, and should return a new instance with an appropriately
modified value; this return value is bound as the new value of the
variable on the left-hand side.

增强赋值运算符最早在 C 编程语言中引入，大多数 C 派生语言，如 **awk**，
C++，Java 和 PHP 也支持它们。 增强赋值补丁由 Thomas Wouters 实现。


字符串的方法
============

Until now string-manipulation functionality was in the "string"
module, which was usually a front-end for the "strop" module written
in C.  The addition of Unicode posed a difficulty for the "strop"
module, because the functions would all need to be rewritten in order
to accept either 8-bit or Unicode strings.  For functions such as
"string.replace()", which takes 3 string arguments, that means eight
possible permutations, and correspondingly complicated code.

相反，Python 2.0 将这个问题推给了字符串类型，使字符串操作功能通过 8 位
字符串和 Unicode 字符串上的方法来实现。

   >>> 'andrew'.capitalize()
   'Andrew'
   >>> 'hostname'.replace('os', 'linux')
   'hlinuxtname'
   >>> 'moshe'.find('sh')
   2

有一件事没有改变，即使是值得注意的愚人节玩笑，Python 字符串仍然是不可
变的。 因此，字符串方法返回的是新的字符串，而不是修改他们操作的原字符
串。

旧的 "string" 模块仍然存在以保持向向兼容，但它主要作为新字符串方法的前
端。

Two methods which have no parallel in pre-2.0 versions, although they
did exist in JPython for quite some time, are "startswith()" and
"endswith()". "s.startswith(t)" is equivalent to "s[:len(t)] == t",
while "s.endswith(t)" is equivalent to "s[-len(t):] == t".

One other method which deserves special mention is "join()".  The
"join()" method of a string receives one parameter, a sequence of
strings, and is equivalent to the "string.join()" function from the
old "string" module, with the arguments reversed. In other words,
"s.join(seq)" is equivalent to the old "string.join(seq, s)".


循环的垃圾回收
==============

Python 的 C 实现使用引用技术来实现垃圾回收。 每个 Python 对象维护一个
指向自身的引用数量，并在引用创建或销毁时调整该计数。 一旦引用计数达到
零，对象就不再可访问，因为访问对象需要一个引用，然后如果计数为零，就不
再存在任何引用。

引用计数有一些令人愉快的特性：它易于理解和实现，结果实现是可移植的，相
当快，并且与其他实现自己内存处理方案的库良好互动。引用计数的主要问题是
有时它无法识别对象不再可访问，从而导致内存泄露，这发生在存在引用循环时
。

考虑最简单的循环，一个类实例引用自身:

   instance = SomeClass()
   instance.myself = instance

在执行完上述两行代码后，"instance" 的引用计数是 2；一个引用来自名为
"'instance'" 的变量，另一个引用来自该实例的 "myself" 属性。

如果下一行代码是 "del instance"，会发生什么？ "instance" 的引用计数会
减少 1，所以它的引用计数变为 1；"myself" 属性中的引用仍然存在。 然而，
该实例不能再通过 Python 代码访问，并且它可以被删除。 如果多个对象相互
引用，它们可以参与一个循环，导致所有对象都无法被垃圾回收，从而导致内存
泄漏。

Python 2.0 通过周期性的执行一个循环检测算法来解决这个问题，该算法查找
不可访问的循环并删除涉及的对象。 一个新的 "gc" 模块提供了执行垃圾回收
、获取调试统计信息和调整回收器参数的功能。

运行循环检测算法需要一些时间，因此会带来一些额外的开销，希望在使用 2.0
版本的循环收集经验之后，Python 2.1 可以通过精细调整来尽量减少开销。 目
前还不清楚性能损失有多大，因为对此进行精准测试很棘手，而且关键在于程序
创建和销毁对象的频率。 如果你不能接受哪怕是微小的速度损失，或者怀疑循
环收集存在问题，可以在编译 Python 时禁用循环检测，通过在运行
**configure** 脚本时指定 "--without-cycle-gc" 开关来实现。

有几个人解决了这个问题并为解决方案做出了贡献。循环检测方法的早期实现由
Toby Kelsey 编写。 当前的算法是在 Eric Tiedemann 访问 CNRI 期间提出的
，Guido van Rossum 和 Neil Schemenauer 分别编写了两个不同的实现，后来
由 Neil 将它们整合。 许多其他人也在过程中提出了建议；python-dev 邮件列
表 2000 年 3 月的存档包含了大部分相关讨论，尤其是在标题为 “Reference
cycle collection for Python” 和 “Finalization again” 的帖子中。


其他核心变化
============

Python 的语法和内置函数进行了各种小改动。 虽然这些改动都不是非常深远，
但它们都是很方便的改进。


细微的语言特性修改
------------------

A new syntax makes it more convenient to call a given function with a
tuple of arguments and/or a dictionary of keyword arguments. In Python
1.5 and earlier, you'd use the "apply()" built-in function: "apply(f,
args, kw)" calls the function "f()" with the argument tuple *args* and
the keyword arguments in the dictionary *kw*.  "apply()"  is the same
in 2.0, but thanks to a patch from Greg Ewing, "f(*args, **kw)" is a
shorter and clearer way to achieve the same effect.  This syntax is
symmetrical with the syntax for defining functions:

   def f(*args, **kw):
       # args is a tuple of positional args,
       # kw is a dictionary of keyword args
       ...

The "print" statement can now have its output directed to a file-like
object by following the "print" with  ">> file", similar to the
redirection operator in Unix shells. Previously you'd either have to
use the "write()" method of the file-like object, which lacks the
convenience and simplicity of "print", or you could assign a new value
to "sys.stdout" and then restore the old value.  For sending output to
standard error, it's much easier to write this:

   print >> sys.stderr, "Warning: action field not supplied"

模块现在可以在导入时重命名，使用语法 "import module as name" 或 "from
module import name as othername"。这个补丁是由 Thomas Wouters 提交的。

当使用 "%" 操作符时有一种新的格式样式可用；'%r' 将插入其参数的
"repr()" 表示。 这也是为了对称性，这次是为了与现有的 %s 格式样式对称，
后者插入其参数的 "str()" 表示。例如，"'%r %s' % ('abc', 'abc')" 返回一
个包含 "'abc' abc" 的字符串。

Previously there was no way to implement a class that overrode
Python's built-in "in" operator and implemented a custom version.
"obj in seq" returns true if *obj* is present in the sequence *seq*;
Python computes this by simply trying every index of the sequence
until either *obj* is found or an "IndexError" is encountered.  Moshe
Zadka contributed a patch which adds a "__contains__()" magic method
for providing a custom implementation for "in". Additionally, new
built-in objects written in C can define what "in" means for them via
a new slot in the sequence protocol.

早期版本的 Python 使用递归算法来删除对象。深度嵌套的数据结构可能导致解
释器填满 C 栈并崩溃。 Christian Tismer 重写了删除逻辑来解决这个问题。
相关地，比较递归对象时会导致无线递归并崩溃。Jeremy Hylton 重写了代码，
使其不再崩溃，而是产生有用的结果。 例如，在以下代码之后:

   a = []
   b = []
   a.append(a)
   b.append(b)

The comparison "a==b" returns true, because the two recursive data
structures are isomorphic. See the thread "trashcan and PR#7" in the
April 2000 archives of the python-dev mailing list for the discussion
leading up to this implementation, and some useful relevant links.
Note that comparisons can now also raise exceptions. In earlier
versions of Python, a comparison operation such as "cmp(a,b)" would
always produce an answer, even if a user-defined "__cmp__()" method
encountered an error, since the resulting exception would simply be
silently swallowed.

来自 ActiveState 的 Trent Mick 主要负责将 Python 移植到 Itanium 处理器
上的 64 位 Windows 上。 （令人困惑的是，在 Win64 上，"sys.platform" 类
型仍然是 "'win32'" 的，因为为了便于移植，MS Visual C++ 在 Itanium 上将
代码视为 32 位。） PythonWin 还支持 Windows CE；更多信息请参见
https://pythonce.sourceforge.net/ 的 Python CE 页面。

另一个新的平台是 Darwin/MacOS X；Python 2.0 中提供了初步支持。如果你指
定 "configure --with-dyld --with-suffix=.x"，动态加载是可行的。 有关更
多说明，请参阅 Python 源代码分发中的 README 文件。

已经尝试解决 Python 的一个问题，即当代码在局部变量赋值之前引用该变量时
，会引发经常令人困惑的 "NameError" 异常。例如，以下代码在 1.5.2 和 2.0
中都会在 "print" 语句上引发异常；在 1.5.2 中，会引发 "NameError" 异常
，而在 2.0 中，会引发一个新的 "UnboundLocalError" 异常。
"UnboundLocalError" 是 "NameError" 的子类，因此任何期望引发
"NameError" 的现有代码应该仍然可以正常工作。

   def f():
       print "i=",i
       i = i + 1
   f()

新引入了两个异常 "TabError" 和 "IndentationError"。 它们均为
"SyntaxError" 的子类，并会在发现 Python 代码缩进不正确时被引发。


对于内置函数的修改
------------------

添加了一个新的内置函数 "zip(seq1, seq2, ...)"。"zip()" 返回一个包含元
组的列表，每个元组包含每个参数序列的第i个元素。"zip()" 和 "map(None,
seq1, seq2)" 的区别在于，如果序列长度不一致，"map()" 会用 "None" 填充
序列，而 "zip()" 会将返回的列表截短到最短的参数序列的长度。

The "int()" and "long()" functions now accept an optional "base"
parameter when the first argument is a string. "int('123', 10)"
returns 123, while "int('123', 16)" returns 291.  "int(123, 16)"
raises a "TypeError" exception with the message "can't convert non-
string with explicit base".

在 "sys" 模块中添加了一个新变量，用于保存更详细的版本信息。
"sys.version_info" 是一个包含五个元素的元组 "(major, minor, micro,
level, serial)"。 例如，在假设的 2.0.1beta1 版本中，"sys.version_info"
将是 "(2, 0, 1, 'beta', 1)"。 *level* 是一个字符串，如 ""alpha""、
""beta"" 或代表最终发布版本的 ""final""。

Dictionaries have an odd new method, "setdefault(key, default)", which
behaves similarly to the existing "get()" method.  However, if the key
is missing, "setdefault()" both returns the value of *default* as
"get()" would do, and also inserts it into the dictionary as the value
for *key*.  Thus, the following lines of code:

   if dict.has_key( key ): return dict[key]
   else:
       dict[key] = []
       return dict[key]

可以简化为单个``return dict.setdefault(key, [])``语句。

解释器设置了一个最大递归深度，以便在填满 C 栈并导致核心储存或 GPF 之前
捕获失控递归。以前这个限制是在编译 Python 时固定的，但在 2.0 中最大递
归深度可以使用 "sys.getrecursionlimit()" 和 "sys.setrecursionlimit()"
读取和修改。 默认值是 1000，可以通过运行一个新脚本
"Misc/find_recursionlimit.py" 来找到给定平台的大致的最大值。


移植 Python 2.0
===============

新的 Python 版本尽力与之前的版本兼容，而且兼容性记录相当不错。 然而，
有些变化被认为足够有用，通常是因为他们修正了最终设计中的错误决定，因此
有时无法避免打破向后兼容性。 本节列出了 Python 2.0 中可能导致旧 Python
代码中断的更改。

The change which will probably break the most code is tightening up
the arguments accepted by some methods.  Some methods would take
multiple arguments and treat them as a tuple, particularly various
list methods such as "append()" and "insert()". In earlier versions of
Python, if "L" is a list, "L.append( 1,2 )" appends the tuple "(1,2)"
to the list.  In Python 2.0 this causes a "TypeError" exception to be
raised, with the message: 'append requires exactly 1 argument; 2
given'.  The fix is to simply add an extra set of parentheses to pass
both values as a tuple:  "L.append( (1,2) )".

The earlier versions of these methods were more forgiving because they
used an old function in Python's C interface to parse their arguments;
2.0 modernizes them to use "PyArg_ParseTuple()", the current argument
parsing function, which provides more helpful error messages and
treats multi-argument calls as errors.  If you absolutely must use 2.0
but can't fix your code, you can edit "Objects/listobject.c" and
define the preprocessor symbol "NO_STRICT_LIST_APPEND" to preserve the
old behaviour; this isn't recommended.

Some of the functions in the "socket" module are still forgiving in
this way.  For example, "socket.connect( ('hostname', 25) )()" is the
correct form, passing a tuple representing an IP address, but
"socket.connect( 'hostname', 25 )()" also works. "socket.connect_ex()"
and "socket.bind()" are similarly easy-going.  2.0alpha1 tightened
these functions up, but because the documentation actually used the
erroneous multiple argument form, many people wrote code which would
break with the stricter checking.  GvR backed out the changes in the
face of public reaction, so for the "socket" module, the documentation
was fixed and the multiple argument form is simply marked as
deprecated; it *will* be tightened up again in a future Python
version.

字符串字面量中的 "\x" 转义现在必须精确地使用2个十六进制数字。之前它会
消耗 x 后面的所有十六进制数字，并取结果的最低8位，所以 "\x123456" 等同
于 "\x56"。

"AttributeError" 和 "NameError" 异常现在有了更友好的错误消息，其文本内
容类似于 "'Spam' instance has no attribute 'eggs'" 或 "name 'eggs' is
not defined"。 之前的错误消息只是缺少的属性名称，如 "eggs"，因此利用这
一事实编写的代码在 2.0 中会中断。

Some work has been done to make integers and long integers a bit more
interchangeable.  In 1.5.2, large-file support was added for Solaris,
to allow reading files larger than 2 GiB; this made the "tell()"
method of file objects return a long integer instead of a regular
integer.  Some code would subtract two file offsets and attempt to use
the result to multiply a sequence or slice a string, but this raised a
"TypeError".  In 2.0, long integers can be used to multiply or slice a
sequence, and it'll behave as you'd intuitively expect it to; "3L *
'abc'" produces 'abcabcabc', and "(0,1,2,3)[2L:4L]" produces (2,3).
Long integers can also be used in various contexts where previously
only integers were accepted, such as in the "seek()" method of file
objects, and in the formats supported by the "%" operator ("%d", "%i",
"%x", etc.).  For example, ""%d" % 2L**64" will produce the string
"18446744073709551616".

最微妙的长整数变化是，长整数的 "str()" 表示不再有尾随的 'L' 字符，尽管
"repr()" 表示仍然包含它。许多人在打印长整数时不希望看到 'L' 字符，因为
他们不得不专门去掉这个字符。在2.0中，这不再是一个问题，但那些使用
"str(longval)[:-1]" 并假设存在 'L' 的代码，现在将丢失最后一个数字。

Taking the "repr()" of a float now uses a different formatting
precision than "str()".  "repr()" uses "%.17g" format string for C's
"sprintf()", while "str()" uses "%.12g" as before.  The effect is that
"repr()" may occasionally show more decimal places than  "str()", for
certain numbers.  For example, the number 8.1 can't be represented
exactly in binary, so "repr(8.1)" is "'8.0999999999999996'", while
str(8.1) is "'8.1'".

The "-X" command-line option, which turned all standard exceptions
into strings instead of classes, has been removed; the standard
exceptions will now always be classes.  The "exceptions" module
containing the standard exceptions was translated from Python to a
built-in C module, written by Barry Warsaw and Fredrik Lundh.


扩展/嵌入更改
=============

有些更改是在底层进行的，仅对编写 C 扩展模块或在更大的应用中嵌入 Python
解释器的人有价值。 如果你不处理 Python 的 C API，可以安全地跳过这一节
。

The version number of the Python C API was incremented, so C
extensions compiled for 1.5.2 must be recompiled in order to work with
2.0.  On Windows, it's not possible for Python 2.0 to import a third
party extension built for Python 1.5.x due to how Windows DLLs work,
so Python will raise an exception and the import will fail.

使用 Jim Fulton 的 ExtensionClass 模块的用户将很高兴地发现，已经添加了
钩子以支持 ExtensionClasses，因此现在支持 "isinstance()" 和
"issubclass()"。 这意味着你不再需要记住编写类似 "if type(obj) ==
myExtensionClass" 这样的代码，而可以使用更自然的 "if isinstance(obj,
myExtensionClass)"。

"Python/importdl.c" 文件，它充满了用于支持在许多不同平台上动态加载的
#ifdef，已被 Greg Stein 清理和重组。现在 "importdl.c" 非常小，平台特定
的代码已被移入一组特定的 "Python/dynload_*.c" 文件中。 另一个清理工作
是：Include/ 目录中有许多包含各种可移植性修改的 "my*.h" 文件；它们已被
合并到一个文件中，即 "Include/pyport.h"。

Vladimir Marangozov's long-awaited malloc restructuring was completed,
to make it easy to have the Python interpreter use a custom allocator
instead of C's standard "malloc()".  For documentation, read the
comments in "Include/pymem.h" and "Include/objimpl.h".  For the
lengthy discussions during which the interface was hammered out, see
the web archives of the 'patches' and 'python-dev' lists at
python.org.

最新版本的 MacOS GUSI 开发环境支持 POSIX 线程。 因此，现在 Python 的
POSIX 线程支持在 Macintosh 上也可以使用。 还贡献了使用用户空间 GNU
"pth" 库的线程支持。

Windows 上的线程支持也得到了增强。 Windows 支持的线程锁在发生争用时才
使用内核对象；在常见的没有争用的情况下，他们使用简单得多的函数，这些函
数快一个数量级。Python 1.5.2 在 NT 上的线程版本比无线程版本慢两倍；有
了 2.0 的改进，差异仅为 10%。 这些改进由 Yakov Markovitch 提供。

Python 2.0 的源代码目前只用 ANSI C 原型，所以现在编译 Python 需要一个
ANSI C 的编译器，而不能通过仅使用支持 K&R C 的编译器完成。

之前，Python 虚拟机在其字节码中使用 16 位数字，限制了源文件的大小。 特
别是，这影响了 Python 源代码中字面量列表和字典的最大大小；偶尔会有人在
生成 Python 代码时遇到这个限制。 Charles G. Waldman 的补丁将这个限制从
"2**16" 提高到 "2**32"。

Three new convenience functions intended for adding constants to a
module's dictionary at module initialization time were added:
"PyModule_AddObject()", "PyModule_AddIntConstant()", and
"PyModule_AddStringConstant()".  Each of these functions takes a
module object, a null-terminated C string containing the name to be
added, and a third argument for the value to be assigned to the name.
This third argument is, respectively, a Python object, a C long, or a
C string.

A wrapper API was added for Unix-style signal handlers.
"PyOS_getsig()" gets a signal handler and "PyOS_setsig()" will set a
new handler.


Distutils：使模块易于安装
=========================

在 Python 2.0 之前，安装模块是一件繁琐的事情 —— 没有办法自动确定
Python 的安装位置，或者用于扩展模块的编译器选项。 软件作者不得不经历一
套繁琐的程序来编辑 Makefile 和配置文件，这些只在 Unix 上真正有效，而
Windows 和 Mac OS 不受支持。 Python 用户面对不同扩展包之间大相径庭的安
装说明，这使得管理 Python 成了一件麻烦事。

The SIG for distribution utilities, shepherded by Greg Ward, has
created the Distutils, a system to make package installation much
easier.  They form the "distutils" package, a new part of Python's
standard library. In the best case, installing a Python module from
source will require the same steps: first you simply mean unpack the
tarball or zip archive, and the run ""python setup.py install"".  The
platform will be automatically detected, the compiler will be
recognized, C extension modules will be compiled, and the distribution
installed into the proper directory.  Optional command-line arguments
provide more control over the installation process, the distutils
package offers many places to override defaults -- separating the
build from the install, building or installing in non-default
directories, and more.

为了使用 Distutils，你需要编写一个 "setup.py" 脚本。 在简单场景下，当
软件仅包含 .py 文件时，最小化的 "setup.py" 可以只有几行代码:

   from distutils.core import setup
   setup (name = "foo", version = "1.0",
          py_modules = ["module1", "module2"])

如果软件是由几个包组成的 "setup.py" 文件也不会太过复杂:

   from distutils.core import setup
   setup (name = "foo", version = "1.0",
          packages = ["package", "package.subpackage"])

最复杂的情况可能是 C 扩展；下面是一个来自 PyXML 包的示例:

   from distutils.core import setup, Extension

   expat_extension = Extension('xml.parsers.pyexpat',
        define_macros = [('XML_NS', None)],
        include_dirs = [ 'extensions/expat/xmltok',
                         'extensions/expat/xmlparse' ],
        sources = [ 'extensions/pyexpat.c',
                    'extensions/expat/xmltok/xmltok.c',
                    'extensions/expat/xmltok/xmlrole.c', ]
          )
   setup (name = "PyXML", version = "0.5.4",
          ext_modules =[ expat_extension ] )

Distutils 还可以负责创建源代码和二进制分发包。运行 "python setup.py
sdist" 的 "sdist" 命令构建一个源代码分发包，如 "foo-1.0.tar.gz"。添加
新命令并不困难，已经有 "bdist_rpm" 和 "bdist_wininst" 命令，分别用于创
建软件的 RPM 分发包和 Windows 安装程序。创建其他分发格式的命令，如
Debian 包和 Solaris ".pkg" 文件，也在开发的不同阶段。

所有这些都记录在一个新手册中，*Distributing Python Modules*，它加入了
Python文档的基本集合中。


XML 模块
========

Python 1.5.2 included a simple XML parser in the form of the "xmllib"
module, contributed by Sjoerd Mullender.  Since 1.5.2's release, two
different interfaces for processing XML have become common: SAX2
(version 2 of the Simple API for XML) provides an event-driven
interface with some similarities to "xmllib", and the DOM (Document
Object Model) provides a tree-based interface, transforming an XML
document into a tree of nodes that can be traversed and modified.
Python 2.0 includes a SAX2 interface and a stripped-down DOM interface
as part of the "xml" package. Here we will give a brief overview of
these new interfaces; consult the Python documentation or the source
code for complete details. The Python XML SIG is also working on
improved documentation.


SAX2 支持
---------

SAX defines an event-driven interface for parsing XML.  To use SAX,
you must write a SAX handler class.  Handler classes inherit from
various classes provided by SAX, and override various methods that
will then be called by the XML parser.  For example, the
"startElement()" and "endElement()" methods are called for every
starting and end tag encountered by the parser, the "characters()"
method is called for every chunk of character data, and so forth.

事件驱动方法的优点是整个文档不必同时驻留在内存中，这在处理非常大的文档
时尤其重要。然而，如果你试图以某种复杂的方式修改文档结构，编写 SAX 处
理程序类可能会变得非常复杂。

例如，这个小示例程序定义了一个处理器，它为每个开始和结束标签打印一条消
息，然后使用它来解析文件 "hamlet.xml":

   from xml import sax

   class SimpleHandler(sax.ContentHandler):
       def startElement(self, name, attrs):
           print 'Start of element:', name, attrs.keys()

       def endElement(self, name):
           print 'End of element:', name

   # Create a parser object
   parser = sax.make_parser()

   # Tell it what handler to use
   handler = SimpleHandler()
   parser.setContentHandler( handler )

   # Parse a file!
   parser.parse( 'hamlet.xml' )

For more information, consult the Python documentation, or the XML
HOWTO at http://pyxml.sourceforge.net/topics/howto/xml-howto.html.


DOM 支持
--------

The Document Object Model is a tree-based representation for an XML
document.  A top-level "Document" instance is the root of the tree,
and has a single child which is the top-level "Element" instance. This
"Element" has children nodes representing character data and any sub-
elements, which may have further children of their own, and so forth.
Using the DOM you can traverse the resulting tree any way you like,
access element and attribute values, insert and delete nodes, and
convert the tree back into XML.

DOM 在修改 XML 文档方面非常有用，因为你可以创建一个 DOM 树，通过添加新
节点或重新排列子树来修改它，然后生成一个新的 XML 文档作为输出。你还可
以手动构建一个 DOM 树并将其转换为 XML，这比简单地将
``<tag1>``...``</tag1>``写入文件更灵活。

The DOM implementation included with Python lives in the
"xml.dom.minidom" module.  It's a lightweight implementation of the
Level 1 DOM with support for XML namespaces.  The  "parse()" and
"parseString()" convenience functions are provided for generating a
DOM tree:

   from xml.dom import minidom
   doc = minidom.parse('hamlet.xml')

"doc" is a "Document" instance.  "Document", like all the other DOM
classes such as "Element" and "Text", is a subclass of the "Node" base
class.  All the nodes in a DOM tree therefore support certain common
methods, such as "toxml()" which returns a string containing the XML
representation of the node and its children.  Each class also has
special methods of its own; for example, "Element" and "Document"
instances have a method to find all child elements with a given tag
name. Continuing from the previous 2-line example:

   perslist = doc.getElementsByTagName( 'PERSONA' )
   print perslist[0].toxml()
   print perslist[1].toxml()

对于 *Hamlet* XML 文件，上面几行代码输出:

   <PERSONA>CLAUDIUS, king of Denmark. </PERSONA>
   <PERSONA>HAMLET, son to the late, and nephew to the present king.</PERSONA>

文件的根元素可以通过 "doc.documentElement" 访问，并且可以通过删除、添
加或一处节点来听松修改节点来轻松修改其子元素:

   root = doc.documentElement

   # Remove the first child
   root.removeChild( root.childNodes[0] )

   # Move the new first child to the end
   root.appendChild( root.childNodes[0] )

   # Insert the new first child (originally,
   # the third child) before the 20th child.
   root.insertBefore( root.childNodes[0], root.childNodes[20] )

Again, I will refer you to the Python documentation for a complete
listing of the different "Node" classes and their various methods.


与 PyXML 的关系
---------------

XML 特别兴趣小组已经致力于与 XML 相关的 Python 代码有一段时间了。 其代
码分发包称为 PyXML，可以从 SIG 的网页
https://www.python.org/community/sigs/current/xml-sig 获取。 PyXML 分
发包也使用了 "xml" 作为包名。 如果你编写了使用 PyXML 的程序，可能会担
心它与 Python 2.0 的 "xml" 包的兼容性。

答案是 Python 2.0 的 "xml" 包与 PyXML 不兼容，但可以通过安装最新版本的
PyXML 来使其兼容。 许多应用程序可以依赖 Python 2.0 中包含的 XML 支持，
但更复杂的应用程序需要安装完整的 PyXML 包。 安装后，版本为 0.6.0 或更
高的 PyXML 将替换随 Python 一起发布的 "xml" 包，并且将是标准包的严格超
集，添加许多额外的功能。 PyXML 中的一些附加功能包括：

* 4DOM，一个来自 FourThought, Inc. 的完整 DOM 实现。

* xmlproc 验证解析器，由 Lars Marius Garshol 编写。

* "sgmlop" 解析器加速器模块，由 Fredrik Lundh 编写。


模組變更
========

Lots of improvements and bugfixes were made to Python's extensive
standard library; some of the affected modules include "readline",
"ConfigParser", "cgi", "calendar", "posix", "readline", "xmllib",
"aifc", "chunk, wave", "random", "shelve", and "nntplib".  Consult the
CVS logs for the exact patch-by-patch details.

Brian Gallew contributed OpenSSL support for the "socket" module.
OpenSSL is an implementation of the Secure Socket Layer, which
encrypts the data being sent over a socket.  When compiling Python,
you can edit "Modules/Setup" to include SSL support, which adds an
additional function to the "socket" module: "socket.ssl(socket,
keyfile, certfile)", which takes a socket object and returns an SSL
socket.  The "httplib" and "urllib" modules were also changed to
support "https://" URLs, though no one has implemented FTP or SMTP
over SSL.

The "httplib" module has been rewritten by Greg Stein to support
HTTP/1.1. Backward compatibility with the 1.5 version of "httplib" is
provided, though using HTTP/1.1 features such as pipelining will
require rewriting code to use a different set of interfaces.

The "Tkinter" module now supports Tcl/Tk version 8.1, 8.2, or 8.3, and
support for the older 7.x versions has been dropped.  The Tkinter
module now supports displaying Unicode strings in Tk widgets. Also,
Fredrik Lundh contributed an optimization which makes operations like
"create_line" and "create_polygon" much faster, especially when using
lots of coordinates.

"curses" 模块在 Oliver Andrich 增强版本的基础上得到了极大的扩展，提供
了许多来自 ncurses 和 SYSV curses 的附加功能，如颜色、替代字符集支持、
手写板和鼠标支持等。 这意味着该模块不再兼容仅有 BSD curses 的操作系统
，但目前似乎没有任何属于这一类别的操作系统正在维护中。

如前面讨论的 Python 2.0 对 Unicode 的支持所提到的，"re" 模块提供的正则
表达式的底层实现已经更改。 SRE，一个新的正则表达式引擎，由 Ferdrik
Lundh 编写，部分由惠普资助，支持匹配 8 位字符串和 Unicode 字符串。


新增模块
========

添加了许多新模块，我们将简单列出它们并附上简要概述；有关特定模块的详细
信息，请查阅 2.0 文档。

* "atexit" 模块用于注册在 Python 解释器退出之前调用的函数。当前直接设
  置 "sys.exitfunc" 的代码应改为使用 "atexit" 模块，导入 "atexit" 并使
  用 "atexit.register()" 调用要在退出时调用的函数。 （由 Skip
  Montanaro 贡献。）

* "codecs", "encodings", "unicodedata":  Added as part of the new
  Unicode support.

* "filecmp": Supersedes the old "cmp", "cmpcache" and "dircmp"
  modules, which have now become deprecated. (Contributed by Gordon
  MacMillan and Moshe Zadka.)

* "gettext": 这个模块通过提供 GNU gettext 消息目录库的接口，为 Python
  程序提供国际化（I18N）和本地化（L10N）支持。 （由 Barry Warsaw 整合
  ，来自 Martin von Löwis, Peter Funk 和 James Henstridge 的独立贡献。
  ）

* "linuxaudiodev": Support for the "/dev/audio" device on Linux, a
  twin to the existing "sunaudiodev" module. (Contributed by Peter
  Bosch, with fixes by Jeremy Hylton.)

* "mmap": 提供对内存映射文件的接口，支持 Windows 和 Unix。文件的内容可
  以直接映射到内存中，此时它表现得像一个可变字符串，因此可以读取和修改
  其内容。它们甚至可以传递给期望普通字符串的函数，例如 "re" 模块。（由
  Sam Rushing 贡献，并由 A.M. Kuchling 提供一些扩展。）

* "pyexpat": An interface to the Expat XML parser. (Contributed by
  Paul Prescod.)

* "robotparser": Parse a "robots.txt" file, which is used for writing
  web spiders that politely avoid certain areas of a web site.  The
  parser accepts the contents of a "robots.txt" file, builds a set of
  rules from it, and can then answer questions about the fetchability
  of a given URL.  (Contributed by Skip Montanaro.)

* "tabnanny": 一个模块/脚本，用于检查 Python 源代码中不歧义的缩进。 （
  由 Tim Peters 贡献。）

* "UserString": A base class useful for deriving objects that behave
  like strings.

* "webbrowser" 模块提供了一种平台独立的方式来在特定 URL 上启动 web 浏
  览器。对于每个平台，模块会按特定顺序尝试各种浏览器。用户可以通过设置
  *BROWSER* 环境变量来更改启动的浏览器。（最初的灵感来自 Eric S.
  Raymond 对 "urllib" 的补丁，该补丁增加了类似的功能，但最终的模块来自
  Fred Drake 最初实现的代码 "Tools/idle/BrowserControl.py"，并由 Fred
  适配到标准库中。）

* "_winreg": An interface to the Windows registry.  "_winreg" is an
  adaptation of functions that have been part of PythonWin since 1995,
  but has now been added to the core  distribution, and enhanced to
  support Unicode. "_winreg" was written by Bill Tutt and Mark
  Hammond.

* "zipfile" 模块：用于读取和写入 ZIP 格式的归档文件。 这些归档文件是由
  DOS/Windows 上的 **PKZIP** 或 Unix 上的 **zip** 生成的，不要与
  **gzip** 格式文件（由 "gzip" 支持）混淆。 （由 James C. Ahlstrom 贡
  献。）

* "imputil": A module that provides a simpler way for writing
  customized import hooks, in comparison to the existing "ihooks"
  module.  (Implemented by Greg Stein, with much discussion on python-
  dev along the way.)


IDLE 改进
=========

IDLE 是官方的 Python 跨平台 IDE，使用 Tkinter 编写。 Python 2.0 包括了
IDLE 0.6，它增加了许多新特性和改进。 部分新内容列表：

* 界面改进和优化，特别是在语法高亮和自动缩进方面。

* 类浏览器现在将显示更多信息，例如一个模块中最高层级的函数。

* 制表符宽度现在是一个用户可设置的选项。在打开现有的 Python 文件时，
  IDLE 会自动检测缩进约定并进行适应。

* 现在支持在各种平台上调用浏览器，用于在浏览器中打开 Python 文档。

* IDLE 现在有一个命令行，它与原版 Python 解释器大致相同。

* 在许多地方添加了调用提示。

* IDLE 现在可以作为一个包被安装。

* 在编辑器窗口中，目前在底部位置增加了一个行/列显示栏。

* 三个新的键盘快捷键：检查模块 ("Alt-F5")，导入模块 ("F5") 和执行脚本
  ("Ctrl-F5")。


删除和弃用的模块
================

A few modules have been dropped because they're obsolete, or because
there are now better ways to do the same thing.  The "stdwin" module
is gone; it was for a platform-independent windowing toolkit that's no
longer developed.

多个模块已被移至 "lib-old" 子目录: "cmp", "cmpcache", "dircmp",
"dump",  "find", "grep", "packmail",  "poly", "util", "whatsound",
"zmod"。 如果你还有依赖于被移至 "lib-old" 的模块的代码，你可以简单地将
该目录添加到 "sys.path" 来恢复它们，但建议你对任何使用这些模块的代码进
行更新。


致謝
====

作者感谢以下人士对本文的各种草稿提出建议： David Bolen, Mark Hammond,
Gregg Hauser, Jeremy Hylton, Fredrik Lundh, Detlef Lannert, Aahz
Maruch, Skip Montanaro, Vladimir Marangozov, Tobias Polzin, Guido van
Rossum, Neil Schemenauer, and Russ Schmidt.
