python 2.6的新功能

作者

A.M.Kuchling（加利福尼亚州AMK的AMK）

本文解释了2008年10月1日发布的python 2.6中的新特性。发布计划在 PEP 361 .

Python2.6的主要主题是准备到Python3.0的迁移路径，这是该语言的一个重大重新设计。只要可能，python 2.6就包含了3.0中的新特性和语法，同时通过不删除旧特性或语法保持与现有代码的兼容性。当无法做到这一点时，python 2.6会尝试尽其所能，在 future_builtins 模块与A -3 切换到警告3.0中不支持的用法。

一些重要的新包已添加到标准库中，例如 multiprocessing 和 json 模块，但并没有多少新功能与Python3.0在某种程度上无关。

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

本文并不试图提供新特性的完整规范，而是提供一个方便的概述。有关完整的详细信息，您应该参考Python2.6的文档。如果您想了解设计和实现的基本原理，请参考PEP了解特定的新特性。只要有可能，“Python的新特性”就会链接到每次更改的bug/patch项。

Python 3

Python2.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派生的一些功能包括：

  • A __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 ，启用有关将在Python3.0中删除的功能的警告。您可以使用此开关运行代码，以查看将代码移植到3.0需要多少工作。这个开关的值对python代码可用作布尔变量。 sys.py3kwarning 和C扩展代码 Py_Py3kWarningFlag .

参见

3xx系列PEP，其中包含了对python 3.0的提议。 PEP 3000 描述了Python3.0的开发过程。从开始 PEP 3100 这描述了Python3.0的一般目标，然后探讨了具有特定特性的编号较高的PEP。

开发过程的变更

在开发2.6的过程中，python的开发过程经历了两个重大的变化：我们从sourceforge的问题跟踪程序切换到了定制的roundup安装程序，并且文档从latex转换为restructuredtext。

新问题跟踪程序：汇总

很长一段时间以来，Python开发人员对SourceForge的bug追踪器越来越恼火。SourceForge的托管解决方案不允许进行太多的定制；例如，无法定制问题的生命周期。

因此，Python软件基金会的基础设施委员会发布了一个发布追踪器的通知，要求志愿者建立不同的产品并从SooCofFoW导入一些bug和补丁。检查了四种不同的跟踪器： Jira _, Launchpad _, Roundup 和 Trac ②委员会最终以两位候选人的身份确定了JIRA和Roundup。JIRA是一种商业产品，它为免费软件项目提供免费的托管实例；Roundup是一个开源项目，需要志愿者管理它，服务器托管它。

在发布了一个志愿者调用之后，在https://bugs.python.org上建立了一个新的Roundup安装。Roundup的一个安装可以承载多个跟踪器，而且这个服务器现在还承载Jython和Python网站的问题跟踪器。将来肯定会有其他用途。在可能的情况下，这个版本的“What's New in python”链接到每个更改的bug/patch项。

python bug tracker的宿主由 Upfront Systems _南非斯泰伦博世。Martin von L_wis花了大量精力从sourceforge导入现有的bug和补丁；他的导入操作脚本位于http://svn.python.org/view/tracker/importer/，对于希望从sourceforge迁移到roundup的其他项目可能很有用。

参见

https://bugs.python.org

python bug跟踪程序。

http://bugs.jython.org:

Jython Bug跟踪器。

http://roundup.sourceforge.net/

汇总下载和文档。

http://svn.python.org/view/tracker/importer/

马丁·冯·路易斯的转换脚本。

新文档格式：使用sphinx重新构造文本

自1989年项目开始以来，python文档是使用 Latex 编写的。在20世纪80年代和90年代初，大多数文档都是打印出来供以后研究，而不是在线查看。LaTex被广泛使用，因为它提供了吸引人的打印输出，而一旦学习了标记的基本规则，它就可以直接编写。

如今，LaTex仍被用于编写要打印的出版物，但编程工具的前景已经发生了变化。我们不再打印成堆的文档，而是在线浏览，HTML已经成为最重要的支持格式。不幸的是，将LaTex转换为HTML相当复杂，而长期使用的Python文档编辑器Fred L.Drake Jr花费了大量时间来维护转换过程。有时，人们会建议将文档转换为SGML和以后的XML，但是执行一个好的转换是一项主要任务，并且从来没有人承诺完成该任务所需的时间。

在2.6开发周期中，GeorgBrandl花了大量精力构建一个新的工具链来处理文档。生成的包称为sphinx，可从http://sphinx doc.org/获取。

Sphinx专注于HTML输出，生成风格迷人的现代HTML；通过转换为LaTex，仍然支持打印输出。输入格式是restructuredtext，这是一种标记语法，支持Python社区中常用的自定义扩展和指令。

Sphinx是一个独立的软件包，可以用于写作，以及其他二十多个项目。 (listed on the Sphinx web site _）采用Sphinx作为他们的文档工具。

参见

Documenting Python

描述如何编写Python文档。

Sphinx

Sphinx工具链的文档和代码。

Docutils

基础的RestructedText分析器和工具集。

PEP 343：“with”声明

上一个版本python 2.5添加了 'with' 语句作为可选功能，由 from __future__ import with_statement 指令。在2.6中，语句不再需要特别启用；这意味着 with 现在始终是关键字。此部分的其余部分是“What's New in python 2.5”文档中相应部分的副本；如果您熟悉 'with' 使用python 2.5中的语句，您可以跳过这一节。

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

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

with expression [as variable]:
    with-block

对表达式进行了计算，它应生成支持上下文管理协议的对象（即， __enter__() 和 __exit__() 方法）。

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

执行后 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
    ...

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

这个 localcontext() 功能在 decimal 模块使保存和恢复当前十进制上下文变得容易，后者封装了计算所需的精度和舍入特征：

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 和 追溯 都是 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 为false，因此将自动重新引发异常。如果您愿意，可以更明确地添加 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模块

这个 contextlib 模块提供了一些函数和一个修饰器，在编写用于 'with' 语句的对象时很有用。

装饰器被称为 contextmanager() ，并允许编写单个生成器函数，而不是定义新类。生成器应只生成一个值。代码到 yield 将作为 __enter__() 方法，生成的值将是方法的返回值，该值将绑定到 'with' 语句中的变量 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显示为a'生成的代码 'with' 语句，这有助于了解语句的工作方式。

文件 contextlib 模块。

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

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

python 2.6的修复程序增加了 __package__ 属性到模块。当该属性存在时，相对导入将相对于该属性的值而不是 __name__ 属性。

然后可以设置PEP 302样式的导入程序 __package__ 必要时。这个 runpy 实现 -m switch现在可以这样做，所以相对导入现在可以在从包内部运行的脚本中正常工作。

PEP 370：每个用户 site-packages 号码簿

运行python时，模块搜索路径 sys.path 通常包括路径以 "site-packages" . 此目录用于保存所有使用计算机或特定站点安装的用户可用的本地安装的包。

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

  • Unix和Mac OS X： ~/.local/

  • Windows： %APPDATA%/Python

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

如果您不类似于默认目录，它可以被环境变量覆盖。 PYTHONUSERBASE 设置用于支持此功能的所有Python版本的根目录。在Windows上，可以通过设置 APPDATA 环境变量。您还可以修改 site.py 用于安装python的文件。

通过使用 -s 选项或设置 PYTHONNOUSERSITE 环境变量。

参见

PEP 370 -每个用户 site-packages 号码簿

由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

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

另外两个类， Pool 和 Manager 提供更高级的接口。 Pool 将创建固定数量的工作进程，然后可以通过调用 apply() 或 apply_async() 添加单个请求，以及 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 1
11 39916800
21 51090942171709440000
31 8222838654177922817725562880000000
41 33452526613163807108170062053440751665152000000000
51 15511187532873822802242430164693032110632597200169861120000...

参见

文件 multiprocessing 模块。

PEP 371 -添加多处理包

由Jesse Noller和Richard Oudkerk编写的PEP；由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                      '

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

性格

效果

<（默认）

左对齐

>

右对齐

^

中心

=

(仅用于数字类型）在符号后加上pad。

格式说明符还可以包括表示类型，该类型控制值的格式。例如，浮点数可以格式化为普通数字或指数符号：

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

提供多种演示类型。参考2.6文件 complete list ；以下是示例：

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。由Eric Smith实施。

PEP 3105： print 作为一个函数

这个 print 语句变为 print() python 3.0中的函数。制作 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。

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:
    ...

Python3.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() 名单上的

主要用途 bytes 在2.6中，将编写对象类型的测试，如 isinstance(x, bytes) . 这将有助于2to3转换器，它无法判断2.x代码是否希望字符串包含字符或8位字节；现在可以使用 bytes 或 str 为了准确地表示您的意图，在Python3.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位字符串类型，称为 PyStringObject 在python 2.x中，到 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；由克里斯蒂安·海姆斯倒转到2.6。

PEP 3116：新的I/O库

Python的内置文件对象支持许多方法，但类似文件的对象不一定支持所有方法。模拟文件的对象通常支持 read() 和 write() 但是他们可能不支持 readline() 例如。python 3.0在 io 将缓冲和文本处理功能与基本读写操作分开的模块。

由提供的抽象基类有三个级别 io 模块：

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

    python 3.0对于文件和套接字有这个类的具体实现，但是python 2.6没有以这种方式重新构造其文件和套接字对象。

  • BufferedIOBase 是一个抽象基类，用于缓冲内存中的数据以减少使用的系统调用数，从而提高I/O处理效率。它支持 RawIOBase 并添加了 raw 包含基础原始对象的属性。

    实施这个ABC有五个具体的类。 BufferedWriter 和 BufferedReader 用于支持只读或只读用法的对象 seek() 随机访问的方法。 BufferedRandom 对象支持对同一基础流的读写访问，以及 BufferedRWPair 用于诸如tty之类的对象，这些对象同时对未连接的数据流执行读操作和写操作。这个 BytesIO 类支持对内存缓冲区的读、写和查找。

  • TextIOBase ：提供读取和写入字符串的函数（记住，字符串在python 3.0中为unicode），并支持 universal newlines . 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。代码由吉多·范·罗森、乔治·布兰德、沃尔特·多瓦尔德、杰里米·希尔顿、马丁·冯·卢维斯、托尼·洛恩斯和其他人编写。

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) 指示外部调用程序已完成。

这个 flags 参数 PyObject_GetBuffer() 指定对返回的内存的约束。例如：

  • PyBUF_WRITABLE 指示内存必须可写。

  • PyBUF_LOCK 请求对内存进行只读或独占锁定。

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

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

参见

PEP 3118 -修改缓冲协议

由特拉维斯·奥列芬特和卡尔·班克斯撰写的PEP计划；由特拉维斯·奥列芬特实施。

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() ，由 MutableMapping 抽象基类

您可以从特定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有一个很强的duck类型传统，在这里不进行显式类型检查，代码只调用对象上的方法，相信这些方法会存在，如果不存在，就会引发异常。明智地检查abc，并且只在绝对必要的地方进行。

您可以使用 abc.ABCMeta 作为类定义中的元类：

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 -介绍抽象基类

吉多·范·罗森和塔林写的PEP。由Guido van Rossum实施。本杰明·阿兰古伦和亚历克斯·马泰利将比分调到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() builtin仍然返回以前导零为前缀的数字，并返回一个新的 bin() builtin返回数字的二进制表示形式：

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

这个 int() 和 long() 当请求base-8或base-2或 base 参数为零（表示所用的基应根据字符串确定）：：

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

参见

PEP 3127 -整型文字支持和语法

由帕特里克·莫平撰写的PEP；由埃里克·史密斯转载到2.6。

PEP 3129：课堂装饰师

装饰器已从函数扩展到类。现在可以合法地写：

@foo
@bar
class A:
  pass

这相当于：

class A:
  pass

A = foo(bar(A))

参见

PEP 3129 -类装饰器

科林·温特写的PEP。

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

python 3.0为受方案的numeric tower启发的numeric类型添加了几个抽象基类。这些类被反向移植到2.6作为 numbers 模块。

最一般的ABC是 Number .它根本不定义任何操作，只允许通过执行以下操作来检查对象是否为数字 isinstance(obj, Number) .

Complex 是的子类 Number . 复数可以进行加法、减法、乘法、除法和求幂的基本运算，并且可以检索实部和虚部并获得一个数的共轭。python的内置复杂类型是 Complex .

Real 进一步衍生自 Complex ，并添加只对实数有效的操作： floor() ， trunc() ，四舍五入，取余数mod n、向下取整数和比较。

Rational 数字来源于 Real 有 numerator 和 denominator 属性，并且可以转换为浮动。python 2.6添加了一个简单的有理数类， Fraction ，在 fractions 模块。（它叫 Fraction 而不是 Rational 避免名称与 numbers.Rational ）

Integral 数字来源于 Rational ，可以左右移动 << 和 >> ，结合使用位操作，如 & 和 | ，并且可以用作数组索引和切片边界。

在Python3.0中，PEP稍微重新定义了现有的内置 round() ， math.floor() ， math.ceil() 并添加了一个新的， math.trunc() ，这已被返回到python 2.6。 math.trunc() 向零取整，返回最近的 Integral 在函数的参数和零之间。

参见

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

杰弗里·亚斯金写的PEP。

Scheme's numerical tower ，来自帮派手册。

Scheme's number datatypes 来自R5RS方案规范。

这个 fractions 模块

要填写数字类型的层次结构，请 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 模块是基于一个由SjoerdMullender在Python中实现的 Demo/classes/ 长时间的目录。Jeffrey Yasskin对该实施进行了重大更新。

其他语言更改

对核心python语言所做的一些较小的更改是：

  • 包含 __main__.py 现在可以通过将文件名传递给解释器来直接执行文件。目录或zip存档文件将自动作为sys.path中的第一个条目插入。（安迪朱的建议和初始补丁，随后由菲利普·J·埃比和尼克·科格伦修订； bpo-1739468 ）

  • 这个 hasattr() 函数捕获并忽略所有错误，前提是它们意味着 __getattr__() 方法失败，返回值为 hasattr() 因此 False . 这种逻辑不应该应用于 KeyboardInterrupt 和 SystemExit 但是，当 hasattr() 遇到他们。（由本杰明·彼得森修订； bpo-2196 ）

  • 当使用 ** 语法为提供关键字参数，不再需要使用python字典；现在可以使用任何映射：：

    >>> def f(**kw):
...    print sorted(kw)
...
>>> ud=UserDict.UserDict()
>>> ud['a'] = 1
>>> ud['b'] = 'string'
>>> f(**ud)
['a', 'b']

    (由亚历山大·伯罗波尔斯基提供； bpo-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 Forgot d'Arc出资； bpo-3473 ）

  • 一个新的内建帐户， next(iterator, [default]) 从指定的迭代器返回下一项。如果 default 提供了参数，如果 迭代器 已经耗尽；否则 StopIteration 将引发异常。（回传） bpo-2719 ）

  • 元组现在有 index() 和 count() 与列表类型匹配的方法 index() 和 count() 方法：：

    >>> t = (0,1,2,3,4,0,1,2)
>>> t.index(3)
3
>>> t.count(0)
2

    (Raymond Hettinger提供）

  • 内置类型现在已经改进了对扩展切片语法的支持，接受了 (start, stop, step) . 以前，支持是部分的，某些角落的案例不起作用。（由Thomas Wouters实施。）

  • 属性现在有三个属性， 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

  • 内置集合类型的几种方法现在可以接受多个iterables： intersection() ， intersection_update() ， union() ， update() ， difference() 和 difference_update() .

    >>> s=set('1234567890')
>>> s.intersection('abc123', 'cdf246')  # Intersection between all inputs
set(['2'])
>>> s.difference('246', '789')
set(['1', '0', '3', '5'])

    (Raymond Hettinger提供。）

  • 添加了许多浮点特性。这个 float() 函数现在将转动字符串 nan 输入IEEE 754而不是数字值，以及 +inf 和 -inf 变为正无穷大或负无穷大。这可以在任何具有IEEE754语义的平台上工作。（由Christian Heimes提供； bpo-1635 ）

    中的其他功能 math 模块， isinf() 和 isnan() ，如果其浮点参数为无穷大或不是数字，则返回true。 (bpo-1640 ）

    增加了转换函数，将浮点数转换为十六进制字符串。 (bpo-3008 ）这些函数将浮点数转换为字符串表示形式或从字符串表示形式转换为浮点数，而不会从十进制和二进制之间的转换中引入舍入错误。花车有一个 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.Dickinson确定； bpo-1507 ）

  • 继承的类 __hash__() 父类的方法不能设置 __hash__ = None 以指示类不可hash。这将使 hash(obj) 举起一个 TypeError 并且该类不会被表示为实现 Hashable 抽象基类

    当您定义了 __cmp__() 或 __eq__() 方法，按对象的值而不是按标识比较对象。所有对象都有一个默认的hash方法，该方法使用 id(obj) 作为hash值。没有整洁的方法来移除 __hash__() 方法继承自父类，因此 None 作为重写实现。在C级别，可以设置扩展 tp_hash 到 PyObject_HashNotImplemented() . （由尼克·科格伦和阿玛利·弗吉特·达奇修复； bpo-2235 ）

  • 这个 GeneratorExit exception now子类 BaseException 而不是 Exception . 这意味着一个异常处理程序 except Exception: 不会无意中抓住 GeneratorExit . （Chad Austin提供； bpo-1537 ）

  • 生成器对象现在具有 gi_code 引用支持生成器的原始代码对象的属性。（由科林·温特提供； bpo-1473257 ）

  • 这个 compile() 内置函数现在接受关键字参数和位置参数。（由托马斯·沃特斯提供； bpo-1444529 ）

  • 这个 complex() 构造函数现在接受包含带括号复数的字符串，这意味着 complex(repr(cplx)) 现在将是往返值。例如， complex('(3+4j)') 现在返回值（3+4J）。 (bpo-1491866 ）

  • 弦 translate() 方法现在接受 None 作为翻译表参数，这被视为身份转换。这使得只删除字符的操作更容易执行。（由Bengt Richter提供并由Raymond Hettinger实施； bpo-1193128 ）

  • 内置的 dir() 函数现在检查 __dir__() 方法。此方法必须返回包含对象有效属性名称的字符串列表，并允许对象控制 dir() 生产。具有 __getattr__() 或 __getattribute__() 方法可以使用它来公布它们将遵守的伪属性。 (bpo-1591665 ）

  • 实例方法对象具有对象的新属性和包含该方法的函数；新的同义词 im_self 是 __self__ 和 im_func 也可作为 __func__ . 在python 2.6中仍然支持旧名称，但在3.0中不支持。

  • 一个模糊的变化：当你使用 locals() 函数内部 class 语句，结果字典不再返回自由变量。（在这种情况下，自由变量是 class 不是类属性的语句。）

优化

  • 这个 warnings 模块已在C语言中重写。这使得从解析器调用警告成为可能，也可能使解释器的启动更快。（Neal Norwitz和Brett Cannon提供； bpo-1631171 ）

  • 类型对象现在有一个方法缓存，可以减少为特定类找到正确方法实现所需的工作量；一旦缓存，解释器就不需要遍历基类来找出要调用的正确方法。如果修改了基类或类本身，则会清除缓存，因此即使面对Python的动态特性，缓存也应该保持正确。（最初的优化由Armin Rigo实现，由Kevin Jacobs为python 2.6更新； bpo-1700288 ）

    默认情况下，此更改仅应用于包含在Python核心中的类型。扩展模块可能不一定与此缓存兼容，因此它们必须显式添加 Py_TPFLAGS_HAVE_VERSION_TAG 模块的 tp_flags 字段以启用方法缓存。（为了与方法缓存兼容，扩展模块的代码不能直接访问和修改 tp_dict 它实现的任何类型的成员。大多数模块不这样做，但Python解释器不可能确定这一点。见 bpo-1878 进行讨论。）

  • 使用关键字参数的函数调用通过执行快速指针比较显著更快，通常可以节省完整字符串比较的时间。（由Raymond Hettinger在Antoine Pitrou初步实施后提供； bpo-1819 ）

  • 中的所有功能 struct 由于在速度冲刺方面的工作，模块已经被改写为C语言。（Raymond Hettinger提供。）

  • 一些标准的内置类型现在在其类型对象中设置了一点。这样可以加快检查对象是否是这些类型的子类的速度。（尼尔·诺维茨供稿）

  • Unicode字符串现在使用更快的代码检测空格和换行符；这将加快 split() 方法约为25%，并且 splitlines() 到35%点。（由Antoine Pitrou提供。）通过对unicode字符串的数据使用pymalloc，可以减少内存使用。

  • 这个 with 语句现在存储 __exit__() 方法在堆栈上，生成一个小的加速。（由Jeffrey Yasskin实施。）

  • 为了减少内存使用，垃圾收集器现在将在垃圾收集最高一代对象时清除内部可用列表。这可能会更快地将内存返回到操作系统。

解释程序更改

保留了两个命令行选项供其他Python实现使用。这个 -J 开关已被Jython保留用于Jython特定的选项，例如传递给底层JVM的开关。 -X 已为特定于特定的Python实现（如cpython、jython或ironpython）的选项保留。如果其中一个选项与python 2.6一起使用，解释器将报告该选项当前未使用。

现在可以阻止python写入 .pyc 或 .pyo 通过提供 -B 切换到python解释器，或通过设置 PYTHONDONTWRITEBYTECODE 运行解释器之前的环境变量。此设置对python程序可用，作为 sys.dont_write_bytecode 变量和python代码可以更改该值以修改解释器的行为。（Neal Norwitz和Georg Brandl提供。）

用于标准输入、输出和标准错误的编码可以通过设置 PYTHONIOENCODING 运行解释器之前的环境变量。值应为窗体中的字符串 <encoding> 或 <encoding>:<errorhandler> . 这个 encoding 部分指定编码的名称，例如 utf-8 或 latin-1 可选的 错误处理程序 部分指定如何处理不能由编码处理的字符，应为“错误”、“忽略”或“替换”之一。（马丁·冯·L·威斯供稿）

新模块和改进模块

与每个版本一样，Python的标准库也收到了一些增强和错误修复。下面是最显著变化的部分列表，按模块名称的字母顺序排列。查阅 Misc/NEWS 在源代码树中查找更完整的更改列表，或者查看子版本日志以获取所有详细信息。

  • 这个 asyncore 和 asynchat 模块再次得到积极维护，并应用了许多补丁和错误修复。（由约西亚·卡尔森维护；见 bpo-1736190 一个补丁。

  • 这个 bsddb 模块还有一个新的维护人员jes_s cea avi_n，该包现在作为独立包提供。包的网页是 www.jcea.es/programacion/pybsddb.htm ②计划是从Python3.0的标准库中删除包，因为它的发布速度比Python的要频繁得多。

    这个 bsddb.dbshelve 模块现在使用可用的最高酸洗协议，而不是将自身限制为协议1。（W.Barnes供稿）

  • 这个 cgi 模块现在将从HTTP POST请求的查询字符串中读取变量。这样就可以对包含查询字符串的URL使用表单操作，如“/cgi bin/add.py”？类别＝1”。（Alexandre Fiori和Nubis提供； bpo-1817 ）

    这个 parse_qs() 和 parse_qsl() 功能已从 cgi 模块到 urlparse 模块。版本仍在 cgi 模块将触发 PendingDeprecationWarning 2.6中的信息 (bpo-600362 ）

  • 这个 cmath 模块经过了广泛的修改，由马克·狄金森和克里斯蒂安·海姆斯贡献。增加了五个新功能：

    • polar() 将复数转换为极坐标形式，返回复数的模和参数。

    • rect() 做相反的事情，将模、参数对转换回相应的复数。

    • phase() 返回复数的参数（也称为角度）。

    • isnan() 如果参数的实部或虚部是NaN，则返回true。

    • isinf() 如果参数的实部或虚部为无穷大，则返回“真”。

    修订版还提高了 cmath 模块。对于所有函数，只要可能，结果的实部和虚部都精确到最小精度（ulps）的几个单位内。见 bpo-1381 有关详细信息。树枝剪成 asinh() ， atanh() 还有 atan() 也得到了纠正。

    该模块的测试得到了极大的扩展，近2000个新的测试用例使用了代数函数。

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

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

    >>> 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 领域。

    (Raymond Hettinger提供。）

  • 另一个变化是 collections 模块是指 deque 类型现在支持可选 麦克伦 参数；如果提供，deque的大小将限制为不超过 麦克伦 项目。添加更多的项目到一个完整的deque会导致旧项目被丢弃。

    >>> 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)

    (Raymond Hettinger提供。）

  • 这个 Cookie 模块的 Morsel 对象现在支持 httponly 属性。在某些浏览器中。javascript代码无法访问或操作具有此属性集的cookie。（由Arvin Schnell提供； bpo-1638033 ）

  • 中的新窗口方法 curses 模块， chgat() ，更改单行上特定数量字符的显示属性。（由Fabian Kreutz提供。）

    # Boldface text starting at y=0,x=21
# and affecting the rest of the line.
stdscr.chgat(0, 21, curses.A_BOLD)

    这个 Textbox 类中 curses.textpad 模块现在支持在插入模式和覆盖模式下进行编辑。插入模式是通过为 insert_mode 创建时的参数 Textbox 实例。

  • 这个 datetime 模块的 strftime() 方法现在支持 %f 格式化扩展到对象中微秒数的代码，在左侧零填充到六个位置。（由Skip Montanaro提供； bpo-1158 ）

  • 这个 decimal 模块已更新为版本1.66 the General Decimal Specification ②新特性包括一些基本数学函数的方法，例如 exp() 和 log10() ：：

    >>> Decimal(1).exp()
Decimal("2.718281828459045235360287471")
>>> Decimal("2.7182818").ln()
Decimal("0.9999999895305022877376682436")
>>> Decimal(1000).log10()
Decimal("3")

    这个 as_tuple() 方法 Decimal 对象现在返回一个命名的元组 sign ， digits 和 exponent 领域。

    （由Facando Batista和Mark Dickinson实施。Raymond Hettinger添加了命名的tuple支持。）

  • 这个 difflib 模块的 SequenceMatcher 类现在返回表示匹配项的命名元组， a ， b 和 size 属性。（Raymond Hettinger提供。）

  • 可选的 timeout 参数（指定以秒为单位的超时）已添加到 ftplib.FTP 类构造函数以及 connect() 方法。（由法坎多·巴蒂斯塔添加）同时， FTP 类的 storbinary() 和 storlines() 现在选择一个选项 回调 在发送数据后将与每个数据块一起调用的参数。（由Phil Schwartz提供； bpo-1221598 ）

  • 这个 reduce() 内置功能也可在 functools 模块。在python 3.0中，内置函数已被删除，并且 reduce() 只能从 functools ；目前还没有在2.x系列中删除内置项的计划。（由Christian Heimes修补； bpo-1739906 ）

  • 如果可能的话， getpass 模块现在将使用 /dev/tty 打印提示信息并读取密码，返回标准错误和标准输入。如果密码可以回送到终端，则会在显示提示之前打印警告。（格雷戈里·史密斯供稿）

  • 这个 glob.glob() 如果使用了Unicode路径并且目录中的Unicode文件名匹配，则函数现在可以返回Unicode文件名。 (bpo-1001604 ）

  • 中的新函数 heapq 模块， merge(iter1, iter2, ...) ，获取按排序顺序返回数据的任意数量的iterables，并返回一个新的生成器，该生成器也按排序顺序返回所有迭代器的内容。例如：：

    >>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16]))
[1, 2, 3, 5, 8, 9, 16]

    另一个新功能， heappushpop(heap, item) 推 item 到上面 heap ，然后弹出并返回最小的项。这比调用给 heappush() 然后 heappop() .

    heapq 现在实现为只使用小于比较，而不是以前使用的小于或等于比较。这使得 heapq 的类型用法与 list.sort() 方法。（Raymond Hettinger提供。）

  • 可选的 timeout 参数（指定以秒为单位的超时）已添加到 httplib.HTTPConnection 和 HTTPSConnection 类构造函数。（由Facando Batista添加。）

  • 大部分的 inspect 模块的功能，例如 getmoduleinfo() 和 getargs() ，现在返回命名的元组。除了表现得像元组，还可以将返回值的元素作为属性访问。（Raymond Hettinger提供。）

    模块中的一些新功能包括 isgenerator() ， isgeneratorfunction() 和 isabstract() .

  • 这个 itertools 模块获得了几个新功能。

    izip_longest(iter1, iter2, ...[, fillvalue]) 从每个元素生成元组；如果某些iterables短于其他元素，则将缺少的值设置为 填充值 . 例如：：

    >>> 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]) 返回提供的iterables的笛卡尔积，这是一组元组，包含从每个iterable返回的元素的每个可能组合。：：

    >>> 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)]

    可选的 重复 关键字参数用于获取iterable或iterables集的乘积，重复 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)]

    有两个iTerables， 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) 返回长度的子序列 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 未指定，它将默认为iterable生成的元素数。：：

    >>> 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) 获取一个应返回其他iterable的iterable。 chain() 然后返回第一个iterable的所有元素，然后返回第二个iterable的所有元素，依此类推。：：

    >>> list(itertools.chain.from_iterable([[1,2,3], [4,5,6]]))
[1, 2, 3, 4, 5, 6]

    (均由Raymond Hettinger提供。）

  • 这个 logging 模块的 FileHandler 类及其子类 WatchedFileHandler ， RotatingFileHandler 和 TimedRotatingFileHandler 现在有一个可选的 延迟 其构造函数的参数。如果 延迟 为true，日志文件的打开将延迟到第一个 emit() 调用来。（由Vinay Sajip提供。）

    TimedRotatingFileHandler 也有 utc 构造函数参数。如果参数为真，则将使用UTC时间确定午夜发生的时间并生成文件名；否则将使用本地时间。

  • 几个新功能被添加到 math 模块：

    • isinf() 和 isnan() 分别确定给定的浮点是（正或负）无穷大还是NaN（非数字）。

    • copysign() 复制IEEE 754数字的符号位，返回 x 与符号位组合 y . 例如， math.copysign(1, -0.0) 返回- 1。（由Christian Heimes提供。）

    • factorial() 计算一个数的阶乘。（由Raymond Hettinger提供； bpo-2138 ）

    • fsum() 把一个不可数的数列相加，并小心避免使用部分和而损失精度。（由Jean Brouwers、Raymond Hettinger和Mark Dickinson撰稿； bpo-2819 ）

    • acosh() ， asinh() 和 atanh() 计算反双曲函数。

    • log1p() 返回的自然对数 1+x （基地） e ）

    • trunc() 向零舍入一个数字，返回最接近的 Integral 在函数的参数和零之间。添加为的后端口的一部分 PEP 3141's type hierarchy for numbers _.

  • 这个 math 模块经过了改进，以便在平台间提供更一致的行为，特别是在处理浮点异常和IEEE754特殊值方面。

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

    (由Christian Heimes和Mark Dickinson提供。）

  • 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'

    （在格雷戈里·彼得罗西恩的建议下，由乔治·布兰德提供。）

    这个 attrgetter() 函数现在接受点名称并执行相应的属性查找：

    >>> inst_name = operator.attrgetter(
...        '__class__.__name__')
>>> inst_name('')
'str'
>>> inst_name(help)
'_Helper'

    (在巴里·华沙的建议下，由乔治·布兰德提供。）

  • 这个 os 模块现在封装了几个新的系统调用。 fchmod(fd, mode) 和 fchown(fd, uid, gid) 更改打开文件的模式和所有权，以及 lchmod(path, mode) 更改符号链接的模式。（由乔治·布兰德和克里斯蒂安·海姆斯撰稿）

    chflags() 和 lchflags() 是对应系统调用的封装器（如果它们可用），更改文件上设置的标志。标志值的常量在 stat 模块；一些可能的值包括 UF_IMMUTABLE 以表示文件不可更改，并且 UF_APPEND 以指示数据只能追加到文件中。（莱文森先生供稿）

    os.closerange(low, high) 有效地关闭来自的所有文件描述符 low 到 high ，忽略任何错误，不包括 high 本身。此函数现在由 subprocess 使启动过程更快的模块。（由乔治布兰德尔提供； bpo-1663329 ）

  • 这个 os.environ 对象的 clear() 方法现在将使用 os.unsetenv() 除了清除对象的键之外。（马丁·霍奇卡供稿； bpo-1181 ）

  • 这个 os.walk() 函数现在有一个 followlinks 参数。如果设置为true，它将遵循指向目录的符号链接并访问目录的内容。为了向后兼容，参数的默认值为false。注意，如果有一个符号链接指向父目录，那么函数可能会陷入无限递归。 (bpo-1273829 ）

  • 在 os.path 模块 splitext() 函数已更改为不拆分前导句点字符。这在操作Unix的点文件时会产生更好的结果。例如， os.path.splitext('.ipython') 现在回报 ('.ipython', '') 而不是 ('', '.ipython') . (bpo-1115886 ）

    新功能， os.path.relpath(path, start='.') ，返回 start 路径（如果已提供），或从当前工作目录到目标 path . （由Richard Barran提供； bpo-1339796 ）

    在Windows上， os.path.expandvars() 现在将展开以“%var%”形式给出的环境变量，并且“~user”将展开到用户的主目录路径中。（由约西亚·卡尔森出资； bpo-957650 ）

  • 由提供的python调试器 pdb 模块获得了一个新命令：“run”重新启动正在调试的python程序，并可以选择为该程序获取新的命令行参数。（由洛基·伯恩斯坦撰稿； bpo-1393667 ）

  • 这个 pdb.post_mortem() 函数，用于开始调试跟踪，现在将使用返回的跟踪 sys.exc_info() 如果没有提供回溯。（由法坎多·巴蒂斯塔提供； bpo-1106316 ）

  • 这个 pickletools 模块现在有一个 optimize() 函数，它获取包含pickle的字符串并删除一些未使用的操作码，返回包含相同数据结构的较短pickle。（Raymond Hettinger提供。）

  • A get_data() 函数已添加到 pkgutil 返回已安装的python包中包含的资源文件内容的模块。例如：：

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

    (由保罗·摩尔提供； bpo-2439 ）

  • 这个 pyexpat 模块的 Parser 对象现在允许设置 buffer_size 属性更改用于保存字符数据的缓冲区的大小。（由阿奇姆·盖德克提供； bpo-1137 ）

  • 这个 Queue 模块现在提供了以不同顺序检索条目的队列变量。这个 PriorityQueue 类将排队的项存储在堆中并按优先级检索它们，以及 LifoQueue 首先检索最近添加的条目，这意味着它的行为类似于堆栈。（Raymond Hettinger提供。）

  • 这个 random 模块的 Random 对象现在可以在32位系统上进行pickle处理，也可以在64位系统上取消pickle处理，反之亦然。不幸的是，这种变化也意味着python 2.6的 Random 不能在早期版本的python上正确地取消对象绑定。（肖恩·利戈基供稿； bpo-1727780 ）

    新的 triangular(low, high, mode) 函数返回三角形分布后的随机数。返回值介于 low 和 high ，不包括 high 自身，以及 mode 作为分布中最常见的值。（由瓦伦佩尔·范德兰和雷蒙德·赫廷格撰稿； bpo-1681432 ）

  • 执行的长正则表达式搜索 re 模块将检查正在传送的信号，因此现在可以中断耗时的搜索。（乔希·霍伊特和拉尔夫·施密特撰稿； bpo-846388 ）

    正则表达式模块是通过为一个小型regex特定的虚拟机编译字节码来实现的。不受信任的代码可能直接创建字节码的恶意字符串并导致崩溃，因此python 2.6包含了regex字节码的验证器。（由Guido van Rossum在谷歌应用引擎工作时提供； bpo-3487 ）

  • 这个 rlcompleter 模块的 Completer.complete() 方法现在将忽略在评估名称时触发的异常。（由洛伦兹·嘎克固定； bpo-2250 ）

  • 这个 sched 模块的 scheduler 实例现在具有只读 queue 返回调度程序队列内容的属性，表示为带有字段的命名元组列表 (time, priority, action, argument) .（由Raymond Hettinger提供； bpo-1861 ）

  • 这个 select 模块现在有了Linux的封装函数 epoll() 和BSD kqueue() 系统调用。 modify() 方法已添加到现有的 poll 物体； pollobj.modify(fd, eventmask) 获取文件描述符或文件对象和事件掩码，修改该文件的记录事件掩码。（由Christian Heimes提供； bpo-1657 ）

  • 这个 shutil.copytree() 函数现在有一个可选的 忽视 接受可调用对象的参数。此可调用文件将接收每个目录路径和目录内容列表，并返回将被忽略而不是复制的名称列表。

    这个 shutil 模块还提供 ignore_patterns() 用于此新参数的函数。 ignore_patterns() 获取任意数量的glob样式模式并返回一个可调用文件，该文件和目录将忽略任何匹配这些模式的文件和目录。下面的示例复制目录树，但跳过两个目录树 .svn 目录和Emacs备份文件，其名称以“~”结尾：

    shutil.copytree('Doc/library', '/tmp/library',
                ignore=shutil.ignore_patterns('*~', '.svn'))

    (由Tarek Ziad_出资； bpo-2663 ）

  • 将信号处理与GUI处理事件循环（如Tkinter或GTK+使用的事件循环）集成一直是一个问题；大多数软件以轮询结束，每过一秒就唤醒一次以检查是否发生了任何GUI事件。这个 signal 模块现在可以提高效率。调用 signal.set_wakeup_fd(fd) 设置要使用的文件描述符；当接收到信号时，将向该文件描述符写入一个字节。还有一个C级函数， PySignal_SetWakeupFd() ，用于设置描述符。

    事件循环将通过打开管道来创建两个描述符，一个用于读取，另一个用于写入。可写描述符将传递到 set_wakeup_fd() ，可读取的描述符将通过 select() 或 poll() . 接收到信号后，将写入一个字节，并唤醒主事件循环，从而避免了轮询的需要。

    (由亚当·奥尔森提供； bpo-1583 ）

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

    这个 setitimer() 和 getitimer() 还添加了功能（在可用的地方）。 setitimer() 允许设置间隔计时器，该计时器将导致在指定时间（以墙时钟时间、消耗的进程时间或组合进程+系统时间度量）后将信号发送到进程。（由Guilherme Polo出资； bpo-2240 ）

  • 这个 smtplib 由于增加了 SMTP_SSL 类。此类支持与现有接口相同的接口 SMTP 类。（由Monty Taylor提供）两个类构造函数都有一个可选的 timeout 指定初始连接尝试超时的参数，以秒为单位。（法坎多·巴蒂斯塔供稿）

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

    SMTP.starttls() 现在遵守 RFC 3207 并且忘记了从服务器获取的任何知识，这些知识不是从TLS协商本身获得的。（补丁由比尔·芬纳提供； bpo-829951 ）

  • 这个 socket 模块现在支持tipc（http://tipc.sourceforge.net/），这是一种为在集群环境中使用而设计的高性能非基于IP的协议。TIPC地址是4或5个元组。（由Alberto Bertogli提供； bpo-1646 ）

    新功能， create_connection() ，获取一个地址并使用可选的超时值连接到该地址，返回连接的socket对象。此函数还查找地址的类型，并根据需要使用IPv4或IPv6连接到该地址。更改代码以使用 create_connection() 而不是 socket(socket.AF_INET, ...) 可能是使您的代码与IPv6一起工作所需的全部。

  • 中的基类 SocketServer 模块现在支持调用 handle_timeout() 在服务器的 timeout 属性。（迈克尔·庞拉宁供稿） serve_forever() 方法现在采用以秒为单位的可选轮询间隔，控制服务器检查关闭请求的频率。（由Pedro Wernick和Jeffrey Yasskin提供； bpo-742598 ， bpo-1193577 ）

  • 这个 sqlite3 由Gerhard H_ring维护的模块已从Python 2.5中的2.3.2版更新到2.4.1版。

  • 这个 struct 模块现在支持C99 _Bool 键入，使用格式字符 '?' . （大卫·雷马尔供稿）

  • 这个 Popen 由提供的对象 subprocess 模块现在有 terminate() ， kill() 和 send_signal() 方法。在Windows上， send_signal() 只支持 SIGTERM 信号，所有这些方法都是win32 api函数的别名 TerminateProcess() .（由Christian Heimes提供。）

  • 中的新变量 sys 模块， float_info ，是一个包含从 float.h 关于平台的浮点支持的文件。此对象的属性包括 mant_dig （尾数的位数） epsilon （1.0和下一个可表示的最大值之间的最小差异）以及其他几个值。（由Christian Heimes提供； bpo-1534 ）

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

    有关提供给python解释器的命令行参数的信息可以通过读取指定元组的属性来获得，这些属性可用为 sys.flags . 例如， verbose 如果在详细模式下执行python，则属性为true， debug 在调试模式等中为真。这些属性都是只读的。（由Christian Heimes提供。）

    新功能， getsizeof() ，获取一个python对象并返回该对象使用的内存量（以字节为单位）。内置对象返回正确的结果；第三方扩展可能不会，但可以定义 __sizeof__() 方法返回对象的大小。（由Robert Schuppenies提供； bpo-2898 ）

    现在可以通过调用 sys.getprofile() 和 sys.gettrace() . （由乔治布兰德尔提供； bpo-1648 ）

  • 这个 tarfile 除了已经支持的posix.1-1988（ustar）和gnu tar格式外，模块现在还支持posix.1-2001（pax）tar文件。默认格式为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() 以及递归添加目录中的文件名。

    (所有变化都是由拉尔斯·古斯特·贝尔促成的）。

  • 可选的 timeout 参数已添加到 telnetlib.Telnet 类构造函数，指定以秒为单位的超时。（由Facando Batista添加。）

  • 这个 tempfile.NamedTemporaryFile 类通常删除它在关闭文件时创建的临时文件。这种行为现在可以通过传球来改变 delete=False 给建设者。（由Damien Miller提供； bpo-1537850 ）

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

    这个 NamedTemporaryFile 和 SpooledTemporaryFile 类都作为上下文管理器工作，因此您可以编写 with tempfile.NamedTemporaryFile() as tmp: ... . （由亚历山大·伯罗波尔斯基提供； bpo-2021 ）

  • 这个 test.test_support 模块获得了许多对编写测试有用的上下文管理器。 EnvironmentVarGuard() 是一个上下文管理器，它临时更改环境变量并自动将其还原为旧值。

    另一个上下文管理器， TransientResource ，可以环绕对可能可用或不可用资源的调用；它将捕获并忽略指定的异常列表。例如，当连接到外部网站时，网络测试可能忽略某些故障：

    with test_support.TransientResource(IOError,
                                errno=errno.ETIMEDOUT):
    f = urllib.urlopen('https://sf.net')
    ...

    最后， check_warnings() 重置 warning 模块的警告筛选并返回一个对象，该对象将记录所有触发的警告消息 (bpo-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.
>>>

    (由德韦恩·贝利提供； bpo-1581073 ）

  • 这个 threading 正在将模块API更改为使用属性，例如 daemon 而不是 setDaemon() 和 isDaemon() 方法和某些方法已重命名为使用下划线而不是camel大小写；例如， activeCount() 方法被重命名为 active_count() . 模块的2.6和3.0版本都支持相同的属性和重命名方法，但不删除旧方法。没有为python 3.x中旧API的取消定义设置日期；在任何2.x版本中都不会删除旧API。（由几个人执行，最著名的是本杰明·彼得森。）

    这个 threading 模块的 Thread 对象获得 ident 返回线程标识符（非零整数）的属性。（由Gregory P.Smith提供； bpo-2871 ）

  • 这个 timeit 模块现在接受可调用文件以及正在计时的语句和设置代码的字符串。为创建 Timer 实例： repeat(stmt, setup, time, repeat, number) 和 timeit(stmt, setup, time, number) 创建一个实例并调用相应的方法。（由埃里克·德马因提供； bpo-1533909 ）

  • 这个 Tkinter 模块现在接受列表和元组作为选项，在将结果值传递给tcl/tk之前，用空格分隔元素。（由Guilherme Polo出资； bpo-2906 ）

  • 这个 turtle GregorLingl大大增强了turtle图形模块。模块中的新功能包括：

    • 更好的动画turtle移动和旋转。

    • 使用新的 delay() ， tracer() 和 speed() 方法。

    • 为turtle设置新形状和定义新坐标系的能力。

    • turtle现在有了 undo() 可以回滚操作的方法。

    • 对输入事件（如鼠标和键盘活动）作出反应的简单支持，使编写简单游戏成为可能。

    • A turtle.cfg 文件可用于自定义turtle屏幕的起始外观。

    • 模块的docstrings可以被翻译成另一种语言的新docstrings替换。

    (bpo-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>
>>>

    (由Facando Batista添加。）

  • 由提供的Unicode数据库 unicodedata 模块已更新为5.1.0版。（由Martin von L_wis更新； bpo-3811 ）

  • 这个 warnings 模块的 formatwarning() 和 showwarning() 获得了一个可选的 line 可用于提供源代码行的参数。（添加为 bpo-1631171 重新实现了 warnings C代码中的模块。）

    新功能， catch_warnings() ，是一个用于测试的上下文管理器，它允许您临时修改警告筛选器，然后还原其原始值。 (bpo-3781 ）

  • XML- RPC SimpleXMLRPCServer 和 DocXMLRPCServer 现在可以通过传递来防止类立即打开并绑定到它们的套接字 False 作为 bind_and_activate 构造函数参数。这可用于修改实例的 allow_reuse_address 属性，然后调用 server_bind() 和 server_activate() 方法打开套接字并开始侦听连接。（由彼得·帕伦特提供； bpo-1599845 ）

    SimpleXMLRPCServer 也有 _send_traceback_header 属性；如果为true，则异常和格式化的回溯将作为HTTP头“x-exception”和“x-traceback”返回。此功能仅用于调试，不应在生产服务器上使用，因为跟踪可能会显示密码或其他敏感信息。（Alan McIntyre为谷歌2007年夏天的代码项目提供了帮助。）

  • 这个 xmlrpclib 模块不再自动转换 datetime.date 和 datetime.time 到 xmlrpclib.DateTime 类型；转换语义不一定对所有应用程序都正确。代码使用 xmlrpclib 应该转换 date 和 time 实例。 (bpo-1330538 ）该代码还可以处理1900年之前的日期（由Ralf Schmitt提供； bpo-2014 ）和64位整数，用 <i8> 在XML-RPC响应中（由Riku Lindblad提供； bpo-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提供； bpo-467924 ）

    这个 open() ， read() 和 extract() 方法现在可以采用文件名或 ZipInfo 对象。当存档文件意外包含重复的文件名时，这很有用。（由格雷厄姆·霍勒提供； bpo-1775025 ）

    最后， zipfile 现在支持对存档文件使用Unicode文件名。（Alexey Borzenkov提供； bpo-1734346 ）

这个 ast 模块

这个 ast 模块提供了Python代码的抽象语法树表示，ArminRonacher贡献了一组帮助函数，用于执行各种常见任务。这些对于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

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

这个 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 模块支持在JSON（javascript对象表示法）中对python类型进行编码和解码。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 格式通常在MacOSX上使用，通过将基本数据类型（数字、字符串、列表和字典）序列化为基于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增强

托马斯·海勒继续保持和加强 ctypes 模块。

ctypes 现在支持 c_bool 表示c99的数据类型 bool 类型。（大卫·雷马尔供稿； bpo-1649190 ）

这个 ctypes 字符串、缓冲区和数组类型改进了对扩展切片语法的支持，其中 (start, stop, step) 供应。（由Thomas Wouters实施。）

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

一个新的调用约定告诉我们 ctypes 清除 errno 或在每次封装调用开始时使用win32 lasterror变量。（由托马斯·海勒实施； bpo-1798 ）

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

Win32 LastError变量同样受 DLL() ， OleDLL() 和 WinDLL() 功能。你提供 use_last_error=True 作为关键字参数，然后调用模块级方法 set_last_error() 和 get_last_error() .

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

改进的SSL支持

Bill Janssen通过添加一个新模块，对python 2.6对安全套接字层的支持进行了广泛的改进， ssl 那是建在 OpenSSL 类库。这个新模块对协商的协议、使用的X.509证书提供了更多的控制，并且对用Python编写SSL服务器（而不是客户机）有更好的支持。中的现有SSL支持 socket 模块还没有被移除并继续工作，尽管它将在python 3.0中被移除。

要使用新模块，必须首先以常规方式创建TCP连接，然后将其传递给 ssl.wrap_socket() 功能。可以指定是否需要证书，并通过调用 getpeercert() 方法。

参见

文件 ssl 模块。

弃用和删除

  • 字符串异常已被删除。尝试使用它们会引发 TypeError .

  • 改变到 Exception 接口由 PEP 352 继续制造。2.6， message 属性正在被弃用，取而代之的是 args 属性。

  • （3.0警告模式）python 3.0将提供一个重新组织的标准库，它将删除许多过时的模块并重命名其他模块。以3.0警告模式运行的python 2.6在导入这些模块时会发出警告。

    不推荐使用的模块列表为： audiodev ， bgenlocations ， buildtools ， bundlebuilder ， Canvas ， compiler ， dircache ， dl ， fpformat ， gensuitemodule ， ihooks ， imageop ， imgfile ， linuxaudiodev ， mhlib ， mimetools ， multifile ， new ， pure ， statvfs ， sunaudiodev ， test.testall 和 toaiff .

  • 这个 gopherlib 模块已移除。

  • 这个 MimeWriter 模块和 mimify 模块已被弃用；请使用 email 改为打包。

  • 这个 md5 模块已被弃用；请使用 hashlib 模块代替。

  • 这个 posixfile 模块已被弃用； fcntl.lockf() 提供更好的锁定。

  • 这个 popen2 模块已被弃用；请使用 subprocess 模块。

  • 这个 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 生成文件的目录。（由Christian Heimes实施）

  • 在MacOSX上，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 模块用于自身目的。（邓肯·格里斯比供稿）

  • 新的缓冲区接口，前面在 the PEP 3118 section 增加 PyObject_GetBuffer() 和 PyBuffer_Release() 以及一些其他功能。

  • python对c stdio库的使用现在是线程安全的，或者至少和底层库一样是线程安全的。如果一个线程关闭了一个文件对象，而另一个线程正在读取或写入该对象，则会发生一个长期存在的潜在错误。在2.6中，文件对象具有引用计数，由 PyFile_IncUseCount() 和 PyFile_DecUseCount() 功能。除非引用计数为零，否则无法关闭文件对象。 PyFile_IncUseCount() 在使用 FILE * 指针，以及 PyFile_DecUseCount() 应在重新获得GIL后立即调用。（安托万·皮特鲁和格雷戈里·P·史密斯撰稿）

  • 在两个不同的线程中同时导入模块不再死锁；它现在将引发 ImportError . 一个新的API函数， PyImport_ImportModuleNoBlock() ，将在中查找模块 sys.modules 首先，在获取导入锁后尝试导入它。如果导入锁由另一个线程持有，则 ImportError 被引发。（由Christian Heimes提供。）

  • 几个函数返回关于平台浮点支持的信息。 PyFloat_GetMax() 返回可表示的最大浮点值，以及 PyFloat_GetMin() 返回最小正值。 PyFloat_GetInfo() 返回一个对象，该对象包含来自 float.h 文件，如 "mant_dig" （尾数的位数） "epsilon" （1.0和下一个可表示的最大值之间的最小差异）以及其他几个值。（由Christian Heimes提供； bpo-1534 ）

  • c使用的函数和方法 PyComplex_AsCComplex() 现在将接受具有 __complex__() 方法。尤其是 cmath 模块现在将使用此方法接受对象。这是Python3.0变更的一个后端口。（马克·狄金森撰稿； bpo-1675423 ）

  • python的c api现在包含两个用于不区分大小写字符串比较的函数， PyOS_stricmp(char*, char*) 和 PyOS_strnicmp(char*, char*, Py_ssize_t) . （由Christian Heimes提供； bpo-1635 ）

  • 许多C扩展定义了自己的小宏，用于将整数和字符串添加到模块的字典中。 init* 功能。python 2.6最终定义了向模块添加值的标准宏， PyModule_AddStringMacro 和 PyModule_AddIntMacro() . （由Christian Heimes提供。）

  • 一些宏在3.0和2.6中都被重新命名，以便更清楚地表明它们是宏，而不是函数。 Py_Size() 成为 Py_SIZE() ， Py_Type() 成为 Py_TYPE() 和 Py_Refcnt() 成为 Py_REFCNT() . 混合大小写宏在python 2.6中仍然可以向后兼容。 (bpo-1629 ）

  • distutils现在在调试版本的python上运行时，将它构建的C扩展放在不同的目录中。（由科林·温特提供； bpo-1530959 ）

  • 一些基本数据类型，如整数和字符串，维护可以重用的对象的内部自由列表。这些自由列表的数据结构现在遵循一个命名约定：变量总是命名的 free_list ，计数器始终命名为 numfree 和宏 Py<typename>_MAXFREELIST 总是被定义的。

  • 一个新的makefile目标“make patchcheck”，准备好python源代码树来创建补丁：它修复所有修改后的空白。 .py 文件，检查文档是否已更改，并报告 Misc/ACKS 和 Misc/NEWS 文件已更新。（布雷特·坎农供稿）

    另一个新目标“make profile opt”使用gcc的profile-guided优化编译了一个python二进制文件。它在启用分析的情况下编译python，运行测试套件以获得一组分析结果，然后使用这些结果进行编译以进行优化。（格雷戈里·史密斯供稿）

端口特定更改：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%。（克里斯汀·海姆斯在阿玛利·福杰特·德阿尔克和马丁·冯·路易威斯的帮助下做出了贡献。）

  • 这个 msvcrt 模块现在支持控制台I/O API的普通和宽字符变体。这个 getwch() 函数读取按键并返回Unicode值，就像 getwche() 功能。这个 putwch() 函数接受一个Unicode字符并将其写入控制台。（由Christian Heimes提供。）

  • os.path.expandvars() 现在将以“%var%”的形式展开环境变量，并且“~user”将展开到用户的主目录路径中。（由约西亚·卡尔森出资； bpo-957650 ）

  • 这个 socket 模块的套接字对象现在具有 ioctl() 提供有限接口的方法 WSAIoctl() 系统接口。

  • 这个 _winreg 模块现在有一个功能， ExpandEnvironmentStrings() ，扩展环境变量引用，例如 %NAME% 在输入字符串中。这个模块提供的句柄对象现在支持上下文协议，因此可以在 with 声明。（由Christian Heimes提供。）

    _winreg 对X64系统也有更好的支持，公开了 DisableReflectionKey() ， EnableReflectionKey() 和 QueryReflectionKey() 函数，用于启用和禁用在64位系统上运行的32位进程的注册表反射。 (bpo-1753245 ）

  • 这个 msilib 模块的 Record 获得的对象 GetInteger() 和 GetString() 以整数或字符串形式返回字段值的方法。（由Floris Bruynooghe提供； bpo-2125 ）

端口特定更改：Mac OS X

  • 在编译python的框架构建时，现在可以通过提供 --with-framework-name= 选择权 configure 脚本。

  • 这个 macfs 模块已移除。这反过来要求 macostools.touched() 要删除的函数，因为它依赖于 macfs 模块。 (bpo-1490190 ）

  • 许多其他Mac OS模块已被弃用，将在python 3.0中删除： _builtinSuites ， aepack ， aetools ， aetypes ， applesingle ， appletrawmain ， appletrunner ， argvemulator ， Audio_mac ， autoGIL ， Carbon ， cfmfile ， CodeWarrior ， ColorPicker ， EasyDialogs ， Explorer ， Finder ， FrameWork ， findertools ， ic ， icglue ， icopen ， macerrors ， MacOS ， macfs ， macostools ， macresource ， MiniAEFrame ， Nav ， Netscape ， OSATerminology ， pimp ， PixMapWrapper ， StdSuites ， SystemEvents ， Terminal 和 terminalcommand .

端口特定更改：IRIX

一些旧的IRIX特定模块已被弃用，将在python 3.0中删除： al 和 AL ， cd ， cddb ， cdplayer ， CL 和 cl ， DEVICE ， ERRNO ， FILE ， FL 和 fl ， flp ， fm ， GET ， GLWS ， GL 和 gl ， IN ， IOCTL ， jpeg ， panelparser ， readcd ， SV 和 sv ， torgb ， videoreader 和 WAIT .

移植到python 2.6

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

  • 不应该是hash的类应该设置 __hash__ = None 在他们的定义中指明事实。

  • 字符串异常已被删除。尝试使用它们会引发 TypeError .

  • 这个 __init__() 方法 collections.deque 现在，在从iterable添加元素之前，清除deque的任何现有内容。此更改使行为匹配 list.__init__() .

  • object.__init__() 以前接受的任意参数和关键字参数，忽略它们。在Python2.6中，不再允许这样做，这将导致 TypeError . 这将影响 __init__() 最后调用相应方法的方法 object （可能通过使用 super() ）见 bpo-1683368 供讨论。

  • 这个 Decimal 当传递字符串时，构造函数现在接受前导空格和尾随空格。以前它会提高 InvalidOperation 例外。另一方面， create_decimal() 方法 Context 对象现在显式地不允许额外的空白，从而提高 ConversionSyntax 例外。

  • 由于实现意外，如果您将文件路径传递给内置的 __import__() 函数，它将实际导入指定的文件。然而，这从未打算起作用，而现在的实现显式地检查了这个案例，并提出了一个 ImportError .

  • C API： PyImport_Import() 和 PyImport_ImportModule() 函数现在默认为绝对导入，而不是相对导入。这将影响导入其他模块的C扩展。

  • C API:不应为hash的扩展数据类型应定义其 tp_hash 槽到 PyObject_HashNotImplemented() .

  • 这个 socket 模块异常 socket.error 现在继承自 IOError . 以前它不是 StandardError 但现在，通过 IOError . （由Gregory P.Smith实施； bpo-1706815 ）

  • 这个 xmlrpclib 模块不再自动转换 datetime.date 和 datetime.time 到 xmlrpclib.DateTime 类型；转换语义不一定对所有应用程序都正确。代码使用 xmlrpclib 应该转换 date 和 time 实例。 (bpo-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 Michlmayer、Antoine Pitrou、Brian Warner。