Python 2.6 中的新功能

作者: 是 Kuchling (amk at amk.ca)

本文介绍了 2008 年 10 月 1 日发布的 Python 2.6 中的新功能。 PEP 361 中描述了发布时间表。

Python 2.6 的主要主题是准备迁移到 Python 3.0 的路径，这是该语言的重大重新设计。只要有可能，Python 2.6 就会合并 3.0 的新功能和语法，同时通过不删除旧功能或语法来保持与现有代码的兼容。当无法做到这一点时，Python 2.6 会尝试尽其所能，在 future_builtins 模块和 -3 模块中添加兼容性函数以警告在3.0.

一些重要的新包已添加到标准库中，例如 multiprocessing 和 json 模块，但在某些方面与 Python 3.0 无关的新功能并不多道路。

Python 2.6 还在整个源代码中看到了许多改进和错误修复。通过更改日志搜索发现，在 Python 2.5 和 2.6 之间应用了 259 个补丁并修复了 612 个错误。这两个数字都可能被低估。

本文不尝试提供新功能的完整规范，而是提供一个方便的概述。有关完整的详细信息，您应该参考 Python 2.6 的文档。如果您想了解设计和实现的基本原理，请参阅特定新功能的 PEP。只要有可能，“Python 中的新功能”链接到每个更改的错误/补丁项。

蟒蛇 3.0

Python 2.6 和 3.0 版本的开发周期是同步的，两个版本的 alpha 和 beta 版本是在同一天发布的。 3.0 的发展影响了 2.6 中的许多功能。

Python 3.0 是对 Python 进行了广泛的重新设计，它打破了与 2.x 系列的兼容性。这意味着现有的 Python 代码需要进行一些转换才能在 Python 3.0 上运行。但是，并非 3.0 中的所有更改都必然会破坏兼容性。在新功能不会导致现有代码中断的情况下，它们已向后移植到 2.6 并在本文档中的适当位置进行了描述。一些 3.0 派生的功能是：

一种将对象转换为复数的 __complex__() 方法。
捕获异常的替代语法：except TypeError as exc。
添加 functools.reduce() 作为内置 reduce() 函数的同义词。

Python 3.0 添加了几个新的内置函数并更改了一些现有内置函数的语义。 3.0 中的新函数，例如 bin() 只是简单地添加到 Python 2.6 中，但现有的内置函数没有改变；相反，future_builtins 模块具有具有新 3.0 语义的版本。编写为与 3.0 兼容的代码可以根据需要执行 from future_builtins import hex, map。

新的命令行开关 -3 启用有关将在 Python 3.0 中删除的功能的警告。您可以使用此开关运行代码以查看将代码移植到 3.0 需要多少工作。此开关的值可作为布尔变量 sys.py3kwarning 用于 Python 代码，并作为 Py_Py3kWarningFlag 用于 C 扩展代码。

也可以看看

3xxx 系列 PEP，其中包含针对 Python 3.0 的提案。 PEP 3000 描述了 Python 3.0 的开发过程。从描述 Python 3.0 总体目标的 PEP 3100 开始，然后探索提出特定功能的更高编号的 PEPS。

开发过程的变化

在开发 2.6 的同时，Python 开发过程经历了两个重大变化：我们从 SourceForge 的问题跟踪器切换到定制的 Roundup 安装，并且文档从 LaTeX 转换为 reStructuredText。

新问题跟踪器：综述

长期以来，Python 开发人员对 SourceForge 的错误跟踪器越来越恼火。 SourceForge 的托管解决方案不允许进行大量定制；例如，无法自定义问题的生命周期。

因此，Python 软件基金会的基础设施委员会发出了对问题跟踪者的呼吁，要求志愿者设置不同的产品并从 SourceForge 导入一些错误和补丁。检查了四种不同的跟踪器：Jira、Launchpad、Roundup和Trac。委员会最终决定将 Jira 和 Roundup 作为两个候选人。 Jira 是一种商业产品，为免费软件项目提供免费托管实例； Roundup 是一个开源项目，需要志愿者来管理它和托管它的服务器。

在发布志愿者呼吁后，在 https://bugs.python.org 设置了一个新的 Roundup 安装。 Roundup 的一个安装可以托管多个跟踪器，该服务器现在还托管 Jython 和 Python 网站的问题跟踪器。它肯定会在未来找到其他用途。在可能的情况下，此版本的“Python 中的新功能”链接到每个更改的错误/补丁项。

Python 错误跟踪器的托管由南非斯泰伦博斯的 Upfront Systems 友情提供。 Martin von Loewis 投入了大量精力从 SourceForge 导入现有的错误和补丁；他用于此导入操作的脚本位于 http://svn.python.org/view/tracker/importer/ 并且可能对希望从 SourceForge 转移到 Roundup 的其他项目有用。

也可以看看

https://bugs.python.org: Python 错误跟踪器。
http://bugs.jython.org：: Jython 错误跟踪器。
http://roundup.sourceforge.net/: 综合下载和文档。
http://svn.python.org/view/tracker/importer/: Martin von Loewis 的转换脚本。

新的文档格式：使用 Sphinx 的 reStructuredText

自 1989 年左右项目开始以来，Python 文档是使用 LaTeX 编写的。在 1980 年代和 1990 年代初期，大多数文档都是打印出来供以后研究的，而不是在线查看的。 LaTeX 被广泛使用，因为它提供了有吸引力的打印输出，同时在学习了标记的基本规则后仍然可以直接编写。

今天，LaTeX 仍然用于编写用于印刷的出版物，但编程工具的格局已经发生变化。我们不再打印大量文档；相反，我们在线浏览它，HTML 已成为最重要的支持格式。不幸的是，将 LaTeX 转换为 HTML 相当复杂，而 Fred L. Drake Jr. 是一位长期从事 Python 文档编辑的人，他花费了大量时间来维护转换过程。有时人们会建议将文档转换为 SGML，然后再转换为 XML，但执行良好的转换是一项重大任务，没有人愿意花时间完成这项工作。

在 2.6 开发周期中，Georg Brandl 投入了大量精力来构建用于处理文档的新工具链。生成的包称为 Sphinx，可从 http://sphinx-doc.org/ 获得。

Sphinx 专注于 HTML 输出，生成具有吸引力的现代 HTML；通过转换为 LaTeX 仍支持打印输出。输入格式是 reStructuredText，这是一种标记语法，支持 Python 社区中常用的自定义扩展和指令。

Sphinx 是一个可用于编写的独立包，并且几乎有两个其他项目（在 Sphinx 网站上列出）已采用 Sphinx 作为其文档工具。

也可以看看

记录 Python: 描述如何编写 Python 的文档。
狮身人面像: Sphinx 工具链的文档和代码。
文档工具: 底层的 reStructuredText 解析器和工具集。

PEP 343：'with' 语句

以前的版本 Python 2.5 添加了 'with' 语句作为可选功能，由 from __future__ import with_statement 指令启用。 2.6中不再需要专门启用该语句；这意味着 with 现在总是一个关键字。本节的其余部分是“Python 2.5 的新增功能”文档中相应部分的副本；如果您熟悉 Python 2.5 中的 'with' 语句，则可以跳过本节。

'with' 语句阐明了以前使用 try...finally 块来确保执行清理代码的代码。在本节中，我将讨论通常会使用的语句。在下一节中，我将检查实现细节并展示如何编写用于此语句的对象。

'with' 语句是一个控制流结构，其基本结构是：

with expression [as variable]:
    with-block

对表达式求值，它应该产生一个支持上下文管理协议的对象（即具有 __enter__() 和 __exit__() 方法）。

对象的 __enter__() 在执行 with-block 之前被调用，因此可以运行设置代码。如果给出，它也可能返回绑定到名称变量的值。（请注意变量是不是分配给 表达式 的结果。）

with-block 执行完成后，对象的 __exit__() 方法被调用，即使该块引发异常，因此可以运行清理代码。

一些标准 Python 对象现在支持上下文管理协议，并且可以与 'with' 语句一起使用。文件对象就是一个例子：

with open('/etc/passwd', 'r') as f:
    for line in f:
        print line
        ... more processing code ...

执行此语句后，f 中的文件对象将自动关闭，即使 for 循环在块中途引发异常。

笔记

在这种情况下，f 与 open() 创建的对象相同，因为 file.__enter__() 返回 self。

threading 模块的锁和条件变量也支持 'with' 语句：

lock = threading.Lock()
with lock:
    # Critical section of code
    ...

在块执行之前获取锁，并且在块完成后总是释放锁。

decimal 模块中的 localcontext() 函数可以轻松保存和恢复当前十进制上下文，它封装了计算所需的精度和舍入特性：

from decimal import Decimal, Context, localcontext

# Displays with default precision of 28 digits
v = Decimal('578')
print v.sqrt()

with localcontext(Context(prec=16)):
    # All code in this block uses a precision of 16 digits.
    # The original context is restored on exiting the block.
    print v.sqrt()

编写上下文管理器

在幕后，'with' 语句相当复杂。大多数人只会将 'with' 与现有对象一起使用，并且不需要了解这些细节，因此如果您愿意，可以跳过本节的其余部分。新对象的作者需要了解底层实现的细节，并应该继续阅读。

上下文管理协议的高级解释是：

表达式被评估并且应该产生一个称为“上下文管理器”的对象。上下文管理器必须有 __enter__() 和 __exit__() 方法。
上下文管理器的 __enter__() 方法被调用。返回的值分配给 VAR。如果不存在 as VAR 子句，则该值将被简单地丢弃。
执行BLOCK中的代码。
如果 BLOCK 引发异常，则使用三个参数调用上下文管理器的 __exit__() 方法，异常详细信息 (type, value, traceback，与 sys.exc_info 返回的值相同()，如果没有异常，也可以是None）。该方法的返回值控制是否重新引发异常：任何假值都会重新引发异常，而 True 将导致抑制它。您很少想抑制异常，因为如果您执行包含 'with' 语句的代码的作者，将永远不会意识到任何错误。
如果 BLOCK 没有引发异常，__exit__() 方法仍会被调用，但 type、value 和 traceback[ X136X] 都是 None。

让我们通过一个例子来思考。我不会提供详细的代码，而只会概述支持事务的数据库所需的方法。

（对于不熟悉数据库术语的人：对数据库的一组更改被分组到一个事务中。事务可以被提交，这意味着所有的更改都被写入数据库，或者回滚，意味着所有的更改都被丢弃并且数据库保持不变。有关更多信息，请参阅任何数据库教科书。）

让我们假设有一个表示数据库连接的对象。我们的目标是让用户编写这样的代码：

db_connection = DatabaseConnection()
with db_connection as cursor:
    cursor.execute('insert into ...')
    cursor.execute('delete from ...')
    # ... more operations ...

如果块中的代码运行完美，则应该提交事务，或者在出现异常时回滚。这是我假设的 DatabaseConnection 的基本界面：

class DatabaseConnection:
    # Database interface
    def cursor(self):
        "Returns a cursor object and starts a new transaction"
    def commit(self):
        "Commits current transaction"
    def rollback(self):
        "Rolls back current transaction"

__enter__() 方法非常简单，只需启动一个新事务。对于此应用程序，生成的游标对象将是一个有用的结果，因此该方法将返回它。然后，用户可以将 as cursor 添加到他们的 'with' 语句以将游标绑定到变量名。

class DatabaseConnection:
    ...
    def __enter__(self):
        # Code to start a new transaction
        cursor = self.cursor()
        return cursor

__exit__() 方法是最复杂的，因为它是大部分工作必须完成的地方。该方法必须检查是否发生异常。如果没有异常，则提交事务。如果出现异常，事务将回滚。

在下面的代码中，执行将只是从函数的结尾处退出，返回默认值 None。 None 为假，所以会自动重新引发异常。如果您愿意，可以更明确地在标记位置添加 return 语句。

class DatabaseConnection:
    ...
    def __exit__(self, type, value, tb):
        if tb is None:
            # No exception, so commit
            self.commit()
        else:
            # Exception occurred, so rollback.
            self.rollback()
            # return False

上下文库模块

contextlib 模块提供了一些函数和装饰器，它们在编写与 'with' 语句一起使用的对象时非常有用。

装饰器称为 contextmanager()，它允许您编写单个生成器函数而不是定义新类。生成器应该只产生一个值。直到 yield 的代码将作为 __enter__() 方法执行，产生的值将是该方法的返回值，该值将绑定到 'with[ X184X]' 语句的 as 子句，如果有的话。 yield之后的代码会在__exit__()方法中执行。 yield 语句将引发块中引发的任何异常。

使用这个装饰器，我们上一节中的数据库示例可以写成：

from contextlib import contextmanager

@contextmanager
def db_transaction(connection):
    cursor = connection.cursor()
    try:
        yield cursor
    except:
        connection.rollback()
        raise
    else:
        connection.commit()

db = DatabaseConnection()
with db_transaction(db) as cursor:
    ...

contextlib 模块还有一个 nested(mgr1, mgr2, ...) 函数，它结合了许多上下文管理器，因此您无需编写嵌套的 'with' 语句。在此示例中，单个 'with' 语句既启动数据库事务又获取线程锁：

lock = threading.Lock()
with nested (db_transaction(db), lock) as (cursor, locked):
    ...

最后，closing() 函数返回它的参数以便它可以绑定到一个变量，并在块的末尾调用参数的 .close() 方法。

import urllib, sys
from contextlib import closing

with closing(urllib.urlopen('http://www.yahoo.com')) as f:
    for line in f:
        sys.stdout.write(line)

也可以看看

PEP 343 - “with”语句: PEP 由 Guido van Rossum 和 Nick Coghlan 撰写；由 Mike Bland、Guido van Rossum 和 Neal Norwitz 实施。 PEP 显示了为“with”语句生成的代码，这有助于了解该语句的工作原理。

contextlib 模块的文档。

PEP 366：来自主模块的显式相对导入

Python 的 -m 开关允许将模块作为脚本运行。当您运行位于包内的模块时，相对导入无法正常工作。

Python 2.6 的修复为模块添加了 __package__ 属性。当此属性存在时，相对导入将相对于该属性的值，而不是 __name__ 属性。

然后，PEP 302 样式的导入器可以根据需要设置 __package__。实现 -m 开关的 runpy 模块现在可以执行此操作，因此相对导入现在可以在从包内部运行的脚本中正常工作。

PEP 370：每用户 site-packages 目录

运行 Python 时，模块搜索路径 sys.path 通常包含一个路径以 "site-packages" 结尾的目录。此目录旨在保存本地安装的软件包，可供使用机器或特定站点安装的所有用户使用。

Python 2.6 引入了用户特定站点目录的约定。目录因平台而异：

Unix 和 Mac OS X：~/.local/
视窗：%APPDATA%/Python

在此目录中，将有特定于版本的子目录，例如 Unix/Mac OS 上的 lib/python2.6/site-packages 和 Windows 上的 Python26/site-packages。

如果您不喜欢默认目录，它可以被环境变量覆盖。 PYTHONUSERBASE 设置用于支持此功能的所有 Python 版本的根目录。在 Windows 上，可以通过设置 APPDATA 环境变量来更改应用程序特定数据的目录。您还可以修改 Python 安装的 site.py 文件。

通过使用 -s 选项运行 Python 或设置 PYTHONNOUSERSITE 环境变量，可以完全禁用该功能。

也可以看看

PEP 370 - 每用户 site-packages 目录: PEP 由 Christian Heimes 编写和实施。

PEP 371：multiprocessing 包

新的 multiprocessing 包允许 Python 程序创建新进程，这些进程将执行计算并将结果返回给父进程。父进程和子进程可以使用队列和管道进行通信，使用锁和信号量同步它们的操作，并且可以共享简单的数据数组。

multiprocessing 模块最初是对 threading 模块的精确模拟，它使用进程而不是线程。这个目标在 Python 2.6 的道路上被丢弃了，但模块的一般方法仍然相似。基本类是 Process，它传递一个可调用对象和一组参数。 start()方法设置可调用运行在子进程中，之后可以调用is_alive()方法检查子进程是否还在运行，join()方法等待进程退出。

这是一个简单的示例，其中子流程将计算阶乘。执行计算的函数写得很奇怪，因此当输入参数是 4 的倍数时，它需要更长的时间。

import time
from multiprocessing import Process, Queue


def factorial(queue, N):
    "Compute a factorial."
    # If N is a multiple of 4, this function will take much longer.
    if (N % 4) == 0:
        time.sleep(.05 * N/4)

    # Calculate the result
    fact = 1L
    for i in range(1, N+1):
        fact = fact * i

    # Put the result on the queue
    queue.put(fact)

if __name__ == '__main__':
    queue = Queue()

    N = 5

    p = Process(target=factorial, args=(queue, N))
    p.start()
    p.join()

    result = queue.get()
    print 'Factorial', N, '=', result

Queue 用于传达阶乘的结果。 Queue 对象存储在一个全局变量中。子进程将在创建子进程时使用该变量的值；因为它是一个Queue，父子可以使用这个对象进行通信。（如果父级要更改全局变量的值，子级的值将不受影响，反之亦然。）

另外两个类 Pool 和 Manager 提供更高级别的接口。 Pool 将创建固定数量的工作进程，然后可以通过调用 apply() 或 apply_async() 添加单个请求将请求分发给工作进程，并且 [ X180X]map() 或 map_async() 添加多个请求。以下代码使用 Pool 将请求分散到 5 个工作进程并检索结果列表：

from multiprocessing import Pool

def factorial(N, dictionary):
    "Compute a factorial."
    ...
p = Pool(5)
result = p.map(factorial, range(1, 1000, 10))
for v in result:
    print v

这会产生以下输出：

1
39916800
51090942171709440000
8222838654177922817725562880000000
33452526613163807108170062053440751665152000000000
...

另一个高级接口 Manager 类创建了一个单独的服务器进程，可以保存 Python 数据结构的主副本。然后其他进程可以使用代理对象访问和修改这些数据结构。以下示例通过调用 dict() 方法创建共享字典；工作进程然后将值插入到字典中。（锁定不会自动为您完成，这在本示例中无关紧要。 Manager 的方法还包括 Lock()、RLock() 和 Semaphore() 来创建共享锁。）

import time
from multiprocessing import Pool, Manager

def factorial(N, dictionary):
    "Compute a factorial."
    # Calculate the result
    fact = 1L
    for i in range(1, N+1):
        fact = fact * i

    # Store result in dictionary
    dictionary[N] = fact

if __name__ == '__main__':
    p = Pool(5)
    mgr = Manager()
    d = mgr.dict()         # Create shared dictionary

    # Run tasks using the pool
    for N in range(1, 1000, 10):
        p.apply_async(factorial, (N, d))

    # Mark pool as closed -- no more tasks can be added.
    p.close()

    # Wait for tasks to exit
    p.join()

    # Output results
    for k, v in sorted(d.items()):
        print k, v

这将产生输出：

1
39916800
51090942171709440000
8222838654177922817725562880000000
33452526613163807108170062053440751665152000000000
15511187532873822802242430164693032110632597200169861120000...

也可以看看

multiprocessing 模块的文档。

PEP 371 - 添加多处理包: PEP 由 Jesse Noller 和 Richard Oudkerk 编写；由 Richard Oudkerk 和 Jesse Noller 实施。

PEP 3101：高级字符串格式

在 Python 3.0 中，% 运算符得到了更强大的字符串格式化方法 format() 的补充。对 str.format() 方法的支持已向后移植到 Python 2.6。

在 2.6 中，8 位和 Unicode 字符串都有一个 .format() 方法，该方法将字符串视为模板并接受要格式化的参数。格式模板使用大括号 ({, }) 作为特殊字符：

>>> # Substitute positional argument 0 into the string.
>>> "User ID: {0}".format("root")
'User ID: root'
>>> # Use the named keyword arguments
>>> "User ID: {uid}   Last seen: {last_login}".format(
...    uid="root",
...    last_login = "5 Mar 2008 07:20")
'User ID: root   Last seen: 5 Mar 2008 07:20'

花括号可以通过将它们加倍来转义：

>>> "Empty dict: {{}}".format()
"Empty dict: {}"

字段名称可以是表示位置参数的整数，例如 {0}、{1} 等。或关键字参数的名称。您还可以提供读取属性或访问字典键的复合字段名称：

>>> import sys
>>> print 'Platform: {0.platform}\nPython version: {0.version}'.format(sys)
Platform: darwin
Python version: 2.6a1+ (trunk:61261M, Mar  5 2008, 20:29:41)
[GCC 4.0.1 (Apple Computer, Inc. build 5367)]'

>>> import mimetypes
>>> 'Content-type: {0[.mp4]}'.format(mimetypes.types_map)
'Content-type: video/mp4'

请注意，使用字典样式的符号（例如 [.mp4]）时，不需要在字符串周围加上任何引号；它将使用 .mp4 作为键来查找值。以数字开头的字符串将被转换为整数。您不能在格式字符串中编写更复杂的表达式。

到目前为止，我们已经展示了如何指定将哪个字段替换为结果字符串。使用的精确格式也可以通过添加一个冒号后跟一个格式说明符来控制。例如：

>>> # Field 0: left justify, pad to 15 characters
>>> # Field 1: right justify, pad to 6 characters
>>> fmt = '{0:15} ${1:>6}'
>>> fmt.format('Registration', 35)
'Registration    $    35'
>>> fmt.format('Tutorial', 50)
'Tutorial        $    50'
>>> fmt.format('Banquet', 125)
'Banquet         $   125'

格式说明符可以通过嵌套引用其他字段：

>>> fmt = '{0:{1}}'
>>> width = 15
>>> fmt.format('Invoice #1234', width)
'Invoice #1234  '
>>> width = 35
>>> fmt.format('Invoice #1234', width)
'Invoice #1234                      '

可以指定所需宽度内的字段对齐方式：

特点	影响
<（默认）	左对齐
>	右对齐
^	中心
=	（仅适用于数字类型）在符号后填充。

格式说明符还可以包括表示类型，它控制值的格式。例如，浮点数可以格式化为一般数或指数表示法：

>>> '{0:g}'.format(3.75)
'3.75'
>>> '{0:e}'.format(3.75)
'3.750000e+00'

提供多种演示类型。请参阅 2.6 文档以获取完整列表；这是一个示例：

`b`	二进制。输出以 2 为底的数字。
`c`	特点。在打印之前将整数转换为相应的 Unicode 字符。
`d`	十进制整数。输出以 10 为底的数字。
`o`	八进制格式。输出基数为 8 的数字。
`x`	十六进制格式。输出以 16 为基数的数字，9 以上的数字使用小写字母。
`e`	指数符号。使用字母“e”表示指数以科学记数法打印数字。
`g`	一般格式。这会将数字打印为定点数，除非数字太大，在这种情况下它会切换到“e”指数表示法。
`n`	数字。这与 'g'（对于浮点数）或 'd'（对于整数）相同，除了它使用当前语言环境设置插入适当的数字分隔符之外。
`%`	百分比。将数字乘以 100 并以固定 ('f') 格式显示，后跟一个百分号。

类和类型可以定义 __format__() 方法来控制它们的格式。它接收一个参数，即格式说明符：

def __format__(self, format_spec):
    if isinstance(format_spec, unicode):
        return unicode(str(self))
    else:
        return str(self)

还有一个 format() 内置函数可以格式化单个值。它使用提供的说明符调用类型的 __format__() 方法：

>>> format(75.6564, '.2f')
'75.66'

也可以看看

格式化字符串语法: 格式字段的参考文档。
PEP 3101 - 高级字符串格式: 塔林写的 PEP。由埃里克·史密斯实施。

PEP 3105：print 作为一个函数

print 语句在 Python 3.0 中变成了 print() 函数。使 print() 成为一个函数可以通过执行 def print(...) 或从其他地方导入新函数来替换该函数。

Python 2.6 有一个 __future__ 导入，它删除了 print 作为语言语法，让您改用函数形式。例如：

>>> from __future__ import print_function
>>> print('# of entries', len(dictionary), file=sys.stderr)

新函数的签名是：

def print(*args, sep=' ', end='\n', file=None)

参数是：

args：将打印其值的位置参数。

sep：分隔符，将在参数之间打印。

end：结束文本，在所有参数输出后打印。

file：输出将发送到的文件对象。

也可以看看

PEP 3105 - 使打印功能: PEP 由 Georg Brandl 编写。

PEP 3110：异常处理更改

Python 程序员偶尔会犯的一个错误是编写以下代码：

try:
    ...
except TypeError, ValueError:  # Wrong!
    ...

作者大概是想同时捕获 TypeError 和 ValueError 异常，但是这段代码实际上做了一些不同的事情：它会捕获 TypeError 并将生成的异常对象绑定到本地名称"ValueError"。 ValueError 异常根本不会被捕获。正确的代码指定了一组异常：

try:
    ...
except (TypeError, ValueError):
    ...

发生此错误是因为此处使用的逗号不明确：它表示解析树中的两个不同节点，还是表示元组的单个节点？

Python 3.0 通过用单词“as”替换逗号来明确这一点。要捕获异常并将异常对象存储在变量 exc 中，您必须编写：

try:
    ...
except TypeError as exc:
    ...

Python 3.0 将仅支持使用“as”，因此将第一个示例解释为捕获两个不同的异常。 Python 2.6 支持逗号和“as”，因此现有代码将继续工作。因此，我们建议在编写只能使用 2.6 执行的新 Python 代码时使用“as”。

也可以看看

PEP 3110 - 在 Python 3000 中捕获异常: 由 Collin Winter 编写和实施的 PEP。

PEP 3112：字节文字

Python 3.0 采用 Unicode 作为语言的基本字符串类型，并以不同的方式表示 8 位文字，如 b'string' 或使用 bytes 构造函数。为了将来的兼容性，Python 2.6 添加了 bytes 作为 str 类型的同义词，并且它还支持 b 表示法。

2.6 str 与 3.0 的 bytes 类型有很多不同；最值得注意的是，构造函数完全不同。在3.0中，bytes([65, 66, 67])的长度为3个元素，包含代表ABC的字节；在 2.6 中，bytes([65, 66, 67]) 返回表示列表的 str() 的 12 字节字符串。

bytes 在 2.6 中的主要用途是编写对象类型的测试，例如 isinstance(x, bytes)。这将有助于 2to3 转换器，它无法判断 2.x 代码是否希望字符串包含字符或 8 位字节；您现在可以使用 bytes 或 str 来准确表达您的意图，并且生成的代码在 Python 3.0 中也将是正确的。

还有一个 __future__ 导入会导致所有字符串文字变成 Unicode 字符串。这意味着 \u 转义序列可用于包含 Unicode 字符：

from __future__ import unicode_literals

s = ('\u751f\u3080\u304e\u3000\u751f\u3054'
     '\u3081\u3000\u751f\u305f\u307e\u3054')

print len(s)               # 12 Unicode characters

在 C 级别，Python 3.0 将现有的 8 位字符串类型（在 Python 2.x 中称为 PyStringObject）重命名为 PyBytesObject。 Python 2.6 使用 #define 来支持使用名称 PyBytesObject()、PyBytes_Check()、PyBytes_FromStringAndSize() 以及所有其他与字符串一起使用的函数和宏。

bytes 类型的实例和字符串一样是不可变的。一个新的 bytearray 类型存储一个可变的字节序列：

>>> bytearray([65, 66, 67])
bytearray(b'ABC')
>>> b = bytearray(u'\u21ef\u3244', 'utf-8')
>>> b
bytearray(b'\xe2\x87\xaf\xe3\x89\x84')
>>> b[0] = '\xe3'
>>> b
bytearray(b'\xe3\x87\xaf\xe3\x89\x84')
>>> unicode(str(b), 'utf-8')
u'\u31ef \u3244'

字节数组支持字符串类型的大部分方法，如startswith()/endswith()、find()/rfind()，以及一些列表的方法，如如 append()、pop() 和 reverse()。

>>> b = bytearray('ABC')
>>> b.append('d')
>>> b.append(ord('e'))
>>> b
bytearray(b'ABCde')

还有一个对应的 C API，有 PyByteArray_FromObject()、PyByteArray_FromStringAndSize() 和其他各种函数。

也可以看看

PEP 3112 - Python 3000 中的字节文字: PEP 由 Jason Orendorff 撰写；由 Christian Heimes 向后移植到 2.6。

PEP 3116：新的 I/O 库

Python 的内置文件对象支持多种方法，但类文件对象不一定支持所有方法。例如，模仿文件的对象通常支持 read() 和 write()，但它们可能不支持 readline()。 Python 3.0 在 io 模块中引入了一个分层的 I/O 库，它将缓冲和文本处理功能与基本的读写操作分开。

io模块提供了三层抽象基类：

RawIOBase 定义原始 I/O 操作：read()、readinto()、write()、seek()、tell()、truncate() 和 close()。此类的大多数方法通常会映射到单个系统调用。还有 readable()、writable() 和 seekable() 方法用于确定给定对象允许哪些操作。

Python 3.0 为文件和套接字提供了此类的具体实现，但 Python 2.6 没有以这种方式重构其文件和套接字对象。
BufferedIOBase 是一个抽象基类，它在内存中缓冲数据以减少使用的系统调用次数，使 I/O 处理更加高效。它支持 [X34X] 的所有方法，并添加了一个 raw 属性来保存底层原始对象。

有五个具体的类来实现这个 ABC。 BufferedWriter 和 BufferedReader 用于支持只写或只读使用的对象，这些对象具有用于随机访问的 seek() 方法。 BufferedRandom 对象支持对同一底层流的读写访问，而 BufferedRWPair 用于对象，例如 TTY，对未连接的数据流进行读写操作。 BytesIO 类支持对内存缓冲区的读取、写入和查找。
TextIOBase：提供读取和写入字符串的函数（记住，字符串在 Python 3.0 中将是 Unicode），并支持通用换行符。 TextIOBase 定义了 readline() 方法并支持对象迭代。

有两个具体的实现。 TextIOWrapper 包装了一个缓冲的 I/O 对象，支持文本 I/O 的所有方法，并添加了一个 buffer 属性来访问底层对象。 StringIO 只是缓冲内存中的所有内容，而无需将任何内容写入磁盘。

（在 Python 2.6 中，io.StringIO 是在纯 Python 中实现的，所以速度很慢。因此，您现在应该坚持使用现有的 StringIO 模块或 cStringIO。在某些时候，Python 3.0 的 io 模块将被重写为 C 以提高速度，也许 C 实现将被反向移植到 2.x 版本。）

在 Python 2.6 中，底层实现尚未重构以构建在 io 模块的类之上。提供该模块是为了更轻松地编写与 3.0 向前兼容的代码，并节省开发人员编写自己的缓冲和文本 I/O 实现的工作量。

也可以看看

PEP 3116 - 新的 I/O: PEP 由 Daniel Stutzbach、Mike Verdone 和 Guido van Rossum 编写。由 Guido van Rossum、Georg Brandl、Walter Doerwald、Jeremy Hylton、Martin von Loewis、Tony Lownds 和其他人编写的代码。

PEP 3118：修订缓冲协议

缓冲区协议是一个 C 级 API，它允许 Python 类型将指针交换到它们的内部表示中。例如，可以将内存映射文件视为字符缓冲区，这让另一个模块（例如 re）将内存映射文件视为要搜索的字符串。

缓冲区协议的主要用户是数字处理包，例如 NumPy，它公开数组的内部表示，以便调用者可以将数据直接写入数组，而不是通过较慢的 API。该 PEP 根据 NumPy 开发的经验更新了缓冲区协议，添加了许多新功能，例如指示数组的形状或锁定内存区域。

最重要的新 C API 函数是 PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)，它接受一个对象和一组标志，并用有关对象的内存表示的信息填充 Py_buffer 结构。对象可以使用此操作将内存锁定到位，而外部调用者可以修改内容，因此有一个相应的 PyBuffer_Release(Py_buffer *view) 来指示外部调用者已完成。

PyObject_GetBuffer() 的 flags 参数指定对返回内存的约束。一些例子是：

PyBUF_WRITABLE 表示内存必须是可写的。

PyBUF_LOCK 请求对内存进行只读或排他锁定。

PyBUF_C_CONTIGUOUS 和 PyBUF_F_CONTIGUOUS 请求 C 连续（最后一维变化最快）或 Fortran 连续（第一维变化最快）数组布局。

PyArg_ParseTuple()、s* 和 z* 的两个新参数代码返回参数的锁定缓冲区对象。

也可以看看

PEP 3118 - 修订缓冲协议: PEP 由 Travis Oliphant 和 Carl Banks 撰写；由 Travis Oliphant 实施。

PEP 3119：抽象基类

一些面向对象的语言（例如 Java）支持接口，声明类具有给定的方法集或支持给定的访问协议。抽象基类（或 ABC）是 Python 的等效功能。 ABC 支持由一个 abc 模块组成，该模块包含一个名为 ABCMeta 的元类，isinstance() 和 issubclass() 对此元类的特殊处理] 内置函数，以及 Python 开发人员认为将被广泛使用的基本 ABC 的集合。 Python 的未来版本可能会添加更多的 ABC。

假设您有一个特定的类，并希望知道它是否支持字典式访问。然而，“字典式”一词含糊不清。这可能意味着使用 obj[1] 访问项目有效。这是否意味着使用 obj[2] = value 设置项目有效？或者对象将具有 keys()、values() 和 items() 方法？诸如 iterkeys() 之类的迭代变体呢？ copy() 和 update()？用 iter() 迭代对象？

Python 2.6 collections 模块包含许多代表这些区别的不同 ABC。 Iterable表示类定义了__iter__()，Container表示类定义了__contains__()方法，因此支持x in y表达式。获取项、设置项、keys()、values()、items()的基本字典接口，由MutableMappingABC定义。

您可以从特定的 ABC 派生自己的类，以表明它们支持该 ABC 的接口：

import collections

class Storage(collections.MutableMapping):
    ...

或者，您可以编写类而不从所需的 ABC 派生，而是通过调用 ABC 的 register() 方法注册该类：

import collections

class Storage:
    ...

collections.MutableMapping.register(Storage)

对于您编写的类，从 ABC 派生可能更清楚。 register() 方法在您编写可以描述现有类型或类的新 ABC 时很有用，或者如果您想声明某个第三方类实现了 ABC。例如，如果你定义了一个 PrintableType ABC，这样做是合法的：

# Register Python's types
PrintableType.register(int)
PrintableType.register(float)
PrintableType.register(str)

类应该遵守 ABC 指定的语义，但 Python 无法检查这一点；由班级作者了解 ABC 的要求并相应地实现代码。

要检查对象是否支持特定接口，您现在可以编写：

def func(d):
    if not isinstance(d, collections.MutableMapping):
        raise ValueError("Mapping object expected, not %r" % d)

不要觉得你现在必须像上面的例子那样开始编写大量的检查。 Python 有一个强大的鸭子类型传统，其中从不进行显式类型检查，代码只是调用对象上的方法，相信这些方法会存在，如果不存在则引发异常。在检查 ABC 时要明智，并且只在绝对必要的情况下才这样做。

您可以使用 abc.ABCMeta 作为类定义中的元类来编写自己的 ABC：

from abc import ABCMeta, abstractmethod

class Drawable():
    __metaclass__ = ABCMeta

    @abstractmethod
    def draw(self, x, y, scale=1.0):
        pass

    def draw_doubled(self, x, y):
        self.draw(x, y, scale=2.0)


class Square(Drawable):
    def draw(self, x, y, scale):
        ...

在上面的 Drawable ABC 中，draw_doubled() 方法以两倍大小渲染对象，并且可以根据 Drawable 中描述的其他方法实现。因此，实现这个 ABC 的类不需要提供他们自己的 draw_doubled() 实现，尽管他们可以这样做。但是，draw() 的实现是必要的； ABC 无法提供有用的通用实现。

您可以将 @abstractmethod 装饰器应用于必须实现的方法，例如 draw()；然后，Python 将为未定义该方法的类引发异常。请注意，仅当您实际尝试创建缺少该方法的子类的实例时才会引发异常：

>>> class Circle(Drawable):
...     pass
...
>>> c = Circle()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Circle with abstract methods draw
>>>

可以使用 @abstractproperty 装饰器声明抽象数据属性：

from abc import abstractproperty
...

@abstractproperty
def readonly(self):
   return self._x

然后子类必须定义 readonly() 属性。

也可以看看

PEP 3119 - 引入抽象基类: 由 Guido van Rossum 和 Talin 编写的 PEP。由 Guido van Rossum 实施。由 Benjamin Aranguren 和 Alex Martelli 向后移植到 2.6。

PEP 3127：整数文字支持和语法

Python 3.0 更改了八进制 (base-8) 整数文字的语法，在它们前面加上“0o”或“0O”而不是前导零，并增加了对二进制 (base-2) 整数文字的支持，由“0b”表示或“0B”前缀。

Python 2.6 没有放弃对前导 0 表示八进制数的支持，但它增加了对“0o”和“0b”的支持：

>>> 0o21, 2*8 + 1
(17, 17)
>>> 0b101111
47

oct() 内置函数仍然返回以前导零为前缀的数字，而新的 bin() 内置函数返回数字的二进制表示：

>>> oct(42)
'052'
>>> future_builtins.oct(42)
'0o52'
>>> bin(173)
'0b10101101'

int() 和 long() 内置函数现在将在请求 base-8 或 base-2 或 时接受“0o”和“0b”前缀base 参数为零（表示使用的基数应从字符串中确定）：

>>> int ('0o52', 0)
42
>>> int('1101', 2)
13
>>> int('0b1101', 2)
13
>>> int('0b1101', 0)
13

也可以看看

PEP 3127 - 整数文字支持和语法: PEP 由 Patrick Maupin 编写；由 Eric Smith 反向移植到 2.6。

PEP 3129：类装饰器

装饰器已经从函数扩展到类。现在写是合法的：

@foo
@bar
class A:
  pass

这相当于：

class A:
  pass

A = foo(bar(A))

也可以看看

PEP 3129 - 类装饰器: PEP 由 Collin Winter 编写。

PEP 3141：数字的类型层次结构

Python 3.0 为受 Scheme 数字塔启发的数字类型添加了几个抽象基类。这些类作为 numbers 模块向后移植到 2.6。

最通用的ABC是Number。它根本没有定义任何操作，只存在允许通过执行 isinstance(obj, Number) 来检查对象是否为数字。

Complex 是 Number 的子类。复数可以进行加、减、乘、除、幂等基本运算，可以求出实部和虚部，得到一个数的共轭。 Python 的内置复杂类型是 Complex 的实现。

Real进一步派生自Complex，增加了只对实数起作用的运算：floor()、trunc()、四舍五入、取余数mod N、地板除法, 和比较。

Rational 数字源自 Real，具有 numerator 和 denominator 属性，并且可以转换为浮点数。 Python 2.6 在 fractions 模块中添加了一个简单的有理数类 Fraction。（它被称为 Fraction 而不是 Rational，以避免与 numbers.Rational 发生名称冲突。）

Integral 数字源自 Rational，可以用 << 和 >> 左右移动，结合使用 & 等按位运算和 |，可用作数组索引和切片边界。

在 Python 3.0 中，PEP 稍微重新定义了现有的内置函数 round()、math.floor()、math.ceil()，并添加了一个新函数, math.trunc()，已向后移植到 Python 2.6。 math.trunc() 向零舍入，返回函数参数和零之间最接近的 Integral。

也可以看看

PEP 3141 - 数字的类型层次结构: 杰弗里·亚斯金 (Jeffrey Yasskin) 撰写的 PEP。

Scheme 的数值塔，来自 Guile 手册。

[R5RS 方案规范的方案编号数据类型] 。

分数模块

为了填充数字类型的层次结构，fractions 模块提供了一个有理数类。有理数将它们的值存储为构成分数的分子和分母，并且可以精确地表示诸如 2/3 之类的浮点数只能近似的数字。

Fraction 构造函数采用两个 Integral 值，它们将作为结果分数的分子和分母。

>>> from fractions import Fraction
>>> a = Fraction(2, 3)
>>> b = Fraction(2, 5)
>>> float(a), float(b)
(0.66666666666666663, 0.40000000000000002)
>>> a+b
Fraction(16, 15)
>>> a/b
Fraction(5, 3)

为了将浮点数转换为有理数，float 类型现在有一个 as_integer_ratio() 方法，该方法返回计算为相同浮点值的分数的分子和分母：

>>> (2.5) .as_integer_ratio()
(5, 2)
>>> (3.1415) .as_integer_ratio()
(7074029114692207L, 2251799813685248L)
>>> (1./3) .as_integer_ratio()
(6004799503160661L, 18014398509481984L)

请注意，只能通过浮点数近似的值，例如 1./3，不会简化为要近似的数；分数尝试与浮点值 完全匹配 。

fractions 模块基于 Sjoerd Mullender 的一个实现，该实现在 Python 的 Demo/classes/ 目录中已有很长时间。 Jeffrey Yasskin 对该实现进行了重大更新。

其他语言更改

对核心 Python 语言进行的一些较小更改是：

包含 __main__.py 文件的目录和 zip 档案现在可以通过将它们的名称传递给解释器来直接执行。目录或 zip 存档会自动作为 sys.path 中的第一个条目插入。（Andy Chu 的建议和初始补丁，随后由 Phillip J. 伊比和尼克科格兰；：问题：`1739468`。）
hasattr() 函数正在捕获并忽略所有错误，假设它们意味着 __getattr__() 方法以某种方式失败并且 hasattr() 的返回值将因此为 False。但是，此逻辑不应应用于 KeyboardInterrupt 和 SystemExit；当 hasattr() 遇到此类异常时，Python 2.6 将不再丢弃它们。（由 Benjamin Peterson 修正；：问题：`2196`。）
当使用 ** 语法调用函数以提供关键字参数时，不再需要使用 Python 字典；任何映射现在都可以工作：
```
>>> def f(**kw):
...    print sorted(kw)
...
>>> ud=UserDict.UserDict()
>>> ud['a'] = 1
>>> ud['b'] = 'string'
>>> f(**ud)
['a', 'b']
```
（由 Alexander Belopolsky 提供；:issue:`1686487`。）

在函数调用的 *args 参数之后提供关键字参数也是合法的。
```
>>> def f(*args, **kw):
...     print args, kw
...
>>> f(1,2,3, *(4,5,6), keyword=13)
(1, 2, 3, 4, 5, 6) {'keyword': 13}
```
以前，这可能是语法错误。（由 Amaury Forgeot d'Arc 提供；：issue:`3473`。）
新的内置函数 next(iterator, [default]) 返回指定迭代器的下一项。如果提供了 default 参数，如果 iterator 已用完，则返回；否则，将引发 StopIteration 异常。（在 :issue:`2719` 中向后移植。）
元组现在有 index() 和 count() 方法匹配列表类型的 index() 和 count() 方法：
```
>>> t = (0,1,2,3,4,0,1,2)
>>> t.index(3)
3
>>> t.count(0)
2
```
（雷蒙德·赫廷格供稿）
内置类型现在改进了对扩展切片语法的支持，接受 (start, stop, step) 的各种组合。以前，支持是部分的，某些极端情况不起作用。（由托马斯·沃特斯实施。）

属性现在具有三个属性，getter、setter 和 deleter，它们是装饰器，它们为向现有属性添加 getter、setter 或 deleter 函数提供了有用的快捷方式。你会像这样使用它们：

class C(object):
    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

class D(C):
    @C.x.getter
    def x(self):
        return self._x * 2

    @x.setter
    def x(self, value):
        self._x = value / 2

内置集合类型的几种方法现在接受多个迭代：intersection()、intersection_update()、union()、update()、difference()和[ X131X]。
```
>>> s=set('1234567890')
>>> s.intersection('abc123', 'cdf246')  # Intersection between all inputs
set(['2'])
>>> s.difference('246', '789')
set(['1', '0', '3', '5'])
```
（雷蒙德·赫廷格供稿。）
添加了许多浮点功能。 float() 函数现在会将字符串 nan 转换为 IEEE 754 Not A Number 值，并将 +inf 和 -inf 转换为正无穷大或负无穷大. 这适用于任何具有 IEEE 754 语义的平台。（由 Christian Heimes 提供；:issue:`1635`。）

math 模块中的其他函数，isinf() 和 isnan()，如果它们的浮点参数是无穷大或不是数字，则返回 true。（：问题：`1640`）

添加了转换函数以将浮点数转换为十六进制字符串 (:issue:`3008`)。这些函数将浮点数与字符串表示形式相互转换，而不会在十进制和二进制之间的转换中引入舍入错误。 Floats 有一个 hex() 方法返回一个字符串表示，而 float.fromhex() 方法将一个字符串转换回一个数字：
```
>>> a = 3.75
>>> a.hex()
'0x1.e000000000000p+1'
>>> float.fromhex('0x1.e000000000000p+1')
3.75
>>> b=1./3
>>> b.hex()
'0x1.5555555555555p-2'
```
数字细节：在支持有符号零（-0 和 +0）的系统上从两个浮点数创建复数时，complex() 构造函数现在将保留零的符号。（由 Mark T. 狄金森；：问题：`1507`。）
从父类继承 __hash__() 方法的类可以设置 __hash__ = None 以指示该类不可散列。这将使 hash(obj) 引发 TypeError 并且该类将不会被指示为实现 Hashable ABC。

当您定义了一个 __cmp__() 或 __eq__() 方法来比较对象的值而不是身份时，您应该这样做。所有对象都有一个默认的哈希方法，使用 id(obj) 作为哈希值。没有简单的方法可以删除从父类继承的 __hash__() 方法，因此分配 None 被实现为覆盖。在 C 级别，扩展可以将 tp_hash 设置为 PyObject_HashNotImplemented()。（由 Nick Coghlan 和 Amaury Forgeot d'Arc 修复；:issue:`2235`。）
GeneratorExit 异常现在子类化 BaseException 而不是 Exception。这意味着执行 except Exception: 的异常处理程序不会无意中捕获 GeneratorExit。（由 Chad Austin 提供；:issue:`1537`。）
生成器对象现在具有 gi_code 属性，该属性引用支持生成器的原始代码对象。（由 Collin Winter 提供；：问题：`1473257`。）
compile() 内置函数现在接受关键字参数和位置参数。（由 Thomas Wouters 提供；:issue:`1444529`。）
complex() 构造函数现在接受包含带括号的复数的字符串，这意味着 complex(repr(cplx)) 现在将往返值。例如，complex('(3+4j)') 现在返回值 (3+4j)。（：问题：`1491866`）
字符串 translate() 方法现在接受 None 作为转换表参数，它被视为身份转换。这样可以更轻松地执行仅删除字符的操作。（由 Bengt Richter 提供，由 Raymond Hettinger 实施；：issue:`1193128`。）
内置的 dir() 函数现在检查它接收到的对象上的 __dir__() 方法。此方法必须返回包含对象有效属性名称的字符串列表，并让对象控制 dir() 产生的值。具有 __getattr__() 或 __getattribute__() 方法的对象可以使用它来通告它们将遵守的伪属性。（：问题：`1591665`）
实例方法对象具有包含该方法的对象和函数的新属性； im_self 的新同义词是 __self__，im_func 也可用作 __func__。 Python 2.6 中仍支持旧名称，但在 3.0 中已消失。
一个模糊的变化：当您在 class 语句中使用 locals() 函数时，生成的字典不再返回自由变量。（在这种情况下，自由变量是在 class 语句中引用的不是类的属性的变量。）

优化

warnings 模块已用 C 重写。这使得从解析器调用警告成为可能，并且还可以使解释器的启动更快。（由 Neal Norwitz 和 Brett Cannon 提供；：问题：`1631171`。）
类型对象现在有一个方法缓存，可以减少为特定类找到正确方法实现所需的工作；一旦缓存，解释器不需要遍历基类来找出正确的方法来调用。如果基类或类本身被修改，缓存会被清除，因此即使面对 Python 的动态特性，缓存也应该保持正确。（由 Armin Rigo 实现的原始优化，由 Kevin Jacobs 针对 Python 2.6 更新；:issue:`1700288`。）

默认情况下，此更改仅应用于 Python 核心中包含的类型。扩展模块不一定与此缓存兼容，因此它们必须显式添加 Py_TPFLAGS_HAVE_VERSION_TAG 到模块的 tp_flags 字段以启用方法缓存。（为了与方法缓存兼容，扩展模块的代码不得直接访问和修改它实现的任何类型的 tp_dict 成员。大多数模块不会这样做，但 Python 解释器不可能确定这一点。有关一些讨论，请参阅 :issue:`1878`。）
通过执行快速指针比较，使用关键字参数的函数调用明显更快，通常可以节省完整字符串比较的时间。（由 Raymond Hettinger 提供，在 Antoine Pitrou 初步实现之后；:issue:`1819`。）
由于在极品飞车冲刺中的工作，struct 模块中的所有函数都已用 C 重写。（雷蒙德·赫廷格供稿。）
一些标准的内置类型现在在它们的类型对象中设置了一些。这加快了检查对象是否是这些类型之一的子类的速度。（尼尔·诺维茨供稿。）
Unicode 字符串现在使用更快的代码来检测空格和换行符；这将 split() 方法的速度提高了约 25%，将 splitlines() 的速度提高了 35%。（由 Antoine Pitrou 提供。）通过对 Unicode 字符串的数据使用 pymalloc 减少了内存使用量。
with 语句现在将 __exit__() 方法存储在堆栈上，从而产生小幅加速。（由杰弗里亚斯金实施。）
为了减少内存使用，垃圾收集器现在将在对最高代对象进行垃圾收集时清除内部空闲列表。这可能会更快地将内存返回给操作系统。

口译员变化

保留了两个命令行选项供其他 Python 实现使用。 -J 开关已保留供 Jython 用于 Jython 特定的选项，例如传递到底层 JVM 的开关。 -X 已保留用于特定于特定 Python 实现的选项，例如 CPython、Jython 或 IronPython。如果任一选项与 Python 2.6 一起使用，解释器将报告当前未使用该选项。

现在可以通过向 Python 解释器提供 -B 开关或设置来阻止 Python 写入 .pyc 或 .pyo 文件]PYTHONDONTWRITEBYTECODE 运行解释器之前的环境变量。此设置作为 sys.dont_write_bytecode 变量可用于 Python 程序，Python 代码可以更改该值以修改解释器的行为。（由 Neal Norwitz 和 Georg Brandl 提供。）

用于标准输入、输出和标准错误的编码可以通过在运行解释器之前设置 PYTHONIOENCODING 环境变量来指定。该值应为 <encoding> 或 <encoding>:<errorhandler> 形式的字符串。 encoding 部分指定编码的名称，例如 utf-8 或 latin-1；可选的 errorhandler 部分指定如何处理编码无法处理的字符，并且应该是“错误”、“忽略”或“替换”之一。（马丁·冯·洛伊斯供稿。）

新的和改进的模块

在每个版本中，Python 的标准库都获得了许多增强功能和错误修复。这是最显着更改的部分列表，按模块名称的字母顺序排序。查阅源代码树中的 Misc/NEWS 文件以获取更完整的更改列表，或查看 Subversion 日志以获取所有详细信息。

asyncore 和 asynchat 模块再次得到积极维护，并应用了许多补丁和错误修复。（由 Josiah Carlson 维护；有关一个补丁，请参阅 :issue:`1736190`。）
bsddb 模块还有一个新的维护者 Jesús Cea Avion，该软件包现在可以作为独立软件包使用。包的网页是 www.jcea.es/programacion/pybsddb.htm。计划是从 Python 3.0 的标准库中删除该包，因为它的发布速度比 Python 快得多。

bsddb.dbshelve 模块现在使用可用的最高酸洗协议，而不是将自身限制为协议 1。（由 W. 巴恩斯。）
cgi 模块现在将从 HTTP POST 请求的查询字符串中读取变量。这使得可以对包含查询字符串的 URL 使用表单操作，例如“/cgi-bin/add.py?category=1”。（由 Alexandre Fiori 和 Nubis 提供；:issue:`1817`。）

parse_qs() 和 parse_qsl() 函数已从 cgi 模块重新定位到 urlparse 模块。 cgi 模块中仍然可用的版本将在 2.6 中触发 PendingDeprecationWarning 消息（:issue:`600362`）。
cmath 模块进行了广泛的修订，由 Mark Dickinson 和 Christian Heimes 贡献。添加了五个新功能：
- polar() 将复数转换为极坐标形式，返回复数的模数和参数。
- rect() 做相反的事情，将模数、参数对转换回相应的复数。
- phase() 返回复数的参数（也称为角度）。
- isnan() 如果其参数的实部或虚部是 NaN，则返回 True。
- isinf() 如果其参数的实部或虚部是无限的，则返回 True。
修订版还改进了 cmath 模块的数值稳健性。对于所有函数，结果的实部和虚部尽可能精确到最小精度 (ulps) 的几个单位内。有关详细信息，请参阅 :issue:`1381`。 asinh()、atanh(): 和 atan() 的分支切割也已得到修正。

大大扩展了模块的测试；近 2000 个新的测试用例运用了代数函数。

在 IEEE 754 平台上，cmath 模块现在以与 C99 标准的附件“G”一致的方式处理 IEEE 754 特殊值和浮点异常。

collections 模块中的新数据类型：namedtuple(typename, fieldnames) 是一个工厂函数，它创建标准元组的子类，其字段可通过名称和索引访问。例如：

>>> var_type = collections.namedtuple('variable',
...             'id name type size')
>>> # Names are separated by spaces or commas.
>>> # 'id, name, type, size' would also work.
>>> var_type._fields
('id', 'name', 'type', 'size')

>>> var = var_type(1, 'frequency', 'int', 4)
>>> print var[0], var.id    # Equivalent
1 1
>>> print var[2], var.type  # Equivalent
int int
>>> var._asdict()
{'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'}
>>> v2 = var._replace(name='amplitude')
>>> v2
variable(id=1, name='amplitude', type='int', size=4)

标准库中返回元组的几个地方已修改为返回 namedtuple 实例。例如，Decimal.as_tuple() 方法现在返回带有 sign、digits 和 exponent 字段的命名元组。

（雷蒙德·赫廷格供稿。）

collections 模块的另一个变化是 deque 类型现在支持可选的 maxlen 参数；如果提供，双端队列的大小将限制为不超过 maxlen 项。将更多项目添加到完整双端队列会导致旧项目被丢弃。
```
>>> from collections import deque
>>> dq=deque(maxlen=3)
>>> dq
deque([], maxlen=3)
>>> dq.append(1); dq.append(2); dq.append(3)
>>> dq
deque([1, 2, 3], maxlen=3)
>>> dq.append(4)
>>> dq
deque([2, 3, 4], maxlen=3)
```
（雷蒙德·赫廷格供稿。）
Cookie 模块的 Morsel 对象现在支持 httponly 属性。在某些浏览器中。 JavaScript 代码无法访问或操作具有此属性集的 cookie。（由 Arvin Schnell 提供；:issue:`1638033`。）
curses 模块中的一个新窗口方法，chgat()，改变了单行一定数量字符的显示属性。（法比安·克罗伊茨供稿。）
```
# Boldface text starting at y=0,x=21
# and affecting the rest of the line.
stdscr.chgat(0, 21, curses.A_BOLD)
```
curses.textpad 模块中的 Textbox 类现在支持在插入模式和覆盖模式下进行编辑。在创建 Textbox 实例时，通过为 insert_mode 参数提供真值来启用插入模式。
datetime 模块的 strftime() 方法现在支持 %f 格式代码，该代码扩展到对象中的微秒数，在左侧填充零到六个位置。（由 Skip Montanaro 提供；:issue:`1158`。）
decimal 模块已更新到通用十进制规范的 1.66 版。新功能包括一些基本数学函数的方法，例如 exp() 和 log10()：
```
>>> Decimal(1).exp()
Decimal("2.718281828459045235360287471")
>>> Decimal("2.7182818").ln()
Decimal("0.9999999895305022877376682436")
>>> Decimal(1000).log10()
Decimal("3")
```
Decimal 对象的 as_tuple() 方法现在返回带有 sign、digits 和 exponent 字段的命名元组。

（由 Facundo Batista 和 Mark Dickinson 实施。 Raymond Hettinger 添加的命名元组支持。）
difflib 模块的 SequenceMatcher 类现在返回表示匹配的命名元组，具有 a、b 和 size 属性。（雷蒙德·赫廷格供稿。）
一个可选的 timeout 参数指定以秒为单位的超时，已添加到 ftplib.FTP 类构造函数以及 connect() 方法。（由 Facundo Batista 添加。）此外，FTP 类的 storbinary() 和 storlines() 现在采用可选的 callback 参数，该参数将随每个块调用数据发送后的数据。（由 Phil Schwartz 提供；:issue:`1221598`。）
reduce() 内置函数也在 functools 模块中可用。在 Python 3.0 中，内置函数已被删除，并且 reduce() 仅可从 functools 获得；目前没有计划在 2.x 系列中删除内置。（由 Christian Heimes 修补；：问题：`1739906`。）
如果可能，getpass 模块现在将使用 /dev/tty 打印提示消息并读取密码，回退到标准错误和标准输入。如果密码可能会回显到终端，则会在显示提示之前打印警告。（由格雷戈里 P. 史密斯。）
glob.glob() 函数现在可以返回 Unicode 文件名，如果使用了 Unicode 路径并且 Unicode 文件名在目录中匹配。（：问题：`1001604`）
heapq 模块中的一个新函数 merge(iter1, iter2, ...) 接受任意数量的迭代器以排序的顺序返回数据，并返回一个新的生成器，该生成器返回所有迭代器的内容，也以排序的顺序返回. 例如：
```
>>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16]))
[1, 2, 3, 5, 8, 9, 16]
```
另一个新函数 heappushpop(heap, item) 将 item 推送到 heap，然后弹出并返回最小的 item。这比先调用 heappush() 然后 heappop() 更有效。

heapq 现在实现为仅使用小于比较，而不是以前使用的小于或等于比较。这使得 heapq 对类型的使用与 list.sort() 方法匹配。（雷蒙德·赫廷格供稿。）
一个可选的 timeout 参数，指定以秒为单位的超时，被添加到 httplib.HTTPConnection 和 HTTPSConnection 类构造函数中。（由 Facundo Batista 添加。）
大多数 inspect 模块的函数，例如 getmoduleinfo() 和 getargs()，现在返回命名元组。除了表现得像元组，返回值的元素也可以作为属性访问。（雷蒙德·赫廷格供稿。）

模块中的一些新功能包括 isgenerator()、isgeneratorfunction() 和 isabstract()。
itertools 模块获得了几个新功能。

izip_longest(iter1, iter2, ...[, fillvalue]) 从每个元素生成元组；如果某些可迭代对象比其他可迭代对象短，则缺失值将设置为 fillvalue。例如：
```
>>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5]))
((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))
```
product(iter1, iter2, ..., [repeat=N]) 返回提供的可迭代对象的笛卡尔积，一组元组包含从每个可迭代对象返回的元素的所有可能组合。
```
>>> list(itertools.product([1,2,3], [4,5,6]))
[(1, 4), (1, 5), (1, 6),
 (2, 4), (2, 5), (2, 6),
 (3, 4), (3, 5), (3, 6)]
```
可选的 repeat 关键字参数用于将可迭代或一组可迭代的乘积与自身相乘，重复 N 次。使用单个可迭代参数，返回 N 元组：
```
>>> list(itertools.product([1,2], repeat=3))
[(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
 (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]
```
使用两个可迭代对象，返回 2N 元组。
```
>>> list(itertools.product([1,2], [3,4], repeat=2))
[(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4),
 (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4),
 (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4),
 (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]
```
combinations(iterable, r) 从 iterable 的元素返回长度为 r 的子序列。
```
>>> list(itertools.combinations('123', 2))
[('1', '2'), ('1', '3'), ('2', '3')]
>>> list(itertools.combinations('123', 3))
[('1', '2', '3')]
>>> list(itertools.combinations('1234', 3))
[('1', '2', '3'), ('1', '2', '4'),
 ('1', '3', '4'), ('2', '3', '4')]
```
permutations(iter[, r]) 返回可迭代元素的长度 r 的所有排列。如果未指定 r，则默认为可迭代生成的元素数。
```
>>> list(itertools.permutations([1,2,3,4], 2))
[(1, 2), (1, 3), (1, 4),
 (2, 1), (2, 3), (2, 4),
 (3, 1), (3, 2), (3, 4),
 (4, 1), (4, 2), (4, 3)]
```
itertools.chain(*iterables) 是 itertools 中的一个现有函数，它在 Python 2.6 中获得了一个新的构造函数。 itertools.chain.from_iterable(iterable) 接受一个应该返回其他迭代的单个迭代。 chain() 然后将返回第一个可迭代对象的所有元素，然后是第二个可迭代对象的所有元素，依此类推。
```
>>> list(itertools.chain.from_iterable([[1,2,3], [4,5,6]]))
[1, 2, 3, 4, 5, 6]
```
（全部由 Raymond Hettinger 提供。）
logging 模块的 FileHandler 类及其子类 WatchedFileHandler、RotatingFileHandler 和 TimedRotatingFileHandler 现在有一个可选的延迟 ] 参数给它们的构造函数。如果 delay 为真，则日志文件的打开将推迟到进行第一个 emit() 调用。（由 Vinay Sajip 提供。）

TimedRotatingFileHandler 也有一个 utc 构造函数参数。如果参数为真，UTC 时间将用于确定午夜发生的时间和生成文件名；否则将使用当地时间。
math 模块中添加了几个新函数：
- isinf() 和 isnan() 分别确定给定的浮点数是（正或负）无穷大还是 NaN（非数字）。
- copysign() 复制 IEEE 754 数字的符号位，返回 x 的绝对值与 y 的符号位组合。例如，math.copysign(1, -0.0) 返回 -1.0。（由克里斯蒂安·海姆斯提供。）
- factorial() 计算一个数的阶乘。（由 Raymond Hettinger 提供；：issue:`2138`。）
- fsum() 将来自可迭代对象的数字流相加，并小心避免使用部分总和造成精度损失。（由 Jean Brouwers、Raymond Hettinger 和 Mark Dickinson 提供；:issue:`2819`。）
- acosh()、asinh() 和 atanh() 计算反双曲函数。
- log1p() 返回 1+x 的自然对数（以 e 为底）。
- trunc() 将数字向零舍入，返回函数参数和零之间最接近的 Integral。作为 PEP 3141 的数字类型层次结构的向后移植的一部分添加。
math 模块已得到改进，以提供更一致的跨平台行为，尤其是在处理浮点异常和 IEEE 754 特殊值方面。

只要有可能，模块就会遵循 C99 标准关于 754 的特殊值的建议。例如，sqrt(-1.) 现在应该在几乎所有平台上给出 ValueError，而 sqrt(float('NaN')) 应该在所有 IEEE 754 平台上返回 NaN。如果 C99 标准的附件“F”建议发出“除以零”或“无效”的信号，Python 将引发 ValueError。如果 C99 标准的附件“F”建议发出“溢出”信号，Python 将引发 OverflowError。（参见 :issue:`711019` 和 :issue:`1640`。）

（由克里斯蒂安·海姆斯和马克·迪金森提供。）
mmap 对象现在有一个 rfind() 方法，该方法搜索从字符串末尾开始的子字符串并向后搜索。 find() 方法还获得了一个 end 参数，给出了停止搜索的索引。（约翰·伦顿供稿。）
operator 模块获得了一个 methodcaller() 函数，该函数接受一个名称和一组可选参数，返回一个可调用对象，该可调用对象将对传递给它的任何参数调用命名函数。例如：
```
>>> # Equivalent to lambda s: s.replace('old', 'new')
>>> replacer = operator.methodcaller('replace', 'old', 'new')
>>> replacer('old wine in old bottles')
'new wine in new bottles'
```
（根据 Gregory Petrosyan 的建议，由 Georg Brandl 提供。）

attrgetter() 函数现在接受点名称并执行相应的属性查找：
```
>>> inst_name = operator.attrgetter(
...        '__class__.__name__')
>>> inst_name('')
'str'
>>> inst_name(help)
'_Helper'
```
（根据 Barry Warsaw 的建议，由 Georg Brandl 提供。）
os 模块现在封装了几个新的系统调用。 fchmod(fd, mode) 和 fchown(fd, uid, gid) 更改打开文件的模式和所有权，lchmod(path, mode) 更改符号链接的模式。（由 Georg Brandl 和 Christian Heimes 提供。）

chflags() 和 lchflags() 是相应系统调用（它们可用的地方）的包装器，更改文件上设置的标志。标志值的常量在 stat 模块中定义；一些可能的值包括 UF_IMMUTABLE 表示文件可能不会被更改，以及 UF_APPEND 表示数据只能附加到文件中。（由 M. 莱文森。）

os.closerange(low, high) 有效地关闭从 low 到 high 的所有文件描述符，忽略任何错误并且不包括 high 本身。 subprocess 模块现在使用此函数来加快启动进程。（由 Georg Brandl 提供；：问题：`1663329`。）
os.environ 对象的 clear() 方法现在将使用 os.unsetenv() 取消设置环境变量以及清除对象的键。（由 Martin Horcicka 提供；:issue:`1181`。）
os.walk() 函数现在有一个 followlinks 参数。如果设置为 True，它将遵循指向目录的符号链接并访问目录的内容。为了向后兼容，该参数的默认值为 false。请注意，如果存在指向父目录的符号链接，则该函数可能会陷入无限递归。（：问题：`1273829`）
在 os.path 模块中，splitext() 函数已更改为不拆分前导句点字符。这在 Unix 的点文件上运行时会产生更好的结果。例如，os.path.splitext('.ipython') 现在返回 ('.ipython', ) 而不是 (, '.ipython')。（：问题：`1115886`）

新函数 os.path.relpath(path, start='.') 返回从 start 路径（如果提供）或从当前工作目录到目标 path 的相对路径。（由 Richard Barran 提供；：问题：`1339796`。）

在 Windows 上，os.path.expandvars() 现在将扩展以“%var%”形式给出的环境变量，“~user”将扩展到用户的主目录路径。（由 Josiah Carlson 提供；:issue:`957650`。）
pdb 模块提供的 Python 调试器获得了一个新命令：“run”重新启动正在调试的 Python 程序，并且可以选择为程序采用新的命令行参数。（由 Rocky Bernstein 提供；：issue:`1393667`。）
pdb.post_mortem() 函数，用于开始调试回溯，如果没有提供回溯，现在将使用 sys.exc_info() 返回的回溯。（由 Facundo Batista 提供；：问题：`1106316`。）
pickletools 模块现在有一个 optimize() 函数，它接受一个包含 pickle 的字符串并删除一些未使用的操作码，返回一个包含相同数据结构的较短的 pickle。（雷蒙德·赫廷格供稿。）

get_data() 函数被添加到 pkgutil 模块中，该模块返回包含在已安装 Python 包中的资源文件的内容。例如：

>>> import pkgutil
>>> print pkgutil.get_data('test', 'exception_hierarchy.txt')
BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StandardError
 ...

（由 Paul Moore 提供；:issue:`2439`。）

pyexpat 模块的 Parser 对象现在允许设置它们的 buffer_size 属性来更改用于保存字符数据的缓冲区的大小。（由 Achim Gaedke 提供；:issue:`1137`。）
Queue 模块现在提供以不同顺序检索条目的队列变体。 PriorityQueue 类将排队的项目存储在堆中并按优先级顺序检索它们，而 LifoQueue 首先检索最近添加的条目，这意味着它的行为类似于堆栈。（雷蒙德·赫廷格供稿。）
random 模块的 Random 对象现在可以在 32 位系统上腌制，在 64 位系统上取消腌制，反之亦然。不幸的是，此更改也意味着 Python 2.6 的 Random 对象无法在早期版本的 Python 上正确解压。（由 Shawn Ligocki 提供；:issue:`1727780`。）

新的 triangular(low, high, mode) 函数返回遵循三角形分布的随机数。返回值介于 low 和 high 之间，不包括 high 本身，其中 mode 作为分布中出现频率最高的值. （由 Wladmir van der Laan 和 Raymond Hettinger 提供；：issue:`1681432`。）
re 模块执行的长正则表达式搜索将检查正在传递的信号，因此现在可以中断耗时的搜索。（由 Josh Hoyt 和 Ralf Schmitt 提供；：问题：`846388`。）

正则表达式模块是通过为一个特定于正则表达式的小型虚拟机编译字节码来实现的。不受信任的代码可能会直接创建恶意的字节码字符串并导致崩溃，因此 Python 2.6 包含一个用于正则表达式字节码的验证器。（由 Google App Engine 工作的 Guido van Rossum 提供；:issue:`3487`。）
rlcompleter 模块的 Completer.complete() 方法现在将忽略评估名称时触发的异常。（由 Lorenz Quack 修复；:issue:`2250`。）
sched 模块的 scheduler 实例现在有一个只读的 queue 属性，它返回调度器队列的内容，表示为带有字段 [X195X 的命名元组列表]。（由 Raymond Hettinger 提供；:issue:`1861`。）
select 模块现在具有 Linux epoll() 和 BSD kqueue() 系统调用的包装函数。 modify() 方法被添加到现有的 poll 对象； pollobj.modify(fd, eventmask) 采用文件描述符或文件对象和事件掩码，修改该文件的记录事件掩码。（由 Christian Heimes 提供；：issue:`1657`。）
shutil.copytree() 函数现在有一个可选的 ignore 参数，它接受一个可调用对象。这个可调用对象将接收每个目录路径和目录内容列表，并返回一个将被忽略而不是复制的名称列表。

shutil 模块还提供了一个 ignore_patterns() 函数以与这个新参数一起使用。 ignore_patterns() 接受任意数量的 glob 样式模式并返回一个可调用对象，它将忽略与这些模式中的任何一个匹配的任何文件和目录。以下示例复制目录树，但跳过名称以“~”结尾的 .svn 目录和 Emacs 备份文件：
```
shutil.copytree('Doc/library', '/tmp/library',
                ignore=shutil.ignore_patterns('*~', '.svn'))
```
（由 Tarek Ziadé 提供；:issue:`2663`。）
将信号处理与 GUI 处理事件循环（如 Tkinter 或 GTk+ 使用的那些）集成长期以来一直是一个问题；大多数软件以轮询结束，每隔几分之一秒唤醒一次以检查是否发生了任何 GUI 事件。 signal 模块现在可以提高效率。调用 signal.set_wakeup_fd(fd) 设置要使用的文件描述符；当接收到信号时，将一个字节写入该文件描述符。还有一个 C 级函数 PySignal_SetWakeupFd()，用于设置描述符。

事件循环将通过打开管道来使用它来创建两个描述符，一个用于读取，一个用于写入。可写描述符将传递给 set_wakeup_fd()，可读描述符将通过 select() 或 poll() 添加到事件循环监视的描述符列表中。接收到信号后，将写入一个字节并唤醒主事件循环，从而无需轮询。

（由 Adam Olsen 提供；:issue:`1583`。）

siginterrupt() 函数现在可从 Python 代码获得，并允许更改信号是否可以中断系统调用。（拉尔夫·施密特供稿。）

setitimer() 和 getitimer() 功能也已添加（在可用的地方）。 setitimer() 允许设置间隔定时器，在指定的时间后将信号传递给进程，以挂钟时间、消耗的进程时间或进程+系统时间的组合来衡量。（由 Guilherme Polo 提供；:issue:`2240`。）
由于添加了 SMTP_SSL 类，smtplib 模块现在支持基于 SSL 的 SMTP。此类支持与现有 SMTP 类相同的接口。（由 Monty Taylor 提供。）两个类构造函数还有一个可选的 timeout 参数，用于指定初始连接尝试的超时时间，以秒为单位。（法昆多·巴蒂斯塔供稿。）

LMTP 协议的实现（RFC 2033）也被添加到模块中。在不管理邮件队列的代理之间传输电子邮件时，使用 LMTP 代替 SMTP。（LMTP 由 Leif Hedstrom 实现；:issue:`957003`。）

SMTP.starttls() 现在符合 RFC 3207 并忘记从服务器获得的任何知识，而不是从 TLS 协商本身获得的。（Bill Fenner 提供的补丁；:issue:`829951`。）
socket 模块现在支持 TIPC (http://tipc.sourceforge.net/)，这是一种设计用于集群环境的高性能非基于 IP 的协议。 TIPC 地址是 4 元组或 5 元组。（由 Alberto Bertogli 提供；:issue:`1646`。）

一个新函数 create_connection() 获取一个地址并使用可选的超时值连接到它，返回连接的套接字对象。此函数还会查找地址的类型并根据需要使用 IPv4 或 IPv6 连接到它。更改您的代码以使用 create_connection() 而不是 socket(socket.AF_INET, ...) 可能是使您的代码与 IPv6 一起工作所需的全部内容。
SocketServer 模块中的基类现在支持在服务器的 timeout 属性指定的一段时间不活动后调用 handle_timeout() 方法。（由 Michael Pomraning 提供。）serve_forever() 方法现在采用以秒为单位的可选轮询间隔，控制服务器检查关闭请求的频率。（由 Pedro Werneck 和 Jeffrey Yasskin 提供；:issue:`742598`, :issue:`1193577`。）
由 Gerhard Haering 维护的 sqlite3 模块已从 Python 2.5 中的 2.3.2 版更新到 2.4.1 版。
struct 模块现在支持 C99 _Bool 类型，使用格式字符 '?'。（大卫·雷马尔供稿。）
subprocess 模块提供的 Popen 对象现在具有 terminate()、kill() 和 send_signal() 方法。在 Windows 上，send_signal() 只支持 SIGTERM 信号，所有这些方法都是 Win32 API 函数 TerminateProcess() 的别名。（由克里斯蒂安·海姆斯提供。）
sys 模块中的一个新变量 float_info 是一个对象，该对象包含从 float.h 文件派生的有关平台浮点支持的信息。此对象的属性包括 mant_dig（尾数中的位数）、epsilon（1.0 与可表示的下一个最大值之间的最小差异）以及其他几个。（由 Christian Heimes 提供；：issue:`1534`。）

另一个新变量 dont_write_bytecode 控制 Python 在导入模块时是否写入任何 .pyc 或 .pyo 文件。如果此变量为真，则不会写入已编译的文件。该变量最初是在启动时通过向 Python 解释器提供 -B 开关，或通过在运行解释器之前设置 PYTHONDONTWRITEBYTECODE 环境变量来设置的。 Python 代码随后可以更改此变量的值以控制是否写入字节码文件。（由 Neal Norwitz 和 Georg Brandl 提供。）

有关提供给 Python 解释器的命令行参数的信息可以通过读取命名元组的属性来获得，如 sys.flags。例如，如果 Python 在详细模式下执行，则 verbose 属性为真，在调试模式下 debug 为真，等等。这些属性都是只读的。（由克里斯蒂安·海姆斯提供。）

一个新函数 getsizeof() 接受一个 Python 对象并返回该对象使用的内存量，以字节为单位。内置对象返回正确的结果；第三方扩展可能不会，但可以定义 __sizeof__() 方法来返回对象的大小。（由 Robert Schuppenies 提供；:issue:`2898`。）

现在可以通过调用 sys.getprofile() 和 sys.gettrace() 来确定当前的分析器和跟踪器函数。（由 Georg Brandl 提供；:issue:`1648`。）
除了已经支持的 POSIX.1-1988 (ustar) 和 GNU tar 格式之外，tarfile 模块现在还支持 POSIX.1-2001 (pax) tarfile。默认格式为 GNU tar；指定 format 参数以使用不同格式打开文件：
```
tar = tarfile.open("output.tar", "w",
                   format=tarfile.PAX_FORMAT)
```
新的 encoding 和 errors 参数指定了字符转换的编码和错误处理方案。 'strict'、'ignore' 和 'replace' 是 Python 处理错误的三种标准方式； 'utf-8' 是一个特殊值，用它们的 UTF-8 表示替换坏字符。（发生字符转换是因为 PAX 格式支持 Unicode 文件名，默认为 UTF-8 编码。）

TarFile.add() 方法现在接受 exclude 参数，该参数可用于从存档中排除某些文件名。该函数必须采用文件名，如果文件应该被排除，则返回 true，如果应该存档，则返回 false。该函数应用于最初传递给 add() 的名称和递归添加目录中的文件名称。

（所有更改均由 Lars Gustäbel 提供）。
一个可选的 timeout 参数被添加到 telnetlib.Telnet 类构造函数中，指定以秒为单位的超时。（由 Facundo Batista 添加。）
tempfile.NamedTemporaryFile 类通常会在文件关闭时删除它创建的临时文件。现在可以通过将 delete=False 传递给构造函数来更改此行为。（由 Damien Miller 提供；：问题：`1537850`。）

新类 SpooledTemporaryFile 的行为类似于临时文件，但将其数据存储在内存中，直到超过最大大小。达到该限制后，内容将写入磁盘临时文件。（由达斯汀 J。米切尔。）

NamedTemporaryFile 和 SpooledTemporaryFile 类都用作上下文管理器，因此您可以编写 with tempfile.NamedTemporaryFile() as tmp: ...。（由 Alexander Belopolsky 提供；:issue:`2021`。）
test.test_support 模块获得了许多对编写测试有用的上下文管理器。 EnvironmentVarGuard() 是一个上下文管理器，可以临时更改环境变量并自动将它们恢复为旧值。

另一个上下文管理器 TransientResource 可以环绕对可能可用或可能不可用的资源的调用；它将捕获并忽略指定的异常列表。例如，当连接到外部网站时，网络测试可能会忽略某些失败：
```
with test_support.TransientResource(IOError,
                                errno=errno.ETIMEDOUT):
    f = urllib.urlopen('https://sf.net')
    ...
```
最后，check_warnings() 重置 warning 模块的警告过滤器并返回一个对象，该对象将记录所有触发的警告消息 (:issue:`3781`)：
```
with test_support.check_warnings() as wrec:
    warnings.simplefilter("always")
    # ... code that triggers a warning ...
    assert str(wrec.message) == "function is outdated"
    assert len(wrec.warnings) == 1, "Multiple warnings raised"
```
（由布雷特·坎农提供。）

textwrap 模块现在可以通过指定 drop_whitespace=False 作为参数来保留新创建行的开头和结尾的现有空白：

>>> S = """This  sentence  has a bunch   of
...   extra   whitespace."""
>>> print textwrap.fill(S, width=15)
This  sentence
has a bunch
of    extra
whitespace.
>>> print textwrap.fill(S, drop_whitespace=False, width=15)
This  sentence
  has a bunch
   of    extra
   whitespace.
>>>

（由 Dwayne Bailey 提供；：问题：`1581073`。）

threading 模块 API 正在更改为使用 daemon 等属性代替 setDaemon() 和 isDaemon() 方法，并且某些方法已重命名为使用下划线而不是驼峰式；例如，activeCount() 方法重命名为 active_count()。模块的 2.6 和 3.0 版本都支持相同的属性和重命名的方法，但不删除旧方法。 Python 3.x 中旧 API 的弃用日期尚未确定；在任何 2.x 版本中都不会删除旧的 API。（由几个人执行，最著名的是本杰明·彼得森。）

threading 模块的 Thread 对象获得了一个 ident 属性，该属性返回线程的标识符，一个非零整数。（由格雷戈里 P. 史密斯；：问题：`2871`。）
timeit 模块现在接受可调用对象以及正在计时的语句和设置代码的字符串。添加了两个用于创建 Timer 实例的便捷函数：repeat(stmt, setup, time, repeat, number) 和 timeit(stmt, setup, time, number) 创建一个实例并调用相应的方法。（由 Erik Demaine 提供；:issue:`1533909`。）
Tkinter 模块现在接受列表和元组作为选项，在将结果值传递给 Tcl/Tk 之前用空格分隔元素。（由 Guilherme Polo 提供；:issue:`2906`。）
Gregor Lingl 大大增强了海龟图形的 turtle 模块。该模块的新功能包括：
- 更好的海龟运动和旋转动画。
- 使用新的 delay()、tracer() 和 speed() 方法控制海龟移动。
- 为海龟设置新形状和定义新坐标系的能力。
- 海龟现在有一个 undo() 方法可以回滚动作。
- 简单支持对输入事件（例如鼠标和键盘活动）做出反应，从而可以编写简单的游戏。
- turtle.cfg 文件可用于自定义海龟屏幕的起始外观。
- 模块的文档字符串可以被翻译成另一种语言的新文档字符串替换。
（：问题：`1513695`）
一个可选的 timeout 参数被添加到 urllib.urlopen() 函数和 urllib.ftpwrapper 类构造函数，以及 urllib2.urlopen() ] 功能。该参数指定以秒为单位的超时。例如：
```
>>> u = urllib2.urlopen("http://slow.example.com",
                        timeout=3)
Traceback (most recent call last):
  ...
urllib2.URLError: <urlopen error timed out>
>>>
```
（由 Facundo Batista 添加。）
unicodedata模块提供的Unicode数据库已更新至5.1.0版本。（由 Martin von Loewis 更新；:issue:`3811`。）
warnings 模块的 formatwarning() 和 showwarning() 获得了一个可选的 line 参数，可用于提供源代码行。（作为 :issue:`1631171` 的一部分添加，它在 C 代码中重新实现了 warnings 模块的一部分。）

一个新函数 catch_warnings() 是一个用于测试目的的上下文管理器，可让您临时修改警告过滤器，然后恢复其原始值 (:issue:`3781`)。
现在可以通过将 False 作为 bind_and_activate 构造函数传递来阻止 XML-RPC SimpleXMLRPCServer 和 DocXMLRPCServer 类立即打开并绑定到它们的套接字范围。这可用于在调用 server_bind() 和 server_activate() 方法打开套接字并开始侦听连接之前修改实例的 allow_reuse_address 属性。（由 Peter Parente 提供；：问题：`1599845`。）

SimpleXMLRPCServer 也有一个 _send_traceback_header 属性；如果为 true，则异常和格式化回溯将作为 HTTP 标头“X-Exception”和“X-Traceback”返回。此功能仅用于调试目的，不应在生产服务器上使用，因为回溯可能会泄露密码或其他敏感信息。（由 Alan McIntyre 提供，作为他 2007 年 Google 代码之夏项目的一部分。）
xmlrpclib 模块不再自动将 datetime.date 和 datetime.time 转换为 xmlrpclib.DateTime 类型；转换语义不一定适用于所有应用程序。使用 xmlrpclib 的代码应该转换 date 和 time 实例。 (:issue:`1330538`) 代码还可以处理 1900 年之前的日期（由 Ralf Schmitt 提供；:issue:`2014`）和使用 [ 表示的 64 位整数X167X] 在 XML-RPC 响应中（由 Riku Lindblad 提供；:issue:`2985`）。
zipfile 模块的 ZipFile 类现在具有 extract() 和 extractall() 方法，可以将单个文件或存档中的所有文件解压到当前目录，或到指定目录：
```
z = zipfile.ZipFile('python-251.zip')

# Unpack a single file, writing it relative
# to the /tmp directory.
z.extract('Python/sysmodule.c', '/tmp')

# Unpack all the files in the archive.
z.extractall()
```
（由 Alan McIntyre 提供；：问题：`467924`。）

open()、read() 和 extract() 方法现在可以采用文件名或 ZipInfo 对象。当存档意外包含重复的文件名时，这很有用。（由 Graham Horler 提供；：问题：`1775025`。）

最后，zipfile 现在支持对归档文件使用 Unicode 文件名。（由 Alexey Borzenkov 提供；:issue:`1734346`。）

ast 模块

ast 模块提供了 Python 代码的抽象语法树表示，Armin Ronacher 贡献了一组执行各种常见任务的辅助函数。这些对于 HTML 模板包、代码分析器和处理 Python 代码的类似工具非常有用。

parse() 函数接受一个表达式并返回一个 AST。 dump() 函数输出一个树的表示，适合调试：

import ast

t = ast.parse("""
d = {}
for i in 'abcdefghijklm':
    d[i + i] = ord(i) - ord('a') + 1
print d
""")
print ast.dump(t)

这将输出一个深度嵌套的树：

Module(body=[
  Assign(targets=[
    Name(id='d', ctx=Store())
   ], value=Dict(keys=[], values=[]))
  For(target=Name(id='i', ctx=Store()),
      iter=Str(s='abcdefghijklm'), body=[
    Assign(targets=[
      Subscript(value=
        Name(id='d', ctx=Load()),
          slice=
          Index(value=
            BinOp(left=Name(id='i', ctx=Load()), op=Add(),
             right=Name(id='i', ctx=Load()))), ctx=Store())
     ], value=
     BinOp(left=
      BinOp(left=
       Call(func=
        Name(id='ord', ctx=Load()), args=[
          Name(id='i', ctx=Load())
         ], keywords=[], starargs=None, kwargs=None),
       op=Sub(), right=Call(func=
        Name(id='ord', ctx=Load()), args=[
          Str(s='a')
         ], keywords=[], starargs=None, kwargs=None)),
       op=Add(), right=Num(n=1)))
    ], orelse=[])
   Print(dest=None, values=[
     Name(id='d', ctx=Load())
   ], nl=True)
 ])

literal_eval() 方法接受一个字符串或一个表示文字表达式的 AST，解析和评估它，并返回结果值。文字表达式是只包含字符串、数字、字典等的 Python 表达式。但没有语句或函数调用。如果您需要计算表达式但不能接受使用 eval() 调用的安全风险，literal_eval() 将安全地处理它：

>>> literal = '("a", "b", {2:4, 3:8, 1:2})'
>>> print ast.literal_eval(literal)
('a', 'b', {1: 2, 2: 4, 3: 8})
>>> print ast.literal_eval('"a" + "b"')
Traceback (most recent call last):
  ...
ValueError: malformed string

该模块还包括用于遍历和修改 AST 的 NodeVisitor 和 NodeTransformer 类，以及用于常见转换（例如更改行号）的函数。

future_builtins 模块

Python 3.0 对内置函数库做了很多改动，大部分改动不能在Python 2.x 系列中引入，因为它们会破坏兼容性。 future_builtins 模块提供了这些内置函数的版本，可以在编写 3.0 兼容代码时导入。

该模块中的功能目前包括：

ascii(obj)：相当于 repr()。在 Python 3.0 中， repr() 将返回一个 Unicode 字符串，而 ascii() 将返回一个纯 ASCII 字节串。
filter(predicate, iterable)、map(func, iterable1, ...)：3.0 版本返回迭代器，与 2.x 内置函数返回列表不同。
hex(value)、oct(value)：这些版本不会调用 __hex__() 或 __oct__() 方法，而是调用 __index__() 方法并将结果转换为十六进制或八进制。 oct() 将使用新的 0o 表示法作为其结果。

json 模块：JavaScript 对象表示法

新的 json 模块支持 Python 类型在 JSON（Javascript Object Notation）中的编码和解码。 JSON 是一种轻量级的交换格式，常用于 Web 应用程序。有关 JSON 的更多信息，请参阅 http://www.json.org。

json 支持对大多数内置 Python 类型进行解码和编码。以下示例对字典进行编码和解码：

>>> import json
>>> data = {"spam": "foo", "parrot": 42}
>>> in_json = json.dumps(data) # Encode the data
>>> in_json
'{"parrot": 42, "spam": "foo"}'
>>> json.loads(in_json) # Decode into a Python object
{"spam": "foo", "parrot": 42}

也可以编写自己的解码器和编码器来支持更多类型。还支持 JSON 字符串的漂亮打印。

json（原名 simplejson）由 Bob Ippolito 编写。

plistlib 模块：属性列表解析器

.plist 格式通常在 Mac OS X 上用于通过将基本数据类型（数字、字符串、列表和字典）序列化为基于 XML 的格式来存储它们。它类似于数据类型的 XML-RPC 序列化。

尽管主要用于 Mac OS X，但该格式与 Mac 无关，并且 Python 实现可在 Python 支持的任何平台上运行，因此 plistlib 模块已升级为标准库。

使用该模块很简单：

import sys
import plistlib
import datetime

# Create data structure
data_struct = dict(lastAccessed=datetime.datetime.now(),
                   version=1,
                   categories=('Personal','Shared','Private'))

# Create string containing XML.
plist_str = plistlib.writePlistToString(data_struct)
new_struct = plistlib.readPlistFromString(plist_str)
print data_struct
print new_struct

# Write data structure to a file and read it back.
plistlib.writePlist(data_struct, '/tmp/customizations.plist')
new_struct = plistlib.readPlist('/tmp/customizations.plist')

# read/writePlist accepts file-like objects as well as paths.
plistlib.writePlist(data_struct, sys.stdout)

ctypes 增强

Thomas Heller 继续维护和增强 ctypes 模块。

ctypes 现在支持表示 C99 bool 类型的 c_bool 数据类型。（由 David Remahl 提供；：问题：`1649190`。）

ctypes 字符串、缓冲区和数组类型改进了对扩展切片语法的支持，其中提供了 (start, stop, step) 的各种组合。（由托马斯·沃特斯实施。）

所有 ctypes 数据类型现在都支持 from_buffer() 和 from_buffer_copy() 方法，这些方法基于提供的缓冲区对象创建 ctypes 实例。 from_buffer_copy() 复制对象的内容，而 from_buffer() 将共享相同的内存区域。

新的调用约定告诉 ctypes 在每次包装调用开始时清除 errno 或 Win32 LastError 变量。（由 Thomas Heller 实施；:issue:`1798`。）

您现在可以在函数调用后检索 Unix errno 变量。创建包装函数时，您可以将 use_errno=True 作为关键字参数提供给 DLL() 函数，然后调用模块级方法 set_errno() 和 get_errno() 以设置和检索错误值。

DLL()、OleDLL() 和 WinDLL() 函数同样支持 Win32 LastError 变量。您提供 use_last_error=True 作为关键字参数，然后调用模块级方法 set_last_error() 和 get_last_error()。

byref() 函数用于检索指向 ctypes 实例的指针，现在有一个可选的 offset 参数，该参数是将添加到返回指针的字节计数。

改进的 SSL 支持

Bill Janssen 通过添加一个新模块 ssl，对 Python 2.6 对安全套接字层的支持进行了大量改进，该模块构建在 OpenSSL 库之上。这个新模块提供了对协商协议、使用的 X.509 证书的更多控制，并更好地支持在 Python 中编写 SSL 服务器（而不是客户端）。 socket 模块中现有的 SSL 支持尚未删除并继续工作，尽管它将在 Python 3.0 中删除。

要使用新模块，您必须首先以通常的方式创建一个 TCP 连接，然后将其传递给 ssl.wrap_socket() 函数。可以指定是否需要证书，并通过调用 getpeercert() 方法获取证书信息。

也可以看看

ssl 模块的文档。

弃用和删除

字符串异常已被删除。尝试使用它们会引发 TypeError。
PEP 352 所规定的对 Exception 界面的更改继续进行。对于 2.6，message 属性被弃用，取而代之的是 args 属性。
（3.0-警告模式）Python 3.0 将具有一个重新组织的标准库，它将删除许多过时的模块并重命名其他模块。以 3.0-warning 模式运行的 Python 2.6 将在导入这些模块时发出警告。

不推荐使用的模块列表是：audiodev、bgenlocations、buildtools、bundlebuilder、Canvas、compiler , dircache, dl, fpformat, gensuitemodule, ihooks, [X202X2X2X28X] ]imgfile、linuxaudiodev、mhlib、mimetools、multifile、new、、 ]、statvfs、sunaudiodev、test.testall 和 toaiff。
gopherlib 模块已被移除。
MimeWriter 模块和 mimify 模块已被弃用；改用 email 包。
md5 模块已被弃用；改用 hashlib 模块。
posixfile 模块已被弃用； fcntl.lockf() 提供更好的锁定。
popen2 模块已被弃用；使用子进程模块。
rgbimg 模块已被移除。
sets 模块已被弃用；最好使用内置的 set 和 frozenset 类型。
sha 模块已被弃用；改用 hashlib 模块。

构建和 C API 更改

Python 构建过程和 C API 的更改包括：

Python 现在必须用 C89 编译器编译（19 年后！）。这意味着 Python 源代码树已经删除了自己的 memmove() 和 strerror() 实现，它们在 C89 标准库中。
Python 2.6 可以使用 Microsoft Visual Studio 2008（9.0 版）构建，这是新的默认编译器。有关构建文件，请参阅 PCbuild 目录。（由克里斯蒂安·海姆斯实施。）
在 Mac OS X 上，Python 2.6 可以编译为 4 路通用构建。 configure 脚本可以采用 --with-universal-archs=[32-bit|64-bit|all] 开关，控制二进制文件是否为 32 位架构（x86、PowerPC）、64 位（x86-64 和 PPC-64）构建，或两者。（罗纳德·奥索伦供稿。）
BerkeleyDB 模块现在有一个 C API 对象，可用作 bsddb.db.api。这个对象可以被其他希望使用 bsddb 模块的 C 扩展用于自己的目的。（邓肯·格里斯比供稿。）
之前在 PEP 3118 部分中描述的新缓冲区接口添加了 PyObject_GetBuffer() 和 PyBuffer_Release()，以及一些其他函数。
Python 对 C stdio 库的使用现在是线程安全的，或者至少与底层库一样是线程安全的。如果一个线程关闭了一个文件对象，而另一个线程正在读取或写入该对象，则会发生一个长期存在的潜在错误。在 2.6 文件对象有一个引用计数，由 PyFile_IncUseCount() 和 PyFile_DecUseCount() 函数操作。除非引用计数为零，否则无法关闭文件对象。在使用 FILE * 指针执行 I/O 操作之前，应在 GIL 仍然保持时调用 PyFile_IncUseCount()，并且应在 GIL 重新启动后立即调用 PyFile_DecUseCount() - 获得。（由 Antoine Pitrou 和 Gregory P. 史密斯。）
在两个不同的线程中同时导入模块不再死锁；它现在将引发 ImportError。一个新的 API 函数 PyImport_ImportModuleNoBlock() 将首先在 sys.modules 中查找模块，然后在获取导入锁后尝试导入它。如果导入锁由另一个线程持有，则会引发 ImportError。（由克里斯蒂安·海姆斯提供。）
几个函数返回有关平台浮点支持的信息。 PyFloat_GetMax() 返回可表示的最大浮点值，PyFloat_GetMin() 返回最小正值。 PyFloat_GetInfo() 从 float.h 文件中返回包含更多信息的对象，例如 "mant_dig"（尾数中的位数）、"epsilon"（最小的1.0 和下一个可表示的最大值之间的差异），以及其他几个。（由 Christian Heimes 提供；：issue:`1534`。）
使用 PyComplex_AsCComplex() 的 C 函数和方法现在将接受具有 __complex__() 方法的参数。特别是，cmath 模块中的函数现在将接受具有此方法的对象。这是 Python 3.0 更改的向后移植。（由 Mark Dickinson 提供；:issue:`1675423`。）
Python 的 C API 现在包括两个用于不区分大小写的字符串比较的函数，PyOS_stricmp(char*, char*) 和 PyOS_strnicmp(char*, char*, Py_ssize_t)。（由 Christian Heimes 提供；:issue:`1635`。）
许多 C 扩展定义了它们自己的小宏，用于在 init* 函数中将整数和字符串添加到模块的字典中。 Python 2.6 最终定义了用于向模块添加值的标准宏，PyModule_AddStringMacro 和 PyModule_AddIntMacro()。（由克里斯蒂安·海姆斯提供。）
一些宏在 3.0 和 2.6 中都被重命名，以更清楚地表明它们是宏，而不是函数。 Py_Size() 变为 Py_SIZE()，Py_Type() 变为 Py_TYPE()，Py_Refcnt() 变为 Py_REFCNT() ]。为了向后兼容，混合大小写宏在 Python 2.6 中仍然可用。（：问题：`1629`）
当在调试版本的 Python 上运行时，Distutils 现在将它构建的 C 扩展放在不同的目录中。（由 Collin Winter 提供；：问题：`1530959`。）
一些基本数据类型，例如整数和字符串，维护可以重用的对象的内部空闲列表。这些空闲列表的数据结构现在遵循命名约定：变量始终命名为 free_list，计数器始终命名为 numfree，并且始终定义宏 Py<typename>_MAXFREELIST。
一个新的 Makefile 目标，“make patchcheck”，为制作补丁准备 Python 源代码树：它修复所有修改过的 .py 文件中的尾随空格，检查文档是否已更改，并报告 Misc/ACKS 和 Misc/NEWS 文件已更新。（由布雷特·坎农提供。）

另一个新目标“make profile-opt”使用 GCC 的配置文件引导优化编译 Python 二进制文件。它在启用分析的情况下编译 Python，运行测试套件以获得一组分析结果，然后使用这些结果进行编译以进行优化。（由格雷戈里 P. 史密斯。）

特定于端口的更改：Windows

已取消对 Windows 95、98、ME 和 NT4 的支持。 Python 2.6 至少需要 Windows 2000 SP4。
Windows 上的新默认编译器是 Visual Studio 2008（版本 9.0）。 Visual Studio 2003（7.1 版）和 2005（8.0 版）的构建目录已移至 PC/ 目录中。新的 PCbuild 目录支持 X64 的交叉编译、调试构建和配置文件引导优化 (PGO)。 PGO 构建比普通构建大约 10% faster。（由 Christian Heimes 在 Amaury Forgeot d'Arc 和 Martin von Loewis 的帮助下提供。）
msvcrt 模块现在支持控制台 I/O API 的普通和宽字符变体。 getwch() 函数读取按键并返回一个 Unicode 值，getwche() 函数也是如此。 putwch() 函数接受一个 Unicode 字符并将其写入控制台。（由克里斯蒂安·海姆斯提供。）
os.path.expandvars() 现在将以“%var%”的形式扩展环境变量，“~user”将扩展到用户的主目录路径。（由 Josiah Carlson 提供；:issue:`957650`。）
socket 模块的 socket 对象现在有一个 ioctl() 方法，它提供了一个到 WSAIoctl() 系统接口的有限接口。
_winreg 模块现在有一个函数 ExpandEnvironmentStrings()，可以在输入字符串中扩展环境变量引用，例如 %NAME%。此模块提供的句柄对象现在支持上下文协议，因此它们可以在 with 语句中使用。（由克里斯蒂安·海姆斯提供。）

_winreg对x64系统也有更好的支持，暴露了DisableReflectionKey()、EnableReflectionKey()和QueryReflectionKey()函数，为32位启用和禁用注册表反射在 64 位系统上运行的进程。（：问题：`1753245`）
msilib 模块的 Record 对象获得了 GetInteger() 和 GetString() 方法，这些方法将字段值作为整数或字符串返回。（由 Floris Bruynooghe 提供；:issue:`2125`。）

特定于端口的更改：Mac OS X

在编译 Python 的框架构建时，您现在可以通过向 configure 脚本提供 --with-framework-name= 选项来指定要使用的框架名称。
macfs 模块已被移除。这反过来又需要删除 macostools.touched() 函数，因为它依赖于 macfs 模块。（：问题：`1490190`）
许多其他 Mac OS 模块已被弃用，并将在 Python 3.0 中删除：_builtinSuites、aepack、aetools、aetypes、 applesingle、appletrawmain、appletrunner、argvemulator、Audio_mac、autoGIL、[X2352X][X235X3X] ]cfmfile、CodeWarrior、ColorPicker、EasyDialogs、Explorer、[X345X]、[X345X]、[X345X]、[X345X] , findertools, ic, icglue, icopen, macerrors, MacOS,MacOS ]、macostools、macresource、MiniAEFrame、Nav、[X5860X]、[X586X]、[X586X] 、pimp、PixMapWrapper、StdSuites、SystemEvents、Terminal和terminalcommand

特定于端口的更改：IRIX

许多旧的 IRIX 特定模块已弃用，并将在 Python 3.0 中删除：al 和 AL、cd、cddb、[ X142X]、CL 和 cl、DEVICE、ERRNO、FILE、[FL]X217 fl、flp、fm、GET、GLWS、GL[X3132X] 、IN、IOCTL、jpeg、panelparser、readcd、SV和X41X 、torgb、视频阅读器和WAIT。

移植到 Python 2.6

本节列出了之前描述的更改和其他可能需要更改代码的错误修复：

不应该是可散列的类应该在其定义中设置 __hash__ = None 以表明事实。
字符串异常已被删除。尝试使用它们会引发 TypeError。
collections.deque 的 __init__() 方法现在会在从可迭代对象添加元素之前清除双端队列的任何现有内容。此更改使行为匹配 list.__init__()。
object.__init__() 以前接受任意参数和关键字参数，忽略它们。在 Python 2.6 中，这不再被允许，将导致 TypeError。这将影响 __init__() 方法，这些方法最终调用 object 上的相应方法（可能通过使用 super()）。参见 :issue:`1683368` 进行讨论。
Decimal 构造函数现在在传递字符串时接受前导和尾随空格。以前它会引发 InvalidOperation 异常。另一方面，Context 对象的 create_decimal() 方法现在明确禁止额外的空格，引发 ConversionSyntax 异常。
由于一个实现事故，如果你将文件路径传递给内置的 __import__() 函数，它实际上会导入指定的文件。然而，这从未打算工作，现在实现明确检查这种情况并引发 ImportError。
C API：PyImport_Import() 和 PyImport_ImportModule() 函数现在默认为绝对导入，而不是相对导入。这将影响导入其他模块的 C 扩展。
C API：不应为可散列的扩展数据类型应将其 tp_hash 槽定义为 PyObject_HashNotImplemented()。
socket 模块异常 socket.error 现在继承自 IOError。以前它不是 StandardError 的子类，但现在是，通过 IOError。（由格雷戈里 P. 史密斯；：问题：`1706815`。）
xmlrpclib 模块不再自动将 datetime.date 和 datetime.time 转换为 xmlrpclib.DateTime 类型；转换语义不一定适用于所有应用程序。使用 xmlrpclib 的代码应该转换 date 和 time 实例。（：问题：`1330538`）
（3.0-警告模式）Exception 类现在在使用切片或索引访问时发出警告；让 Exception 表现得像一个元组正在被淘汰。
（3.0-警告模式）两个字典或两个未实现比较方法的对象之间的不等式比较被报告为警告。 dict1 == dict2 仍然有效，但 dict1 < dict2 正在逐步淘汰。

单元格之间的比较是 Python 范围规则的一个实现细节，也会导致警告，因为在 3.0 中完全禁止这种比较。

致谢

作者要感谢以下人员对本文的各种草稿提供建议、更正和帮助：Georg Brandl、Steve Brown、Nick Coghlan、Ralph Corderoy、Jim Jewett、Kent Johnson、Chris Lambacher、Martin Michlmayr、Antoine Pitrou，布赖恩华纳。

Python 2.6 的新特性 — Python 文档

Python 2.6 中的新功能

蟒蛇 3.0

开发过程的变化

新问题跟踪器：综述

新的文档格式：使用 Sphinx 的 reStructuredText

PEP 343：'with' 语句

编写上下文管理器

上下文库模块

PEP 366：来自主模块的显式相对导入

PEP 370：每用户 site-packages 目录

PEP 371：multiprocessing 包

PEP 3101：高级字符串格式

PEP 3105：print 作为一个函数

PEP 3110：异常处理更改

PEP 3112：字节文字

PEP 3116：新的 I/O 库

PEP 3118：修订缓冲协议

PEP 3119：抽象基类

PEP 3127：整数文字支持和语法

PEP 3129：类装饰器

PEP 3141：数字的类型层次结构

分数 模块

其他语言更改

优化

口译员变化

新的和改进的模块

ast 模块

future_builtins 模块

json 模块：JavaScript 对象表示法

plistlib 模块：属性列表解析器

ctypes 增强

改进的 SSL 支持

弃用和删除

构建和 C API 更改

特定于端口的更改：Windows

特定于端口的更改：Mac OS X

特定于端口的更改：IRIX

移植到 Python 2.6

致谢

分数模块