Python 2.6 的新增Function

  • Author

    • 上午。库奇林(amk 在 amk.ca)

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

Python 2.6 的主要主题是准备向 Python 3.0 的迁移路径,这是对该语言的重大重新设计。只要有可能,Python 2.6 就从 3.0 引入新Function和语法,同时pass不删除旧Function或语法保持与现有代码的兼容性。当不可能做到这一点时,Python 2.6 会try做它能做的事情,在future_builtins模块和-3开关中添加兼容性Function,以警告 3.0 中将不再支持的用法。

标准库中已经添加了一些重要的新程序包,例如multiprocessingjson模块,但是并没有很多与 Python 3.0 无关的新Function。

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

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

Python 3.0

Python 2.6 和 3.0 版本的开发周期已同步,两个版本的 alpha 和 beta 版本在同一天发布。 3.0 的 Developing 影响了 2.6 中的许多Function。

Python 3.0 是 Python 的广泛重新设计,破坏了与 2.x 系列的兼容性。这意味着现有的 Python 代码需要进行一些转换才能在 Python 3.0 上运行。但是,并非 3.0 中的所有更改都必然会破坏兼容性。如果新Function不会导致现有代码break,则将它们反向移植到 2.6,并在本文档的适当位置进行了描述。 3.0 派生的一些Function包括:

  • 一种将对象转换为复数的complex()方法。

  • 捕获异常的备用语法:except TypeError as exc

  • 添加了functools.reduce()作为内置reduce()函数的同义词。

Python 3.0 添加了一些新的内置函数,并更改了一些现有内置函数的语义。 3.0 中新增的Function,例如bin(),已简单地添加到 Python 2.6 中,但是现有的内置函数没有更改;而是future_builtins模块具有带有新 3.0 语义的版本。编写为与 3.0 兼容的代码可以根据需要from future_builtins import hex, map

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

See also

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

对开发流程的更改

在开发 2.6 时,Python 的开发过程发生了两个重大变化:我们从 SourceForge 的问题跟踪程序切换到自定义的 Roundup 安装,文档从 LaTeX 转换为 reStructuredText。

新问题跟踪:汇总

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

因此,Python 软件基金会的基础结构委员会发布了一个问题跟踪器的电话,要求志愿者设置不同的产品并从 SourceForge 导入一些错误和补丁。检查了四个不同的跟踪器:JiraLaunchpadRoundupTrac。该委员会finally选择了 Jira 和 Roundup 作为两名候选人。 Jira 是一种商业产品,可为免费软件项目提供免费的托管实例。综述是一个开源项目,需要志愿者来 Management 它,并需要一个服务器来托管它。

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

南非 Stellenbosch 的Upfront Systems友好地托管 Python 错误跟踪器。 Martin von Loewis 投入了大量精力来从 SourceForge 导入现有的错误和补丁。他用于此导入操作的脚本位于http://svn.python.org/view/tracker/importer/,对于希望从 SourceForge 转到 Roundup 的其他项目可能有用。

See also

新文档格式:使用 Sphinx 的 reStructuredText

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

时至今日,LaTeX 仍用于编写要印刷的出版物,但编程工具的前景已发生变化。我们不再打印大量文件;取而代之的是,我们在线浏览它,而 HTML 已成为支持的最重要格式。不幸的是,将 LaTeX 转换为 HTML 相当复杂,并且长期的 Python 文档编辑器 Fred L. Drake Jr.花了很多时间来维护转换过程。有时人们会建议将文档转换为 SGML 和更高版本的 XML,但是执行良好的转换是一项主要任务,而且没人会花时间完成这项工作。

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

Sphinx 专注于 HTML 输出,生成样式精美的现代 HTML。pass转换为 LaTeX,仍支持打印输出。Importing 格式为 reStructuredText,这是一种标记语法,支持 Python 社区中常用的自定义 extensions 和指令。

Sphinx 是一个独立的程序包,可用于编写代码,几乎还有其他十二个项目(在狮身人面像网站上列出)已将 Sphinx 用作其文档工具。

See also

  • Documenting Python

  • 描述如何编写 Python 文档。

  • Sphinx

  • Sphinx 工具链的文档和代码。

  • Docutils

  • 基础的 reStructuredText 解析器和工具集。

PEP 343:“ with”语句

先前的版本 Python 2.5 新增了with语句作为可选Function,可passfrom __future__ import with_statement指令启用。在 2.6 中,不再需要专门启用该语句;这意味着with现在始终是关键字。本节的其余部分是“ Python 2.5 的新增Function”文档中相应部分的副本;如果您熟悉 Python 2.5 中的'with'语句,则可以跳过本节。

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

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

with expression [as variable]:
    with-block

对表达式进行求值,它应产生一个支持上下文 Management 协议的对象(即具有enter()exit()方法)。

对象的enter()在* with-block 执行之前被调用,因此可以运行设置代码。如果给定,它也可能返回绑定到名称 variable 的值。 (请注意, variable 不是 expression *的结果.)

  • with-block *执行完成后,即使该块引发异常,该对象的exit()方法也会被调用,因此可以运行清除代码。

现在,一些标准的 Python 对象支持上下文 Management 协议,并且可以与'with'语句一起使用。文件对象是一个示例:

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

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

Note

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

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

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

该锁在执行该块之前获取,并在该块完成后始终释放。

decimal模块中的localcontext()函数使保存和恢复当前的十进制上下文变得容易,它封装了计算所需的精度和舍入 Feature:

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

编写上下文 Management 器

在幕后,“ with”语句相当复杂。大多数人只会在与现有对象配合使用时使用“ with”,并且不需要知道这些详细信息,因此您可以根据需要跳过本节的其余部分。新对象的作者将需要了解底层实现的详细信息,并应 continue 阅读。

上下文 Management 协议的高级解释是:

  • 该表达式将被求值,并应产生一个称为“上下文 Management 器”的对象。上下文 Management 器必须具有enter()exit()方法。

  • 上下文 Management 器的enter()方法被调用。返回的值分配给* VAR *。如果不存在as VAR子句,则仅丢弃该值。

    • BLOCK *中的代码被执行。
  • 如果* BLOCK *引发异常,则使用三个参数调用上下文 Management 器的exit()方法,即异常详细信息(type, value, traceback,由sys.exc_info()返回的相同值,如果没有发生异常,则也可以为None)。该方法的返回值控制是否重新引发异常:任何假值都会引发异常,并且True将导致抑制它。您只会很少希望抑制该异常,因为如果您这样做,包含'with'语句的代码的作者将永远不会意识到任何错误。

  • 如果* BLOCK 没有引发异常,则仍会调用exit()方法,但 type value traceback *均为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()方法最复杂,因为它是大多数工作要做的地方。该方法必须检查是否发生异常。如果没有异常,则提交事务。如果存在异常,则事务将回滚。

在下面的代码中,执行将在函数末尾结束,并返回默认值NoneNone为假,因此将自动重新引发异常。如果需要,可以更加明确,并在标记的位置添加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模块提供了一些Function和装饰器,这些Function和装饰器在编写与'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, ...)函数,该函数结合了许多上下文 Management 器,因此您无需编写嵌套的'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)

See also

  • PEP 343-“ with”语句

  • 由 Guido van Rossum 和 Nick Coghlan 撰写的 PEP;由 Mike Bland,Guido van Rossum 和 Neal Norwitz 实施。 PEP 显示为“ with”语句生成的代码,这有助于了解该语句的工作方式。

contextlib模块的文档。

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

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

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

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

PEP 370:每位用户网站程序包目录

当您运行 Python 时,模块搜索路径sys.path通常包括目录,其路径以"site-packages"结尾。该目录用于保存使用计算机或特定站点安装的所有用户可用的本地安装软件包。

Python 2.6 引入了针对特定于用户的站点目录的约定。该目录因平台而异:

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

  • Windows:%APPDATA%/Python

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

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

可以pass使用-s选项运行 Python 或设置 PYTHONNOUSERSITE环境变量来完全禁用该Function。

See also

  • PEP 370-每个用户site-packages目录

  • PEP 由 Christian Heimes 编写和实施。

PEP 371:multiprocessing 程序包

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

multiprocessing模块最初是使用进程而不是线程对threading模块的精确仿真。该目标在 Python 2.6 的开发过程中被抛弃了,但是该模块的通用方法仍然相似。基本类是Process,该类传递了可调用对象和参数集合。 start()方法设置子进程中正在运行的可调用对象,之后您可以调用is_alive()方法以检查子进程是否仍在运行,而join()方法则 await 该进程退出。

这是一个简单的示例,其中子流程将计算阶乘。进行计算的函数的编写方式很奇怪,因此当 Importing 参数为 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,所以 parent 和孩子都可以使用该对象进行通信。 (如果父级更改全局变量的值,则子级的值将不受影响,反之亦然.)

PoolManager两个其他类提供了更高级别的接口。 Pool将创建固定数量的工作进程,然后可以pass调用apply()apply_async()添加单个请求,并passmap()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 数据结构的主副本。然后其他进程可以使用代理对象访问和修改这些数据结构。下面的示例pass调用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...

See also

multiprocessing模块的文档。

  • PEP 371-添加 multiprocessing 程序包

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

弯括号可以pass加倍来逃脱:

>>> "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作为关键字来查找值。以数字开头的字符串将转换为整数。您不能在格式字符串内编写更复杂的表达式。

到目前为止,我们已经展示了如何指定要替换为结果字符串的字段。也可以pass添加冒号和格式说明符来控制使用的精确格式。例如:

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

格式说明符可以pass嵌套引用其他字段:

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

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

CharacterEffect
< (default)Left-align
>Right-align
^Center
=(仅适用于数字类型)在符号后加空格。

格式说明符还可以包括表示类型,该类型控制值的格式。例如,浮点数可以格式化为通用数或指数表示法:

>>> '{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十六进制格式。以小写字母输出 9 以上的数字,以 16 为基数输出数字。
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'

See also

PEP 3105:按Function打印

print语句在 Python 3.0 中成为print()函数。使print()为函数可以pass执行def print(...)或从其他位置导入新函数来替换该函数。

Python 2.6 具有__future__导入,可删除print作为语言语法,从而使您可以使用Function形式。例如:

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

新Function的签名是:

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

参数为:

Note

    • args *:位置参数,其值将被打印出来。
    • sep *:分隔符,将在参数之间打印。
    • end *:结束文本,将在输出所有参数后打印。
    • file *:输出将被发送到的文件对象。

See also

  • PEP 3105-使打印Function

  • PEP 由 Georg Brandl 撰写。

PEP 3110:异常处理更改

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

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

作者可能正在try同时捕获TypeErrorValueError异常,但是此代码实际上做了一些不同:它将捕获TypeError并将结果异常对象绑定到本地名称"ValueError"。根本不会捕获ValueError异常。正确的代码指定了一个异常 Tuples:

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

发生此错误的原因是此处的逗号含糊不清:它是否表示解析树中的两个不同节点,或表示一个 Tuples 的单个节点?

Python 3.0 pass用逗号“ as”替换逗号来使这一点明确。要捕获异常并将异常对象存储在变量exc中,必须编写:

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

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

See also

  • PEP 3110-Python 3000 中的捕获异常

  • PEP 由 Collin Winter 编写和实施。

PEP 3112:字节 Literals

Python 3.0 采用 Unicode 作为语言的基本字符串类型,并以b'string'或使用bytes构造函数表示 8 位 Literals。为了将来的兼容性,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 字节字符串。

2.6 中bytes的主要用途是编写对象类型(例如isinstance(x, bytes))的测试。这将有助于 2to3 转换器,后者无法分辨 2.x 代码是否打算将字符串包含字符或 8 位字节。您现在可以使用bytesstr准确表示您的意图,并且在 Python 3.0 中生成的代码也将正确。

还有一个__future__导入,使所有字符串 Literals 变为 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()和其他各种Function。

See also

  • PEP 3112-Python 3000 中的字节字面量

  • 由 Jason Orendorff 撰写的 PEP;由 Christian Heimes 反向移植到 2.6.

PEP 3116:新的 I/O 库

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

io模块提供了三个级别的抽象 Base Class:

  • RawIOBase定义原始 I/O 操作:read()readinto()write()seek()tell()truncate()close()。此类的大多数方法通常都将 Map 到单个系统调用。还有readable()writable()seekable()方法来确定给定对象将允许的操作。

Python 3.0 为文件和套接字提供了此类的具体实现,但 Python 2.6 并未以这种方式重组其文件和套接字对象。

  • BufferedIOBase是抽象 Base Class,它在内存中缓冲数据以减少使用的系统调用次数,从而使 I/O 处理更加有效。它支持RawIOBase的所有方法,并添加了一个raw属性,该属性包含基础原始对象。

有五个实现此 ABC 的具体类。 BufferedWriterBufferedReader用于支持仅写或只读用法且具有seek()方法用于随机访问的对象。 BufferedRandom对象支持对同一基础流的读写访问,而BufferedRWPair适用于 TTY 之类的对象,它们具有对未连接的数据流起作用的读写操作。 BytesIO类支持在内存缓冲区中进行读取,写入和查找。

  • TextIOBase:提供用于读取和写入字符串的Function(请记住,在 Python 3.0 中字符串将是 Unicode),并支持universal newlinesTextIOBase定义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 实现的工作量。

See also

  • 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 类型可以将指针交换到其内部表示中。例如,可以将内存 Map 文件视为字符的缓冲区,这使诸如re之类的另一个模块将内存 Map 文件视为要搜索的字符串。

缓冲协议的主要用户是数字处理程序包(例如 NumPy),该程序包公开了数组的内部表示形式,以便调用者可以将数据直接写入数组中,而不必pass较慢的 API。该 PEP 根据 NumPy 开发的经验更新了缓冲区协议,并添加了许多新Function,例如指示阵列的形状或锁定存储区域。

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

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

Note

  • PyBUF_WRITABLE表示内存必须可写。

  • PyBUF_LOCK请求对内存进行只读或互斥锁定。

  • PyBUF_C_CONTIGUOUSPyBUF_F_CONTIGUOUS请求 C 连续(最后一个维度变化最快)或 Fortran 连续(第一个维度变化最快)阵列布局。

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

See also

  • PEP 3118-修改缓冲区协议

  • 由 Travis Oliphant 和 Carl Banks 撰写的 PEP;由 Travis Oliphant 实施。

PEP 3119:抽象 Base Class

一些面向对象的语言(例如 Java)支持接口,它们语句类具有给定的方法集或支持给定的访问协议。抽象 Base Class(或 ABC)是 Python 的等效Function。 ABC 支持包括一个abc模块,该模块包含一个称为ABCMeta的元类,由isinstance()issubclass()内置函数对该元类进行特殊处理,以及一组 Python 开发人员认为将广泛使用的基本 ABC。Future 的 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 派生自己的类,以表明它们支持 ABC 的界面:

import collections

class Storage(collections.MutableMapping):
    ...

另外,您可以编写类而不衍生所需的 ABC,而是pass调用 ABC 的register()方法来注册该类:

import collections

class Storage:
    ...

collections.MutableMapping.register(Storage)

对于您编写的类,从 ABC 派生可能更清晰。当您编写了一个可以描述现有类型或类的新 ABC 时,或者要语句某个第三方类实现了 ABC 时,register()方法很有用。例如,如果您定义了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 将为未定义方法的类引发异常。请注意,仅当您实际上try创建缺少该方法的子类的实例时,才会引发该异常:

>>> 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()属性。

See also

  • PEP 3119-介绍抽象 Base Class

  • 由 Guido van Rossum 和 Talin 撰写的 PEP。由 Guido van Rossum 实施。本杰明·阿朗古伦(Benjamin Aranguren)与亚历克斯·马丁里(Alex Martelli)一起将其移植到 2.6.

PEP 3127:整数 Literals 支持和语法

Python 3.0 更改了八进制(基数为 8)整数 Literals 的语法,为它们加上前缀“ 0o”或“ 0O”而不是前导零,并增加了对二进制(基数为 2)整数 Literals 的支持,以“ 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'

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

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

See also

  • PEP 3127-整数 Literals 支持和语法

  • PEP 由 Patrick Maupin 撰写;由埃里克·史密斯(Eric Smith)反向移植到 2.6.

PEP 3129:类装饰器

装饰器已从Function扩展到类。现在写是合法的:

@foo
@bar
class A:
  pass

这等效于:

class A:
  pass

A = foo(bar(A))

See also

  • PEP 3129-类装饰器

  • PEP 由 Collin Winter 撰写。

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

Python 3.0 为一些受 Scheme 的数字塔启发的数字类型添加了一些抽象 Base Class。这些类已作为numbers模块反向移植到 2.6.

最一般的 ABC 是Number。它根本不定义任何操作,仅存在以允许pass执行isinstance(obj, Number)来检查对象是否为数字。

ComplexNumber的子类。复数可以进行加,减,乘,除和乘幂的基本操作,并且您可以检索实部和虚部并获得数字的共轭数。 Python 的内置复杂类型是Complex的实现。

Real进一步从Complex派生,并添加了仅对实数有效的运算:floor()trunc(),舍入,取余数 mod N,下限除法和比较。

Rational数字源自Real,具有numeratordenominator属性,并且可以转换为浮点数。 Python 2.6 在fractions模块中添加了一个简单的有理数类Fraction。 (为了避免名称与numbers.Rational冲突,将其称为Fraction而不是Rational。)

Integral数字从Rational派生而来,可以pass<<>>左右移动,并可以使用诸如&|之类的按位运算进行组合,并且可以用作数组索引和切片边界。

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

See also

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

  • PEP 由 Jeffrey Yasskin 撰写。

方案的数字塔,来自 Guile 手册。

R5RS Scheme 规范中的方案的数字数据类型

分数模块

为了填写数字类型的层次结构,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)

请注意,只能pass浮点数近似的值(例如 1./3)不会简化为近似数;分数试图“完全”匹配浮点值。

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

其他语言更改

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

  • 现在,可以将包含__main__.py文件的目录和 zip 存档直接传递给解释器,以执行它们。目录或 zip 归档文件将自动作为 sys.path 中的第一个条目插入。 (Andy Chu 的建议和初步补丁,随后由 Phillip J. Eby 和 Nick Coghlan 修改; bpo-1739468。)

  • hasattr()函数正在捕获并忽略所有错误,并假设它们意味着getattr()方法以某种方式失败,因此hasattr()的返回值为False。但是,不应将此逻辑应用于KeyboardInterruptSystemExit;当hasattr()遇到此类异常时,Python 2.6 将不再丢弃此类异常。 (由本杰明·彼得森修正; bpo-2196。)

  • 使用**语法调用函数以提供关键字参数时,不再需要使用 Python 字典;任何 Map 现在都可以使用:

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

(由 Alexander Belopolsky 提供; 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 Forgeot d'Arc 提供; bpo-3473。)

  • 新的内置函数next(iterator, [default])返回指定迭代器的下一项。如果提供了* default 参数,则当 iterator *用尽时将返回该参数;否则,将引发StopIterationexception。 (在bpo-2719中向后移植。)

  • Tuples 现在具有与列表类型的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 实施.)

  • 现在,属性具有三个属性gettersetterdeleter,它们是修饰器,为将 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()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 提供.)

  • 增加了许多浮点Function。 float()函数现在会将字符串nan转换为 IEEE 754 非数字值,并将+inf-inf转换为正或负无穷大。这可以在具有 IEEE 754 语义的任何平台上使用。 (由 Christian Heimes 贡献; bpo-1635。)

math模块中的其他函数isinf()isnan(),如果它们的浮点参数为无穷大或不是数字,则返回 true。 (bpo-1640)

添加了转换Function,以将浮点数转换为十六进制字符串(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(obj)引发TypeError,并且该类不会被表示为实现Hashable ABC。

当您定义了cmp()eq()方法时,应按对象的值而不是标识来比较对象,然后执行此操作。所有对象都有一个默认的哈希方法,该方法使用id(obj)作为哈希值。没有清除从父类继承的hash()方法的整洁方法,因此将None分配为替代。在 C 级别,扩展可以将tp_hash设置为PyObject_HashNotImplemented()。 (由 Nick Coghlan 和 Amaury Forgeot d'Arc 固定; bpo-2235。)

  • GeneratorExitexception 现在继承了BaseException而不是Exception的子类。这意味着执行except Exception:的异常处理程序不会无意中捕获GeneratorExit。 (由 Chad Austin 提供; bpo-1537。)

  • 生成器对象现在具有gi_code属性,该属性引用支持生成器的原始代码对象。 (由 Collin Winter 提供; bpo-1473257。)

  • compile()内置函数现在可以接受关键字参数以及位置参数。 (由 Thomas Wouters 贡献; 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)

  • 实例方法对象具有对象的新属性以及组成该方法的Function; im_self的新同义词是__self__,并且im_func也可以作为__func__使用。 Python 2.6 仍支持旧名称,但 3.0 中已不再使用。

  • 一项不明显的更改:在class语句中使用locals()函数时,生成的字典不再返回自由变量。 (在这种情况下,自由变量是class语句中引用的不是类属性的变量。)

Optimizations

  • warnings模块已用 C 重写。这使得可以从解析器中调用警告,还可以使解释器的启动更快。 (由 Neal Norwitz 和 Brett Cannon 贡献; bpo-1631171。)

  • 类型对象现在具有方法缓存,可以减少为特定类找到正确的方法实现所需的工作;一旦被缓存,解释器就不需要遍历 Base Class 来找出正确的调用方法。如果 Base Class 或类本身被修改,则清除缓存,因此即使面对 Python 的动态特性,缓存也应保持正确。 (由 Armin Rigo 实现的原始优化,由 Kevin Jacobs 为 python 2.6 更新; bpo-1700288。)

默认情况下,此更改仅适用于 Python 核心随附的类型。扩展模块可能不一定与此高速缓存兼容,因此扩展模块必须将Py_TPFLAGS_HAVE_VERSION_TAG显式添加到模块的tp_flags字段中以启用方法高速缓存。 (为了与方法缓存兼容,扩展模块的代码不得直接访问和修改其实现的任何类型的tp_dict成员.大多数模块不会执行此操作,但是 Python 解释器无法确定这一点.请参见bpo-1878进行讨论。)

  • pass执行快速的指针比较,使用关键字参数的函数调用明显更快,通常可以节省完整字符串比较的时间。 (由 Raymond Hettinger 提供,在 Antoine Pitrou 最初实施之后; bpo-1819。)

  • 由于在 Need For Speed 冲刺中的工作,struct模块中的所有Function都已用 C 重写。 (由 Raymond Hettinger 提供.)

  • 现在,一些标准的内置类型在其类型对象中设置了一些位。这样可以加快检查对象是否为这些类型之一的子类。 (由 Neal Norwitz 提供.)

  • Unicode 字符串现在使用更快的代码来检测空格和换行符;这样可以将split()方法的速度提高约 25%,将splitlines()的速度提高 35%。 (由 Antoine Pitrou 提供.)pass对 Unicode 字符串的数据使用 pymalloc 可以减少内存使用。

  • 现在,with语句将exit()方法存储在堆栈中,从而产生较小的加速。 (由 Jeffrey Yasskin 实施.)

  • 为了减少内存使用,现在垃圾回收器将在垃圾回收最新一代的对象时清除内部空闲列表。这可能会更快地将内存返回 os。

Interpreter Changes

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

现在可以pass在 Python 解释器上提供-B开关,或者在运行解释器之前设置 PYTHONDONTWRITEBYTECODE环境变量来防止 Python 写入.pyc.pyo文件。此设置可作为sys.dont_write_bytecode变量提供给 Python 程序,并且 Python 代码可以更改该值以修改解释程序的行为。 (由 Neal Norwitz 和 Georg Brandl 贡献.)

可以在运行解释器之前pass设置 PYTHONIOENCODING环境变量来指定用于标准 Importing,输出和标准错误的编码。该值应该是<encoding><encoding>:<errorhandler>形式的字符串。 * encoding 部分指定编码的名称,例如utf-8latin-1;可选的 errorhandler *部分指定如何处理编码无法处理的字符,并且应为“错误”,“忽略”或“替换”之一。 (由 Martin von Loewis 提供.)

新模块和改进模块

与每个发行版一样,Python 的标准库得到了许多增强和错误修复。这是最值得注意的更改的部分列表,按模块名称的字母 Sequences 排列。请查阅源代码树中的Misc/NEWS文件以获得更完整的更改列表,或者查看 Subversion 日志以获取所有详细信息。

  • asyncoreasynchat模块将再次得到积极维护,并应用了许多补丁程序和错误修正。 (由 Josiah Carlson 维护;有关一个补丁,请参见bpo-1736190。)

  • bsddb模块还具有一个新的维护程序 JesúsCea Avion,该软件包现在可以作为独立软件包使用。软件包的网页是www.jcea.es/programacion/pybsddb.htm。计划是从 Python 3.0 的标准库中删除该软件包,因为其发布速度比 Python 频繁得多。

bsddb.dbshelve模块现在使用可用的最高 Pickling 协议,而不是将自身限制为协议 1.(由 W. Barnes 贡献)。

  • 现在,cgi模块将从 HTTP POST 请求的查询字符串中读取变量。这样就可以将表单操作与包含查询字符串(例如“ /cgi-bin/add.py?category=1”)的 URL 一起使用。 (由 Alexandre Fiori 和 Nubis 贡献; bpo-1817。)

parse_qs()parse_qsl()Function已从cgi模块重新定位到urlparse模块。 cgi模块中仍可用的版本将触发 2.6(bpo-600362)中的PendingDeprecationWarning消息。

  • cmath模块由 Mark Dickinson 和 Christian Heimes 进行了广泛的修订。添加了五个新Function:

  • polar()将复数转换为极坐标形式,并返回该复数的模数和自变量。

    • rect()进行相反的操作,将模数参数对重新转换为相应的复数。

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

    • isnan()如果其参数的实部或虚部为 NaN,则返回 True。

    • 如果其参数的实部或虚部为无穷大,则isinf()返回 True。

这些修订还改善了cmath模块的数值稳定性。对于所有Function,结果的实部和虚部都尽可能精确到几个最小精度(单位:ulps)的单位。有关详情,请参见bpo-1381asinh()atanh():和atan()的分支切口也已更正。

该模块的测试已大大扩展;近 2000 个新的测试用例行使代数Function。

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

  • collections模块中的新数据类型:namedtuple(typename, fieldnames)是一种工厂函数,它创建标准 Tuples 的子类,其字段可pass名称和索引访问。例如:
>>> 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)

标准库中返回 Tuples 的几个位置已被修改为返回namedtuple个实例。例如,Decimal.as_tuple()方法现在返回具有signdigitsexponent字段的命名 Tuples。

(由 Raymond Hettinger 提供.)

  • collections模块的另一个更改是deque类型现在支持可选的* maxlen 参数;如果提供,则 deque 的大小不得超过 maxlen *个项目。将更多项目添加到完全 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属性。在某些浏览器中。设置了此属性的 cookie 不能被 JavaScript 代码访问或操纵。 (由 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)

curses.textpad模块中的Textbox类现在支持在插入模式和覆盖模式下进行编辑。pass在创建Textbox实例时为* insert_mode *参数提供一个真值来启用插入模式。

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

  • decimal模块已更新为通用十进制规范的 1.66 版本。新Function包括一些用于一些基本 math 函数的方法,例如exp()log10()

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

现在,Decimal个对象的as_tuple()方法返回具有signdigitsexponent字段的命名 Tuples。

(由 Facundo Batista 和 Mark Dickinson 实施.由 Raymond Hettinger 添加的命名 Tuples 支持.)

  • difflib模块的SequenceMatcher类现在返回表示匹配的命名 Tuples,具有absize属性。 (由 Raymond Hettinger 提供.)

  • 可选的timeout参数(指定以秒为单位的超时)已添加到ftplib.FTP类构造函数以及connect()方法。 (由 Facundo Batista 添加.)而且,FTP类的storbinary()storlines()现在采用可选的* callback *参数,该参数将在发送数据后随每个数据块一起调用。 (由 Phil Schwartz 提供; bpo-1221598。)

  • reduce()内置Function在functools模块中也可用。在 Python 3.0 中,内置函数已被删除,reduce()仅可用于functools;当前尚无计划在 2.x 系列中删除内置函数。 (由 Christian Heimes 修补; bpo-1739906。)

  • getpass模块现在将在可能的情况下使用/dev/tty打印提示信息并读取密码,并返回标准错误和标准 Importing。如果可以将密码回显到终端,则在显示提示之前会打印警告。 (由格雷戈里·史密斯(Gregory P. Smith)提供。)

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

  • heapq模块merge(iter1, iter2, ...)中的新函数采用任意数量的可迭代对象,以排序 Sequences 返回数据,并返回一个新生成器,该生成器也以排序 Sequences 返回所有迭代器的内容。例如:

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

另一个新Functionheappushpop(heap, item)将* item 推入 heap *,然后弹出并返回最小的项。这比先调用heappush()然后再调用heappop()更有效。

heapq现在已实现为仅使用小于比较,而不是以前使用的小于或等于比较。这使得heapq的类型用法与list.sort()方法匹配。 (由 Raymond Hettinger 提供.)

  • 可选的timeout参数,指定以秒为单位的超时,已添加到httplib.HTTPConnectionHTTPSConnection类的构造函数中。 (由 Facundo Batista 添加.)

  • inspect模块的大多数Function(例如getmoduleinfo()getargs())现在返回已命名的 Tuples。除了像 Tuples 一样,返回值的元素也可以作为属性来访问。 (由 Raymond Hettinger 提供.)

模块中的一些新Function包括isgenerator()isgeneratorfunction()isabstract()

  • itertools模块获得了几个新Function。

izip_longest(iter1, iter2, ...[, fillvalue])由每个元素组成 Tuples;如果某些可迭代项比其他可迭代项短,则将缺少的值设置为* 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])返回所提供的可迭代对象的笛卡尔乘积,即一组 Tuples,其中包含从每个可迭代对象返回的元素的每种可能组合。

>>> 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 *-Tuples:

>>> 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 *-Tuples。

>>> 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 *,则默认为 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)采用单个可迭代对象,该可迭代对象应返回其他可迭代对象。 chain()然后将返回第一个可迭代的所有元素,然后返回第二个可迭代的所有元素,依此类推。

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

(全部由 Raymond Hettinger 提供.)

  • logging模块的FileHandler类及其子类WatchedFileHandlerRotatingFileHandlerTimedRotatingFileHandler现在对其构造函数具有可选的* delay 参数。如果 delay *为 true,则将延迟打开日志文件,直到进行第一个emit()调用为止。 (由 Vinay Sajip 提供.)

TimedRotatingFileHandler还有一个* utc *构造函数参数。如果该参数为 true,则将使用 UTC 时间确定午夜的时间以及生成文件名。否则将使用当地时间。

  • math模块中添加了几个新Function:

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

    • copysign()复制 IEEE 754 编号的符号位,返回* x 的绝对值和 y *的符号位。例如,math.copysign(1, -0.0)返回-1.0. (由 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 的数字类型层次结构的反向端口的一部分。

  • math模块已得到改进,可在平台之间提供更一致的行为,尤其是在处理浮点异常和 IEEE 754 特殊值方面。

只要有可能,该模块就会遵循 C99 标准关于 754 特殊值的建议。例如,sqrt(-1.)现在应该在几乎所有平台上给出ValueError,而sqrt(float('NaN'))应该在所有 IEEE 754 平台上返回 NaN。如果 C99 标准的附件“ F”建议用 signal 表示“被零除”或“无效”,则 Python 将引发ValueError。在 C99 标准的附件“ F”建议发 signal 通知“溢出”的地方,Python 将提高OverflowError。 (请参见bpo-711019bpo-1640。)

(由 Christian Heimes 和 Mark Dickinson 贡献.)

  • mmap对象现在具有rfind()方法,该方法搜索从字符串末尾开始并向后搜索的子字符串。 find()方法还获得了* end *参数,该参数给出了停止搜索的索引。 (由 John Lenton 提供.)

  • operator模块获得了一个methodcaller()函数,该函数带有一个名称和一组可选参数,返回一个 callable,它将对传递给它的所有参数调用命名函数。例如:

>>> # 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)建议后由乔治·布兰 del(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. Levinson 贡献.)

os.closerange(low, high)有效地关闭所有文件 Descriptors,从* low high ,忽略任何错误并且不包括 high *本身。 subprocess模块现在使用此Function来加快启动过程。 (由 Georg Brandl 贡献; bpo-1663329。)

  • 现在,除了清除对象的键之外,os.environ对象的clear()方法还将使用os.unsetenv()取消设置环境变量。 (由 Martin Horcicka 提供; bpo-1181。)

  • os.walk()函数现在具有followlinks参数。如果设置为 True,它将跟随指向目录的符号链接并访问目录的内容。为了向后兼容,该参数的默认值为 false。请注意,如果存在指向父目录的符号链接,则该函数可能会陷入无限递归。 (bpo-1273829)

  • os.path模块中,已将splitext()Function更改为不按前导句号分割。在 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”将扩展为用户的主目录路径。 (由 Josiah Carlson 提供; bpo-957650。)

  • pdb模块提供的 Python 调试器获得了一个新命令:“运行”重新启动正在调试的 Python 程序,并可以选择为该程序采用新的命令行参数。 (由 Rocky Bernstein 贡献; bpo-1393667。)

  • 如果没有提供回溯,则用于开始调试回溯的pdb.post_mortem()函数现在将使用sys.exc_info()返回的回溯。 (由 Facundo Batista 提供; bpo-1106316。)

  • pickletools模块现在具有optimize()函数,该函数接受包含 pickle 的字符串并删除一些未使用的操作码,从而返回包含相同数据结构的较短 pickle。 (由 Raymond Hettinger 提供.)

  • get_data()函数已添加到pkgutil模块中,该函数返回已安装的 Python 软件包随附的资源文件的内容。例如:

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

(由 Paul Moore 提供; bpo-2439。)

  • pyexpat模块的Parser对象现在允许设置其buffer_size属性来更改用于保存字符数据的缓冲区的大小。 (由 Achim Gaedke 提供; bpo-1137。)

  • Queue模块现在提供了队列变体,可以按不同 Sequences 检索条目。 PriorityQueue类将排队的项目存储在堆中并按优先级 Sequences 检索它们,而LifoQueue首先检索最近添加的条目,这意味着它的行为类似于堆栈。 (由 Raymond Hettinger 提供.)

  • 现在,可以在 32 位系统上对random模块的Random对象进行 Pickling,而在 64 位系统上可以对其进行不 Pickling,反之亦然。不幸的是,此更改还意味着在早期版本的 Python 上无法正确解开 Python 2.6 的Random对象。 (由 Shawn Ligocki 贡献; bpo-1727780。)

新的triangular(low, high, mode)函数返回遵循三角分布的随机数。返回的值在* low high 之间,不包括 high 本身,并且 mode *是分布中最频繁出现的值。 (由 Wladmir van der Laan 和 Raymond Hettinger 贡献; bpo-1681432。)

  • re模块执行的长正则表达式搜索将检查是否有传递的 signal,因此现在可以break耗时的搜索。 (由 Josh Hoyt 和 Ralf Schmitt 贡献; bpo-846388。)

正则表达式模块是pass为微型正则表达式专用虚拟机编译字节码来实现的。不受信任的代码可能会直接创建字节码的恶意字符串并导致崩溃,因此 Python 2.6 包含了用于 regex 字节码的验证程序。 (由 Guido van Rossum 在 Google App Engine 工作中贡献; bpo-3487。)

  • rlcompleter模块的Completer.complete()方法现在将忽略在评估名称时触发的异常。 (由 Lorenz Quack 修复; bpo-2250。)

  • sched模块的scheduler实例现在具有只读的queue属性,该属性返回调度程序队列的内容,表示为具有字段(time, priority, action, argument)的命名 Tuples 列表。 (由 Raymond Hettinger 提供; bpo-1861。)

  • select模块现在具有用于 Linux epoll()和 BSD kqueue()系统调用的包装器Function。 modify()方法已添加到现有的poll对象中; pollobj.modify(fd, eventmask)带有文件 Descriptors 或文件对象以及事件掩码,从而修改了该文件的记录事件掩码。 (由 Christian Heimes 贡献; bpo-1657。)

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

shutil模块还提供了ignore_patterns()函数以与此新参数一起使用。 ignore_patterns()接受任意数量的 glob 样式的模式,并返回一个 callable,它将忽略与这些模式匹配的任何文件和目录。以下示例复制目录树,但是跳过.svn目录和 Emacs 备份文件,它们的名称以'~'结尾:

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

(由 TarekZiadé提供; bpo-2663。)

  • 长期以来,将 signal 处理与 GUI 处理事件循环(如 Tkinter 或 GTk 使用的事件循环)集成在一起一直是一个问题。大多数软件finally都会轮询,因此每隔一秒就会唤醒一次,以检查是否发生了 GUI 事件。 signal模块现在可以提高效率。调用signal.set_wakeup_fd(fd)设置要使用的文件 Descriptors;当接收到 signal 时,将一个字节写入该文件 Descriptors。还有一个 C 级函数PySignal_SetWakeupFd(),用于设置 Descriptors。

事件循环将pass打开管道来创建两个 Descriptors,一个用于读取,另一个用于写入来使用此方法。可写 Descriptors 将传递给set_wakeup_fd(),可读 Descriptors 将passselect()poll()添加到事件循环监视的 Descriptors 列表中。接收到 signal 后,将写入一个字节,并且将唤醒主事件循环,从而避免了轮询。

(由 Adam Olsen 贡献; bpo-1583。)

siginterrupt()函数现在可以从 Python 代码中使用,并且可以更改 signal 是否可以break系统调用。 (由拉尔夫·施密特(Ralf Schmitt)贡献。)

setitimer()getitimer()函数也已添加(在可用的地方)。 setitimer()允许设置间隔计时器,该间隔计时器将导致在指定时间后以壁钟时间,消耗的处理时间或组合的处理系统时间为单位,将 signal 发送到过程。 (由 Guilherme Polo 提供; bpo-2240。)

  • 由于添加了SMTP_SSL类,smtplib模块现在支持基于 SSL 的 SMTP。该类支持与现有SMTP类相同的接口。 (由 Monty Taylor 提供.)这两个类的构造函数还具有一个可选的timeout参数,该参数指定初始连接try的超时时间(以秒为单位)。 (由 Facundo Batista 提供.)

LMTP 协议( RFC 2033)的实现也已添加到模块中。在不 Management 邮件队列的代理之间传输电子邮件时,可以使用 LMTP 代替 SMTP。 (LMTP 由 Leif Hedstrom 实施; bpo-957003。)

SMTP.starttls()现在符合 RFC 3207,并且忘记了从服务器获得的,不是从 TLS 协商本身获得的任何知识。 (由 Bill Fenner 提供的补丁; bpo-829951。)

一个新函数create_connection()获取一个地址,并使用一个可选的超时值连接到该地址,并返回连接的套接字对象。此Function还会查询地址的类型,并根据需要使用 IPv4 或 IPv6 连接到该地址。将代码更改为使用create_connection()而不是socket(socket.AF_INET, ...)可能是使代码与 IPv6 兼容所需的全部操作。

  • SocketServer模块中的 Base Class 现在支持在服务器的timeout属性指定的非活动范围后调用handle_timeout()方法。 (由 Michael Pomraning 贡献.)serve_forever()方法现在采用可选的轮询间隔,以秒为单位,以控制服务器检查关闭请求的频率。 (由 Pedro Werneck 和 Jeffrey Yasskin 贡献; bpo-742598bpo-1193577。)

  • 由 Gerhard Haering 维护的sqlite3模块已从 Python 2.5 中的 2.3.2 版本更新为 2.4.1 版本。

  • struct模块现在支持 C99 _Bool类型,使用格式字符'?'。 (由 David Remahl 贡献.)

  • subprocess模块提供的Popen对象现在具有terminate()kill()send_signal()方法。在 Windows 上,send_signal()仅支持SIGTERMsignal,并且所有这些方法都是 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文件。如果此变量为 true,则不会写入已编译的文件。该变量最初是在启动时pass将-B开关提供给 Python 解释器或在运行解释器之前设置 PYTHONDONTWRITEBYTECODE环境变量来设置的。 Python 代码随后可以更改此变量的值,以控制是否写入字节码文件。 (由 Neal Norwitz 和 Georg Brandl 贡献.)

pass读取命名为sys.flags的 Tuples 的属性,可以获得有关提供给 Python 解释器的命令行参数的信息。例如,如果 Python 以详细模式执行,则verbose属性为 true,在调试模式下debug为 true,等等。这些属性均为只读。 (由 Christian Heimes 贡献.)

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

现在可以pass调用sys.getprofile()sys.gettrace()来确定当前的探查器和跟踪器Function。 (由 Georg Brandl 提供; bpo-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)

新的encodingerrors参数指定字符转换的编码和错误处理方案。 'strict''ignore''replace'是 Python 处理错误的三种标准方式; 'utf-8'是一个特殊值,它将错误字符替换为其 UTF-8 表示形式。 (发生字符转换是因为 PAX 格式支持 Unicode 文件名,默认为 UTF-8 编码.)

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

(所有更改由 LarsGustäbel 贡献)。

  • 可选的timeout参数已添加到telnetlib.Telnet类的构造函数中,指定以秒为单位的超时。 (由 Facundo Batista 添加.)

  • tempfile.NamedTemporaryFile类通常会删除在关闭文件后创建的临时文件。现在可以pass将delete=False传递给构造函数来更改此行为。 (由 Damien Miller 贡献; bpo-1537850。)

新类SpooledTemporaryFile的行为类似于临时文件,但将其数据存储在内存中,直到超过最大大小为止。达到该限制后,内容将被写入磁盘上的临时文件。 (由 Dustin J. Mitchell 提供.)

NamedTemporaryFileSpooledTemporaryFile类都可以用作上下文 Management 器,因此您可以编写with tempfile.NamedTemporaryFile() as tmp: ...。 (由 Alexander Belopolsky 提供; bpo-2021。)

  • test.test_support模块获得了许多可用于编写测试的上下文 Management 器。 EnvironmentVarGuard()是上下文 Management 器,可以临时更改环境变量并将其自动恢复为旧值。

另一个上下文 Management 器TransientResource可以包围对可能可用或不可用的资源的调用。它会捕获并忽略指定的 exception 列表。例如,在连接到外部网站时,网络测试可能会忽略某些故障:

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"

(由布雷特·坎农(Brett Cannon)贡献。)

  • textwrap模块现在可以pass将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 提供; bpo-1581073。)

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

threading模块的Thread对象获得了ident属性,该属性返回线程的标识符(非零整数)。 (由 Gregory P. Smith 提供; bpo-2871。)

  • timeit模块现在接受可计时的语句以及设置代码的可调用对象以及字符串。添加了两个便捷函数来创建Timer实例:repeat(stmt, setup, time, repeat, number)timeit(stmt, setup, time, number)创建实例并调用相应的方法。 (由 Erik Demaine 贡献; bpo-1533909。)

  • Tkinter模块现在接受列表和 Tuples 作为选项,在将结果值传递到 Tcl/Tk 之前,用空格分隔元素。 (由 Guilherme Polo 提供; bpo-2906。)

  • Gregor Lingl 大大增强了用于 turtle 图形的turtle模块。该模块中的新Function包括:

  • 更好的Turtle motion和旋转动画。

    • 使用新的delay()tracer()speed()方法控制turtle 的移动。

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

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

    • 对 Importing 事件(例如鼠标和键盘活动)做出反应的简单支持,使编写简单游戏成为可能。

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

    • 可以将模块的文档字符串替换为已翻译为另一种语言的新文档字符串。

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

(由 Facundo Batista 添加.)

  • unicodedata模块提供的 Unicode 数据库已更新至版本 5.1.0. (由 Martin von Loewis 更新; bpo-3811。)

  • warnings模块的formatwarning()showwarning()获得了可选的* line *参数,可用于提供源代码行。 (作为bpo-1631171的一部分添加的,它在 C 代码中重新实现了warnings模块的一部分。)

新Functioncatch_warnings()是用于测试目的的上下文 Management 器,它使您可以临时修改警告过滤器,然后恢复其原始值(bpo-3781)。

  • 现在可以pass传递False作为* bind_and_activate *构造函数参数来防止 XML-RPC SimpleXMLRPCServerDocXMLRPCServer类立即打开并绑定到其套接字。在调用server_bind()server_activate()方法打开套接字并开始侦听连接之前,可以使用它来修改实例的allow_reuse_address属性。 (由 Peter Parente 提供; bpo-1599845。)

SimpleXMLRPCServer还具有_send_traceback_header属性;如果为 true,则将异常和格式化的跟踪作为 HTTPHeaders“ X-Exception”和“ X-Traceback”返回。此Function仅用于调试目的,不应在生产服务器上使用,因为回溯可能会泄露密码或其他敏感信息。 (由艾伦·麦金太尔(Alan McIntyre)供其在 Google 的“代码之夏 2007”项目中使用。)

  • xmlrpclib模块不再自动将datetime.datedatetime.time转换为xmlrpclib.DateTime类型;转换语义不一定适用于所有应用程序。使用xmlrpclib的代码应转换datetime实例。 (bpo-1330538)该代码还可以处理 1900 年之前的日期(由 Ralf Schmitt 贡献; bpo-2014)和在 XML-RPC 响应中使用<i8>表示的 64 位整数(由 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对象。当存档意外包含重复的文件名时,此Function很有用。 (由 Graham Horler 提供; bpo-1775025。)

最后,zipfile现在支持将 Unicode 文件名用于存档文件。 (由 Alexey Borzenkov 贡献; bpo-1734346。)

ast 模块

ast模块提供了 Python 代码的抽象语法树表示形式,而 Armin Ronacher 提供了一组帮助程序Function,可以执行各种常见任务。这些对于 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()方法采用表示 Literals 表达式的字符串或 AST,对其进行解析和计算,然后返回结果值。Literals 表达式是 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 的NodeVisitorNodeTransformer类,以及用于常见转换(例如更改行号)的Function。

future_builtins 模块

Python 3.0 对内置函数的Function进行了许多更改,并且大多数更改无法在 Python 2.x 系列中引入,因为它们会破坏兼容性。 future_builtins模块提供了这些内置函数的版本,可以在编写与 3.0 兼容的代码时将其导入。

该模块中的Function当前包括:

  • ascii(obj):等效于repr()。在 Python 3.0 中,repr()将返回 Unicode 字符串,而ascii()将返回纯 ASCII 字节字符串。

  • filter(predicate, iterable)map(func, iterable1, ...):3.0 版本返回迭代器,而 2.x 内置函数返回列表。

  • hex(value)oct(value):这些版本将调用index()方法并将结果转换为十六进制或八进制,而不是调用hex()oct()方法。 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格式在 Mac OS X 上通常用于pass将基本数据类型(数字,字符串,列表和字典)序列化为基于 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 Enhancements

Thomas Hellercontinue 维护和增强ctypes模块。

ctypes现在支持表示 C99 bool类型的c_bool数据类型。 (由 David Remahl 贡献; bpo-1649190。)

ctypes字符串,缓冲区和数组类型改进了对扩展切片语法的支持,其中提供了(start, stop, step)的各种组合。 (由 Thomas Wouters 实施.)

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

一个新的调用约定告诉ctypes在每个包装的调用开始时清除errno或 Win32 LastError 变量。 (由 Thomas Heller 实施; bpo-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()

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

改进了 SSL 支持

Bill Janssen pass添加在OpenSSL库之上构建的新模块ssl,对 Python 2.6 对安全套接字层的支持进行了广泛的改进。这个新模块提供了对协商协议,使用的 X.509 证书的更多控制,并更好地支持以 Python 编写 SSL 服务器(相对于 Client 端)。 socket模块中现有的 SSL 支持尚未删除,并且可以 continue 工作,尽管在 Python 3.0 中将删除它。

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

See also

ssl模块的文档。

弃用和移除

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

  • PEP 352要求 continue 对Exception接口进行更改。对于 2.6,不推荐使用message属性,而推荐使用args属性。

  • (3.0 警告模式)Python 3.0 将具有经过重组的标准库,该库将删除许多过时的模块并重命名其他模块。在 3.0 警告模式下运行的 Python 2.6 在导入这些模块时会发出警告。

弃用的模块列表为:audiodevbgenlocationsbuildtoolsbundlebuilderCanvascompilerdircachedlfpformatgensuitemoduleihooksimageopimgfilelinuxaudiodevmhlibmimetoolsmultifile,_12,newtoaiff

Build 和 C API 的更改

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

  • 现在必须使用 C89 编译器来编译 Python(19 年后!)。这意味着 Python 源代码树已经删除了自己的memmove()strerror()实现,它们在 C89 标准库中。

  • 可以使用 Microsoft Visual Studio 2008(版本 9.0)构建 Python 2.6,这是新的默认编译器。有关构建文件,请参见PCbuild目录。 (由 Christian Heimes 实施.)

  • 在 Mac OS X 上,Python 2.6 可以编译为 4 向通用构建。 configure 脚本可以使用--with-universal-archs=[32-bit|64-bit|all]开关,以控制二进制文件是针对 32 位体系结构(x86,PowerPC),64 位(x86-64 和 PPC-64)还是两者而构建。 (由 Ronald Oussoren 提供.)

  • BerkeleyDB 模块现在具有一个 C API 对象,可以作为bsddb.db.api使用。希望将bsddb模块用于自己的目的的其他 C 扩展可以使用此对象。 (由邓肯·格里斯比(Duncan Grisby)提供。)

  • 先前在PEP 3118 部分中描述的新缓冲区接口增加了PyObject_GetBuffer()PyBuffer_Release()以及其他一些Function。

  • Python 对 C stdio 库的使用现在是线程安全的,或者至少与基础库一样是线程安全的。如果一个线程关闭了文件对象,而另一个线程正在读取或写入对象,则会发生长期存在的潜在错误。在 2.6 中,文件对象具有引用计数,这些计数由PyFile_IncUseCount()PyFile_DecUseCount()函数操纵。除非引用计数为零,否则无法关闭文件对象。在使用FILE *指针执行 I/O 操作之前,应在 GIL 保持不变的情况下调用PyFile_IncUseCount(),并且应在重新获取 GIL 之后立即调用PyFile_DecUseCount()。 (由 Antoine Pitrou 和 Gregory P. Smith 贡献.)

  • 同时在两个不同的线程中导入模块不再死锁;现在它将引发一个ImportError。新的 API 函数PyImport_ImportModuleNoBlock()会先在sys.modules中查找模块,然后在获取导入锁后try将其导入。如果导入锁由另一个线程持有,则会引发ImportError。 (由 Christian Heimes 贡献.)

  • 几个函数返回有关平台浮点支持的信息。 PyFloat_GetMax()返回可表示的最大浮点值,而PyFloat_GetMin()返回最小的正值。 PyFloat_GetInfo()返回一个对象,该对象包含来自float.h文件的更多信息,例如"mant_dig"(尾数的位数),"epsilon"(1.0 和下一个可表示的下一个最大值之间的最小差)等。 (由 Christian Heimes 贡献; bpo-1534。)

  • 使用PyComplex_AsCComplex()的 C 函数和方法现在将接受具有complex()方法的参数。特别是,cmath模块中的函数现在将使用此方法接受对象。这是 Python 3.0 更改的反向移植。 (由 Mark Dickinson 提供; bpo-1675423。)

  • Python 的 C API 现在包括两个用于区分大小写的字符串比较的函数PyOS_stricmp(char*, char*)PyOS_strnicmp(char*, char*, Py_ssize_t)。 (由 Christian Heimes 贡献; bpo-1635。)

  • 许多 C 扩展定义了自己的 little 宏,用于在init*函数中将整数和字符串添加到模块的字典中。 Python 2.6 finally定义了用于向模块PyModule_AddStringMacroPyModule_AddIntMacro()添加值的标准宏。 (由 Christian Heimes 贡献.)

  • 一些宏在 3.0 和 2.6 中都被重命名,以使其更清楚地表明它们是宏,而不是函数。 Py_Size()变成Py_SIZE()Py_Type()变成Py_TYPE(),并且Py_Refcnt()变成Py_REFCNT()。混合大小写宏在 Python 2.6 中仍然可用,以实现向后兼容。 (bpo-1629)

  • 现在,当在调试版本的 Python 上运行时,Distutils 会将其生成的 Cextensions 放在其他目录中。 (由 Collin Winter 提供; bpo-1530959。)

  • 几种基本数据类型,例如整数和字符串,维护着内部可用的对象空闲列表,这些列表可以重复使用。这些自由列表的数据结构现在遵循命名约定:变量始终命名为free_list,计数器始终命名为numfree,并且始终定义了宏Py<typename>_MAXFREELIST

  • 一个新的 Makefile 目标“ make patchcheck”,准备用于制作补丁的 Python 源代码树:它修复了所有已修改的.py文件中的尾随空格,检查文档是否已更改,并报告Misc/ACKSMisc/NEWS文件是否已更新。 (由布雷特·坎农(Brett Cannon)贡献。)

另一个新目标“ make profile-opt”使用 GCC 的配置文件引导优化Function来编译 Python 二进制文件。它编译启用了概要分析的 Python,运行测试套件以获得一组概要分析结果,然后使用这些结果进行编译以进行优化。 (由格雷戈里·史密斯(Gregory P. Smith)提供。)

端口特定的更改: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 的交叉编译,调试版本和 Profile Guided Optimization(PGO)。 PGO 构建比正常构建快大约 10%。 (由 Christian Heimes 在 Amaury Forgeot d'Arc 和 Martin von Loewis 的帮助下提供.)

  • msvcrt模块现在支持控制台 I/O API 的普通和宽字符版本。 getwch()函数与getwche()函数一样,读取按键并返回 Unicode 值。 putwch()函数采用 Unicode 字符并将其写入控制台。 (由 Christian Heimes 贡献.)

  • os.path.expandvars()现在将以“%var%”的形式扩展环境变量,而“~user”将扩展为用户的主目录路径。 (由 Josiah Carlson 提供; bpo-957650。)

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

  • _winreg模块现在具有函数ExpandEnvironmentStrings(),该函数可在 Importing 字符串中扩展诸如%NAME%之类的环境变量引用。该模块提供的句柄对象现在支持上下文协议,因此可以在with语句中使用它们。 (由 Christian Heimes 贡献.)

_winreg还对 x64 系统提供了更好的支持,公开了DisableReflectionKey()EnableReflectionKey()QueryReflectionKey()函数,这些函数为在 64 位系统上运行的 32 位进程启用和禁用注册表反射。 (bpo-1753245)

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

端口特定的更改:Mac OS X

端口特定的更改:IRIX

许多旧的 IRIX 特定模块已被弃用,并将在 Python 3.0 中删除:alALcdcddbcdplayerCLclDEVICEERRNOFILEFLflflpfmGET,_ GLglINIOCTLjpegpanelparserreadcdSVsvtorgbvideoreaderWAIT

移植到 Python 2.6

本节列出了先前描述的更改和其他可能需要对代码进行更改的错误修正:

  • 不应被散列的类应在其定义中设置__hash__ = None来表明事实。

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

  • 现在,collections.dequeinit()方法清除了 deque 的所有现有内容,然后再从可迭代对象中添加元素。此更改使行为匹配list.__init__()

  • object.init()以前接受任意参数和关键字参数,而忽略它们。在 Python 2.6 中,不再允许这样做,并且会导致TypeError。这将影响init()方法,这些方法finally在object上调用相应的方法(也许pass使用super())。参见bpo-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的子类。 (由 Gregory P. Smith 实现; bpo-1706815。)

  • xmlrpclib模块不再自动将datetime.datedatetime.time转换为xmlrpclib.DateTime类型;转换语义不一定适用于所有应用程序。使用xmlrpclib的代码应转换datetime实例。 (bpo-1330538)

  • (3.0 警告模式)现在,使用切片或索引访问来访问Exception类时会发出警告;具有Exception的行为就像被淘汰的 Tuples 一样。

  • (3.0 警告模式)两个字典或两个未实现比较方法的对象之间的不相等比较被报告为警告。 dict1 == dict2仍然有效,但是dict1 < dict2正在被淘汰。

单元之间的比较(这是 Python 范围规则的实现细节)也会引起警告,因为在 3.0 中完全禁止这种比较。

Acknowledgements

作者要感谢以下人员为本文的各种草案提供建议,更正和帮助:Georg Brandl,Steve Brown,Nick Coghlan,Ralph Corderoy,Jim Jewett,Kent Johnson,Chris Lambacher,Martin Michlmayr,Antoine Pitrou,布莱恩·华纳。