Python 2.0 新特性

作者:

A.M. Kuchling 和 Moshe Zadka

引言

Python 2.0 版于 2000 年 10 月 16 日发布。本文介绍了 2.0 中令人兴奋的新功能，强调了一些其他有用的更改，并指出了一些可能需要重写代码的不兼容更改。

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 提供的工具来存储源代码、跟踪 bug 报告以及管理补丁提交队列。要报告 Python 2.0 的 bug 或提交补丁，请使用 Python 项目页面（位于 https://sourceforge.net/projects/python/）提供的 bug 跟踪和补丁管理器工具。

目前托管在 SourceForge 上的最重要的服务是 Python CVS 树，它是包含 Python 源代码的版本控制存储库。以前，大约有 7 个人对 CVS 树拥有写入权限，所有补丁都必须由这个短名单上的人员之一进行检查和签入。显然，这不太具有可扩展性。通过将 CVS 树移至 SourceForge，可以授予更多人写入权限；截至 2000 年 9 月，有 27 人能够签入更改，增加了四倍。这使得大规模更改成为可能，如果必须通过少数核心开发人员进行过滤，这些更改就不会被尝试。例如，有一天 Peter Schneider-Kamp 决定放弃 K&R C 兼容性，并将 Python 的 C 源代码转换为 ANSI C。在 python-dev 邮件列表上获得批准后，他发起了一连串的签入，持续了大约一周，其他开发人员也加入帮助，工作完成了。如果只有 5 个人拥有写入权限，可能这项任务就会被视为“不错，但不值得花费时间和精力”，并且永远不会完成。

转向使用 SourceForge 服务显著提高了开发速度。补丁现在被提交、评论、由原始提交者以外的人修改，并在人们之间来回传递，直到补丁被认为值得签入。Bug 在一个中心位置进行跟踪，可以分配给特定的人进行修复，我们可以统计未解决的 bug 数量来衡量进度。这并非没有代价：开发人员现在需要处理更多的电子邮件，关注更多的邮件列表，并且必须为新环境编写专用工具。例如，SourceForge 发送的默认补丁和 bug 通知电子邮件完全没有帮助，因此 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 目的和指南”的介绍

PEP 代表 Python 增强提案。PEP 是为 Python 社区提供信息或描述 Python 新功能的设计文档。PEP 应该提供该功能的简明技术规范和理由。

我们打算将 PEP 作为提出新功能、收集社区对某个问题的意见以及记录 Python 设计决策的主要机制。PEP 作者负责在社区内建立共识并记录不同意见。

阅读 PEP 1 的其余部分，了解 PEP 编辑流程、风格和格式的详细信息。PEP 保存在 SourceForge 上的 Python CVS 树中，尽管它们不是 Python 2.0 分发的一部分，并且也可以从 https://peps.pythonlang.cn/ 获取 HTML 形式。截至 2000 年 9 月，共有 25 个 PEP，从 PEP 201，“Lockstep Iteration”，到 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 集成”。本文将仅介绍 Unicode 接口的最重要点。

在 Python 源代码中，Unicode 字符串写为 u"string"。任意 Unicode 字符可以使用新的转义序列 \uHHHH 来书写，其中 HHHH 是一个 4 位十六进制数字，范围从 0000 到 FFFF。现有的 \xHH 转义序列也可以使用，八进制转义序列可以用于 U+01FF 及以下的字符，U+01FF 由 \777 表示。

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

组合 8 位字符串和 Unicode 字符串总是强制转换为 Unicode，使用默认的 ASCII 编码；'a' + u'bc' 的结果是 u'abc'。

已添加新的内置函数，并修改了现有内置函数以支持 Unicode

• unichr(ch) 返回一个长度为 1 的 Unicode 字符串，包含字符 ch。

• ord(u)，其中 u 是一个单字符的普通字符串或 Unicode 字符串，返回该字符的数值（整数）。

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

• exec 语句，以及各种内置函数如 eval()、getattr() 和 setattr() 也将接受 Unicode 字符串以及普通字符串。（很可能修复此问题时遗漏了一些内置函数；如果您发现接受字符串但不接受 Unicode 字符串的内置函数，请将其报告为 bug。）

新模块 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 是一个 8 位字符串，其中包含已转换为给定编码的 Unicode 字符串的一部分（可能全部），而 length 告诉您 Unicode 字符串转换了多少。

• decode_func 与 encode_func 相反，它接受一个 8 位字符串并返回一个 2 元素元组 (ustring, length)，其中包含结果 Unicode 字符串 ustring 和整数 length，表示已消费了多少 8 位字符串。

• stream_reader 是一个支持从流中解码输入的类。stream_reader(file_obj) 返回一个支持 read()、readline() 和 readlines() 方法的对象。这些方法都将从给定编码进行转换并返回 Unicode 字符串。

• stream_writer 类似地，是一个支持将输出编码到流的类。stream_writer(file_obj) 返回一个支持 write() 和 writelines() 方法的对象。这些方法期望 Unicode 字符串，并在输出时将其转换为给定编码。

例如，以下代码将一个 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()

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

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

列表推导式

列表是 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…in 子句包含要迭代的序列。序列不必是相同的长度，因为它们 不 是并行迭代的，而是从左到右迭代的；这在以下段落中解释得更清楚。生成列表的元素将是 expression 的连续值。最后的 if 子句是可选的；如果存在，只有当 condition 为真时，expression 才会被评估并添加到结果中。

为了使语义非常清晰，列表推导式等价于以下 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…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 语法中引入歧义，如果 expression 正在创建元组，则必须用括号将其括起来。下面的第一个列表推导式是语法错误，而第二个是正确的

# 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。

支持的完整赋值运算符列表是 +=, -=, *=, /=, %=, **=, &=, |=, ^=, >>=, 和 <<=。Python 类可以通过定义名为 __iadd__(), __isub__() 等方法来重写增量赋值运算符。例如，下面的 Number 类存储一个数字并支持使用 += 来创建具有递增值的新实例。

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

__iadd__() 特殊方法以增量值调用，并应返回一个具有适当修改值的新实例；此返回值被绑定为左侧变量的新值。

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

字符串方法

到目前为止，字符串操作功能位于 string 模块中，该模块通常是 C 语言编写的 strop 模块的前端。Unicode 的添加给 strop 模块带来了困难，因为所有函数都需要重写以接受 8 位或 Unicode 字符串。对于像 string.replace() 这样的函数，它接受 3 个字符串参数，这意味着有八种可能的排列，以及相应复杂的代码。

相反，Python 2.0 将问题推给字符串类型，使字符串操作功能通过 8 位字符串和 Unicode 字符串的方法提供。

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

有一点没有改变，尽管有一个值得注意的愚人节玩笑，那就是 Python 字符串是不可变的。因此，字符串方法返回新字符串，并且不修改它们操作的字符串。

为了向后兼容，旧的 string 模块仍然存在，但它主要充当新字符串方法的前端。

有两个在 2.0 之前的版本中没有对应方法，但在 JPython 中存在了相当长一段时间的方法，它们是 startswith() 和 endswith()。s.startswith(t) 等价于 s[:len(t)] == t，而 s.endswith(t) 等价于 s[-len(t):] == t。

另一个值得特别提及的方法是 join()。字符串的 join() 方法接收一个参数，一个字符串序列，它等价于旧 string 模块中的 string.join() 函数，但参数顺序颠倒。换句话说，s.join(seq) 等价于旧的 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 能够通过仔细调整将开销最小化。目前尚不清楚会损失多少性能，因为对此进行基准测试很棘手，并且关键取决于程序创建和销毁对象的频率。如果无法承受哪怕一点点速度损失，或者怀疑循环收集存在 bug，则可以在编译 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 的语法和内置函数进行了一些小的更改。这些更改都不深远，但它们是方便的。

次要语言变更

新的语法使得用元组参数和/或关键字参数字典调用给定函数更加方便。在 Python 1.5 及更早版本中，您会使用 apply() 内置函数：apply(f, args, kw) 调用函数 f()，其中参数元组为 args，关键字参数位于字典 kw 中。apply() 在 2.0 中保持不变，但多亏了 Greg Ewing 的补丁，f(*args, **kw) 是一种更短、更清晰的方式来实现相同的效果。这个语法与函数定义的语法是对称的

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

print 语句现在可以通过在 print 后面加上 >> file 来将其输出重定向到文件类对象，类似于 Unix shell 中的重定向运算符。以前，您要么必须使用文件类对象的 write() 方法，它缺乏 print 的便利性和简单性，要么您可以将新值分配给 sys.stdout 然后恢复旧值。对于将输出发送到标准错误，这样写要容易得多

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 的字符串。

以前，无法实现一个类来覆盖 Python 内置的 in 运算符并实现自定义版本。obj in seq 如果 obj 存在于序列 seq 中，则返回 true；Python 通过简单地尝试序列的每个索引直到找到 obj 或遇到 IndexError 来计算此值。Moshe Zadka 贡献了一个补丁，该补丁添加了 __contains__() 魔术方法，用于为 in 提供自定义实现。此外，用 C 编写的新内置对象可以通过序列协议中的新槽来定义 in 的含义。

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

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

比较 a==b 返回 true，因为这两个递归数据结构是同构的。有关导致此实现的讨论和一些有用的相关链接，请参阅 python-dev 邮件列表 2000 年 4 月存档中标题为“垃圾箱和 PR#7”的线程。请注意，现在比较也可以引发异常。在早期版本的 Python 中，比较操作（例如 cmp(a,b)）总是会产生一个答案，即使用户定义的 __cmp__() 方法遇到错误，因为由此产生的异常会被悄悄地吞噬。

已经开展了将 Python 移植到 Itanium 处理器上的 64 位 Windows 的工作，主要由 ActiveState 的 Trent Mick 完成。（令人困惑的是，在 Win64 上 sys.platform 仍然是 'win32'，因为为了便于移植，MS Visual C++ 似乎在 Itanium 上将代码视为 32 位。）PythonWin 也支持 Windows CE；有关更多信息，请参阅 Python CE 页面 https://pythonce.sourceforge.net/。

另一个新平台是 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() 会将返回的列表截断为最短参数序列的长度。

当第一个参数是字符串时，int() 和 long() 函数现在接受一个可选的“基数”参数。int('123', 10) 返回 123，而 int('123', 16) 返回 291。int(123, 16) 会引发 TypeError 异常，并显示消息：“无法将非字符串转换为带有显式基数的类型”。

一个新的变量已添加到 sys 模块中，其中包含更详细的版本信息。sys.version_info 是一个元组 (major, minor, micro, level, serial)。例如，在一个假设的 2.0.1beta1 中，sys.version_info 将是 (2, 0, 1, 'beta', 1)。level 是一个字符串，如 "alpha"、"beta"，或者最终版本为 "final"。

字典有一个奇怪的新方法 setdefault(key, default)，其行为类似于现有的 get() 方法。但是，如果键丢失，setdefault() 不仅像 get() 那样返回 default 的值，还会将其插入字典中作为 key 的值。因此，以下几行代码

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 来找到给定平台的近似最大值。

移植到 2.0

新的 Python 版本力求与之前的版本兼容，并且记录一直相当好。然而，一些更改被认为足够有用，通常是因为它们修复了最初被证明是错误的设计决策，因此无法总是避免破坏向后兼容性。本节列出了 Python 2.0 中可能导致旧 Python 代码中断的更改。

最可能破坏大部分代码的更改是收紧了某些方法接受的参数。有些方法会接受多个参数并将其视为元组，特别是各种列表方法，例如 append() 和 insert()。在早期版本的 Python 中，如果 L 是一个列表，L.append( 1,2 ) 会将元组 (1,2) 追加到列表中。在 Python 2.0 中，这会引发 TypeError 异常，并显示消息：“append 需要正好 1 个参数；给出了 2 个”。修复方法是简单地添加一对额外的括号，将两个值作为元组传递：L.append( (1,2) )。

这些方法的早期版本之所以更宽松，是因为它们使用了 Python C 接口中的一个旧函数来解析其参数；2.0 将它们现代化，以使用 PyArg_ParseTuple()（当前的参数解析函数），该函数提供更有用的错误消息并将多参数调用视为错误。如果您绝对必须使用 2.0 但无法修复代码，您可以编辑 Objects/listobject.c 并定义预处理器符号 NO_STRICT_LIST_APPEND 以保留旧行为；不建议这样做。

socket 模块中的某些函数仍然如此宽容。例如，socket.connect( ('hostname', 25) ) 是正确的形式，传递一个表示 IP 地址的元组，但 socket.connect('hostname', 25) 也有效。socket.connect_ex 和 socket.bind 也同样宽松。2.0alpha1 收紧了这些函数，但由于文档实际上使用了错误的多个参数形式，许多人编写的代码会在更严格的检查下中断。GvR 在公众反对下撤销了这些更改，因此对于 socket 模块，文档得到了修复，并且多个参数形式被标记为已弃用；它 将 在未来的 Python 版本中再次收紧。

字符串字面量中的 \x 转义序列现在正好接受 2 个十六进制数字。以前，它会消耗 'x' 后面的所有十六进制数字，并取结果的最低 8 位，因此 \x123456 等价于 \x56。

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

已经完成了一些工作，使整数和长整数的互换性更好。在 1.5.2 中，为 Solaris 添加了大文件支持，以允许读取大于 2 GiB 的文件；这使得文件对象的 tell() 方法返回一个长整数而不是普通整数。一些代码会减去两个文件偏移量并尝试使用结果来乘以序列或切片字符串，但这会引发 TypeError。在 2.0 中，长整数可以用于乘以或切片序列，并且其行为将如您直观期望的那样；3L * 'abc' 产生 'abcabcabc'，而 (0,1,2,3)[2L:4L] 产生 (2,3)。长整数也可以用于以前只接受整数的各种上下文，例如文件对象的 seek() 方法，以及 % 运算符支持的格式（%d、%i、%x 等）。例如，"%d" % 2L**64 将产生字符串 18446744073709551616。

所有微妙的长整数变化中，最重要的是长整数的 str() 不再带有尾随的 'L' 字符，尽管 repr() 仍然包含它。'L' 让许多希望打印看起来像普通整数的长整数的人感到恼火，因为他们不得不费尽心思将其截掉。这在 2.0 中不再是问题，但那些执行 str(longval)[:-1] 并假设 'L' 存在的代码，现在将丢失最后一位数字。

浮点数的 repr() 现在使用与 str() 不同的格式精度。repr() 使用 C 语言 sprintf() 的 %.17g 格式字符串，而 str() 像以前一样使用 %.12g。其效果是，对于某些数字，repr() 可能偶尔会显示比 str() 更多的十进制位数。例如，数字 8.1 无法在二进制中精确表示，因此 repr(8.1) 是 '8.0999999999999996'，而 str(8.1) 是 '8.1'。

-X 命令行选项（它将所有标准异常转换为字符串而不是类）已被移除；标准异常现在将始终是类。包含标准异常的 exceptions 模块已从 Python 转换为由 Barry Warsaw 和 Fredrik Lundh 编写的内置 C 模块。

扩展/嵌入变更

某些更改是内部的，只有编写 C 扩展模块或将 Python 解释器嵌入到大型应用程序中的人才能察觉。如果您不处理 Python 的 C API，可以安全地跳过本节。

Python C API 的版本号增加了，因此为 1.5.2 编译的 C 扩展必须重新编译才能与 2.0 兼容。在 Windows 上，由于 Windows DLL 的工作方式，Python 2.0 无法导入为 Python 1.5.x 构建的第三方扩展，因此 Python 将引发异常并导致导入失败。

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

文件 Python/importdl.c，它曾是大量 #ifdefs 用于支持在许多不同平台上进行动态加载，由 Greg Stein 清理并重新组织。importdl.c 现在相当小，平台特定代码已移至一系列 Python/dynload_*.c 文件中。另一个清理工作是：Include/ 目录中曾有许多 my*.h 文件，用于各种可移植性黑客；它们已合并为一个文件，Include/pyport.h。

Vladimir Marangozov 期待已久的 malloc 重构已经完成，以便 Python 解释器可以轻松使用自定义分配器而不是 C 的标准 malloc()。有关文档，请阅读 Include/pymem.h 和 Include/objimpl.h 中的注释。有关接口敲定过程中的漫长讨论，请参阅 python.org 上“patches”和“python-dev”列表的网络存档。

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

Windows 上的线程支持也得到了增强。Windows 支持仅在争用情况下使用内核对象的线程锁；在没有争用的常见情况下，它们使用更简单的函数，速度快一个数量级。在 NT 上，Python 1.5.2 的线程版本比非线程版本慢两倍；通过 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。

新增了三个方便的函数，用于在模块初始化时向模块字典添加常量：PyModule_AddObject()、PyModule_AddIntConstant() 和 PyModule_AddStringConstant()。这些函数中的每一个都接受一个模块对象、一个包含要添加的名称的以空字符结尾的 C 字符串，以及一个用于分配给该名称的值的第三个参数。第三个参数分别是一个 Python 对象、一个 C long 或一个 C 字符串。

添加了一个用于 Unix 风格信号处理程序的包装 API。PyOS_getsig() 获取一个信号处理程序，PyOS_setsig() 设置一个新的处理程序。

Distutils：让模块易于安装

在 Python 2.0 之前，安装模块是一件繁琐的事情——无法自动确定 Python 安装在哪里，或者扩展模块使用什么编译器选项。软件作者必须经历编辑 Makefiles 和配置文件等艰苦的仪式，这些只在 Unix 上真正有效，并且不支持 Windows 和 MacOS。Python 用户面临着不同扩展包之间差异巨大的安装说明，这使得管理 Python 安装成为一项苦差事。

由 Greg Ward 领导的发行版实用程序 SIG 创建了 Distutils，这是一个使软件包安装变得更容易的系统。它们组成了 distutils 包，它是 Python 标准库的新部分。在最佳情况下，从源代码安装 Python 模块将需要相同的步骤：首先，您只需解压 tarball 或 zip 存档，然后运行“python setup.py install”。平台将自动检测，编译器将识别，C 扩展模块将编译，并且发行版将安装到正确的目录中。可选的命令行参数提供了对安装过程的更多控制，distutils 包提供了许多覆盖默认值的地方——将构建与安装分离，在非默认目录中构建或安装等等。

要使用 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 还可以负责创建源代码和二进制分发。“sdist”命令，通过“python setup.py sdist”运行，构建一个源代码分发，例如 foo-1.0.tar.gz。添加新命令并不困难，已经贡献了“bdist_rpm”和“bdist_wininst”命令，分别用于为软件创建 RPM 分发和 Windows 安装程序。创建其他分发格式（如 Debian 包和 Solaris .pkg 文件）的命令处于不同的开发阶段。

所有这些都记录在一本新手册《分发 Python 模块》中，该手册已加入 Python 文档的基础集合。

XML 模块

Python 1.5.2 包含一个简单的 XML 解析器，以 Sjoerd Mullender 贡献的 xmllib 模块的形式出现。自 1.5.2 发布以来，两种不同的 XML 处理接口变得普遍：SAX2（XML 简单 API 的第 2 版）提供了一个事件驱动接口，与 xmllib 有些相似；DOM（文档对象模型）提供了一个基于树的接口，将 XML 文档转换为可以遍历和修改的节点树。Python 2.0 在 xml 包中包含了一个 SAX2 接口和一个简化版 DOM 接口。这里我们将简要概述这些新接口；有关完整的详细信息，请查阅 Python 文档或源代码。Python XML SIG 也在努力改进文档。

SAX2 支持

SAX 定义了一个用于解析 XML 的事件驱动接口。要使用 SAX，您必须编写一个 SAX 处理器类。处理器类继承自 SAX 提供的各种类，并覆盖将由 XML 解析器调用的各种方法。例如，startElement() 和 endElement() 方法在解析器遇到每个开始和结束标签时被调用，characters() 方法在每个字符数据块时被调用，等等。

事件驱动方法的优点是整个文档不必同时驻留在内存中，这在处理非常大的文档时很重要。但是，如果您试图以某种复杂的方式修改文档结构，编写 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' )

有关更多信息，请查阅 Python 文档，或访问 XML HOWTO (https://pyxml.sourceforge.net/topics/howto/xml-howto.html)。

DOM 支持

文档对象模型是 XML 文档的树形表示。顶层 Document 实例是树的根，并具有一个子节点，即顶层 Element 实例。此 Element 具有表示字符数据和任何子元素的子节点，这些子元素可能拥有自己的更多子节点，依此类推。使用 DOM，您可以随心所欲地遍历生成的树，访问元素和属性值，插入和删除节点，并将树转换回 XML。

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

Python 中包含的 DOM 实现位于 xml.dom.minidom 模块中。它是一个轻量级的 Level 1 DOM 实现，支持 XML 命名空间。提供了 parse() 和 parseString() 便捷函数用于生成 DOM 树

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

doc 是一个 Document 实例。Document，像所有其他 DOM 类（如 Element 和 Text）一样，是 Node 基类的子类。因此，DOM 树中的所有节点都支持某些常见方法，例如 toxml()，它返回一个包含节点及其子节点的 XML 表示的字符串。每个类也都有其自己的特殊方法；例如，Element 和 Document 实例有一个方法可以查找具有给定标签名称的所有子元素。继续上面两行的例子

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

对于《哈姆雷特》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] )

再次，我将引导您查阅 Python 文档，以获取不同 Node 类及其各种方法的完整列表。

与 PyXML 的关系

XML 特别兴趣小组已在 XML 相关的 Python 代码上工作了一段时间。其代码分发称为 PyXML，可从 SIG 的网页 https://pythonlang.cn/community/sigs/current/xml-sig 获取。PyXML 分发也使用了包名 xml。如果您编写了使用 PyXML 的程序，您可能想知道它与 2.0 xml 包的兼容性。

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

• 4DOM，FourThought, Inc. 的完整 DOM 实现。

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

• 由 Fredrik Lundh 编写的 sgmlop 解析器加速模块。

模块变更

Python 庞大的标准库进行了大量改进和错误修复；一些受影响的模块包括 readline、ConfigParser、cgi、calendar、posix、readline、xmllib、aifc、chunk、wave、random、shelve 和 nntplib。有关准确的逐个补丁的详细信息，请查阅 CVS 日志。

Brian Gallew 为 socket 模块贡献了 OpenSSL 支持。OpenSSL 是安全套接字层 (Secure Socket Layer) 的一种实现，它对通过套接字发送的数据进行加密。编译 Python 时，您可以编辑 Modules/Setup 以包含 SSL 支持，这会向 socket 模块添加一个额外的函数：socket.ssl(socket, keyfile, certfile)，它接受一个套接字对象并返回一个 SSL 套接字。httplib 和 urllib 模块也进行了更改以支持 https:// URL，尽管还没有人实现基于 SSL 的 FTP 或 SMTP。

httplib 模块已由 Greg Stein 重写以支持 HTTP/1.1。

尽管提供了与 1.5 版 httplib 的向后兼容性，但使用 HTTP/1.1 功能（例如管道）将需要重写代码以使用不同的接口集。

Tkinter 模块现在支持 Tcl/Tk 8.1、8.2 或 8.3 版，并已放弃对旧版 7.x 的支持。Tkinter 模块现在支持在 Tk 小部件中显示 Unicode 字符串。此外，Fredrik Lundh 贡献了一个优化，使得 create_line 和 create_polygon 等操作更快，尤其是在使用大量坐标时。

curses 模块已从 Oliver Andrich 的增强版本开始进行了大幅扩展，提供了 ncurses 和 SYSV curses 的许多附加功能，例如颜色、备用字符集支持、衬垫和鼠标支持。这意味着该模块不再与仅具有 BSD curses 的操作系统兼容，但目前似乎没有任何处于维护状态的操作系统属于此类别。

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

新模块

添加了一些新模块。我们将简单地列出它们并提供简要说明；有关特定模块的详细信息，请查阅 2.0 文档。

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

• codecs、encodings、unicodedata：作为新 Unicode 支持的一部分添加。

• filecmp：取代了旧的 cmp、cmpcache 和 dircmp 模块，这些模块现已弃用。（由 Gordon MacMillan 和 Moshe Zadka 贡献。）

• gettext：此模块通过提供 GNU gettext 消息目录库的接口，为 Python 程序提供国际化 (I18N) 和本地化 (L10N) 支持。（由 Barry Warsaw 集成，来自 Martin von Löwis、Peter Funk 和 James Henstridge 的独立贡献。）

• linuxaudiodev：支持 Linux 上的 /dev/audio 设备，是现有 sunaudiodev 模块的孪生模块。（由 Peter Bosch 贡献，Jeremy Hylton 进行了修复。）

• mmap：Windows 和 Unix 上内存映射文件的接口。文件内容可以直接映射到内存中，此时它表现为可变字符串，因此可以读取和修改其内容。它们甚至可以传递给期望普通字符串的函数，例如 re 模块。（由 Sam Rushing 贡献，A.M. Kuchling 进行了部分扩展。）

• pyexpat：Expat XML 解析器的接口。（由 Paul Prescod 贡献。）

• robotparser：解析 robots.txt 文件，该文件用于编写礼貌地避免网站某些区域的网络爬虫。解析器接受 robots.txt 文件的内容，从中构建一组规则，然后可以回答有关给定 URL 可获取性的问题。（由 Skip Montanaro 贡献。）

• tabnanny：一个模块/脚本，用于检查 Python 源代码中是否存在含糊不清的缩进。（由 Tim Peters 贡献。）

• UserString：一个有用的基类，用于派生行为类似于字符串的对象。

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

• _winreg：Windows 注册表的接口。_winreg 是自 1995 年以来一直是 PythonWin 一部分的功能的改编，但现在已添加到核心发行版中，并增强以支持 Unicode。_winreg 由 Bill Tutt 和 Mark Hammond 编写。

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

• imputil：一个模块，提供了一种更简单的方式来编写自定义导入钩子，与现有 ihooks 模块相比。（由 Greg Stein 实现，在此过程中在 python-dev 上进行了大量讨论。）

IDLE 改进

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

• UI 改进和优化，尤其是在语法高亮和自动缩进方面。

• 类浏览器现在显示更多信息，例如模块中的顶级函数。

• Tab 宽度现在是一个用户可设置的选项。打开现有 Python 文件时，IDLE 会自动检测缩进约定并进行调整。

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

• IDLE 现在有一个命令行，与普通的 Python 解释器大致相似。

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

• IDLE 现在可以作为包安装。

• 在编辑器窗口中，底部现在有一个行/列栏。

• 三个新的按键命令：检查模块 (Alt-F5)、导入模块 (F5) 和运行脚本 (Ctrl-F5)。

已删除和已弃用的模块

一些模块已被删除，因为它们已过时，或者因为现在有更好的方法可以做同样的事情。stdwin 模块已不复存在；它曾是一个不再开发的独立于平台的窗口工具包。

许多模块已移至 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 和 Russ Schmidt。