# Python 2.3 有什么新变化

作者:

  A.M. Kuchling

本文介绍了 Python 2.3 的新特性。 Python 2.3 发布于 2003 年 7 月 29 日。

Python 2.3 的主要主题是完善在 2.2 中添加的一些功能、为核心语言添加各种小但实用的增强功能，以及扩展标准库。 上一版本引入的新对象模型已经受益于 18 个月的错误修复和优化努力，这些优化提升了新式类的性能。 新增了几个内置函数，例如 `sum()` 和 `enumerate()`。 `in` 操作符现在可以用于子字符串搜索 (例如，`"ab" in "abc"` 将返回 `True`)。

许多新库功能包括布尔值、集合、堆、日期/时间数据类型，从ZIP格式的归档文件中导入模块的能力，期待已久的 Python 目录的元数据支持，更新版本的 IDLE，以及用于日志记录、文本包装、解析 CSV 文件、处理命令行选项、使用 BerkeleyDB 数据库的模块…… 新模块和增强模块的列表相当长。

本文并不试图提供对新功能的完整规范，而是提供了一个方便的概览。 有关详细信息，你应该参考 Python 2.3 的文档，例如 Python 库参考和 Python 参考手册。 如果你想了解完整的实现和设计原理，请参阅特定新功能的 PEP。

## PEP 218: 标准集合数据类型

新的 `sets` 模块包含一个集合数据类型的实现。 `Set` 类用于可变集合，即可以添加和删除成员的集合。 `ImmutableSet` 类用于不可修改的集合，因此 `ImmutableSet` 的实例可以用作字典的键。 集合是基于字典构建的，因此集合中的元素必须是可哈希的。

这是一个简单的示例:

    >>> import sets
    >>> S = sets.Set([1,2,3])
    >>> S
    Set([1, 2, 3])
    >>> 1 in S
    True
    >>> 0 in S
    False
    >>> S.add(5)
    >>> S.remove(3)
    >>> S
    Set([1, 2, 5])
    >>>

集合的并集和交集可以用 `union()` 和 `intersection()` 方法进行计算；还有使用按位运算符 `&` 和 `|` 的替代写法。 可变集合还具有这些方法的原地修改版本 `union_update()` 和 `intersection_update()`。

    >>> S1 = sets.Set([1,2,3])
    >>> S2 = sets.Set([4,5,6])
    >>> S1.union(S2)
    Set([1, 2, 3, 4, 5, 6])
    >>> S1 | S2                  # 替代写法
    Set([1, 2, 3, 4, 5, 6])
    >>> S1.intersection(S2)
    Set([])
    >>> S1 & S2                  # 替代写法
    Set([])
    >>> S1.union_update(S2)
    >>> S1
    Set([1, 2, 3, 4, 5, 6])
    >>>

还可以获取两个集合的对称差集。 这是在并集中但不在交集中的所有元素。 换一种说法就是对称差集包含所有恰好只在一个集合中的元素。 同样地，还有一个替代写法 (`^`)，以及一个名称有点冗长的原地修改版本 `symmetric_difference_update()`。

    >>> S1 = sets.Set([1,2,3,4])
    >>> S2 = sets.Set([3,4,5,6])
    >>> S1.symmetric_difference(S2)
    Set([1, 2, 5, 6])
    >>> S1 ^ S2
    Set([1, 2, 5, 6])
    >>>

另外还有 `issubset()` 和 `issuperset()` 方法用来检查一个集合是否为另一个集合的子集或超集:

    >>> S1 = sets.Set([1,2,3])
    >>> S2 = sets.Set([2,3])
    >>> S2.issubset(S1)
    True
    >>> S1.issubset(S2)
    False
    >>> S1.issuperset(S2)
    True
    >>>

参见

PEP 218 - 添加内置集合对象类型

  PEP 由 Greg V. Wilson 撰写 ; 由 Greg V. Wilson, Alex Martelli 和 GvR 实现。

## PEP 255: 简单的生成器

在 Python 2.2 中，生成器作为一个可选特性被添加，需要通过 `from __future__ import generators` 指令来启用。 在 2.3 版本中，生成器不再需要特别启用，现在总是存在；这意味着 `yield` 现在始终是一个关键字。 本节的其余部分是从《Python 2.2的新特性》文档中复制的生成器描述；如果你在 Python 2.2 发布时已经阅读过，可以跳过本节的其余部分。

你一定熟悉在 Python 或 C 语言中函数调用的工作方式。 当你调用一个函数时，它会获得一个私有命名空间，在这个命名空间中创建其局部变量。 当函数执行到 `return` 语句时，这些局部变量会被销毁，并将结果值返回给调用者。 稍后对同一个函数的调用将获得一套全新的局部变量。 但是，如果局部变量在函数退出时不被丢弃呢？如果你可以在函数停止的地方稍后恢复执行呢？这就是生成器所提供的功能；它们可以被视为可恢复的函数。

这里是一个生成器函数的最简示例:

    def generate_ints(N):
        for i in range(N):
            yield i

一个新的关键字 `yield` 被引入用于生成器。 任何包含 `yield` 语句的函数都是生成器函数；这由 Python 的字节码编译器检测到，并因此对函数进行特殊编译。

当你调用生成器函数时，它不会返回一个单独的值；相反，它会返回一个支持迭代器协议的生成器对象。在执行 `yield` 语句时，生成器会输出 `i` 的值 ，类似于 `return` 语句。 `yield` 与 `return` 语句之间的最大区别在于，在到达 `yield` 时，生成器的执行状态会暂停，并保留本地变量。 在下一次调用生成器 的 `.next()` 方法时，函数将在 `yield` 语句之后立即恢复执行。 （由于复杂的原因，`yield` 语句不允许在 `try`...`finally` 语句的 `try` 代码块内出现；有关 `yield` 和异常之间交互的完整解释，请阅读 PEP 255。）

下面是 `generate_ints()` 生成器的用法示例:

    >>> gen = generate_ints(3)
    >>> gen
    <generator object at 0x8117f90>
    >>> gen.next()
    0
    >>> gen.next()
    1
    >>> gen.next()
    2
    >>> gen.next()
    Traceback (most recent call last):
      File "stdin", line 1, in ?
      File "stdin", line 2, in generate_ints
    StopIteration

你可以等价地写成 `for i in generate_ints(5)` 或 `a,b,c = generate_ints(3)`。

在生成器函数内部， `return` 语句只能不带值使用，并表示值的生成过程结束；之后，生成器不能再返回任何值。在生成器函数内部，带值的 `return`，例如 `return 5`，是语法错误。生成器结果的结束也可以通过手动引发 `StopIteration` 异常来指示，或者只是让执行流自然地从函数底部流出。

你可以通过编写自己的类并将生成器的所有局部变量存储为实例变量，手动实现生成器的效果。例如，返回一个整数列表可以通过将 `self.count` 设置为0，并让 `next()` 方法递增 `self.count` 并返回它。然而，对于一个中等复杂的生成器，编写一个相应的类将会更加混乱。`Lib/test/test_generators.py` 包含了一些更有趣的例子。其中最简单的一个使用生成器递归实现了树的中序遍历：

    # 一个递归地按顺序生成 Tree 叶子节点的生成器。
    def inorder(t):
        if t:
            for x in inorder(t.left):
                yield x
            yield t.label
            for x in inorder(t.right):
                yield x

在 `Lib/test/test_generators.py` 中还有另外两个例子，它们分别解决了N皇后问题（在$NxN$的棋盘上放置$N$个皇后，使得没有任何皇后威胁到其他皇后）和骑士巡游问题（在$NxN$的棋盘上，骑士访问每一个方格且不重复访问任何方格的路径）。

生成器的概念源自其他编程语言，尤其是 Icon（https://www2.cs.arizona.edu/icon/ ），在 Icon 语言中，生成器的概念是核心。在 Icon 中，每个表达式和函数调用都可以表现得像一个生成器。以下是来自“Icon 编程语言概述”（https://www2.cs.arizona.edu/icon/docs/ipd266.htm ）中的一个示例，展示了其用法:

    sentence := "Store it in the neighboring harbor"
    if (i := find("or", sentence)) > 5 then write(i)

在Icon中，`find()` 函数返回子字符串"or"所在的索引：3、23、33。在 `if` 语句中，`i` 首先被赋值为 3，但 3 小于 5，因此比较失败，Icon 会使用第二个值 23 进行重试。 23 大于 5，因此比较成功，代码将值 23 打印到屏幕上。

Python并不像Icon那样将生成器作为核心概念来采用。生成器被视为Python核心语言的一部分，但学习或使用它们并不是强制的；如果它们不能解决你遇到的问题，可以完全忽略它们。与Icon相比，Python接口的一个新颖特性是生成器的状态表示为一个具体的对象（迭代器），可以传递给其他函数或存储在数据结构中。

参见

PEP 255 - 简单生成器

  由 Neil Schemenauer, Tim Peters, Magnus Lie Hetland 撰写。 主要由 Neil Schemenauer 和 Tim Peters 实现，并包含来自 Python Labs 团队的修正。

## PEP 263: 源代码的字符编码格式

现在可以声明Python源文件使用不同的字符集编码。通过在源文件的第一行或第二行包含特定格式的注释来声明编码。例如，一个UTF-8文件可以这样声明：

    #!/usr/bin/env python
    # -*- coding: UTF-8 -*-

如果没有这样的编码声明，默认使用7位ASCII编码。执行或导入包含8位字符的字符串字面量且没有编码声明的模块时，在Python 2.3中会触发 `DeprecationWarning` 警告；而在Python 2.4中，这将成为语法错误。

编码声明只影响Unicode字符串字面量，这些字面量将使用指定的编码转换为Unicode。请注意，Python的标识符仍然限制为ASCII字符，因此变量名不能使用超出常规字母数字字符范围的字符。

参见

PEP 263 - 定义 Python 源代码的编码格式

  由 Marc-André Lemburg 和 Martin von Löwis 撰写 ; 由 Suzuki Hisao 和 Martin von Löwis 实现。

## PEP 273: 从ZIP压缩包导入模块

通过新的 `zipimport` 模块增加了从 ZIP 格式归档文件导入模块的支持。 你不需要显式地导入模块；它将在 ZIP 归档文件名被添加到 `sys.path` 的情况下自动导入。 例如：

    amk@nyman:~/src/python$ unzip -l /tmp/example.zip
    Archive:  /tmp/example.zip
      Length     Date   Time    Name
     --------    ----   ----    ----
         8467  11-26-02 22:30   jwzthreading.py
     --------                   -------
         8467                   1 file
    amk@nyman:~/src/python$ ./python
    Python 2.3 (#1, Aug 1 2003, 19:54:32)
    >>> import sys
    >>> sys.path.insert(0, '/tmp/example.zip')  # 将 .zip 文件添加到 path 的开头
    >>> import jwzthreading
    >>> jwzthreading.__file__
    '/tmp/example.zip/jwzthreading.py'
    >>>

`sys.path` 中的一个条目现在可以是 ZIP 归档文件的文件名。ZIP 归档可以包含任何类型的文件，但只有名为 `*.py`、`*.pyc` 或 `*.pyo` 的文件可以被导入。如果归档仅包含 `*.py` 文件，Python 不会尝试通过添加相应的 `*.pyc` 文件来修改归档，这意味着如果 ZIP 归档不包含 `*.pyc` 文件，导入可能会相当慢。

也可以指定归档内的路径，以仅从子目录导入；例如，路径 `/tmp/example.zip/lib/` 将仅从归档中的 `lib/` 子目录导入。

参见

PEP 273 - 从 ZIP 压缩包导入模块

  由James C. Ahlstrom撰写，并提供了一个实现。Python 2.3遵循 PEP 273 中的规范，但使用了Just van Rossum编写的实现，该实现利用了 PEP 302 中描述的导入钩子。有关新导入钩子的描述，请参见 PEP 302: 新导入钩子 的相关部分。

## PEP 277: 针对 Windows NT 的 Unicode 文件名支持

在Windows NT、2000和XP上，系统将文件名存储为Unicode字符串。传统上，Python将文件名表示为字节字符串，这种方式不够完善，因为它会导致某些文件名无法访问。

Python 现在允许在所有期望文件名的函数中使用任意 Unicode 字符串（在文件系统的限制范围内），尤其是内置函数 `open()`。如果将 Unicode 字符串传递给 `os.listdir()`，Python 现在返回一个 Unicode 字符串列表。一个新的函数 `os.getcwdu()` 返回当前目录作为 Unicode 字符串。

字节串仍可被用作文件名，并且在 Windows 上 Python 将透明地使用 `mbcs` 编码格式将其转换为 Unicode。

其他系统也允许使用 Unicode 字符串作为文件名，但在将它们传递给系统之前将它们转换为字节字符串，这可能会引发 `UnicodeError`。应用程序可以通过检查 `os.path.supports_unicode_filenames` (一个布尔值) 来测试是否支持将任意 Unicode 字符串作为文件名。

在 MacOS 下，`os.listdir()` 现在可以返回 Unicode 文件名。

参见

PEP 277 - 针对 Windows NT 的 Unicode 文件名支持

  由 Neil Hodgson 撰写 ; 由 Neil Hodgson, Martin von Löwis 和 Mark Hammond 实现。

## PEP 278: 通用换行支持

目前使用的三大操作系统是微软的 Windows、苹果的 Macintosh OS 和各种 Unix 衍生系统。跨平台工作的一个小麻烦是，这三个平台都使用不同的字符来标记文本文件中的行结束。Unix 使用换行符（ASCII 字符 10），MacOS 使用回车符（ASCII 字符 13），Windows 使用回车符加换行符的双字符序列。

Python 的文件对象现在可以支持与 Python 运行平台不同的行结束约定。使用 `'U'` 或 `'rU'` 模式打开文件将以 universal newlines 模式打开文件供读取。 所有这三种行结束约定都将在各种文件方法如 `read()` 和 `readline()` 返回的字符串中翻译为 `'\n'`。

在导入模块和使用 `execfile()` 函数执行文件时，也会使用通用换行支持。 这意味着 Python 模块可以在所有三种操作系统之间共享，而无需转换行尾。

在编译 Python 时，可以通过在运行 Python 的 configure 脚本时指定 `--without-universal-newlines` 开关禁用该功能。

参见

PEP 278 - 通用换行支持

  由 Jack Jansen 撰写并实现。

## PEP 279: enumerate()

新的内置函数 `enumerate()` 将使某些循环更加清晰。 在 `enumerate(thing)` 中，如果 thing 是迭代器或序列，则返回一个迭代器，该迭代器将返回 `(0, thing[0])`，`(1, thing[1])`，`(2, thing[2])`，以此类推。

改变一个列表中每个元素的常见写法看起来像是这样:

    for i in range(len(L)):
        item = L[i]
        # ... 基于条目计算某个结果 ...
        L[i] = result

可以使用 `enumerate()` 重写为：

    for i, item in enumerate(L):
        # ... 基于条目计算某个结果 ...
        L[i] = result

参见

PEP 279 - 内置函数 enumerate()

  由 Raymond D. Hettinger 撰写并实现。

## PEP 282: logging 包

Python 2.3 中新增了一个用于编写日志的标准软件包 `logging`。 它为生成日志输出提供了一个强大而灵活的机制，这些输出可以通过各种方式进行过滤和处理。用标准格式编写的配置文件可以用来控制程序的日志行为。 Python 包含的处理器可以将日志记录写入标准错误、文件或套接字，发送到系统日志，甚至通过电子邮件发送到特定地址；当然，你也可以编写自己的处理器类。

`Logger` 类是主要的类。大多数应用程序代码将处理一个或多个 `Logger` 对象，每个对象由应用程序的特定子系统使用。每个 `Logger` 都由一个名称标识，名称通过使用 `.` 作为组件分隔符组织成层次结构。例如，你可能有名为 `server`、`server.auth` 和 `server.network` 的 `Logger` 实例。后两个实例在层次结构中位于 `server` 之下。这意味着如果你提高 `server` 的详细级别或将 `server` 消息定向到不同的处理器，更改也将应用于记录到 `server.auth` 和 `server.network` 的记录。还有一个根 `Logger`，它是所有其他记录器的父级。

为了简化使用，`logging` 包提供了一些始终使用根日志的便捷函数:

    import logging

    logging.debug('Debugging information')
    logging.info('Informational message')
    logging.warning('Warning:config file %s not found', 'server.conf')
    logging.error('Error occurred')
    logging.critical('Critical error -- shutting down')

这会产生以下输出:

    WARNING:root:Warning:config file server.conf not found
    ERROR:root:Error occurred
    CRITICAL:root:Critical error -- shutting down

在默认配置中，信息和调试信息被忽略，输出被发送到标准错误。 你可以通过调用根日志记录器上的 `setLevel()` 方法来启用信息和调试信息的显示。

请注意 `warning()` 调用使用了字符串格式化运算符；所有记录信息的函数都使用参数 `(msg, arg1, arg2, ...)`，并记录 `msg % (arg1, arg2, ...)` 产生的字符串。

还有一个 `exception()` 函数可记录最近的回溯。如果为关键字参数 exc_info 指定了真值，其他函数也会记录回溯：

    def f():
        try:    1/0
        except: logging.exception('Problem recorded')

    f()

这会产生以下输出:

    ERROR:root:Problem recorded
    Traceback (most recent call last):
      File "t.py", line 6, in f
        1/0
    ZeroDivisionError: integer division or modulo by zero

稍微高级一些的程序将使用除根记录器之外的记录器。`getLogger(name)` 函数用于获取特定的日志，如果该日志尚不存在则创建它。`getLogger(None)` 返回根记录器。:

    log = logging.getLogger('server')
     ...
    log.info('Listening on port %i', port)
     ...
    log.critical('Disk full')
     ...

日志记录通常会向上传播，因此 `server` 和 `root` 也会看到记录到 `server.auth` 的信息，但 `Logger` 可以通过将其 `propagate` 属性设置为 `False` 来避免这种情况。

`logging` 包提供了更多可以自定义的类。当 `Logger` 实例被告知记录消息时，它会创建一个 `LogRecord` 实例，该实例被发送到任意数量的不同 `Handler` 实例。记录器和处理器还可以附加过滤器列表，每个过滤器可以导致 `LogRecord` 被忽略，或者可以在传递之前修改记录。当它们最终输出时，`LogRecord` 实例由 `Formatter` 类转换为文本。所有这些类都可以由你自己编写的特殊类替换。

`logging` 软件包具有所有这些功能，即使是最复杂的应用程序也能灵活运用。 本文仅是对其功能的不完整概述，因此请参阅软件包的参考文档了解所有细节。 阅读 PEP 282 也会有所帮助。

参见

PEP 282 - Logging 系统

  由 Vinay Sajip 和 Trent Mick 撰写 ; 由 Vinay Sajip 实现。

## PEP 285: 布尔类型

Python 2.3 中增加了布尔类型。 `__builtin__` 模块中新增了两个常量： `True` 和 `False`。 (`True` 和 `False` 常量被添加到了 Python 2.2.1 的内置模块中，但 2.2.1 版本的常量只是被设置为 1 和 0 的整数值，并不是一种不同的类型。)

这个新类型的类型对象名为 `bool`；它的构造函数接收任何 Python 值，并将其转换为 `True` 或 `False`。:

    >>> bool(1)
    True
    >>> bool(0)
    False
    >>> bool([])
    False
    >>> bool( (1,) )
    True

大多数标准库模块和内置函数都改为返回布尔值：

    >>> obj = []
    >>> hasattr(obj, 'append')
    True
    >>> isinstance(obj, list)
    True
    >>> isinstance(obj, tuple)
    False

添加 Python 布尔运算的主要目的是使代码更清晰。 例如，如果你在阅读一个函数时遇到 `return 1` 语句，你可能会想知道 `1` 代表的是布尔真值、索引还是乘以其他量的系数。 然而，如果语句是 `return True`，返回值的含义就非常清楚了。

Python 的布尔值 不是 为了严格的类型检查而添加的。 像 Pascal 这样非常严格的语言也会阻止你使用布尔进行算术运算，并要求 `if` 语句中的表达式总是求布尔结果。 正如 PEP 285 所明确指出的，Python 没有这么严格，以后也不会有。 这意味着你仍然可以在 `if` 语句中使用任何表达式，甚至是求值为 list、tuple 或一些随机对象的表达式。 布尔类型是 `int` 类的子类，因此使用布尔值进行算术运算仍然有效：

    >>> True + 1
    2
    >>> False + 1
    1
    >>> False * 75
    0
    >>> True * 75
    75

用一句话概括 `True` 和 `False`: 它们是拼写整数值 1 和 0 的另一种方式，唯一不同的是 `str()` 和 `repr()` 返回的字符串是 `'True'` 和 `'False'`，而不是 `'1'` 和 `'0'`。

参见

PEP 285 - 添加布尔类型

  由 GvR 撰写并实现。

## PEP 293: 编解码器错误处理回调

将 Unicode 字符串编码为字节字符串时，可能会遇到无法编码的字符。 到目前为止，Python 允许将错误处理指定为 "strict" (引发 `UnicodeError`)、"ignore" (跳过该字符) 或 "replace" (在输出字符串中使用问号)，其中 "strict" 是默认行为。 可能需要指定对此类错误的其他处理方式，例如在转换后的字符串中插入 XML 字符引用或 HTML 实体引用。

Python 现在有一个灵活的框架，可以添加不同的处理策略。可以通过 `codecs.register_error()` 添加新的错误处理器，然后编解码器可以通过 `codecs.lookup_error()` 访问错误处理器。 错误处理器会获取必要的状态信息，如正在转换的字符串、字符串中检测到错误的位置以及目标编码。 然后，处理器可以引发异常或返回替换字符串。

使用该框架还实现了两个额外的错误处理器： "backslashreplace" 使用 Python 反斜杠引号来表示无法编码的字符，而 "xmlcharrefreplace" 则转换为 XML 字符引用。

参见

PEP 293 - 编解码器错误处理回调

  由 Walter Dörwald 撰写并实现。

## PEP 301: Distutils的软件包索引和元数据

广受期待的对 Python 编目的支持在 2.3 版中首次出现。

编目功能的核心是新的 Distutils register 命令。 运行 `python setup.py register` 将会收集描述软件包的元数据，例如其名称、版本、维护者、描述信息等等，并将其发送给中央编目服务器。 结果编目数据可在 https://pypi.org 获取。

为了使目录更加有用，Distutils 的 `setup()` 函数中新增了一个可选的 classifiers 关键字参数。 可以提供一系列 Trove 风格的字符串来帮助对软件进行分类。

下面是一个带有分类器的 `setup.py` 示例，其编写是为了兼容旧版本的 Distutils：

    from distutils import core
    kw = {'name': "Quixote",
          'version': "0.5.1",
          'description': "A highly Pythonic Web application framework",
          # ...
          }

    if (hasattr(core, 'setup_keywords') and
        'classifiers' in core.setup_keywords):
        kw['classifiers'] = \
            ['Topic :: Internet :: WWW/HTTP :: Dynamic Content',
             'Environment :: No Input/Output (Daemon)',
             'Intended Audience :: Developers'],

    core.setup(**kw)

完整的 classifiers 列表可通过运行 `python setup.py register --list-classifiers` 来获取。

参见

PEP 301 - Distutils 的软件包索引和元数据

  由 Richard Jones 撰写并实现。

## PEP 302: 新导入钩子

虽然自从在 Python 1.3 中引入 `ihooks` 模块后，就可以编写自定义导入钩子了，但由于编写新的导入钩子既困难又混乱，所以从来没有人对它真正满意过。 曾有人提出过各种替代方案，如 `imputil` 和 `iu` 模块，但都没有得到广泛认可，而且都不容易从 C 代码中使用。

PEP 302 借鉴了其前身，尤其是 Gordon McMillan 的 `iu` 模块。 `sys` 模块新增了三个条目：

- `sys.path_hooks` 是一个可调用对象列表，通常是类。 每个可调用对象都接收一个包含路径的字符串，然后返回一个可处理从该路径导入的导入器对象，如果不能处理该路径，则引发 `ImportError` 异常。

- `sys.path_importer_cache` 会缓存每条路径的导入器对象，因此 `sys.path_hooks` 只需为每条路径遍历一次。

- `sys.meta_path` 是一个导入器对象列表，在检查 `sys.path` 之前将遍历该列表。 该列表最初为空，但用户代码可以向其中添加对象。 其他内置模块和冻结模块可以通过添加到该列表中的对象导入。

导入器对象必须有一个方法，即 `find_module(fullname, path=None)`。 fullname 将是一个模块或软件包名称，如 `string` 或 `distutils.core`。 `find_module()` 必须返回一个加载器对象，该加载器对象必须有一个方法 `load_module(fullname)`，用于创建和返回相应的模块对象。

因此，Python 新导入逻辑的伪代码如下 (略有简化；详情请参见 PEP 302)：

    for mp in sys.meta_path:
        loader = mp(fullname)
        if loader is not None:
            <module> = loader.load_module(fullname)

    for path in sys.path:
        for hook in sys.path_hooks:
            try:
                importer = hook(path)
            except ImportError:
                # ImportError，则尝试其他路径钩子
                pass
            else:
                loader = importer.find_module(fullname)
                <module> = loader.load_module(fullname)

    # 未找到！
    raise ImportError

参见

PEP 302 - 新导入钩子

  由 Just van Rossum 和 Paul Moore 撰写 ; 由 Just van Rossum 实现。

## PEP 305: 逗号分隔文件

以逗号作为分隔符的文件是一种常用于从数据库和电子表格导出数据的格式。 Python 2.3 增加了一个针对逗号分隔文件的解析器。

逗号分隔文件乍一看非常简单:

    Costs,150,200,3.95

读取一行并调用 `line.split(',')`: 再简单不过了吧？ 但是考虑到可能包含逗号的字符串数据，事情就变得复杂起来:

    "Costs",150,200,3.95,"Includes taxes, shipping, and sundry items"

一个大的丑陋的正则表达式可以解析这些内容，但使用新的 `csv` 软件包要简单得多：

    import csv

    input = open('datafile', 'rb')
    reader = csv.reader(input)
    for line in reader:
        print line

`reader()` 函数有多种不同的选项。 字段分隔符不限于逗号，可以改为任何字符，引号和行尾字符也是如此。

可以定义和注册不同的逗号分隔文件方言；目前有两种方言，均由 Microsoft Excel 使用。一个单独的 `csv.writer` 类将从一系列元组或列表生成逗号分隔文件，并对包含分隔符的字符串进行引用。

参见

PEP 305 - CSV 文件 API

  由 Kevin Altis, Dave Cole, Andrew McNamara, Skip Montanaro, Cliff Wells 撰写并实现。

## PEP 307：对 pickle 的改进

`pickle` 和 `cPickle` 模块在 2.3 开发周期中受到了关注。 在 2.2 中，新式类的 pickle 并不困难，但 pickle 得并不紧凑；PEP 307 引用了一个微不足道的例子，在这个例子中，新式类的 pickle 字符串比经典类的 pickle 字符串长三倍。

解决办法就是发明一种新的 pickle 协议。 `pickle.dumps()` 函数很早就支持文本或二进制标志。 在 2.3 中，该标志从布尔值重新定义为整数：0 表示旧的文本模式 pickle 格式，1 表示旧的二进制格式，现在 2 表示新的 2.3 专用格式。 一个新常量 `pickle.HIGHEST_PROTOCOL` 可用来选择最先进的协议。

unpickle 不再被视为安全操作。 2.2 的 `pickle` 提供了钩子，试图阻止不安全的类被 unpickle （特别是 `__safe_for_unpickling__` 属性），但这些代码都没有经过审计，因此在 2.3 中都被删除了。 在任何版本的 Python 中，你都不应该 unpickle 不信任的数据。

为了减少新式类的序列化开销，添加了一个新的接口用于自定义序列化，使用三个特殊方法：`__getstate__()`、`__setstate__()` 和 `__getnewargs__()`。请参考 PEP 307 了解这些方法的完整语义。

为了进一步压缩 pickle 类，现在可以使用整数代码而不是长字符串来标识 pickle 类。 Python 软件基金会将维护一个标准化代码列表；还有一系列供私人使用的代码。 目前还没有指定任何代码。

参见

PEP 307 - pickle 协议的扩展

  PEP 由 Guido van Rossum 和 Tim Peters 撰写和实现。

## 扩展切片

从 Python 1.4 开始，切片语法支持可选的第三个“step”或“stride”参数。例如，这些都是合法的 Python 语法: `L[1:10:2]`，`L[:-1:1]`，`L[::-1]`。 这是应 Numerical Python 开发者的要求添加到 Python 中的，因为 Numerical Python 广泛使用第三个参数。 然而，Python 内置的 list、tuple 和字符串序列类型从未支持过这一特性，如果你尝试使用，会引发 `TypeError`。 Michael Hudson 提供了一个补丁来修复这一缺陷。

例如，你现在可以轻松地提取出具有偶数索引的列表元素：

    >>> L = range(10)
    >>> L[::2]
    [0, 2, 4, 6, 8]

也可以用负值以按相反顺序复制相同的列表：

    >>> L[::-1]
    [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

这也适用于元组、数组和字符串：

    >>> s='abcd'
    >>> s[::2]
    'ac'
    >>> s[::-1]
    'dcba'

如果你有一个可变序列如列表或数组，你可以对扩展切片进行赋值或删除，但对扩展切片的赋值与对常规切片的赋值有一些区别。对常规片段的赋值可以用来改变序列的长度：

    >>> a = range(3)
    >>> a
    [0, 1, 2]
    >>> a[1:3] = [4, 5, 6]
    >>> a
    [0, 4, 5, 6]

扩展分片则没有这种灵活性。 在为扩展分片赋值时，语句右侧的列表必须包含与要替换的分片相同数量的项目：

    >>> a = range(4)
    >>> a
    [0, 1, 2, 3]
    >>> a[::2]
    [0, 2]
    >>> a[::2] = [0, -1]
    >>> a
    [0, 1, -1, 3]
    >>> a[::2] = [0,1,2]
    Traceback (most recent call last):
      File "<stdin>", line 1, in ?
    ValueError: attempt to assign sequence of size 3 to extended slice of size 2

删除操作更为直观：

    >>> a = range(4)
    >>> a
    [0, 1, 2, 3]
    >>> a[::2]
    [0, 2]
    >>> del a[::2]
    >>> a
    [1, 3]

现在，我们还可以将切片对象传递给内置序列的 `__getitem__()` 方法：

    >>> range(10).__getitem__(slice(0, 5, 2))
    [0, 2, 4]

或者直接在下标中使用切片对象：

    >>> range(10)[slice(0, 5, 2)]
    [0, 2, 4]

为了简化支持扩展切片的序列的实现，切片对象现在有了一个方法 `indices(length)`，在给定序列长度的情况下，它返回一个 `(start, stop, step)` 元组，可以直接传给 `range()`。 `indices()` 处理省略和越界索引的方式与常规切片一致（这个无伤大雅的短语隐藏了大量令人困惑的细节！）。 该方法的使用方法如下：

    class FakeSeq:
        ...
        def calc_item(self, i):
            ...
        def __getitem__(self, item):
            if isinstance(item, slice):
                indices = item.indices(len(self))
                return FakeSeq([self.calc_item(i) for i in range(*indices)])
            else:
                return self.calc_item(i)

从这个例子中还可以看到，内置的 `slice` 对象现在是 slice 类型的类型对象，而不再是函数。 这与 Python 2.2 是一致的，在 Python 2.2 中，`int`，`str` 等也经历了同样的变化。

## 其他语言特性修改

以下是 Python 2.3 针对核心 Python 语言的所有改变。

- `yield` 语句现在将始终是关键字，如本文档的 PEP 255: 简单的生成器 一节所描述的。

- 新增内置函数 `enumerate()`，如本文档的 PEP 279: enumerate() 一节所描述的。

- 新增两个常量 `True` 和 `False` 以及内置的 `bool` 类型，如本文档的 PEP 285: 布尔类型 一节所描述的。

- `int()` 类型构造函数现在会返回一个长整数，而不会在字符串或浮点数太大而无法放入整数时引发 `OverflowError`。 这可能会导致 `isinstance(int(expression), int)` 为假的矛盾结果，但在实践中似乎不太可能造成问题。

- 内置类型现在支持扩展的切分语法，详见本文档 扩展切片 一节。

- 一个新的内置函数 `sum(iterable, start=0)` 用于对可迭代对象中的数值项进行求和并返回其总和。`sum()` 只接受数字，意味着你不能用它来连接一堆字符串。（由 Alex Martelli 贡献。）

- 以前 `list.insert(pos, value)` 在 pos 为负值时会将 value 插入到列表的前面。 现在，该行为已被修改为与切片索引一致，因此当 pos 为 -1 时，值将被插入最后一个元素之前，以此类推。

- `list.index(value)` 会在列表中搜索 value，并返回其索引，现在可以使用可选的 start 和 stop 参数，将搜索范围限制在列表的一部分。

- 字典有一个新方法 `pop(key[, *default*])`，可返回 key 对应的值，并从字典中删除该键/值对。如果请求的键不在字典中，如果指定了 default，则返回 default，如果没有指定则会引发 `KeyError`。

      >>> d = {1:2}
      >>> d
      {1: 2}
      >>> d.pop(4)
      Traceback (most recent call last):
        File "stdin", line 1, in ?
      KeyError: 4
      >>> d.pop(1)
      2
      >>> d.pop(1)
      Traceback (most recent call last):
        File "stdin", line 1, in ?
      KeyError: 'pop(): dictionary is empty'
      >>> d
      {}
      >>>

  还有一个新的类方法 `dict.fromkeys(iterable, value)`，用于创建一个字典，其键取自所提供的迭代器 iterable，所有值设置为 value，默认为 `None`。

  （由 Raymond Hettinger 贡献补丁。）

  此外，现在 `dict()` 构建器可接受关键字参数以简化小型字典的创建:

      >>> dict(red=1, blue=2, green=3, black=4)
      {'blue': 2, 'black': 4, 'green': 3, 'red': 1}

  （由 Just van Rossum 贡献。）

- `assert` 语句将不再检查 `__debug__` 旗标，因此你无法再通过为 `__debug__` 赋值来禁用断言。 使用 `-O` 开关运行 Python 仍会生成不执行任何断言的代码。

- 大多数类型对象现在都是可调用的，因此你可以用它们来创建新对象，如函数、类和模块。（这意味着 `new` 模块可以在未来的 Python 版本中被废弃，因为你现在可以使用 `types` 模块中可用的类型对象）。例如，你可以用下面的代码创建一个新的模块对象：

      >>> import types
      >>> m = types.ModuleType('abc','docstring')
      >>> m
      <module 'abc' (built-in)>
      >>> m.__doc__
      'docstring'

- 添加了一个新的警告 `PendingDeprecationWarning`，用于指示正在被废弃的功能。 默认情况下 不会 打印该警告。 要检查是否使用了将来会被废弃的功能，可在命令行中提供 `-Walways::PendingDeprecationWarning::` 或使用 `warnings.filterwarnings()`。

- 与 `raise "Error occurred"` 一样，基于字符串的异常的废弃过程已经开始。 现在，引发字符串异常将触发 `PendingDeprecationWarning`。

- 现在使用 `None` 作为变量名将导致 `SyntaxWarning` 警告。 在未来的 Python 版本中，`None` 将最终成为一个保留关键字。

- 在 Python 2.1 中引入的文件对象的 `xreadlines()` 方法已不再需要，因为文件现在可以作为自己的迭代器来运行。 引入 `xreadlines()` 的初衷是为了更快地循环遍历文件中的所有行，但现在只需写入 `for line in file_obj` 即可。 文件对象还有一个新的只读 `encoding` 属性，它给出了文件使用的编码；写入文件的 Unicode 字符串将使用给定的编码自动转换为字节。

- 新式类使用的方法解析顺序发生了变化，不过只有在继承层次结构非常复杂的情况下，你才会注意到这种差异。 经典类不受这一变化的影响。 Python 2.2 最初使用类祖先的拓扑排序，但 2.3 现在使用 C3 算法，如论文 "A Monotonic Superclass Linearization for Dylan" 所述。 要了解这一变化的动机，请阅读 Michele Simionato 的文章 Python 2.3 方法解析顺序，或阅读 python-dev 上从 https://mail.python.org/pipermail/python-dev/2002-October/029035.html 开始的消息。 Samuele Pedroni 首先指出了这个问题，并通过编码 C3 算法实现了修复。

- Python 运行多线程程序时，会在执行 N 个字节码后切换线程。 N 的默认值已从 10 个字节码增加到 100 个，通过减少切换开销来加快单线程应用程序的速度。 一些多线程应用程序的响应时间可能会变慢，但这很容易解决，只需使用 `sys.setcheckinterval(N)` 将限制设回一个较低的数值即可。 使用新的 `sys.getcheckinterval()` 函数可以检索限制值。

- 一个微小但影响深远的变化是，由 Python 附带的模块定义的扩展类型的名称现在包含模块和类型名称前面的 `'.'`。 例如，在 Python 2.2 中，如果你创建了一个套接字并打印了它的 `__class__`，你会得到这样的输出：

      >>> s = socket.socket()
      >>> s.__class__
      <type 'socket'>

  在 2.3 中，你会得到以下信息：

      >>> s.__class__
      <type '_socket.socket'>

- 旧式类和新式类之间一个已知的不兼容问题已被移除：现在你可以为新式类的 `__name__` 和 `__bases__` 属性赋值。对于可以赋给 `__bases__` 的值有一些限制，类似于对实例的 `__class__` 属性赋值的限制。

### 字符串的改变

- `in` 运算符现在对字符串的作用不同了。 以前，当计算 `X in Y` 时，X 和 Y 都是字符串，X 只能是单字符。 现在情况有所改变；X 可以是任意长度的字符串，如果 X 是 Y 的子串，`X in Y` 将返回 `True`。 如果 X 是空字符串，结果总是 `True`。

      >>> 'ab' in 'abcd'
      True
      >>> 'ad' in 'abcd'
      False
      >>> '' in 'abcd'
      True

  请注意，这不会告诉你子串从哪里开始；如果需要该信息，请使用字符串方法 `find()`。

- `strip()`、`lstrip()` 和 `rstrip()` 字符串方法现在有了一个可选参数，用于指定要删除的字符。默认值仍然是删除所有空白字符：

      >>> '   abc '.strip()
      'abc'
      >>> '><><abc<><><>'.strip('<>')
      'abc'
      >>> '><><abc<><><>\n'.strip('<>')
      'abc<><><>\n'
      >>> u'\u4000\u4001abc\u4000'.strip(u'\u4000')
      u'\u4001abc'
      >>>

  （由 Simon Brunning 提议并由 Walter Dörwald 实现。）

- `startswith()` 和 `endswith()` 字符串方法的 start 和 end 参数现在可接受负数。

- 另一个新增的字符串方法是 `zfill()`，原本是 `string` 模块中的一个函数。 `zfill()` 会在一个表示数字的字符串左侧填充零直至达到指定的宽度。 请注意 `%` 运算符相比 `zfill()` 仍然是更灵活和更强大的。

      >>> '45'.zfill(4)
      '0045'
      >>> '12345'.zfill(4)
      '12345'
      >>> 'goofy'.zfill(6)
      '0goofy'

  （由 Walter Dörwald 贡献。）

- 添加了一个新的类型对象 `basestring`。8位字符串和 Unicode 字符串都继承自这个类型，所以 `isinstance(obj, basestring)` 对这两种字符串都会返回 `True`。这是一个完全抽象的类型，所以你不能创建 `basestring` 实例。

- 内部字符串不再是不朽的，现在当它们唯一的引用来自内部字符串字典时，将按照通常的方式进行垃圾回收。（由 Oren Tirosh 实现。）

### 性能优化

- 新式类实例的创建速度获得大幅提升；现在已经比经典类更快了！

- 列表对象的 `sort()` 方法已被 Tim Peters 全面改写，其实现的运行速度显著提高。

- 由于实现了Karatsuba乘法算法，大长整数的乘法现在更快了。这种算法的扩展性比学校乘法算法所需的*O*(n2)要好得多。（原始补丁由Christopher A. Craig提供，Tim Peters进行了大量重写。）

- `SET_LINENO` 操作码现已移除。这可能提供小幅速度提升，具体取决于你编译器的特性。详见 其他的改变和修正 部分的详细解释。（由Michael Hudson移除。）

- `xrange()` 对象现在拥有自己的迭代器，使得 `for i in xrange(n)` 比 `for i in range(n)` 稍微快一些。（由Raymond Hettinger提供补丁。）

- 在多个热点区域进行了一些小的调整以提升性能，例如内联函数或移除部分代码。（主要由GvR实现，但许多人都贡献了单个更改。）

2.3 优化的总体结果是 Python 2.3 运行 pystone 基准测试的速度比 Python 2.2 加快了大约 25%。

## 新增，改进和弃用的模块

一如既往，Python标准库获得了一系列增强和错误修复。以下是一些最显著变化的部分列表，按模块名称字母顺序排序。查阅源树中的 `Misc/NEWS` 文件可获得更完整的变化列表，或通过CVS日志查看所有详细信息。

- `array` 模块现在支持使用 `'u'` 格式字符的Unicode字符数组。数组还支持使用 `+=` 赋值运算符来添加另一个数组的内容，以及使用 `*=` 赋值运算符来重复数组。（由 Jason Orendorff 贡献。）

- `bsddb` 模块已被 PyBSDDB 包的4.1.6版本替换，提供了对BerkeleyDB库事务特性的更完整接口。

  旧版本的模块已被重命名为 `bsddb185`，并且不再自动构建；你需要编辑 `Modules/Setup` 以启用它。请注意，新的 `bsddb` 包旨在与旧模块兼容，因此如果你发现任何不兼容问题，请务必提交错误报告。在升级到 Python 2.3 时，如果新解释器是与新版本的底层 BerkeleyDB 库一起编译的，你几乎肯定需要将数据库文件转换为新的版本。你可以使用新脚本 `db2pickle.py` 和 `pickle2db.py` 相当容易地完成此操作，这些脚本位于发行版的 `Tools/scripts` 目录中。如果你已经使用 PyBSDDB 包并将其作为 `bsddb3` 导入，你将需要更改你的 `import` 语句以将其作为 `bsddb` 导入。

- 新的 `bz2` 模块是 bz2 数据压缩库的接口。bz2 压缩的数据通常比相应的 `zlib`-压缩数据更小。（由 Gustavo Niemeyer 贡献。）

- 在新的 `datetime` 模块中添加了一组标准日期/时间类型。更多详细信息请参见下一节。

- Distutils 的 `Extension` 类现在支持一个名为 depends 的额外构造函数参数，用于列出扩展所依赖的其他源文件。这使得 Distutils 在任何依赖文件被修改时重新编译模块。例如，如果 `sampmodule.c` 包含头文件 `sample.h`，你将像这样创建 `Extension` 对象:

      ext = Extension("samp",
                      sources=["sampmodule.c"],
                      depends=["sample.h"])

  修改 `sample.h` 将导致模块被重新编译。 （由 Jeremy Hylton 贡献。）

- 对 Distutils 的其他小修改：现在它会检查 `CC`, `CFLAGS`, `CPP`, `LDFLAGS` 和 `CPPFLAGS` 环境变量，使用它们来覆盖 Python 配置中的设置（由 Robert Weber 贡献）。

- 之前 `doctest` 模块只会在公共方法和函数的文档字符串中搜索测试用例，但现在它也会检查私有方法和函数。`DocTestSuite()` 函数从一组 `doctest` 测试中创建一个 `unittest.TestSuite` 对象。

- 新的 `gc.get_referents(object)` 函数将返回由 object 引用的所有对象组成的列表。

- 模块 `getopt` 新增了一个函数 `gnu_getopt()`，该函数支持与现有 `getopt()` 函数相同的参数，但使用 GNU 风格的扫描模式。现有的 `getopt()` 函数在遇到非选项参数时停止处理选项，但在 GNU 风格模式下，处理会继续进行，这意味着选项和参数可以混合使用。例如：

      >>> getopt.getopt(['-f', 'filename', 'output', '-v'], 'f:v')
      ([('-f', 'filename')], ['output', '-v'])
      >>> getopt.gnu_getopt(['-f', 'filename', 'output', '-v'], 'f:v')
      ([('-f', 'filename'), ('-v', '')], ['output'])

  （由 Peter Åstrand 贡献。）

- 现在 `grp`, `pwd` 和 `resource` 模块将返回加强版的元组:

      >>> import grp
      >>> g = grp.getgrnam('amk')
      >>> g.gr_name, g.gr_gid
      ('amk', 500)

- 现在 `gzip` 模块能够处理超过 2 GiB 的文件。

- 新的 `heapq` 模块包含了一个堆队列算法的实现。堆是一种类似数组的数据结构，它保持元素处于部分排序状态，对于每个索引 k，满足 `heap[k] <= heap[2*k+1]` 和 `heap[k] <= heap[2*k+2]`。这使得快速移除最小元素变得容易，同时插入新元素并保持堆属性的时间复杂度为 O(log n)。（更多信息请参见 https://xlinux.nist.gov/dads//HTML/priorityque.html，了解优先队列数据结构。）

  模块 `heapq` 提供了 `heappush()` 和 `heappop()` 函数，用于在保持堆属性的同时，对某些其他可变的 Python 序列类型添加和移除元素。以下是一个使用 Python 列表的示例：

      >>> import heapq
      >>> heap = []
      >>> for item in [3, 7, 5, 11, 1]:
      ...    heapq.heappush(heap, item)
      ...
      >>> heap
      [1, 3, 5, 11, 7]
      >>> heapq.heappop(heap)
      1
      >>> heapq.heappop(heap)
      3
      >>> heap
      [5, 7, 11]

  （由 Kevin O'Connor 贡献。）

- 集成开发环境 IDLE 已使用 IDLEfork 项目（https://idlefork.sourceforge.net）的代码进行更新。最显著的功能是，正在开发的代码现在在子进程中执行，这意味着不再需要手动执行 `reload()` 操作。IDLE 的核心代码已作为 `idlelib` 包纳入标准库。

- 模块 `imaplib` 现在支持通过 SSL 的 IMAP。（由 Piers Lauder 和 Tino Lange 贡献。）

- 模块 `itertools` 包含了许多用于迭代器的实用函数，灵感来自 ML 和 Haskell 语言提供的各种函数。例如，`itertools.ifilter(predicate, iterator)` 返回迭代器中所有使函数 `predicate()` 返回 `True` 的元素，而 `itertools.repeat(obj, N)` 返回 `obj` N 次。模块中还有许多其他函数；详细信息请参阅包的参考文档。（由 Raymond Hettinger 贡献。）

- 模块 `math` 中新增了两个函数，`degrees(rads)` 和 `radians(degs)`，用于在弧度和度之间进行转换。模块 `math` 中的其他函数，如 `math.sin()` 和 `math.cos()`，一直需要以弧度为单位输入值。此外，`math.log()` 函数增加了一个可选的 base 参数，以便更容易计算除 `e` 和 `10` 以外的对数。（由 Raymond Hettinger 贡献。）

- 模块 `posix` 中新增了几个 POSIX 函数 (`getpgid()`、`killpg()`、`lchown()`、`loadavg()`、`major()`、`makedev()`、`minor()` 和 `mknod()`)，该模块是 `os` 模块的基础。 （由 Gustavo Niemeyer、Geert Jansen 和 Denis S. Otkidach 贡献。）

- 在模块 `os` 中，`*stat()` 函数家族现在可以报告时间戳中的秒数分数。此类时间戳表示为浮点数，类似于 `time.time()` 返回的值。

  在测试过程中发现，某些应用程序在时间戳为浮点数时会崩溃。为了兼容性，当使用 `stat_result` 的元组接口时，时间戳将表示为整数。当使用命名字段（Python 2.2 首次引入的特性）时，时间戳仍然表示为整数，除非调用 `os.stat_float_times()` 以启用浮点数返回值:

      >>> os.stat("/tmp").st_mtime
      1034791200
      >>> os.stat_float_times(True)
      >>> os.stat("/tmp").st_mtime
      1034791200.6335014

  在 Python 2.4 中，默认将改为总是返回浮点数。

  应用开发者应仅在所有库在面对浮点时间戳时均能正常工作，或者使用元组API时启用此功能。如果使用，该功能应在应用级别激活，而不是尝试在每次使用时启用。

- `optparse` 模块包含一个新的命令行参数解析器，可以将选项值转换为特定的Python类型，并自动生成使用说明。更多详情请参见下一节。

- 旧的且从未文档化的 `linuxaudiodev` 模块已被弃用，新增了一个名为 `ossaudiodev` 的新版本。该模块被重命名是因为OSS声音驱动可以在除Linux之外的其他平台上使用，且接口也进行了整理和更新。（由Greg Ward和Nicholas FitzRoy-Dale贡献。）

- 新的 `platform` 模块包含多个函数，尝试确定你正在运行的平台的各项属性。有获取架构、CPU类型、Windows操作系统版本，甚至Linux发行版版本的函数。（由Marc-André Lemburg贡献。）

- `pyexpat` 模块提供的解析器对象现在可以选择性地缓冲字符数据，从而减少对字符数据处理器的调用，提高性能。将解析器对象的 `buffer_text` 属性设置为 `True` 将启用缓冲。

- `sample(population, k)` 函数已添加到 `random` 模块中。population 是一个包含种群元素的序列或 `xrange` 对象，`sample()` 从种群中不重复地选择 k 个元素。k 可以是任何不超过 `len(population)` 的值。例如：

      >>> days = ['Mo', 'Tu', 'We', 'Th', 'Fr', 'St', 'Sn']
      >>> random.sample(days, 3)      # 选择 3 个元素
      ['St', 'Sn', 'Th']
      >>> random.sample(days, 7)      # 选择 7 个元素
      ['Tu', 'Th', 'Mo', 'We', 'St', 'Fr', 'Sn']
      >>> random.sample(days, 7)      # 再次选择 7 个
      ['We', 'Mo', 'Sn', 'Fr', 'Tu', 'St', 'Th']
      >>> random.sample(days, 8)      # 无法选择八个
      Traceback (most recent call last):
        File "<stdin>", line 1, in ?
        File "random.py", line 414, in sample
            raise ValueError, "sample larger than population"
      ValueError: sample larger than population
      >>> random.sample(xrange(1,10000,2), 10)   # Choose ten odd nos. under 10000
      [3407, 3805, 1505, 7023, 2401, 2267, 9733, 3151, 8083, 9195]

  现在 `random` 模块使用新的“梅森旋转”算法，并以 C 实现。 它的速度更快并且与之前的算法相比研究更充分。

  （所有改变均由 Raymond Hettinger 贡献。）

- `readline` 模块也增加了几个新函数: `get_history_item()`, `get_current_history_length()` 和 `redisplay()`。

- `rexec` 和 `Bastion` 模块已被宣布废弃，尝试导入它们将会引发 `RuntimeError` 异常。新式类提供了新的方法来突破 `rexec` 提供的受限执行环境，并且没有人有兴趣或时间去修复它们。如果你的应用程序使用了 `rexec`，请重写它们以使用其他替代方案。

  （继续使用 Python 2.2 或 2.1 不会使你的应用程序更安全，因为这些版本中的 `rexec` 模块存在已知漏洞。重申：如果你正在使用 `rexec`，请立即停止使用。）

- `rotor` 模块已被弃用，因为它使用的加密算法被认为是不安全的。如果你需要加密，请使用单独提供的几种 AES Python 模块之一。

- `shutil` 模块新增了一个 `move(src, dest)` 函数，用于递归地将文件或目录移动到新位置。

- 对更高级的 POSIX 信号处理的支持已添加到 `signal` 模块中，但随后又因无法在各个平台间可靠地工作而被移除。

- `socket` 模块现在支持超时设置。你可以在套接字对象上调用 `settimeout(t)` 方法来设置 t 秒的超时时间。后续的套接字操作如果超过 t 秒未完成将被中止，并引发 `socket.timeout` 异常。

  最初的超时实现由 Tim O'Malley 完成。Michael Gilfix 将其集成到 Python 的 `socket` 模块中，并经过长时间的审查。代码提交后，Guido van Rossum 重写了部分内容。（这是一个协作开发过程的良好示例。）

- 在 Windows，`socket` 模块现在将附带安全套接字层（SSL）支持。

- 现在 C `PYTHON_API_VERSION` 宏的值将在 Python 层级上暴露为 `sys.api_version`。 当前的异常可通过调用新的 `sys.exc_clear()` 函数来清除。

- 新的 `tarfile` 模块允许读取和写入 tar格式的归档文件。（由 Lars Gustäbel 贡献。)

- 新的 `textwrap` 模块包含用于包装包含段落文本的字符串的函数。`wrap(text, width)` 函数接收一个字符串，并返回一个列表，其中包含将文本拆分为不超过所选宽度的行。`fill(text, width)` 函数返回一个单个字符串，重新格式化以适应不超过所选宽度的行。（如你所料，`fill()` 是基于 `wrap()` 构建的。例如:

      >>> import textwrap
      >>> paragraph = "Not a whit, we defy augury: ... more text ..."
      >>> textwrap.wrap(paragraph, 60)
      ["Not a whit, we defy augury: there's a special providence in",
       "the fall of a sparrow. If it be now, 'tis not to come; if it",
       ...]
      >>> print textwrap.fill(paragraph, 35)
      Not a whit, we defy augury: there's
      a special providence in the fall of
      a sparrow. If it be now, 'tis not
      to come; if it be not to come, it
      will be now; if it be not now, yet
      it will come: the readiness is all.
      >>>

  该模块还包含一个 `TextWrapper` 类，实际实现了文本包装策略。`TextWrapper` 类和 `wrap()` 以及 `fill()` 函数都支持多个额外的关键字参数，用于微调格式；详情请参阅模块文档。（由 Greg Ward 贡献。）

- `thread` 和 `threading` 模块现在有配套模块 `dummy_thread` 和 `dummy_threading`，为不支持线程的平台提供了 `thread` 模块接口的空实现。目的是通过在顶部放置以下代码来简化线程感知模块（那些不依赖线程运行的模块):

      try:
          import threading as _threading
      except ImportError:
          import dummy_threading as _threading

  在此示例中，`_threading` 用作模块名称，以明确所使用的模块不一定是实际的 `threading` 模块。代码可以调用 `_threading` 中的函数并使用其类，无论是否支持线程，从而避免使用 `if` 语句，并使代码略显清晰。此模块不会神奇地使多线程代码在没有线程的情况下运行；等待另一个线程返回或执行某事的代码将永远挂起。

- 模块 `time` 的 `strptime()` 函数长期以来一直是个麻烦，因为它使用平台 C 库的 `strptime()` 实现，而不同平台有时会有奇怪的 bug。Brett Cannon 贡献了一个纯 Python 编写的便携实现，该实现应在所有平台上表现一致。

- 新的 `timeit` 模块帮助测量 Python 代码片段执行所需的时间。文件 `timeit.py` 可以直接从命令行运行，或者可以导入模块的 `Timer` 类并直接使用。以下是一个简短示例，用于确定将 8 位字符串转换为 Unicode 是通过追加一个空 Unicode 字符串更快，还是使用 `unicode()` 函数更快：

      import timeit

      timer1 = timeit.Timer('unicode("abc")')
      timer2 = timeit.Timer('"abc" + u""')

      # 运行三次试验
      print timer1.repeat(repeat=3, number=100000)
      print timer2.repeat(repeat=3, number=100000)

      # 在我的笔记本电脑上输出如下：
      # [0.36831796169281006, 0.37441694736480713, 0.35304892063140869]
      # [0.17574405670166016, 0.18193507194519043, 0.17565798759460449]

- 模块 `Tix` 已收到针对当前版本 Tix 包的各种 bug 修复和更新。

- `Tkinter` 模块现在可以与支持线程的 Tcl 版本一起工作。Tcl 的线程模型要求只能从创建它们的线程中访问小部件；从另一个线程访问可能会导致 Tcl 出现恐慌。对于某些 Tcl 接口，当从不同线程访问小部件时，`Tkinter` 现在将自动避免这种情况，通过编组命令，将其传递给正确的线程，并等待结果。其他接口无法自动处理，但 `Tkinter` 现在会在这种访问时引发异常，以便至少可以发现问题。有关此更改的更详细解释，请参阅 https://mail.python.org/pipermail/python-dev/2002-December/031107.html。（由 Martin von Löwis 实现。）

- 通过 `_tkinter` 调用 Tcl 方法不再仅返回字符串。相反，如果 Tcl 返回其他对象，这些对象将转换为它们的 Python 等效对象（如果存在的话），或者如果没有 Python 等效对象，则用 `_tkinter.Tcl_Obj` 对象包装。此行为可以通过 `tkapp` 对象的 `wantobjects()` 方法进行控制。

  当通过 `Tkinter` 模块使用 `_tkinter` (大多数 Tkinter 应用程序都会这样做) 时，此功能始终处于激活状态。它不应引起兼容性问题，因为 Tkinter 会尽可能将字符串结果转换为 Python 类型。

  如果发现任何不兼容性，可以通过在创建第一个 `tkapp` 对象之前，将 `Tkinter` 模块中的 `wantobjects` 变量设置为 false 来恢复旧的行为。:

      import Tkinter
      Tkinter.wantobjects = 0

  由此更改引起的任何问题都应作为错误报告。

- `UserDict` 模块新增了一个 `DictMixin` 类，该类为已具备最小映射接口的类定义了所有字典方法。这使得编写可替代字典的类变得大大简化，例如 `shelve` 模块中的类。

  添加该混入类作为超类将在类定义了 `__getitem__()`, `__setitem__()`, `__delitem__()` 和 `keys()` 的时候提供完整的字典接口。 例如:

      >>> import UserDict
      >>> class SeqDict(UserDict.DictMixin):
      ...     """Dictionary lookalike implemented with lists."""
      ...     def __init__(self):
      ...         self.keylist = []
      ...         self.valuelist = []
      ...     def __getitem__(self, key):
      ...         try:
      ...             i = self.keylist.index(key)
      ...         except ValueError:
      ...             raise KeyError
      ...         return self.valuelist[i]
      ...     def __setitem__(self, key, value):
      ...         try:
      ...             i = self.keylist.index(key)
      ...             self.valuelist[i] = value
      ...         except ValueError:
      ...             self.keylist.append(key)
      ...             self.valuelist.append(value)
      ...     def __delitem__(self, key):
      ...         try:
      ...             i = self.keylist.index(key)
      ...         except ValueError:
      ...             raise KeyError
      ...         self.keylist.pop(i)
      ...         self.valuelist.pop(i)
      ...     def keys(self):
      ...         return list(self.keylist)
      ...
      >>> s = SeqDict()
      >>> dir(s)      # See that other dictionary methods are implemented
      ['__cmp__', '__contains__', '__delitem__', '__doc__', '__getitem__',
       '__init__', '__iter__', '__len__', '__module__', '__repr__',
       '__setitem__', 'clear', 'get', 'has_key', 'items', 'iteritems',
       'iterkeys', 'itervalues', 'keylist', 'keys', 'pop', 'popitem',
       'setdefault', 'update', 'valuelist', 'values']

  （由 Raymond Hettinger 贡献。）

- 现在 `xml.dom.minidom` 中的 DOM 实现能够通过向 DOM 节点的 `toxml()` 和 `toprettyxml()` 方法提供可选的 encoding 参数以特定的编码格式生成 XML 输出。

- `xmlrpclib` 模块现在支持处理 nil 数据值如 Python 的 `None` 的 XML-RPC 扩展。 在解组 XML-RPC 响应时始终支持 nil 值。 要生成包含 `None` 的请求，必须在创建 `Marshaller` 实例时为 allow_none 参数提供真值。

- 新的 `DocXMLRPCServer` 模块允许编写自文档化的 XML-RPC 服务器。以演示模式（作为程序）运行它以查看其效果。将网页浏览器指向 RPC 服务器将生成 pydoc 风格的文档；将 xmlrpclib 指向服务器则允许调用实际方法。（由 Brian Quinlan 贡献。）

- 已添加对国际化域名（RFC 3454、3490、3491 和 3492）的支持。可以使用 "idna" 编码在 Unicode 域名和该名称的 ASCII 兼容编码（ACE）之间进行转换。:

      >{}>{}> u"www.Alliancefrançaise.nu".encode("idna")
      'www.xn--alliancefranaise-npb.nu'

  `socket` 模块也已扩展，能够在将 Unicode 主机名传递给 C 库之前透明地将其转换为 ACE 版本。处理主机名的模块如 `httplib` 和 `ftplib` 也支持 Unicode 主机名；`httplib` 还使用域名的 ACE 版本发送 HTTP `Host` 头。 `urllib` 支持带有非 ASCII 主机名的 Unicode URL，只要 URL 的 `path` 部分为 ASCII 即可。

  为实现此项更改，增加了 `stringprep` 模块，`mkstringprep` 工具以及 `punycode` 编码格式。

### Date/Time 类型

通过 `datetime` 模块增加了适用于表示时间戳的日期和时间类型。 这些类型并不支持其他的历法或很多丰富的特性，只专注于简单地表示时间。

三种主要类型是：`date`，表示天、月和年；`time`，包含小时、分钟和秒；以及 `datetime`，包含 `date` 和 `time` 的所有属性。还有一个 `timedelta` 类，表示两个时间点之间的差异，时区逻辑由继承自抽象 `tzinfo` 类的类实现。

你可以通过向适当的构造函数提供关键字参数来创建 `date` 和 `time` 的实例，例如 `datetime.date(year=1972, month=10, day=15)`，或者使用许多类方法之一。例如，`today()` 类方法返回当前本地日期。

一旦创建，日期/时间类的实例都是不可变的。有几种方法可以从对象生成格式化字符串：

    >>> import datetime as dt
    >>> now = dt.datetime.now()
    >>> now.isoformat()
    '2002-12-30T21:27:03.994956'
    >>> now.ctime()  # 仅在 date, datetime 上可用
    'Mon Dec 30 21:27:03 2002'
    >>> now.strftime('%Y %d %b')
    '2002 30 Dec'

`replace()` 方法允许修改 `date` 或 `datetime` 实例的一个或多个字段，返回一个新的实例：

    >>> d = dt.datetime.now()
    >>> d
    datetime.datetime(2002, 12, 30, 22, 15, 38, 827738)
    >>> d.replace(year=2001, hour=12)
    datetime.datetime(2001, 12, 30, 12, 15, 38, 827738)
    >>>

实例可以进行比较、哈希和转换为字符串（结果与 `isoformat()` 相同）。`date` 和 `datetime` 实例可以相互减去，并且可以添加到 `timedelta` 实例。最大的缺失功能是标准库不支持解析字符串并返回 `date` 或 `datetime`。

更多相关信息，请参阅模块的参考文档。 （由 Tim Peters 贡献。）

### optparse 模块

`getopt` 模块提供了简单的命令行参数解析。新的 `optparse` 模块（原名Optik）提供了更复杂的命令行解析，遵循Unix约定，自动创建 `--help` 的输出，并且可以为不同的选项执行不同的操作。

首先，创建一个 `OptionParser` 的实例，并告诉它你的程序有哪些选项。:

    import sys
    from optparse import OptionParser

    op = OptionParser()
    op.add_option('-i', '--input',
                  action='store', type='string', dest='input',
                  help='设置输入文件名')
    op.add_option('-l', '--length',
                  action='store', type='int', dest='length',
                  help='设置输出最大长度')

通过调用 `parse_args()` 方法来解析命令行。:

    options, args = op.parse_args(sys.argv[1:])
    print options
    print args

这将返回一个包含所有选项值的对象，以及一个包含剩余参数的字符串列表。

现在，使用各种参数调用脚本将按预期工作。请注意，长度参数会自动转换为整数。

    $ ./python opt.py -i data arg1
    <Values at 0x400cad4c: {'input': 'data', 'length': None}>
    ['arg1']
    $ ./python opt.py --input=data --length=4
    <Values at 0x400cad2c: {'input': 'data', 'length': 4}>
    []
    $

帮助信息会自动为你生成：

    $ ./python opt.py --help
    用法：opt.py [选项]

    选项：
      -h, --help            显示此帮助信息并退出
      -iINPUT, --input=INPUT
                            设置输入文件名
      -lLENGTH, --length=LENGTH
                            设置输出最大长度
    $

有关更多详细信息，请参见模块的文档。

Optik 由 Greg Ward 编写，吸收了 Getopt SIG 读者的建议。

## Pymalloc：一种专用对象分配器

Pymalloc 是由 Vladimir Marangozov 编写的一种专用对象分配器，作为特性添加到 Python 2.1 中。Pymalloc 旨在比系统的 `malloc()` 更快，并且对于典型的 Python 程序分配模式具有更低的内存开销。该分配器使用 C 的 `malloc()` 函数获取大内存池，然后从这些池中满足较小的内存请求。

在 2.1 和 2.2 版中，pymalloc 是一个实验性特性，默认不启用；你必须在编译 Python 时通过向 configure 脚本提供 `--with-pymalloc` 选项来显式启用它。在 2.3 版中，pymalloc 进行了进一步改进，现在默认启用；你需要提供 `--without-pymalloc` 选项来禁用它。

这一更改对用 Python 编写的代码是透明的；然而，pymalloc 可能会暴露 C 扩展中的错误。C 扩展模块的作者应该测试其代码在 pymalloc 启用时的表现，因为一些不正确的代码可能导致运行时核心转储。

有一个特别常见的错误会导致问题。Python的C API中有许多内存分配函数，之前只是C库中 `malloc()` 和 `free()` 的别名，这意味着如果你不小心调用了不匹配的函数，错误可能不会被注意到。当对象分配器启用时，这些函数不再是 `malloc()` 和 `free()` 的别名，调用错误的函数来释放内存可能会导致核心转储。例如，如果内存是使用 `PyObject_Malloc()` 分配的，它必须使用 `PyObject_Free()` 来释放，而不是 `free()`。Python自带的一些模块就遇到了这个问题，并且必须修复；毫无疑问，还有更多的第三方模块也会存在同样的问题。

作为这一变化的一部分，令人困惑的多种内存分配接口已被整合为两个API家族。使用一个家族分配的内存不得使用另一个家族的函数进行操作。有一个家族用于分配内存块，另一个家族的函数专门用于分配Python对象。

- 要分配和释放一个普通的内存块，使用“原始内存”家族：`PyMem_Malloc()`，`PyMem_Realloc()` 和 `PyMem_Free()`。

- “对象内存”家族是上述pymalloc设施的接口，偏向于大量“小”分配：`PyObject_Malloc()`，`PyObject_Realloc()` 和 `PyObject_Free()`。

- 要分配和释放Python对象，使用“对象”家族：`PyObject_New`，`PyObject_NewVar` 和 `PyObject_Del()`。

感谢 Tim Peters 的大量工作，2.3 中的 pymalloc 还提供了调试功能，用于捕获扩展模块和解释器本身的内存覆盖和双重释放。 要启用此支持，请通过运行带 `--with-pydebug` 选项的 configure 命令来编译 Python 解释器的调试版本。

为了帮助扩展开发者，Python 2.3 的源代码中分发了一个头文件 `Misc/pymemcompat.h`，它允许 Python 扩展在编译针对自 1.5.2 以来的任何版本的 Python 时使用 2.3 的内存分配接口。 你需要从 Python 的源代码分发中复制该文件，并将其与你的扩展源代码捆绑在一起。

参见

https://hg.python.org/cpython/file/default/Objects/obmalloc.c

  有关pymalloc实现的详细信息，请参阅Python源代码中 `Objects/obmalloc.c` 文件顶部的注释。上述链接指向python.org SVN浏览器中的该文件。

## 构建和 C API 的改变

针对 Python 构建过程和 C API 的改变包括:

- 垃圾收集使用的循环检测实现已被证明是稳定的，因此现在已被设为强制性。你不能再编译不带此功能的Python，且 configure 中的 `--with-cycle-gc` 选项已被移除。

- 现在可以可选地将Python构建为共享库(`libpython2.3.so`)，方法是在运行Python的 configure 脚本时提供 `--enable-shared` 选项。（由 Ondrej Palkovsky 贡献。）

- `DL_EXPORT` 和 `DL_IMPORT` 宏现在已被弃用。Python扩展模块的初始化函数现在应使用新的宏 `PyMODINIT_FUNC` 声明，而Python核心通常会使用 `PyAPI_FUNC` 和 `PyAPI_DATA` 宏。

- 通过向 configure 脚本提供 `--without-doc-strings` 选项，可以编译不带任何内置函数和模块文档字符串的解释器。这使得Python可执行文件大约减小了10%，但也意味着你无法获取Python内置函数的帮助。（由 Gustavo Niemeyer 贡献。）

- `PyArg_NoArgs()` 宏现已弃用，使用它的代码应进行修改。对于 Python 2.2 及更高版本，方法定义表可以指定 `METH_NOARGS` 标志，表示没有参数，从而可以移除参数检查。如果需要与 Python 2.2 之前的版本兼容，代码可以使用 `PyArg_ParseTuple(args, "")` 代替，但这会比使用 `METH_NOARGS` 慢。

- `PyArg_ParseTuple()` 接受新的格式字符来表示各种大小的无符号整数：`B` 表示 unsigned char，`H` 表示 unsigned short int，`I` 表示 unsigned int，以及 `K` 表示 unsigned long long。

- 新增了一个函数 `PyObject_DelItemString(mapping, char *key)`，作为 `PyObject_DelItem(mapping, PyString_New(key))` 的简写。

- 文件对象现在以不同的方式管理其内部字符串缓冲区，需要时按指数增加。这导致 `Lib/test/test_bufio.py` 中的基准测试速度显著提升（根据一次测量，从 57 秒提升到 1.7 秒）。

- 现在可以为 C 扩展类型定义类方法和静态方法，通过在方法的 `PyMethodDef` 结构中设置 `METH_CLASS` 或 `METH_STATIC` 标志。

- Python 现在包含 Expat XML 解析器的源代码副本，消除了对系统版本或本地安装的 Expat 的依赖。

- 如果在扩展中动态分配类型对象，你应该注意与 `__module__` 和 `__name__` 属性相关的规则变化。简而言之，你需要确保类型的字典中包含一个 `'__module__'` 键；将模块名作为类型名中最后一个点之前的部分将不再产生预期效果。更多详情，请阅读 API 参考文档或源代码。

### 移植专属的改变

对使用 EMX 运行环境将 Python 移植到 IBM 的 OS/2 系统的支持已合并到 Python 主源代码树中。EMX 是一个在 OS/2 系统API之上的 POSIX 模拟层。针对 EMX 的 Python 移植尝试支持 EMX 运行时暴露的所有 POSIX 类似功能，并且大部分成功；`fork()` 和 `fcntl()` 受到底层模拟层限制的影响。标准的 OS/2 移植版本，使用 IBM 的 Visual Age 编译器，也在将 EMX 移植集成到 CVS 的过程中获得了对大小写敏感的导入语义的支持。（由 Andrew MacIntyre 贡献。）

在 MacOS 上，大多数工具箱模块已经通过弱链接来提高向后兼容性。这意味着如果当前 OS 版本中缺少单个例程，模块将不再加载失败。相反，调用缺失的例程将引发异常。（由 Jack Jansen 贡献。）

位于 Python 源代码分发版中的 `Misc/RPM/` 目录中的 RPM 规范文件已更新为 2.3 版。（由 Sean Reifschneider 贡献。）

Python 现在支持的其他新平台包括 AtheOS（http://www.atheos.cx/）、GNU/Hurd 和 OpenVMS。

## 其他的改变和修正

一如既往，源代码树中散布着许多其他改进和错误修复。通过搜索 CVS 更改日志，发现在 Python 2.2 和 2.3 之间应用了 523 个补丁并修复了 514 个错误。这两个数字可能都被低估了。

一些较为重要的改变:

- 如果设置了 `PYTHONINSPECT` 环境变量，Python 解释器在运行 Python 程序后会进入交互式提示符，就像使用 `-i` 选项调用 Python 一样。环境变量可以在运行 Python 解释器之前设置，也可以由 Python 程序在其执行过程中设置。

- `regrtest.py` 脚本现在提供了一种方法，允许“所有资源除了 foo。”传递给 `-u` 选项的资源名现在可以以连字符 (`'-'`) 为前缀，表示“移除此资源”。 例如，选项 '`-uall,-bsddb`' 可以用来启用除 `bsddb` 以外的所有资源。

- 用于构建文档的工具现在在 Cygwin 和 Unix 下都能工作。

- `SET_LINENO` 操作码已被移除。在很久以前，这个操作码用于在追溯中生成行号和支持跟踪函数 (例如 `pdb`)。 自 Python 1.5 起，追溯中的行号已通过不同的机制计算，该机制与“python -O”兼容。 对于 Python 2.3，Michael Hudson 实现了一个类似的方案来确定何时调用跟踪函数，完全移除了对 `SET_LINENO` 的需求。

  从 Python 代码中很难检测到由此产生的差异，除非在未使用 `-O` 的情况下运行 Python 时会有轻微的速度提升。

  访问帧对象中的 `f_lineno` 字段的 C 扩展应改为调用 `PyCode_Addr2Line(f->f_code, f->f_lasti)`。这将使代码在早期版本的 Python 中也能在“python -O”下按预期工作。

  一个很酷的新特性是，跟踪函数现在可以分配给帧对象的 `f_lineno` 属性，改变将要执行的行。`pdb` 调试器中添加了一个 `jump` 命令，利用了这个新特性。（由 Richie Hindle 实现。）

## 移植到 Python 2.3

本节列出了先前描述的可能需要修改你的代码的改变：

- 现在 `yield` 始终是一个关键字；如果它在你的代码中被用作变量名，则必须选择不同的名称。

- 对于字符串 X 和 Y，`X in Y` 现在当 X 长度超过一个字符时也是有效的。

- 现在 `int()` 类型构造器在字符串或浮点数因太大而无法以整数类型来容纳时将返回一个长整数而不是引发 `OverflowError`。

- 如果你的 Unicode 字符串包含 8 位字符，你必须通过在文件顶部添加注释来声明文件的编码（UTF-8、Latin-1 或其他）。更多信息请参见 PEP 263: 源代码的字符编码格式 部分。

- 通过 `_tkinter` 调用 Tcl 方法不再仅返回字符串。相反，如果 Tcl 返回其他对象，这些对象会被转换为它们的 Python 等效对象（如果存在的话），或者如果没有 Python 等效对象，则会被包装在 `_tkinter.Tcl_Obj` 对象中。

- 像 `0xffffffff` 这样的大型八进制和十六进制字面量现在会触发 `FutureWarning`。目前它们被存储为 32 位数字，并导致负值，但在 Python 2.4 中，它们将变为正的长整数。

  有几种方法可以修复这个警告。如果你确实需要一个正数，只需在字面量末尾添加一个 `L`。如果你试图获取一个低位设置的 32 位整数，并且之前使用了类似 `~(1 << 31)` 的表达式，最清晰的方法是从所有位都设置开始，然后清除所需的高位。例如，要仅清除最高位（位 31），你可以写 `0xffffffffL &~(1L<<31)`。

- 你不能再通过赋值给 `__debug__` 来禁用断言。

- Distutils 的 `setup()` 函数获得了各种新的关键字参数，例如 depends。旧版本的 Distutils 在传递未知关键字时会中止。解决方案是在你的 `setup.py` 中检查新的 `get_distutil_options()` 函数的存在，并且仅在使用支持这些新关键字的 Distutils 版本时使用这些新关键字：

      from distutils import core

      kw = {'sources': 'foo.c', ...}
      if hasattr(core, 'get_distutil_options'):
          kw['depends'] = ['foo.h']
      ext = Extension(**kw)

- 现在使用 `None` 作为变量名将会导致 `SyntaxWarning` 警告。

- 由 Python 包含的模块定义的扩展类型名称现在包含模块和一个在类型名称前的 `'.'`。

## 致谢

作者感谢以下人员为本文的各种草案提供建议，更正和帮助： Jeff Bauer、Simon Brunning、Brett Cannon、Michael Chermside、Andrew Dalke、Scott David Daniels、Fred L. Drake、Jr.、David Fraser、 Kelly Gerber、Raymond Hettinger、Michael Hudson、Chris Lambert、Detlef Lannert、Martin von Löwis、Andrew MacIntyre、Lalo Martins、Chad Netzer、Gustavo Niemeyer、Neal Norwitz、Hans Nowak、Chris Reedy、Francesco Ricciardi、Vinay Sajip、Neil Schemenauer、Roman Suzi、Jason Tishler、Just van Rossum。