# What's New in Python 2.6

著者:

  A.M. Kuchling (amk at amk.ca)

This article explains the new features in Python 2.6, released on October 1, 2008. The release schedule is described in PEP 361.

The major theme of Python 2.6 is preparing the migration path to Python 3.0, a major redesign of the language. Whenever possible, Python 2.6 incorporates new features and syntax from 3.0 while remaining compatible with existing code by not removing older features or syntax. When it's not possible to do that, Python 2.6 tries to do what it can, adding compatibility functions in a `future_builtins` module and a `-3` switch to warn about usages that will become unsupported in 3.0.

`multiprocessing` や `json` といった、いくつか重要な新しいパッケージが標準ライブラリに追加されましたが、Python 3.0 に何らかも関係しない新機能はあまり多くはありません。

Python 2.6 ではさらに、たくさんの改善とバグフィックスがソースコードのありとあらゆる場所に見られます。Python 2.5 から 2.6 の変更ログを手繰ってみると、低く見積もっても、適用されたパッチは 259、フィックスされたバグは 612 にのぼります。

このドキュメントは新機能の完全な詳細を提供するのではなくて、簡易な概要を提供することを目的にしています。完全な詳細が知りたければ、 Python 2.6 のドキュメントを参照してください。設計と実装の根拠を理解したい場合は、新機能に関する PEP を参照してください。可能な限り、 "What’s New in Python" は各変更の bug や patch に対してリンクしています。

## Python 3.0

Python 2.6 と 3.0 の開発サイクルは同期していました。両バージョンのアルファ、ベータリリースは同じ日にリリースされています。3.0 の開発は 2.6 の多くの機能に影響を与えました。

Python 3.0 は、2.x シリーズとの互換性を破壊する、広範囲な再設計です。これは、Python 3.0 で動作させるためには既存のコードに何らかの変換が必要なことを意味しています。しかしながら、必ずしも全ての 3.0 での変更が互換性を破壊するわけではありません。新機能が既存のコードの破壊を引き起こさないケースにおいては、それらは 2.6 にバックポートされました。これらについてはこのドキュメントの適切な場所に記載しています。3.0 由来の機能の一部としては以下があります:

- オブジェクトを複素数(虚数)に変換する `__complex__()` メソッド。

- 例外の捕捉の、これまでとは別の文法の追加: `except TypeError as exc` 。

- 組み込み関数 `reduce()` への別名としての `functools.reduce()` の追加。

Python 3.0 adds several new built-in functions and changes the semantics of some existing builtins. Functions that are new in 3.0 such as `bin()` have simply been added to Python 2.6, but existing builtins haven't been changed; instead, the `future_builtins` module has versions with the new 3.0 semantics. Code written to be compatible with 3.0 can do `from future_builtins import hex, map` as necessary.

A new command-line switch, `-3`, enables warnings about features that will be removed in Python 3.0. You can run code with this switch to see how much work will be necessary to port code to 3.0. The value of this switch is available to Python code as the boolean variable `sys.py3kwarning`, and to C extension code as `Py_Py3kWarningFlag`.

参考

The 3xxx series of PEPs, which contains proposals for Python 3.0. PEP 3000 describes the development process for Python 3.0. Start with PEP 3100 that describes the general goals for Python 3.0, and then explore the higher-numbered PEPs that propose specific features.

## 開発プロセスに関する変更

2.6 の開発の間で、Python 開発プロセスは 2 つの重要な変更を経験しました: SourceForge の課題トラッカーから、カスタイマイズした Roundup インストレーションに乗り換えました。また、ドキュメントは LaTeX から reStructuredText に変換しました。

### 新しい課題トラッカー: Roundup

もう随分長いこと Python 開発者たちは、SourceForge のバグトラッカーにイライラを高め続けてきました。SourceForge がホストするソリューションには全くカスタマイズの余地がなく、たとえば課題のライフサイクルをカスタマイズ出来ませんでした。

The infrastructure committee of the Python Software Foundation therefore posted a call for issue trackers, asking volunteers to set up different products and import some of the bugs and patches from SourceForge. Four different trackers were examined: Jira, Launchpad, Roundup, and Trac. The committee eventually settled on Jira and Roundup as the two candidates. Jira is a commercial product that offers no-cost hosted instances to free-software projects; Roundup is an open-source project that requires volunteers to administer it and a server to host it.

ボランティアへの呼び掛けののち、新しい Roundup インストレーションが https://bugs.python.org にセットアップされました。Roundup の一つのインストレーションは複数のトラッカーをホスト出来るため、このサーバは今では Jython と Python ウェブサイトのための課題トラッカーもホストしています。間違いなく将来はほかのものもホストするでしょう。可能な場所では、"What's New in Python" のこのエディションでは、それぞれの変更についてのバグ/パッチの Roundup アイテムにリンクします。

Hosting of the Python bug tracker is kindly provided by Upfront Systems of Stellenbosch, South Africa. Martin von Löwis put a lot of effort into importing existing bugs and patches from SourceForge; his scripts for this import operation are at `https://svn.python.org/view/tracker/importer/` and may be useful to other projects wishing to move from SourceForge to Roundup.

参考

https://bugs.python.org

  Python のバグトラッカー。

https://bugs.jython.org:

  Jython のバグトラッカー。

https://roundup.sourceforge.io/

  Roundup のダウンロードとドキュメント。

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

  Martin von Löwis の変換スクリプト。

### 新しいドキュメンテーションフォーマット: Sphinx を使っての reStructuredText

Python のドキュメンテーションは、そのプロジェクトの開始した 1989 年頃より LaTeX を使って書かれてきました。1980 年代と 1990 年代初期は、ほとんどのドキュメンテーションはあとで学習するために印刷されるもので、オンラインで見るものではありませんでした。LaTeX はとても魅惑的な印刷をしてくれるものですから、非常に大変広く広く使われていましたが、一方では、学んだマークアップの基礎的なルールで直裁的に、書いたらそれっきり、というものでもありました。

こんにちにおいてもなお、印刷を命題とする出版において LaTeX は健在といえど、プログラミングの道具立ての風景は変わりました。わたしたちはもはやドキュメンテーションの紙束をプリントアウトはしません。代わりにオンラインでブラウズします。ですから HTML は、サポートすべき最も重要なフォーマットになりました。悲しいかな、 LaTeX から HTML への変換は気が狂うほどに複雑で、Fred L. Drake Jr.、彼は長らく Python ドキュメンテーションのエディターを務めていますが、彼はその変換処理の保守に多大な時間を浪費していたのです。ときおり人々はドキュメンテーションを SGML に変換して、それから XML にすればいいでしょ、と持ちかけるのですが、良い変換を達成することにとらわれて、誰一人として仕事を完遂させようと時間を捧げることはしませんでした。

During the 2.6 development cycle, Georg Brandl put a lot of effort into building a new toolchain for processing the documentation. The resulting package is called Sphinx, and is available from https://www.sphinx-doc.org/.

Sphinx は HTML 出力に集中し、人を惹きつけるスタイルでモダンな HTML を生成します。印刷出力は LaTeX への変換を経由することで健在です。入力のフォーマットは reStructuredText です。これはカスタムな拡張とディレクティブをサポートしているマークアップ文法で、Python コミュニティでは広く使われています。

Sphinx は執筆に使えるスタンドアロンのパッケージです。そして 2 ダースに届かんばかりのプロジェクト (Sphinx ウェブサイトのリスト) が Sphinx をドキュメンテーションツールとして採用しました。

参考

Documenting Python

  Python ドキュメントの書き方について書いています。

Sphinx

  Sphinx ツールチェインのドキュメントとコードです。

Docutils

  縁の下の力持ちになっている reStructuredText のパーサとツールセットです。

## PEP 343: "with" ステートメント

Python 2.5 では、 '`with`' 文が `from __future__ import with_statement` ディレクティブで有効に出来るオプションの機能として追加されました。2.6 では '`with`' 文は特別に有効化する必要なく、もういつでもそこにあります。このセクションの残りの部分は "What's New in Python 2.5" の対応するセクションからの丸々コピーですので、2.5 で '`with`' 文に馴染んでいるなら読み飛ばしてもらって結構です。

'`with`' ステートメントは、以前なら後片付けが実行されるのを確実にするために `try...finally` ブロックを使ったであろうようなコードを、より単純明快にします。このセクションでは、このステートメントの普通の使い方を説明します。続くセクションでは実装の詳細を調べ、このステートメントとともに使うためにオブジェクトをどうやって書けば良いかをお見せします。

'`with`' ステートメントは基本構造が以下となる制御フロー構造です:

    with expression [as variable]:
        with-block

The expression is evaluated, and it should result in an object that supports the context management protocol (that is, has `__enter__()` and `__exit__()` methods).

The object's `__enter__()` is called before with-block is executed and therefore can run set-up code. It also may return a value that is bound to the name variable, if given. (Note carefully that variable is not assigned the result of expression.)

After execution of the with-block is finished, the object's `__exit__()` method is called, even if the block raised an exception, and can therefore run clean-up code.

いくつかの Python 標準オブジェクトが既にコンテキスト管理プロトコルをサポートしていて、 '`with`' とともに使えます。ファイルオブジェクトがその一例です:

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

このステートメントが実行し終わったあかつきには、 f のファイルオブジェクトは、たとえ `for` ループが道半ばにして例外と成り果てても、自動的にクローズされます。

注釈

In this case, f is the same object created by `open()`, because `__enter__()` returns self.

`threading` モジュールのロック・条件変数でも '`with`' ステートメントの恩恵にあずかれます:

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

ブロックが実行される前にロックが獲得されて、ブロックが完了するやいなや必ず解放されます。

The `localcontext()` function in the `decimal` module makes it easy to save and restore the current decimal context, which encapsulates the desired precision and rounding characteristics for computations:

    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`' とともに使うだけのことでその詳細を知る必要は無いので、それで良いならこのセクションの残りの部分は読み飛ばして結構です。新しいオブジェクトの作者は基礎となる実装の詳細について知る必要があるので、このまま読み進めるべきです。

コンテキスト管理プロトコルの高度な説明はこんなです:

- The expression is evaluated and should result in an object called a "context manager". The context manager must have `__enter__()` and `__exit__()` methods.

- The context manager's `__enter__()` method is called. The value returned is assigned to VAR. If no `as VAR` clause is present, the value is simply discarded.

- BLOCK 内のコードが実行されます。

- If BLOCK raises an exception, the context manager's `__exit__()` method is called with three arguments, the exception details (`type, value, traceback`, the same values returned by `sys.exc_info()`, which can also be `None` if no exception occurred). The method's return value controls whether an exception is re-raised: any false value re-raises the exception, and `True` will result in suppressing it. You'll only rarely want to suppress the exception, because if you do the author of the code containing the '`with`' statement will never realize anything went wrong.

- If BLOCK didn't raise an exception, the `__exit__()` method is still called, but type, value, and traceback are all `None`.

例を通じて考えましょう。枝葉末節を含んだ完璧なコードを提示しようとは思いませんが、データベースのためにトランザクションをサポートするのに必要となるメソッドの書き方についてスケッチしてみようと思います。

(データベース用語に不慣れな方へ:データベースへの変更のセットは、トランザクションという単位でグループ化されています。トランザクションは「コミット」される、その意味は、全ての変更がデータベースに書き込まれることです、もしくは「ロールバック」される、この場合全ての変更が捨てられてデータベースが変更されません、この 2 つのいずれかになりえます。詳しくはなにかデータベースの著述を読んで下さい。)

データベース接続を表現するオブジェクトがあると仮定しましょう。私たちの目標は、そのオブジェクトのユーザがこのように書けるようになることです:

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

The transaction should be committed if the code in the block runs flawlessly or rolled back if there's an exception. Here's the basic interface for `DatabaseConnection` that I'll assume:

    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"

The `__enter__()` method is pretty easy, having only to start a new transaction. For this application the resulting cursor object would be a useful result, so the method will return it. The user can then add `as cursor` to their '`with`' statement to bind the cursor to a variable name.

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

The `__exit__()` method is the most complicated because it's where most of the work has to be done. The method has to check if an exception occurred. If there was no exception, the transaction is committed. The transaction is rolled back if there was an exception.

下記のコード内では実行がメソッドの末尾まで落ちていって、なのでデフォルトの `None` 返却になります。 `None` は偽なので、例外は自動的に再送出されます。望むならもっと明示的に、コメントでマークした部分で `return` 文を書いてもよろしいです:

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

### contextlib モジュール

`contextlib` モジュールは、 '`with`' ステートメントで使えるオブジェクトを書く際に便利ないくつかの関数とデコレータを提供しています。

The decorator is called `contextmanager()`, and lets you write a single generator function instead of defining a new class. The generator should yield exactly one value. The code up to the `yield` will be executed as the `__enter__()` method, and the value yielded will be the method's return value that will get bound to the variable in the '`with`' statement's `as` clause, if any. The code after the `yield` will be executed in the `__exit__()` method. Any exception raised in the block will be raised by the `yield` statement.

このデコレータを使って、前セクションの私たちのデータベースの例はこのように書けます:

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

Finally, the `closing()` function returns its argument so that it can be bound to a variable, and calls the argument's `.close()` method at the end of the block.

    import urllib, sys
    from contextlib import closing

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

参考

PEP 343 - "with" ステートメント

  PEP は Guido van Rossum と Nick Coghlan によって書かれ、Mike Bland、 Guido van Rossum、Neal Norwitz により実装されました。この PEP は '`with`' ステートメントによって生成されるコードを見せてくれるので、このステートメントがどうやって動作するのかを知るのに役立ちます。

`contextlib` モジュールについてのドキュメント。

## PEP 366: メインモジュールからの明示的相対インポート

Python のオプション `-m` で、モジュールをスクリプトとして実行出来ます。パッケージ内のモジュールを実行する際に、相対インポートが正しく動作していませんでした。

The fix for Python 2.6 adds a `module.__package__` attribute. When this attribute is present, relative imports will be relative to the value of this attribute instead of the `__name__` attribute.

PEP 302-style importers can then set `__package__` as necessary. The `runpy` module that implements the `-m` switch now does this, so relative imports will now work correctly in scripts running from inside a package.

## PEP 370: ユーザごとの `site-packages` ディレクトリ

When you run Python, the module search path `sys.path` usually includes a directory whose path ends in `"site-packages"`. This directory is intended to hold locally installed packages available to all users using a machine or a particular site installation.

Python 2.6 ではユーザ固有のサイトディレクトリのための決まりを導入しました。ディレクトリはプラットフォームに依存して変わります。

- Unix と Mac OS X: `~/.local/`

- Windows: `%APPDATA%/Python`

このディレクトリ内にはバージョン固有のサブディレクトリが入ります。Unix/Mac OS では `lib/python2.6/site-packages` のように、Windows では `Python26/site-packages` のように。

If you don't like the default directory, it can be overridden by an environment variable. `PYTHONUSERBASE` sets the root directory used for all Python versions supporting this feature. On Windows, the directory for application-specific data can be changed by setting the `APPDATA` environment variable. You can also modify the `site.py` file for your Python installation.

この機能は Python 起動時に `-s` オプションを付けるか、環境変数 `PYTHONNOUSERSITE` をセットすることで完全に無効に出来ます。

参考

PEP 370 - ユーザごとの `site-packages` ディレクトリ

  PEP 著と実装 Christian Heimes.

## PEP 371: `multiprocessing` パッケージ

新しい `multiprocessing` により、Python プログラムが新たなプロセスを作成して何か計算を実行させて結果を返させることが出来ます。親と子のプロセスはキューとパイプを使って通信し、ロックとセマフォを使って同期し、単純なデータの配列を共有出来ます。

The `multiprocessing` module started out as an exact emulation of the `threading` module using processes instead of threads. That goal was discarded along the path to Python 2.6, but the general approach of the module is still similar. The fundamental class is the `Process`, which is passed a callable object and a collection of arguments. The `start()` method sets the callable running in a subprocess, after which you can call the `is_alive()` method to check whether the subprocess is still running and the `join()` method to wait for the process to exit.

ここに、サブプロセスが階乗を計算する例を示します。その計算をする関数はヘンテコリンに書かれていて、入力が 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` が factorial の結果を通信して返すのに使われています。 `Queue` オブジェクトはグローバル変数に格納されています。子プロセスは、子プロセスが作成された時点のその変数の値を使うことになります; `Queue` なので、親子はそのオブジェクトを通信のために使うことが出来ます。(プロセス作成後に親がグローバル変数 queue を差し替えても、子の値は左右されませんし、逆もしかりです。)

Two other classes, `Pool` and `Manager`, provide higher-level interfaces. `Pool` will create a fixed number of worker processes, and requests can then be distributed to the workers by calling `apply()` or `apply_async()` to add a single request, and `map()` or `map_async()` to add a number of requests. The following code uses a `Pool` to spread requests across 5 worker processes and retrieve a list of results:

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

The other high-level interface, the `Manager` class, creates a separate server process that can hold master copies of Python data structures. Other processes can then access and modify these data structures using proxy objects. The following example creates a shared dictionary by calling the `dict()` method; the worker processes then insert values into the dictionary. (Locking is not done for you automatically, which doesn't matter in this example. `Manager`'s methods also include `Lock()`, `RLock()`, and `Semaphore()` to create shared locks.)

    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 - multiprocessing パッケージの追加

  PEP 著 Jesse Noller と Richard Oudkerk; 実装 Richard Oudkerk と Jesse Noller.

## PEP 3101: 進化版文字列フォーマッティング

In Python 3.0, the `%` operator is supplemented by a more powerful string formatting method, `format()`. Support for the `str.format()` method has been backported to Python 2.6.

In 2.6, both 8-bit and Unicode strings have a `.format()` method that treats the string as a template and takes the arguments to be formatted. The formatting template uses curly brackets (`{`, `}`) as special characters:

    >>> # 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}`, …、またはキーワード引数に対応する名前です。属性を読み出したり辞書のキーにアクセスするような合成フィールド名(compound field names)も与えることが出来ます:

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

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

`[.mp4]` のように辞書スタイルの記法を使う際は文字列の周りを引用符で囲む必要はありません; `.mp4` をキーに値のルックアップされます。数値で始まる文字列は整数に変換されます。フォーマット文字列内でこれ以上複雑な表現は書けません。

ここまでは、結果文字列に置き換えられるフィールドを指定する方法について見てきました。フォーマッティングではさらに、コロンに続けて書式指定子を追加することでコントロール可能です。例えば:

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

書式指定子として、ネストによる他フィールド参照が使えます:

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

望みの幅内でのフィールドの整列を指定可能です:

文字 | 効果
--- | ---
< (デフォルト) | 左寄せ
> | 右寄せ
^ | 中央寄せ
= | (数値型についてのみ) 符号のあとにパディング

書式指定子には体裁のタイプも含めることが出来ます。値をどのようにフォーマットするかです。たとえば浮動小数点数は普通の数値に、あるいは指数形式でフォーマット出来ます:

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

たくさんの体裁のタイプを利用出来ます。2.6 ドキュメントの complete list を調べてみてください。以下はその一部です:

`b` | 2進数。出力される数値は2を基数とします。
`c` | 文字。数値を対応するユニコード文字に変換します。
`d` | 10進数。出力される数値は10を基数とします。
`o` | 8進数。出力される数値は8を基数とします。
`x` | 16進数。出力される数値は16を基数とします。 10進で9を超える数字には小文字が使われます。
`e` | 指数表現です。指数を示す 'e' を使った科学的記数法で表示します。
`g` | 汎用フォーマット。数値が大き過ぎない限りは固定小数点表現をしますが、大きい値では 'e' 指数表現に切り替えます。
`n` | 数値です。現在のロケールに合わせて、数値分割文字が挿入されることを除き、 `'g'` (浮動小数点数の場合) または 'd' (整数の場合) と同じです。
`%` | パーセンテージです。数値は 100 倍され、固定小数点数フォーマット (`'f'`) でパーセント記号付きで表示されます。

Classes and types can define a `__format__()` method to control how they're formatted. It receives a single argument, the format specifier:

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

There's also a `format()` builtin that will format a single value. It calls the type's `__format__()` method with the provided specifier:

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

参考

書式指定文字列の文法

  リファレンスドキュメント。

PEP 3101: 進化版文字列フォーマッティング

  PEP 著 Talin; 実装 Eric Smith。

## PEP 3105: `print` を関数にする

`print` 文は Python 3.0 では `print()` 関数になります。 `print()` が関数になることで、 `def print(...)` やなにかほかの場所からの新しい関数をインポートするなどの方法で置き換え可能になります。

Python 2.6 では `__future__` インポートで 言語構文としての `print` を取り除き、関数形式のものを代わりに使えるように出来ます。たとえば:

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

この新しい関数のシグネチャは以下の通りです:

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

パラメータは以下のとおりです:

- args: 出力される値を指定する位置引数リスト。

- sep: 引数リスト args を出力するのに使われる区切り文字。

- end: 引数リスト args を全て出力したあとに出力するテキスト。

- file: 出力が送られるファイルオブジェクト。

参考

PEP 3105 - print を関数にする

  Georg Brandl 著の PEP。

## PEP 3110: 例外処理の変更

Python プログラマが時折やらかしてしまう誤りの一つにこんなのがあります:

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

このコードの作者はきっと `TypeError` 例外と `ValueError` 例外の両方とっつかまえてやろうと思ったのでしょうが、このコードは実際にはちょっと違ったことをします: `TypeError` を捕捉したらこれを `"ValueError"` というローカル名の例外オブジェクトに束縛します…。 `ValueError` 例外は決して捕捉されません。正しくは、例外のタプルで指定します:

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

こんなことが起こってしまうのは、ここではカンマの使用が曖昧だからです: それ、解析木内で 2 つのノードを示すのかな、タプルな単一ノードかしら?

Python 3.0 はカンマからワード "as" に置き換えてこの曖昧さをなくします。例外を捕捉して例外オブジェクトを `exc` に記憶するには、こう書かなければなりません:

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

Python 3.0 は "as" の使用のみをサポートするようになるので、最初の例は 2 つの異なる例外を捕捉するものとして翻訳されます。Python 2.6 ではカンマも "as" もサポートするので、既存のコードはそのまま動作します。新たに 2.6 で実行される Python コードを書くならば、 "as" の使用を勧めます。

参考

PEP 3110 - Python 3000 での例外の捕捉

  PEP 著と実装 Collin Winter.

## PEP 3112: バイトリテラル

Python 3.0 は Unicode を言語の基本文字列型として採用し、8 ビットリテラルは異なった記法で指示します。それには `b'string'` とするか、 `bytes` のコンストラクタを用います。前方互換のために、Python 2.6 は `str` 型に対する別名として `bytes` を追加のうえで、 `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)` とすることでしょう。またこれは、 2.x コードが文字列として ASCII 文字と 8 ビットバイトのどちらを意図しているのか知ることが出来ない 2to3 コンバータの助けになります; あなたは今や `bytes` と `str` の区別を、あなたの意図を正確に表現するのに使えます。そして結果のコードは Python 3.0 で正しいものに修正されるでしょう。

全ての文字列リテラルを Unicode 文字列としてしまう `__future__` インポートもあります。これは Unicode 文字を含むのに `\u` エスケープシーケンスを使えることを意味します。

    from __future__ import unicode_literals

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

    print len(s)               # 12 Unicode characters

At the C level, Python 3.0 will rename the existing 8-bit string type, called `PyStringObject` in Python 2.x, to `PyBytesObject`. Python 2.6 uses `#define` to support using the names `PyBytesObject()`, `PyBytes_Check()`, `PyBytes_FromStringAndSize()`, and all the other functions and macros used with strings.

`bytes` 型のインスタンスは単に文字列と同じで immutable です。 `bytearray` 型が、バイト列を mutable シーケンスとして格納するものとして新しく追加されました:

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

Byte arrays support most of the methods of string types, such as `startswith()`/`endswith()`, `find()`/`rfind()`, and some of the methods of lists, such as `append()`, `pop()`, and `reverse()`.

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

対応する C API もあります。 `PyByteArray_FromObject()`, `PyByteArray_FromStringAndSize()` や色々その他関数です。

参考

PEP 3112 - Python 3000 でのバイトリテラル

  PEP 著 Jason Orendorff; 2.6 へのバックポート Christian Heimes.

## PEP 3116: 新しい I/O ライブラリ

Python's built-in file objects support a number of methods, but file-like objects don't necessarily support all of them. Objects that imitate files usually support `read()` and `write()`, but they may not support `readline()`, for example. Python 3.0 introduces a layered I/O library in the `io` module that separates buffering and text-handling features from the fundamental read and write operations.

`io` モジュールによって提供される抽象基底クラスには 3 つのレベルがあります:

- `RawIOBase` defines raw I/O operations: `read()`, `readinto()`, `write()`, `seek()`, `tell()`, `truncate()`, and `close()`. Most of the methods of this class will often map to a single system call. There are also `readable()`, `writable()`, and `seekable()` methods for determining what operations a given object will allow.

  Python 3.0 はこのクラスのファイルとソケットに対する具象実装を持っていますが、Python 2.6 はファイル、ソケットオブジェクトのこの方法での再構築はしていません。

- `BufferedIOBase` is an abstract base class that buffers data in memory to reduce the number of system calls used, making I/O processing more efficient. It supports all of the methods of `RawIOBase`, and adds a `raw` attribute holding the underlying raw object.

  There are five concrete classes implementing this ABC. `BufferedWriter` and `BufferedReader` are for objects that support write-only or read-only usage that have a `seek()` method for random access. `BufferedRandom` objects support read and write access upon the same underlying stream, and `BufferedRWPair` is for objects such as TTYs that have both read and write operations acting upon unconnected streams of data. The `BytesIO` class supports reading, writing, and seeking over an in-memory buffer.

- `TextIOBase`: Provides functions for reading and writing strings (remember, strings will be Unicode in Python 3.0), and supporting universal newlines. `TextIOBase` defines the `readline()` method and supports iteration upon objects.

  There are two concrete implementations. `TextIOWrapper` wraps a buffered I/O object, supporting all of the methods for text I/O and adding a `buffer` attribute for access to the underlying object. `StringIO` simply buffers everything in memory without ever writing anything to disk.

  (In Python 2.6, `io.StringIO` is implemented in pure Python, so it's pretty slow. You should therefore stick with the existing `StringIO` module or `cStringIO` for now. At some point Python 3.0's `io` module will be rewritten into C for speed, and perhaps the C implementation will be backported to the 2.x releases.)

Python 2.6 では根底にある実装が `io` モジュールのクラスの上に組み立てられるようには再構築されていません (訳注: Python HowTo の移植ガイドにも触れられている通り、2.7 も同じです)。このモジュールは 3.0 への前方互換のコードを書くのを容易にするために、また、開発者たちがバッファリング I/O とテキスト I/O を自身で書く労力を省くために提供されています。

参考

PEP 3116 - 新しい I/O

  PEP 著: Daniel Stutzbach, Mike Verdone, Guido van Rossum. 実装: Guido van Rossum, Georg Brandl, Walter Doerwald, Jeremy Hylton, Martin von Loewis, Tony Löwis, ほか.

## PEP 3118: 改訂版バッファプロトコル

バッファプロトコルは Python 型にその内部表現へのポインタをやりとりさせる、C レベル API です。例えば、メモリマップドファイルは文字のバッファとして見ることが出来ます。そしてこれは `re` のようなほかのモジュールが、それを文字列として扱って検索するようなことを許します。

バッファプロトコルの主なユーザは NumPy のような数値演算パッケージで、それらは呼び出し元がより遅い API を経由することなく直接的に行列にデータを書き込むことが出来るように、行列の内部表現を曝しています。この PEP は NumPy 開発の経験を踏まえてバッファプロトコルを更新するもので、行列の形状を表明したり、メモリ領域をロックしたりするような多数の新機能を追加します。

最重要の新規 C API 関数は `PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)` で、これはオブジェクトを受け取って、フラグをセットし、 `Py_buffer` 構造体にオブジェクトのメモリ表現についての情報を埋めます。オブジェクトはこの操作を、外部の呼び出し元がその内容を修正している間所定のメモリをロックするのに使えます。ですので対応する操作 `PyBuffer_Release(Py_buffer *view)` があり、これで外部呼出し元が処理を終えたことを表明します。

`PyObject_GetBuffer()` への flags 引数は返されるメモリについての制約条件を指定します。いくつかの例として:

- `PyBUF_WRITABLE` indicates that the memory must be writable.

- `PyBUF_LOCK` requests a read-only or exclusive lock on the memory.

- `PyBUF_C_CONTIGUOUS` and `PyBUF_F_CONTIGUOUS` requests a C-contiguous (last dimension varies the fastest) or Fortran-contiguous (first dimension varies the fastest) array layout.

`PyArg_ParseTuple()` のための 2 つの新しい書式化コード `s*` と `z*` は、パラメータとしてロックされたバッファオブジェクトを返します。

参考

PEP 3118 - 改訂版バッファプロトコル

  PEP 著: Travis Oliphant, Carl Banks; 実装: Travis Oliphant.

## PEP 3119: 抽象基底クラス

Some object-oriented languages such as Java support interfaces, declaring that a class has a given set of methods or supports a given access protocol. Abstract Base Classes (or ABCs) are an equivalent feature for Python. The ABC support consists of an `abc` module containing a metaclass called `ABCMeta`, special handling of this metaclass by the `isinstance()` and `issubclass()` builtins, and a collection of basic ABCs that the Python developers think will be widely useful. Future versions of Python will probably add more ABCs.

Let's say you have a particular class and wish to know whether it supports dictionary-style access. The phrase "dictionary-style" is vague, however. It probably means that accessing items with `obj[1]` works. Does it imply that setting items with `obj[2] = value` works? Or that the object will have `keys()`, `values()`, and `items()` methods? What about the iterative variants such as `iterkeys()`? `copy`and :meth:()`!update`? Iterating over the object with `iter()`?

The Python 2.6 `collections` module includes a number of different ABCs that represent these distinctions. `Iterable` indicates that a class defines `__iter__()`, and `Container` means the class defines a `__contains__()` method and therefore supports `x in y` expressions. The basic dictionary interface of getting items, setting items, and `keys()`, `values()`, and `items()`, is defined by the `MutableMapping` ABC.

あなた自身のクラスを特定の ABC から派生して、ABC のインターフェイスをサポートすることを示せます:

    import collections

    class Storage(collections.MutableMapping):
        ...

Alternatively, you could write the class without deriving from the desired ABC and instead register the class by calling the ABC's `register()` method:

    import collections

    class Storage:
        ...

    collections.MutableMapping.register(Storage)

For classes that you write, deriving from the ABC is probably clearer. The `register()` method is useful when you've written a new ABC that can describe an existing type or class, or if you want to declare that some third-party class implements an ABC. For example, if you defined a `PrintableType` ABC, it's legal to do:

    # 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 についてのチェックには分別を持ち、それが絶対的に必要な場合にだけそうするようにしましょう。

あなた自身の ABCs を書くには、クラス定義内のメタクラスとして `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):
            ...

In the `Drawable` ABC above, the `draw_doubled()` method renders the object at twice its size and can be implemented in terms of other methods described in `Drawable`. Classes implementing this ABC therefore don't need to provide their own implementation of `draw_doubled()`, though they can do so. An implementation of `draw()` is necessary, though; the ABC can't provide a useful generic implementation.

You can apply the `@~abc.abstractmethod` decorator to methods such as `draw()` that must be implemented; Python will then raise an exception for classes that don't define the method. Note that the exception is only raised when you actually try to create an instance of a subclass lacking the method:

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

Subclasses must then define a `readonly` property.

参考

PEP 3119 - 抽象基底クラスの導入

  PEP は Guido van Rossum と Talin によって著され、Guido van Rossum により実装されています。Python 2.6 へのバックポートは Benjamin Aranguren と Alex Martelli により行われました。

## PEP 3127: 整数リテラルのサポートと文法

Python 3.0 は octal (基数 8: 8 進数) 整数リテラルの構文を変更し、先行するゼロの代わりに "0o" または "0O" (「ゼロオー」)としています。また、 binary (基数 2: 2 進数) 整数リテラルのサポートを追加し、これは "0b" または "0B" で指示します。

Python 2.6 は先行するゼロの形式での 8 進数サポートをやめませんが、 "0o" と "0b" は追加サポートします:

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

ビルトイン関数 `oct()` はまだ先行ゼロ形式での表現を返します。新しいビルトイン関数 `bin()` は数値の 2 進数表現を返します:

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

ビルトイン `int()`, `long()` が、基数 8 か 0 を要求された場合の "0o" プレフィクス、基数 2 か 0 を要求された場合の "0b" プレフィクスをそれぞれ許容するようになりました(基数 base = 0 は文字列から基数を決めるべきであることを指示します):

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

参考

PEP 3127 - 整数リテラルのサポートと文法

  PEP 著 Patrick Maupin、2.6 へのバックポートは Eric Smith による。

## PEP 3129: クラスデコレータ

デコレータが拡張されて関数だけでなクラスにも使えるようになりました。今やこのように書くのは合法です:

    @foo
    @bar
    class A:
      pass

これは次と等価です:

    class A:
      pass

    A = foo(bar(A))

参考

PEP 3129 - クラスデコレータ

  PEP 著 Collin Winter.

## PEP 3141: 数値の型階層

Python 3.0 では Scheme の numeric tower に触発された、いくつかの数値型のための抽象基底クラスを追加しています。これらのクラスは `numbers` モジュール として 2.6 にバックポートされています。

一番てっぺんの汎用 ABC が `Number` です。これには何の演算も含まれず、オブジェクトがなんらか数値であることをチェックするためだけにあります。 `isinstance(obj, Number)` として使えます。

`Complex` は `Number` のサブクラスです。複素数は基礎的な追加の演算の加算、減算、積算、除算、累乗に耐えるとともに、実数部と虚数部の抽出と共役数の取得が出来ます。Python のビルトインの complex 型は `Complex` を実装しています。

`Real` は `Complex` から更に派生し、実数のみで動作する演算を追加しています: `floor()`, `trunc()`, 丸め, divmod, floor division, 比較、です。

`Rational` 数は `Real` からの派生で、プロパティ `numerator`, `denominator` を持ち、浮動小数点数への変換が出来ます。Python 2.6 は単純な有理数クラス `Fraction` を `fractions` モジュールに追加しています。(`Rational` ではなく `Fraction` なのは、 `numbers.Rational` と名前が衝突するのを避けるためです。)

`Integral` 数は `Rational` からの派生で、シフト演算 `<<`, `>>` が出来て、 `&` や `|` のようなビット演算で混ぜ合わせることができて、また、配列のインデクスとスライスの境界として使えます。

Python 3.0 では、その PEP は少し既存のビルトイン `round()`, `math.floor()`, `math.ceil()` を再定義していて、また、Python 2.6 にバックポートされている新しい `math.trunc()` を追加しています。 `math.trunc()` はゼロに向かう方向の丸めで、引数とゼロの間で一番近い `Integral` を返します。

参考

PEP 3141 - 数値の型階層

  PEP 著: Jeffrey Yasskin.

Guile マニュアルの Scheme's numerical tower 。

Scheme's number datatypes from the R5RS Scheme specification.

### `fractions` モジュール

数値型階層を埋めるべく、 `fractions` モジュールが有理数クラスを提供しています。有理数は分子(numerator)と分母(denominator)で構成される分数としてその値を格納し、浮動小数点数では近似しか出来ない `2/3` のような数を正確に表現出来ます。

`Fraction` のコンストラクタは 2 つの `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)

For converting floating-point numbers to rationals, the float type now has an `as_integer_ratio()` method that returns the numerator and denominator for a fraction that evaluates to the same floating-point value:

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

1./3 のような浮動小数点数で近似にしかならない値は、近似して単純化されたりはしないことに注意してください; その分数は浮動小数点数に 正確に 合うように試みられます。

`fractions` モジュールは、ずっと長い間 Python の `Demo/classes/` ディレクトリにいた Sjoerd Mullender による実装に基いています。この実装が Jeffrey Yasskin によって大幅に更新されました。

## その他の言語変更

Python 言語コアに小さな変更がいくつか行われました:

- `__main__.py` を含んだディレクトリ名と zip アーカイブ名をインタプリタに渡して直接実行出来るようになりました。そのディレクトリと zip アーカイブは自動的に sys.path エントリの先頭に追加されます。(Suggestion and initial patch by Andy Chu, subsequently revised by Phillip J. Eby and Nick Coghlan; bpo-1739468.)

- `hasattr()` 関数は `__getattr__()` メソッドが例外を起こすと何か失敗したのだと仮定して、全て捕捉して無視して `False` を返していました。ですがそのロジックは `KeyboardInterrupt` と `SystemExit` まで捕まえるべきではなかったのです。Python 2.6 では `hasattr()` はもはやそれら例外に出会ってもそれを捨てません。 (Fixed by Benjamin Peterson; bpo-2196.)

- `**` 構文を使ってキーワード引数を許容する関数を呼び出すのに、もう Python 辞書を使う必要はありません; 任意のマッピングプロトコルをサポートするオブジェクトで今では動作します:

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

  (Contributed by 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}

  以前はこれは構文エラーになっていました。 (Contributed by Amaury Forgeot d'Arc; bpo-3473.)

- 新しいビルトイン `next(iterator, [default])` は指定したイテレータより次のアイテムを返します。 iterator が使い果たされている場合、 default 引数が与えられていれがこれを、そうでなければ `StopIteration` 例外を起こします。 (Backported in bpo-2719.)

- Tuples now have `index()` and `count()` methods matching the list type's `index()` and `count()` methods:

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

  (Contributed by Raymond Hettinger)

- ビルトイン型が拡張スライス構文をサポートするために改善されています。色々な `(start, stop, step)` 組み合わせを受け付けます。以前はこれのサポートは限定的で、ものによっては動作しませんでした。 (Implemented by Thomas Wouters.)

- property に `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

- ビルトインの set 型のいくつかのメソッドが複数イテラブルを受け付けるようになっています: `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'])

  (Contributed by Raymond Hettinger.)

- たくさんの浮動小数点数機能が追加されました。 `float()` 関数は文字列 `nan` を IEEE 754 非数 (Not A Number) 値に変換し、 `+inf` と `-inf` は正あるいは負の無限大に変換します。これは IEEE 754 セマンティクスのあらゆるプラットフォームで動作します。 (Contributed by Christian Heimes; bpo-1635.)

  ほか `math` モジュールに `isinf()` と `isnan()` が追加されています; 浮動小数点数が、前者は無限大ならば、後者は非数ならばそれぞれ真を返します。 (bpo-1640)

  浮動小数点数を 16 進表記文字列に変換する変換関数が追加されています (bpo-3008)。これら関数は 10 進と 2 進との間の変換で起こる丸め誤差を持ち込まずに浮動小数点数と文字列表現の相互変換をします。浮動小数点数は文字列表現を返す `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) をサポートするシステムで 2 つの浮動小数点数から複素数を作る際に、 `complex()` コンストラクタがゼロの符号を維持するようになりました。 (Fixed by Mark T. Dickinson; bpo-1507.)

- `__hash__()` メソッドを親クラスから継承するクラスは、ハッシュ出来ないことを示すのに `__hash__ = None` をセット出来ます。これにより `hash(obj)` は `TypeError` を起こし、そのクラスは `Hashable` ABC を実装していないことを示します。

  `__cmp__()` か `__eq__()` を定義するのにその比較にオブジェクトの身元ではなくその値を使ったならば、あなたはこれをすべきです。全てのオブジェクトはその値として `id(obj)` を使うデフォルトのハッシュ化メソッドを持っています。親クラスから継承した `__hash__()` を削除する整理された方法はありません。ですのでオーバライドとしての `None` の代入が実装されました。 C API のレベルでは、拡張は `tp_hash` に `PyObject_HashNotImplemented()` をセット出来ます。 (Fixed by Nick Coghlan and Amaury Forgeot d'Arc; bpo-2235.)

- `GeneratorExit` 例外が `Exception` ではなく `BaseException` のサブクラスになっています。 `except Exception:` をする例外ハンドラが意図せず `GeneratorExit` 捕捉してしまうことがなくなります。 (Contributed by Chad Austin; bpo-1537.)

- ジェネレータオブジェクトが、そのジェネレータを返すオリジナルのコードオブジェクトを参照する `gi_code` 属性を持つようになりました。 (Contributed by Collin Winter; bpo-1473257.)

- ビルトイン関数 `compile()` が位置引数だけでなくキーワード引数も受け付けるようになりました。 (Contributed by Thomas Wouters; bpo-1444529.)

- `complex()` コンストラクタが括弧で囲まれた複素数表現文字列を受け付けるようになっています。 `complex(repr(cplx))` で元に戻せるということです。例えば `complex('(3+4j)')` は今では値 `(3+4j)` を返します。 (bpo-1491866)

- 文字列の `translate()` メソッドが変形テーブルパラメータとして `None` を受け付けるようになりました。そのまま同じものを返す変形として扱われます。これにより文字を削除する操作を実行するのが簡単になります。 (Contributed by Bengt Richter and implemented by Raymond Hettinger; bpo-1193128.)

- ビルトインの `dir()` 関数が、受け取ったオブジェクトの `__dir__()` メソッドをチェックするようになりました。このメソッドはそのオブジェクトで妥当な属性名を含む文字列のリストを返さなければなりません。これにより `dir()` が生成する値を制御出来ます。 `__getattr__()` や `__getattribute__()` メソッドを使うオブジェクトはこれを使うことで、約束するつもりの擬似属性を公表出来ます。 (bpo-1591665)

- Instance method objects have new attributes for the object and function comprising the method; the new synonym for `im_self` is `__self__`, and `im_func` is also available as `__func__`. The old names are still supported in Python 2.6, but are gone in 3.0.

- 目立たない変更: `locals()` 関数を `class` ステートメント内で使う際、結果の辞書はもはや自由変数を返しません。(この場合、自由変数は `class` ステートメント内で参照される変数で、クラスの属性ではありません。)

### 最適化

- `warnings` モジュールが C で書き直されました。これにより警告をパーサから発行出来、また、インタプリタの起動が高速化しています。 (Contributed by Neal Norwitz and Brett Cannon; bpo-1631171.)

- 型オブジェクトがメソッドのキャッシュを持つようになっています。これは個別のクラスについての正しいメソッド実装を見つけるのに必要な仕事を減らします。いったんキャッシュされれば、インタプリタは呼び出さなければならない正しいメソッドを知るために基底クラス群を横断しなくてもよくなります。基底クラスやクラス自身が修正されれば、Python の動的な振る舞いの面においても正しくあり続けなければならないので、キャッシュはクリアされます。 (Original optimization implemented by Armin Rigo, updated for Python 2.6 by Kevin Jacobs; bpo-1700288.)

  デフォルトではこの変更は、Python コアに含まれる型のみに適用されます。拡張モジュールは必ずしもこのキャッシュに互換ではなく、拡張モジュールはメソッドキャッシュを有効にするために、モジュールの `tp_flags` フィールドに明示的に `Py_TPFLAGS_HAVE_VERSION_TAG` を追加しなければなりません。(このメソッドキャッシュに対して互換であるためには、拡張モジュールのコードは、それが実装するどんな型についても `tp_dict` メンバに直接アクセスしたり修正したりしてはなりません。ほとんどのモジュールはこれをしていませんが、Python インタプリタがそれを検知することは出来ません。 bpo-1878 にいくらかの議論がありますので参照してください。)

- キーワード引数を使う関数呼び出しが、素早くポインタで比較することで顕著に高速化しています。これは常に文字列丸ごとを比較する時間を省きます。 (Contributed by Raymond Hettinger, after an initial implementation by Antoine Pitrou; bpo-1819.)

- `struct` モジュールの全ての関数が C で書き換えられました。「Need For Speed スプリント」での作業の成果です。 (Contributed by Raymond Hettinger.)

- いくつかの標準ビルトイン型が、その型オブジェクトにビットをセットするようになりました。これは、オブジェクトがそれら型のサブクラスの一つであるかどうかのチェックするのを高速化します。 (Contributed by Neal Norwitz.)

- Unicode 文字列が、空白文字と改行を検出するためのコードにより高速な実装を使うようになりました; `split()` メソッドでおよそ 25% の速度向上、 `splitlines()` メソッドでは 35% です。(Contributed by Antoine Pitrou.) Unicode 文字列データのために pymalloc を使うことでメモリ使用が減りました。

- The `with` statement now stores the `__exit__()` method on the stack, producing a small speedup. (Implemented by Jeffrey Yasskin.)

- メモリ使用を減らすために、一番作られたオブジェクトをガーベージコレクトする際に、ガーベージコレクタが内部のフリーリストをクリアするようになりました。これはオペレーティングシステムにすぐに返されます。

### インタプリタの変更

Two command-line options have been reserved for use by other Python implementations. The `-J` switch has been reserved for use by Jython for Jython-specific options, such as switches that are passed to the underlying JVM. `-X` has been reserved for options specific to a particular implementation of Python such as CPython, Jython, or IronPython. If either option is used with Python 2.6, the interpreter will report that the option isn't currently used.

Python インタプリタに `-B` スイッチを渡すか、インタプリタ実行前に環境変数 `PYTHONDONTWRITEBYTECODE` をセットするかのどちらかで、 `.pyc` や `.pyo` が作られないようにすることが出来るようになりました。この設定は Python プログラムから `sys.dont_write_bytecode` 変数として利用可能で、Python コードはこの変数を変更してインタプリタの振る舞いを変えることが出来ます。 (Contributed by Neal Norwitz and Georg Brandl.)

標準入力、標準出力、標準エラー出力に使うエンコーディングを、インタプリタ起動前に環境変数 `PYTHONIOENCODING` を設定することで指定出来るようになりました。値は `<encoding>` または `<encoding>:<errorhandler>` 形式の文字列でなければなりません。 encoding 部分はエンコーディングの名前で、例えば `utf-8` や `latin-1` です; 省略可能な errorhandler 部分はエンコーディングによって処理出来ない文字に対して何をするのかを指定するもので、 "error", "ignore", "replace" のどれかです。 (Contributed by Martin von Löwis.)

## 新しいモジュールと改良されたモジュール

全てのリリースに置いて、 Python の標準ライブラリはたくさんの改良とバグ修正がされてきました。ここでは一部の注目に値する変更を、モジュール名で辞書順ソートしてリストアップしています。もっと完全な変更リストが見たければ、ソースツリー内の `Misc/NEWS` ファイルか、全ての完全な詳細が入っている Subversion のログを参照してください。

- The `asyncore` and `asynchat` modules are being actively maintained again, and a number of patches and bugfixes were applied. (Maintained by Josiah Carlson; see bpo-1736190 for one patch.)

- `bsddb` モジュールは新しいメンテナ Jesús Cea Avión を得て、パッケージは今ではスタンドアロンのパッケージとして入手可能です。パッケージのウェブページは www.jcea.es/programacion/pybsddb.htm です。このモジュールは Python 3.0 では標準ライブラリからは削除される予定です。というのも、これの更新ペースは Python のそれよりも遥かに頻繁だからです。

  `bsddb.dbshelve` モジュールは pickle 化で、プロトコル 1 に制限するのではなく利用出来る一番高いプロトコルバージョンを使うようになりました。(Contributed by W. Barnes.)

- The `cgi` module will now read variables from the query string of an HTTP POST request. This makes it possible to use form actions with URLs that include query strings such as "/cgi-bin/add.py?category=1". (Contributed by Alexandre Fiori and Nubis; bpo-1817.)

  The `parse_qs()` and `parse_qsl()` functions have been relocated from the `cgi` module to the `urlparse` module. The versions still available in the `cgi` module will trigger `PendingDeprecationWarning` messages in 2.6 (bpo-600362).

- `cmath` モジュールに大掛かりな改訂が行われました。Mark Dickinson と Christian Heimes による貢献です。5 つの新しい関数が追加されました:

  - `polar()` は複素数を極形式 (polar form) に変換し、複素数の絶対値 (modulus) と偏角 (argument) を返します。

  - `rect()` はその逆で、絶対値と偏角から対応する複素数に戻します。

  - `phase()` は複素数の偏角 (angle とも呼ばれています) を返します。

  - `isnan()` はその引数の実数部か虚数部のどちらかが NaN であれば真を返します。

  - `isinf()` はその引数の実数部か虚数部のどちらかが無限大であれば真を返します。

  その改訂では、 `cmath` モジュールの数値的安定性も改善されました。全ての関数で、結果の実数部、虚数部は最小精度単位で少しの範囲内で、可能な限り正確です。詳細は bpo-1381 を見てください。 `asinh()`, `atanh()`:, `atan()` に対する分岐截線 (branch cut) も修正されています。(--- 訳注: units of least precision に対する枯れた訳語はないようなので最小精度単位としていますが仮数部の最下位ビットのことです。ので、within a few ulps は下位数ビットという意味。分岐截線 (branch cut) は一般的な訳語かどうかはわかりませんが、wikipedia から採りました。---)

  そのモジュールのテストは大変拡大しました; およそ 2000 の新たなテストケースが数学関数群を鍛え上げます。

  IEEE 754 プラットフォームでは `cmath` モジュールは、IEEE 754 の特殊値と浮動小数点例外を、C99 標準の付録 'G' での一貫性のある方法で処理するようになりました。

- A new data type in the `collections` module: `namedtuple(typename, fieldnames)` is a factory function that creates subclasses of the standard tuple whose fields are accessible by name as well as index. For example:

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

  Several places in the standard library that returned tuples have been modified to return `namedtuple()` instances. For example, the `Decimal.as_tuple()` method now returns a named tuple with `sign`, `digits`, and `exponent` fields.

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

  (Contributed by Raymond Hettinger.)

- The `Cookie` module's `Morsel` objects now support an `httponly` attribute. In some browsers. cookies with this attribute set cannot be accessed or manipulated by JavaScript code. (Contributed by Arvin Schnell; bpo-1638033.)

- `curses` モジュールの新しい window メソッド `chgat()` は、一行での指定数ぶん文字の表示属性を変更します。 (Contributed by 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` クラスが上書きモードのほかに挿入モード編集をサポートするようになりました。挿入モードは `Textbox` インスタンス構築時に insert_mode パラメータを真にすることで有効になります。

- `datetime` モジュールの `strftime()` メソッドが `%f` 書式化コードをサポートするようになりました。これはオブジェクトのマイクロ秒をミリ秒としてゼロ埋めで 6 桁で展開します。 (---訳注: 言葉だけだとどうしても伝わりにくいですが、フィールドとしてミリ秒を持たずにマイクロ秒を持っている datetime で「秒.ミリ秒」という表記をするのにマイクロ秒精度まで表示するのが目的です。ですので 654 ミリ秒が「654000」と書式化されますし、32 ミリ秒は「032000」です。---) (Contributed by Skip Montanaro; bpo-1158.)

- The `decimal` module was updated to version 1.66 of the General Decimal Specification. New features include some methods for some basic mathematical functions such as `exp()` and `log10()`:

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

  `Decimal` クラスの `as_tuple()` メソッドが `sign`, `digits`, `exponent` フィールドを持った名前付きタプルを返すようになりました。

  (Implemented by Facundo Batista and Mark Dickinson. Named tuple support added by Raymond Hettinger.)

- `difflib` モジュールの `SequenceMatcher` クラスが、マッチを `a`, `b`, `size` 属性を持つ名前付きタプルで返すようになりました。 (Contributed by Raymond Hettinger.)

- `ftplib.FTP` クラスのコンストラクタと `connect()` メソッドに省略可能 `timeout` パラメータが追加されました。タイムアウトを秒で指定します。(Added by Facundo Batista.) また、 `FTP` クラスの `storbinary()` と `storlines()` メソッドが callback パラメータを新たに受け取ります。これはデータが送信されたあとでデータの各ブロックごとに呼び出されます。 (Contributed by Phil Schwartz; bpo-1221598.)

- ビルトイン関数の `reduce()` が `functools` モジュールでも利用可能です。Python 3.0 ではビルトイン関数は削除されて `functools` のものだけが使えます; 現在のところ 2.x シリーズでビルトイン版を削除する計画はありません。 (Patched by Christian Heimes; bpo-1739906.) (---訳注: 2.7 でも削除されていません。使用を検出するには `-3` オプションなどで警告をチェックしてください。 ---)

- 可能な場合には、 `getpass` モジュールはプロンプトメッセージ出力とパスワードの読み取りに `/dev/tty` を使うようになりました。利用出来ない場合は標準エラー出力と標準入力が使われます。端末に入力パスワードがエコーされるかもしれない場合、プロンプト表示の前に警告が出力されます。 (Contributed by Gregory P. Smith.)

- `glob.glob()` 関数が、Unicode パスが使われるかディレクトリ内に Unicode ファイル名がマッチすると Unicode ファイル名を返すようになりました。 (bpo-1001604)

- `heapq` モジュールの新しい関数 `merge(iter1, iter2, ...)` は、任意の数のソートされたデータを返すイテラブルを取り、全てのイテラブルの内容をソートされた順に返す新しいジェネレータを返します (---訳注: 誤解を招く表現なので補足しておきますが、入力のイテレータはソート済みであることを「仮定」し、出力のジェネレータは「入力が主張している」順序に従うだけです。入力がソートされていなくても並べ替えられるわけではありません。リファレンスにはここはきちんと書かれています。---)。例えば:

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

  もう一つの新たな関数 `heappushpop(heap, item)` は、 item を heap に push した後、pop を行って heap から最初の要素を返します。この一続きの動作を `heappush()` に引き続いて `heappop()` を別々に呼び出すよりも効率的に実行します。

  `heapq` は以前使っていた「以下(`<=`)」比較ではなく「より小さい(`<`)」比較だけを使って実装されています。これにより `heapq` に格納する型の要件が `list.sort()` メソッドに合致します。 (Contributed by Raymond Hettinger.)

- An optional `timeout` parameter, specifying a timeout measured in seconds, was added to the `httplib.HTTPConnection` and `HTTPSConnection` class constructors. (Added by Facundo Batista.)

- `getmoduleinfo()` や `getargs()` のようなほとんどの `inspect` モジュール関数が、名前付きタプルを返すようになりました。タプルのように振る舞うだけでなく、属性でアクセスすることも出来ます。 (Contributed by Raymond Hettinger.)

  モジュールには `isgenerator()`, `isgeneratorfunction()`, `isabstract()` を含むいくつかの新しい関数が追加されています。

- `itertools` モジュールにいくつかの関数が追加されています。

  `izip_longest(iter1, iter2, ...[, fillvalue])` はそれぞれの要素群からタプルを生成します; イテラブルの要素数がほかのものより短ければ欠落値として fillvalue が埋められます。例えば:

      >>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5]))
      ((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))

  `product(iter1, iter2, ..., [repeat=N])` は与えたイテラブルの直積 (Cartesian product)、つまりそれぞれのイテラブルから返るその要素たちの全てのありうる組み合わせを含むタプルの集合を返します。:

      >>> 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 回与えられたとみなします。単一のイテラブルに対しては 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)]

  2 つのイテラブルであれば 2N 要素タプルのリストで返ります:

      >>> list(itertools.product([1,2], [3,4], repeat=2))
      [(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4),
       (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4),
       (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4),
       (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]

  `combinations(iterable, r)` は、入力 iterable の要素からなる長さ r の部分列を返します (---訳注: 数学の初等組み合わせ論の「組合せ (combination)」 ---):

      >>> 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])` は入力 iterable の長さ r の順列を返します。 r が指定されなければ、イテラブルが生成する全要素数がデフォルトで使われます (---訳注: 数学の初等組み合わせ論の「順列 (sequence without repetition)」または群論や組合せ論の「置換 (permutation)」。リファレンスでは訳出で置換も順列も両方出てきていますが、高校教育で習う用語で「順列」が伝わりやすいのでここでは「順列」としています。 ---):

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

  (All contributed by Raymond Hettinger.)

- `logging` モジュールの `FileHandler` クラスとそのサブクラスの `WatchedFileHandler`, `RotatingFileHandler`, `TimedRotatingFileHandler` がそのコンストラクタで省略可能 delay パラメータを受け取るようになりました。 delay が真の場合、ログファイルのオープンは最初の `emit()` が呼び出されるまで延期されます。 (Contributed by Vinay Sajip.)

  `TimedRotatingFileHandler` ではコンストラクタに utc パラメータも取るようになっています。これが真の場合、 `when='midnight'` などの切り替え時刻判定とその生成ファイル名に UTC が使われます。

- いくつかの新しい関数が `math` モジュールに追加されました:

  - `isinf()` と `isnan()` は与えられた浮動小数点数が、順に、(正または負の) 無限大であるかどうか、非数 (NaN=Not a Number) であるかどうかを返します。

  - `copysign()` は IEEE 754 数の符号ビットをコピーします。 x の絶対値と y の符号ビットを組み合わせたものを返します。例えば `math.copysign(1, -0.0)` は -1.0 を返します。 (Contributed by Christian Heimes.)

  - `factorial()` は階乗を計算します。 (Contributed by Raymond Hettinger; bpo-2138.)

  - `fsum()` はイテラブルからの数列を、部分和の計算を通じて精度の損失を避けながら積み上げた合計の計算をします。 (Contributed by Jean Brouwers, Raymond Hettinger, and Mark Dickinson; bpo-2819.)

  - `acosh()`, `asinh()`, `atanh()` は逆双曲線関数を計算します。

  - `log1p()` は 1+x の自然対数 (底 e の対数) を返します。

  - `trunc()` はゼロに向かう方向に丸めを行い、与えられた引数とゼロに最も近い `Integral` を返します。これは PEP 3141: 数値の型階層 のバックポートの一部として追加されました。

- `math` モジュールは、特に浮動小数点例外と IEEE 754 の特殊値の処理において、プラットフォーム間に渡る振る舞いの一貫性をさらに高めるように改善されました。

  可能な場合にはいつでもこのモジュールは 754 の特殊値について、C99 標準の勧告に従います。例えば、 `sqrt(-1.)` は今ではほとんど全てのプラットフォームで `ValueError` となるはずで、 `sqrt(float('NaN'))` は全ての IEEE 754 プラットフォームで NaN を返すはずです。C99 標準の付録 'F' で 'divide-by-zero' または 'invalid' を伝えることを勧告している箇所では Python は `ValueError` を投げます。C99 標準の付録 'F' で 'overflow' を伝えることを勧告している箇所では Python は `OverflowError` を投げます。 (See bpo-711019 and bpo-1640.)

  (Contributed by Christian Heimes and Mark Dickinson.)

- `mmap` オブジェクトに `rfind()` メソッドが追加されています。部分文字列の検索を、末尾から後ろ向きに検索します。 `find()` には新しい引数 end パラメータが追加されていて、検索対象の終了位置を指定することが出来ます。 (Contributed by John Lenton.)

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

  (Contributed by Georg Brandl, after a suggestion by Gregory Petrosyan.)

  `attrgetter()` 関数がドット付きの名前を受け付け、対応する属性ルックアップをするようになりました:

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

  (Contributed by Georg Brandl, after a suggestion by Barry Warsaw.)

- `os` モジュールがいくつか新しくシステムコールをラップしています。開いたファイルについて、 `fchmod(fd, mode)` はモードを変更し、 `fchown(fd, uid, gid)` は所有権を変更し、 `lchmod(path, mode)` はシンボリックリンクのモードを変更します。 (Contributed by Georg Brandl and Christian Heimes.)

  `chflags()` と `lchflags()` は対応するシステムコール (利用可能であれば) へのラッパーで、ファイルのフラグを変更します。そのフラグ値についての定数が `stat` モジュールに定義されています; いくつかの取りうる値には、ファイルが変更されるべきではないことを伝える `UF_IMMUTABLE` 、ファイルにはデータの追記のみが可能であることを伝える `UF_APPEND` 、があります。 (Contributed by M. Levinson.)

  `os.closerange(low, high)` は効率よく全ての low から high のファイルデスクリプタをクローズします。全てのエラーは無視されます。それと high はクローズ対象ではないです。この関数は既に `subprocess` モジュールがプロセスを開始するのを高速化するために使われています。 (Contributed by Georg Brandl; bpo-1663329.)

- `os.environ` オブジェクトの `clear()` メソッドが、オブジェクトのキーから取り除くだけでなく `os.unsetenv()` を使って環境変数を未設定にするようになりました。 (Contributed by Martin Horcicka; bpo-1181.)

- `os.walk()` 関数に `followlinks` パラメータが追加されています。これを真にすると、シンボリックリンクが指す相手のディレクトリを渡り歩くようになります。後方互換のためにこのパラメータのデフォルトは偽です。なお、親ディレクトリを指すシンボリックリンクなど参照が循環していると、無限再帰に陥りますので注意してください。 (bpo-1273829)

- `os.path` モジュールの `splitext()` 関数が、先行するピリオドで分割しないように変更されています。これにより Unix のドットファイルの処理結果がよくなります。例えば `os.path.splitext('.ipython')` は `('', '.ipython')` ではなく `('.ipython', '')` を返すようになっています。 (bpo-1115886)

  新規関数 `os.path.relpath(path, start='.')` は、与えられれば `start` からの、与えられなければカレントディレクトリからの、目的地 `path` への相対パスを返します。 (Contributed by Richard Barran; bpo-1339796.)

  Windows において、 `os.path.expandvars()` が "%var%" 形式の記述に環境変数を展開し、 "~user" にユーザのホームディレクトリのパスを展開するようになりました。 (Contributed by Josiah Carlson; bpo-957650.) (---訳注: "~user" は実在した仕様かわかりません。2.7 に該当する実装もコメントも docstring もリファレンスもありませんし、当然この振る舞いは現在実在していません。---)

- `pdb` モジュールで提供される Python デバッガに新たなコマンドが追加されました: "run" はデバッグ対象の Python プログラムを再起動します。またオプションとして、対象プログラムに与えるコマンドライン引数を渡せます。 (Contributed by Rocky Bernstein; bpo-1393667.)

- トレースバックのデバッグを開始するのに使われる `pdb.post_mortem()` が、トレースバックが与えられない場合に `sys.exc_info()` からの戻り値のトレースバックを使うようになりました。 (Contributed by Facundo Batista; bpo-1106316.)

- `pickletools` モジュールに `optimize()` 関数が追加されました。これは pickle を含んだ文字列を受け取って、未使用 opcode を削除の上で同じデータ構造を含んだより小さい pickle を返します。 (Contributed by Raymond Hettinger.)

- `pkgutil` モジュールに `get_data()` 関数が追加されました。これはインストールされている Python パッケージに含まれるリソースファイルの内容を返します。例えば:

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

  (Contributed by Paul Moore; bpo-2439.)

- `pyexpat` モジュールの `Parser` オブジェクトで、 `buffer_size` 属性の設定により文字データの保持に使うバッファのサイズを変更出来るようになりました。 (Contributed by Achim Gaedke; bpo-1137.)

- `Queue` モジュールが、エントリを違った順序で取り出すような queue の変種をサポートするようになっています。 `PriorityQueue` クラスはキューアイテムをヒープで格納し、それを優先順で取り出します。 `LifoQueue` クラスは、最後にエントリに追加されたものを最初に取り出します。つまり stack のように振舞うということです。 (Contributed by Raymond Hettinger.)

- `random` モジュールの `Random` が、今では 32 ビットシステムで pickle 出来、64 ビットシステムで unpickle 出来、逆も出来ます。残念ながらこの変更は Python 2.6 の `Random` オブジェクトを以前の Python で正しく unpickle 出来ないことを意味します。 (Contributed by Shawn Ligocki; bpo-1727780.)

  新たな `triangular(low, high, mode)` は、三角分布 (triangular distribution) に従う乱数を生成します。 mode は分布内の最頻値で、返却値は high を含まない low と high の間です。 (Contributed by Wladmir van der Laan and Raymond Hettinger; bpo-1681432.)

- `re` モジュールによって実行される長い正規表現検索が届けられるシグナルをチェックするようになり、これにより多大な時間を要する検索を中断出来るようになります。 (Contributed by Josh Hoyt and Ralf Schmitt; bpo-846388.) (---訳注: 原文を忠実に訳すとわかりにくいですが、単に C のレベルでシグナルハンドラを仕掛けたので Python が割り込める、というのがここで言っていることです。本質的には「長い」や「時間のかかる」はあまり関係ないです。---)

  正規表現モジュールは、小さな正規表現固有仮想マシン用のバイトコードをコンパイルすることで実装されています。信頼出来ないコードにより、悪意あるバイトコード文字列を直接作って破滅させることが出来ます。ですので、2.6 では正規表現バイトコードの検証をするようにしてあります。(Contributed by Guido van Rossum from work for Google App Engine; bpo-3487.)

- The `rlcompleter` module's `Completer.complete()` method will now ignore exceptions triggered while evaluating a name. (Fixed by Lorenz Quack; bpo-2250.)

- `sched` モジュールの `scheduler` インスタンスが読み出し専用の `queue` 属性を持つようになりました。これはスケジューラのキュー内容を名前付きタプル `(time, priority, action, argument)` で返します。 (Contributed by Raymond Hettinger; bpo-1861.)

- The `select` module now has wrapper functions for the Linux `epoll()` and BSD `kqueue()` system calls. `modify()` method was added to the existing `poll` objects; `pollobj.modify(fd, eventmask)` takes a file descriptor or file object and an event mask, modifying the recorded event mask for that file. (Contributed by Christian Heimes; bpo-1657.)

- `shutil.copytree()` が省略可能引数 ignore を取るようになっています。呼び出し可能オブジェクトを渡します。この呼び出し可能オブジェクトはそれぞれのディレクトリパスとその内容リストを受け取って、コピーせずに無視したい名前のリストを返します。

  `shutil` モジュールでは同時に、この新たなパラメータのために使える `ignore_patterns()` も提供しています。 `ignore_patterns()` は任意の数の glob スタイルのパターンを取り、これらパターンに合致する任意のファイルとディレクトリを無視する呼び出し可能オブジェクトを返します。以下は、 `.svn` ディレクトリと '~' で終わるファイル名を持つ Emacs のバックアップファイルをスキップしてディレクトリコピーをする例です:

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

  (Contributed by Tarek Ziadé; bpo-2663.)

- Tkinter や GTK+ などのような場所で、シグナルハンドリングと GUI 処理のイベントループを組み合わせることは、長い間悩みの種でした; ほとんどのソフトウェアはポーリングを行って、わずかばかりの時間で起き上がっては GUI イベントが起きていないかチェックするハメになっています。 `signal` モジュールが、これをより効率的に行えるようにしました。 `signal.set_wakeup_fd(fd)` でファイルデスクリプタをセットすると、イベント受信時にファイルデスクリプタにバイトが書き込まれます。 C レベルの関数 `PySignal_SetWakeupFd()` もあります。同じくファイルデスクリプタを渡します。

  Event loops will use this by opening a pipe to create two descriptors, one for reading and one for writing. The writable descriptor will be passed to `set_wakeup_fd()`, and the readable descriptor will be added to the list of descriptors monitored by the event loop via `select()` or `poll()`. On receiving a signal, a byte will be written and the main event loop will be woken up, avoiding the need to poll.

  (Contributed by Adam Olsen; bpo-1583.)

  `siginterrupt()` 関数が Python コードから利用可能になりました。対象シグナルがシステムコールを中断出来るかどうかを変更出来ます。 (Contributed by Ralf Schmitt.)

  `setitimer()`, `getitimer()` 関数も追加されています (利用可能であれば)。 `setitimer()` は、指定時間経過後に処理にシグナルを届けます。時間は「壁時計時間 (wall-clock time)」(訳注: リファレンスでは「実時間」と表現している)、「プロセスの実行時間 (consumed process time)」、またはプロセス + システム時間の組合せで指定します。(Contributed by Guilherme Polo; bpo-2240.)

- `smtplib` モジュールが、 `SMTP_SSL` クラスの追加によって SMTP over SSL をサポートするようになっています。このクラスは既存の `SMTP` と同じインターフェイスです。(Contributed by Monty Taylor.) 両方のクラスのコンストラクタでは新たに省略可能な `timeout` パラメータを取ります。最初に接続を試みる際のタイムアウト値を秒で指定します。(Contributed by Facundo Batista.)

  LMTP プロトコル (RFC 2033) 実装もモジュールに追加されています。LMTP はメールキューを管理しないエージェント間で e-mail を転送する際に、SMTP の代わりに使われます。(LMTP implemented by Leif Hedstrom; bpo-957003.)

  `SMTP.starttls()` は今や RFC 3207 遵守であり、TLS ネゴシエーション自身で得たのでないサーバから得られるいかなる知識も記憶しません。(Patch contributed by Bill Fenner; bpo-829951.)

- The `socket` module now supports TIPC (https://tipc.sourceforge.net/), a high-performance non-IP-based protocol designed for use in clustered environments. TIPC addresses are 4- or 5-tuples. (Contributed by Alberto Bertogli; bpo-1646.)

  新規の `create_connection()` 関数はアドレスを取り、省略可能なタイムアウト値を使って接続を行い、接続されたソケットオブジェクトを返します。この関数は同時に、アドレスのタイプを調べて IPv4 と IPv6 の相応しい方を使って接続します。あなたのコードが `socket(socket.AF_INET, ...)` を使う代わりに `create_connection()` に乗り換えることは、それが IPv6 対応で必要なこと全て、となるでしょう。

- The base classes in the `SocketServer` module now support calling a `handle_timeout()` method after a span of inactivity specified by the server's `timeout` attribute. (Contributed by Michael Pomraning.) The `serve_forever()` method now takes an optional poll interval measured in seconds, controlling how often the server will check for a shutdown request. (Contributed by Pedro Werneck and Jeffrey Yasskin; bpo-742598, bpo-1193577.)

- Gerhard Häring により保守されている `sqlite3` モジュールが、Python 2.5 時のバージョン 2.3.2 からバージョン 2.4.1 に更新されました。

- The `struct` module now supports the C99 _Bool type, using the format character `'?'`. (Contributed by David Remahl.)

- The `Popen` objects provided by the `subprocess` module now have `terminate()`, `kill()`, and `send_signal()` methods. On Windows, `send_signal()` only supports the `SIGTERM` signal, and all these methods are aliases for the Win32 API function `TerminateProcess()`. (Contributed by Christian Heimes.)

- `sys` モジュールに新たに追加された変数 `float_info` は、 `float.h` に由来するプラットフォームの浮動小数点数サポートについての情報を含んだオブジェクトです。このオブジェクトの属性としては、 `mant_dig` (仮数部の桁数)、 `epsilon` (1.0 と、それより大きい表現可能な最小値との差)などがあります。 (Contributed by Christian Heimes; bpo-1534.)

  もう一つの新たな変数 `dont_write_bytecode` は Python がモジュールインポート時に `.pyc` や `.pyo` を作るかどうかを制御します。この変数が真ならば、コンパイル済みファイルは作られません。この変数は Python インタプリタを `-B` スイッチ付きで起動するか環境変数 `PYTHONDONTWRITEBYTECODE` をセットすることで初期設定されます。Python コードはこのあとでこの変数の値を変更することで、バイトコードファイルを作るかどうかを制御出来ます。 (Contributed by Neal Norwitz and Georg Brandl.)

  Python インタプリタに与えられたコマンドライン引数についての情報を、 `sys.flags` として利用可能な名前付きタプルで知ることが出来ます。例えば Python が冗長モードで起動された場合は `verbose` 属性は真となり、デバッグモードでは `debug` 属性が真、などです。これら属性は全て読み出し専用です。 (Contributed by Christian Heimes.)

  新しい関数 `getsizeof()` が追加されました。 Python オブジェクトを受け取り、そのオブジェクトが利用しているメモリサイズをバイト単位で返します。 ビルトインオブジェクトは正確な結果を返しますが、サードパーティの拡張は正確な値を返さないかもしれません。 その場合 `__sizeof__()` メソッドを定義してオブジェクトのサイズを返すことができます。 (Robert Schuppenies による貢献. bpo-2898)

  現在動作中のプロファイラとトレーサーを、 `sys.getprofile()` と `sys.gettrace()` で知ることが出来るようになりました。 (Contributed by Georg Brandl; bpo-1648.)

- `tarfile` モジュールが、既にサポートされている POSIX.1-1988 (ustar) と GNU tar フォーマットに加えて、POSIX.1-2001 (pax) をサポートするようになりました。デフォルトは GNU tar です; これと違うフォーマットでファイルを開くには `format` パラメータで指定します:

      tar = tarfile.open("output.tar", "w",
                         format=tarfile.PAX_FORMAT)

  新しい `encoding` と `errors` パラメータはエンコーディングと文字変換のエラー処理方法を指定します。 `'strict'`, `'ignore'`, `'replace'` は Python の 3 つの標準エラー処理です; `'utf-8'` は特殊で、不正な文字を、それの UTF-8 表現に置き換えます。(文字変換は、PAX フォーマットが Unicode ファイル名をサポートするために現れ、デフォルトは UTF-8 エンコーディングです。)

  The `TarFile.add()` method now accepts an `exclude` argument that's a function that can be used to exclude certain filenames from an archive. The function must take a filename and return true if the file should be excluded or false if it should be archived. The function is applied to both the name initially passed to `add()` and to the names of files in recursively added directories.

  (All changes contributed by Lars Gustäbel).

- An optional `timeout` parameter was added to the `telnetlib.Telnet` class constructor, specifying a timeout measured in seconds. (Added by Facundo Batista.)

- `tempfile.NamedTemporaryFile` クラスは普通はこれが作った一時ファイルを、ファイルクローズ時に削除します。この振る舞いを、コンストラクタのパラメータに `delete=False` を渡すことで変更出来るようになりました。 (Contributed by Damien Miller; bpo-1537850.)

  新しいクラス `SpooledTemporaryFile` は一時ファイルのように振舞いますが、そのデータは最大サイズを超えるまではメモリ内に格納されます。その制限を超えると、その内容がディスク上の一時ファイルに書き込まれます。 (Contributed by Dustin J. Mitchell.)

  `NamedTemporaryFile` と `SpooledTemporaryFile` のともにコンテキストマネージャとして動作しますので、 `with tempfile.NamedTemporaryFile() as tmp: ...` のように書くことが出来ます。 (Contributed by Alexander Belopolsky; bpo-2021.)

- The `test.test_support` module gained a number of context managers useful for writing tests. `EnvironmentVarGuard()` is a context manager that temporarily changes environment variables and automatically restores them to their old values.

  もう一つのコンテキストマネージャ `TransientResource` は、利用出来るかもしれないし出来ないかもしれないリソースの呼び出しを包むことが出来ます; 指定した例外リストを捕捉して無視します(---訳注: この紹介、良くないと思うのと、多分著者が誤解してます。確かに属性名/属性値を特定してこれに一致する場合にだけ例外を受け取るためのものなので、一致しないものは無視、という事実には反しませんが、「狙った例外は受け取る(ResourceDenied)」でもあるはずです。「期待した例外が発生する」ことをテストしたいでしょう、「期待しない例外はテストには関係ない」であるとともに。それとリファレンスと docstring によれば「指定した例外と属性に合致する場合に ResourceDenied」と言っているので、やはり事実とは反しています。---)。例えば、ネットワークのテストでは外部のウェブサイトとの接続時の特定の失敗を無視するでしょう:

      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"

  (Contributed by Brett Cannon.)

- The `textwrap` module can now preserve existing whitespace at the beginnings and ends of the newly created lines by specifying `drop_whitespace=False` as an argument:

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

  (Contributed by Dwayne Bailey; bpo-1581073.)

- `threading` モジュールの API が、 `setDaemon()`, `isDaemon()` メソッドではなく `daemon` のようにプロパティを使うように変更中です。また、いくつかのメソッドはキャメルケースではなくアンダースコアスタイルに名前変更されています; 例えば `activeCount()` メソッドは `active_count()` にリネームされます。2.6 と 3.0 の両バージョンのモジュールは同じプロパティとリネームされたメソッドをサポートしますが、古いメソッドは削除されません。古い API が Python 3.x で撤廃するのがいつになるのかは未定です; 2.x バージョンでは削除されないでしょう。 (Carried out by several people, most notably Benjamin Peterson.) (--- 訳注: 3.5 でもこの状態は続いたままです。今でもキャメルケーススタイルのメソッドが使えます。ですが、もちろん新しい名前を使うべきです。---)

  `threading` モジュールの `Thread` オブジェクトに `ident` プロパティが追加されています。スレッドの識別子を非ゼロの整数で返します。 (Contributed by Gregory P. Smith; bpo-2871.)

- `timeit` モジュールが、計測されるステートメントとセットアップコードとして、文字列だけでなく呼び出し可能オブジェクトを渡せるようになりました。 `Timer` インスタンスを作成する 2 つの便利関数が追加されています: `repeat(stmt, setup, time, repeat, number)` と `timeit(stmt, setup, time, number)` で、インスタンスを作成して対応するメソッドを呼びます。 (Contributed by Erik Demaine; bpo-1533909.)

- `Tkinter` モジュールが、オプションとしてリストとタプルを受け付けるようになっています。Tcl/Tk へは空白区切りの文字列にして渡されます。 (Contributed by Guilherme Polo; bpo-2906.)

- タートルグラフィックスのための `turtle` モジュールが Gregor Lingl により大幅に拡張されました。 モジュールの新しい機能は次の通りです:

  - 亀の移動と回転のアニメーションの改善。

  - 新しい `delay()` メソッド、 `tracer()` メソッド、 `speed()` メソッドを使って亀の動きをコントロールできるようになりました。

  - 亀に新しい姿を設定できたり、新しい座標系を定義できるようになりました。

  - Turtles now have an `undo()` method that can roll back actions.

  - マウスやキーボードからの入力イベントに反応するための簡易なサポートが入り、簡単なゲームを書けるようになりました。

  - `turtle.cfg` を使って、turtle の画面の起動時の見た目をカスタマイズできるようになりました。

  - モジュールの docstring が、他の言語に翻訳された docstring に置き換えられるようになりました。

  (bpo-1513695)

- An optional `timeout` parameter was added to the `urllib.urlopen` function and the `urllib.ftpwrapper` class constructor, as well as the `urllib2.urlopen` function. The parameter specifies a timeout measured in seconds. For example:

      >>> u = urllib2.urlopen("http://slow.example.com",
                              timeout=3)
      Traceback (most recent call last):
        ...
      urllib2.URLError: <urlopen error timed out>
      >>>

  (Added by Facundo Batista.)

- `unicodedata` モジュールで提供される Unicode データベースが、バージョン 5.1.0 に更新されました。 (Updated by Martin von Löwis; bpo-3811.)

- `warnings` モジュールの `formatwarning()` と `showwarning()` に省略可能な line 引数が追加されました。ソースコードの行番号を与えることが出来ます。 (Added as part of bpo-1631171, which re-implemented part of the `warnings` module in C code.)

  新しい関数 `catch_warnings()` はコンテキストマネージャで、テスト目的で警告フィルタを一時的に変更して元に戻すのに使えます。 (bpo-3781).

- The XML-RPC `SimpleXMLRPCServer` and `DocXMLRPCServer` classes can now be prevented from immediately opening and binding to their socket by passing `False` as the bind_and_activate constructor parameter. This can be used to modify the instance's `allow_reuse_address` attribute before calling the `server_bind()` and `server_activate()` methods to open the socket and begin listening for connections. (Contributed by Peter Parente; bpo-1599845.)

  `SimpleXMLRPCServer` はさらに `_send_traceback_header` 属性を持つようになりました。真の場合、例外とフォーマットされたトレースバックが HTTP ヘッダ "X-Exception" と "X-Traceback" として返ります。この機能はデバッグのみに使い、製品のサーバには使ってはなりません。トレースバックには剥き出しのパスワードが含まれるかもしれず、あるいはほかの何か企業秘密だったり国家秘密だったりするような繊細な情報満載かもしれないのです。 (Contributed by Alan McIntyre as part of his project for Google's Summer of Code 2007.)

- The `xmlrpclib` module no longer automatically converts `datetime.date` and `datetime.time` to the `xmlrpclib.DateTime` type; the conversion semantics were not necessarily correct for all applications. Code using `xmlrpclib` should convert `date` and `time` instances. (bpo-1330538) The code can also handle dates before 1900 (contributed by Ralf Schmitt; bpo-2014) and 64-bit integers represented by using `<i8>` in XML-RPC responses (contributed by 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()

  (Contributed by Alan McIntyre; bpo-467924.)

  `open()`, `read()`, `extract()` メソッドはファイル名か `ZipInfo` オブジェクトのどちらかを受け取れるようになっています。これは誤って重複したファイル名を含んでいるアーカイブで有用でしょう。 (Contributed by Graham Horler; bpo-1775025.)

  最後に、 `zipfile` がアーカイブするファイルのファイル名として Unicode の使用をサポートするようになりました。 (Contributed by Alexey Borzenkov; bpo-1734346.) (---訳注: リファレンスに注意事項として書かれていますが、zip ファイルのファイル名標準は存在しないのでこれは問題を起こすことがあります。---)

### `ast` モジュール

`ast` モジュールは Python コードの抽象構文木 (Abstract Syntax Tree) 表現を提供します。また、Armin Ronacher は共通タスクを実行するさまざまなヘルパー関数を寄稿しました。これらは HTML テンプレートパッケージであるとか、コードアナライザ、などなどの、Python コードを処理するツールで有用となるでしょう。

`parse()` 関数は式を受け取り AST を返します。 `dump()` 関数はツリー表現をデバッギングに相応しい出力をします:

    import ast

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

これの出力は深くネストされたツリーです:

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

`literal_eval()` メソッドは、文字列またはリテラル式を表現する AST を受け取り解析と評価を行い、結果の値を返します。リテラル式は、文字列、数値、辞書などのみを含む Python 式で、文や関数呼び出しを含みません。もしもあなたに式を評価する必要があって、だけれども `eval()` を呼び出すことによるセキュリティリスクを許容出来ないということであれば、 `literal_eval()` がそれを安全に処理してくれます:

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

モジュールには、AST を横断し、修正するための `NodeVisitor` と `NodeTransformer` クラス、例えば行番号の変更などの共通的な変形を行う関数群が含まれています。

### The `future_builtins` module

Python 3.0 makes many changes to the repertoire of built-in functions, and most of the changes can't be introduced in the Python 2.x series because they would break compatibility. The `future_builtins` module provides versions of these built-in functions that can be imported when writing 3.0-compatible code.

このモジュールに今のところ含まれるのは:

- `ascii(obj)`: 2.x の `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__()` メソッドを呼び出した結果を hexadecimal または octal に変換します。こちらのバージョンの `oct()` は新しい `0o` 記法で返却します。

### `json` モジュール: JavaScript オブジェクト記法

新しい `json` モジュールは、JSON (Javascript Object Notation) と Python 型のエンコーディング、デコーディングをサポートします。JSON は軽量なデータ交換フォーマットで、頻繁にウェブアプリケーションで使われます。JSON の詳細情報は http://www.json.org にあります。

`json` モジュールはほとんどのビルトイン型のデコーディングとエンコーディングサポートを備えています。以下の例は辞書のエンコードとデコードをしています:

    >>> 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 文字列の pretty-printing もサポートされています。

`json` (もともと simplejson と呼ばれていました) は Bob Ippolito によって書かれました。

### `plistlib` モジュール: プロパティリストパーサ

`.plist` フォーマットは Mac OS X で一般的に使われ、基本的なデータ型(数値、文字列、リスト、辞書)を XML ベースのフォーマットにシリアライズして格納します。データ型の XML-RPC シリアライズに似ています。

Mac OS X で主に使われるとはいえ、そのフォーマットはまったく Mac 固有ではなくその Python 実装は Python がサポートするあらゆるプラットフォームで動作するので、`plistlib` は標準ライブラリに昇格しました。

モジュールを使うのは単純です:

    import sys
    import plistlib
    import datetime

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

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

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

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

### ctypes の強化

Thomas Heller は `ctypes` モジュールの保守と拡張を続けました。

`ctypes` は今では C99 `bool` 型を表す `c_bool` データ型をサポートします。 (Contributed by David Remahl; bpo-1649190.)

`ctypes` の string, buffer, array 型が拡張スライスインデクス構文をサポートするように改善され、 `(start, stop, step)` の色々な組み合わせが使えます。 (Implemented by Thomas Wouters.)

全ての `ctypes` データ型が `from_buffer()`, `from_buffer_copy()` メソッドをサポートするようになりました。これは与えられた buffer オブジェクトに基く ctypes インスタンスを作ります。 `from_buffer_copy()` はそのオブジェクトの内容をコピーし、 `from_buffer()` はその同じメモリ領域を共有します。

新しい呼び出しの慣例は、 `ctypes` にそれぞれのラップされた呼び出しの発生時に `errno` あるいは Win32 LastError 変数をクリアすることを伝えることです。 (Implemented by Thomas Heller; bpo-1798.)

Unix `errno` 変数を関数呼び出し後に抽出できるようになっています。ラップされた関数を作る際、 `use_errno=True` を `DLL()` 関数へのキーワード引数として渡すことが出来、それによりモジュールレベル関数の `set_errno()` と `get_errno()` を、 errno 値を設定・取得するのに呼び出せます。

Win32 LastError は `DLL()`, `OleDLL()`, `WinDLL()` 関数で同じようにサポートされています。同じように `use_last_error=True` を与え、モジュールレベル関数 `set_last_error()` と `get_last_error()` を使います。

ctypes インスタンスへのポインタを抽出にするのに使われる `byref()` 関数が、省略可能な offset パラメータを受け取るようになりました。これは返されるポインタに追加されるバイト数です。

### SSL サポートの改善

Bill Janssen は Python 2.6 の Secure Sockets Layer サポートを大掛かりに改善しました。行われたのは新モジュール `ssl` の追加です。これは OpenSSL ライブラリの上に構築されています。この新しいモジュールはプロトコルのネゴシエイトのさらなる制御、X.509 証明書の使用、そして SSL サーバ (クライアントの対語としての) を Python で書くためのより良いサポートを提供しています。既存の `socket` モジュールにある SSL サポートは削除されずにそのまま使えますが、Python 3.0 では削除されます。

この新たなモジュールを使うには、まず最初にいつものやり方で TCP コネクションを作らなければなりません。そしてその上でそれを `ssl.wrap_socket()` 関数に渡します (---訳注: 2.7.9 ではさらに進化した `SSLContext.wrap_socket` が使えます ---)。証明書が必要かどうかを指定することが出来、証明書の情報を `getpeercert()` メソッドで取得することも出来ます。

参考

`ssl` モジュールについてのドキュメント。

## 非推奨と削除

- 文字列を例外として送出することは出来なくなりました。これをすると `TypeError` を起こします。

- Changes to the `Exception` interface as dictated by PEP 352 continue to be made. For 2.6, the `message` attribute is being deprecated in favor of the `args` attribute.

- (3.0 警告モード) Python 3.0 はたくさんの時代遅れのモジュールを削除し、ほかのものも名前変更するような標準ライブラリの再編成が特色となります。Python 2.6 を 3.0 警告モードで動かすと、それらがインポートされる際に警告が励起されます。

  The list of deprecated modules is: `audiodev`, `bgenlocations`, `buildtools`, `bundlebuilder`, `Canvas`, `compiler`, `dircache`, `dl`, `fpformat`, `gensuitemodule`, `ihooks`, `imageop`, `imgfile`, `linuxaudiodev`, `mhlib`, `mimetools`, `multifile`, `new`, `pure`, `statvfs`, `sunaudiodev`, `test.testall`, and `toaiff`.

- The `gopherlib` module has been removed.

- The `MimeWriter` module and `mimify` module have been deprecated; use the `email` package instead.

- The `md5` module has been deprecated; use the `hashlib` module instead.

- The `posixfile` module has been deprecated; `fcntl.lockf()` provides better locking.

- The `popen2` module has been deprecated; use the `subprocess` module.

- The `rgbimg` module has been removed.

- The `sets` module has been deprecated; it's better to use the built-in `set` and `frozenset` types.

- The `sha` module has been deprecated; use the `hashlib` module instead.

## ビルドならびに C API の変更

Python のビルド過程と C API の変更は以下の通りです:

- Python now must be compiled with C89 compilers (after 19 years!). This means that the Python source tree has dropped its own implementations of `memmove()` and `strerror()`, which are in the C89 standard library.

- Python 2.6 は Microsoft Visual Studio 2008 (version 9.0) でビルド出来ます。そしてこれが新しいデフォルトコンパイラです。 `PCbuild` ディレクトリのビルドファイルを参照して下さい。 (Implemented by Christian Heimes.)

- Mac OS X では、Python 2.6 は 4 種類のユニバーサルビルドでコンパイル出来ます。 configure スクリプトは `--with-universal-archs=[32-bit|64-bit|all]` スイッチを取って、32-bit アーキテクチャ (x86, PowerPC), 64-bit (x86-64 and PPC-64), あるいは両方のバイナリをビルド出来ます。 (Contributed by Ronald Oussoren.)

- A new function added in Python 2.6.6, `PySys_SetArgvEx()`, sets the value of `sys.argv` and can optionally update `sys.path` to include the directory containing the script named by `sys.argv[0]` depending on the value of an updatepath parameter.

  This function was added to close a security hole for applications that embed Python. The old function, `PySys_SetArgv()`, would always update `sys.path`, and sometimes it would add the current directory. This meant that, if you ran an application embedding Python in a directory controlled by someone else, attackers could put a Trojan-horse module in the directory (say, a file named `os.py`) that your application would then import and run.

  If you maintain a C/C++ application that embeds Python, check whether you're calling `PySys_SetArgv()` and carefully consider whether the application should be using `PySys_SetArgvEx()` with updatepath set to false. Note that using this function will break compatibility with Python versions 2.6.5 and earlier; if you have to continue working with earlier versions, you can leave the call to `PySys_SetArgv()` alone and call `PyRun_SimpleString("sys.path.pop(0)\n")` afterwards to discard the first `sys.path` component.

  Security issue reported as CVE 2008-5983; discussed in gh-50003, and fixed by Antoine Pitrou.

- BerkeleyDB モジュールが C API オブジェクトを公開しています。 `bsddb.db.api` として利用可能です。このモジュールは `bsddb` モジュールを自身の独自の目的で使いたいほかの C 拡張で使えます。 (Contributed by Duncan Grisby.)

- PEP 3118 改訂版バッファプロトコル で前述の新しいバッファインターフェイスのために、 `PyObject_GetBuffer()` と `PyBuffer_Release()` とほか少しの関数が追加されました。

- Python's use of the C stdio library is now thread-safe, or at least as thread-safe as the underlying library is. A long-standing potential bug occurred if one thread closed a file object while another thread was reading from or writing to the object. In 2.6 file objects have a reference count, manipulated by the `PyFile_IncUseCount()` and `PyFile_DecUseCount()` functions. File objects can't be closed unless the reference count is zero. `PyFile_IncUseCount()` should be called while the GIL is still held, before carrying out an I/O operation using the `FILE *` pointer, and `PyFile_DecUseCount()` should be called immediately after the GIL is re-acquired. (Contributed by Antoine Pitrou and Gregory P. Smith.)

- 異なるスレッドから同時にモジュールをインポートすることでデッドロックが発生することはなくなりました; 今では `ImportError` になります。新たな API 関数 `PyImport_ImportModuleNoBlock()` は最初に `sys.modules` を探し、インポートロック獲得後にインポートしようと試みます。インポートロックが他のスレッドにより獲得されていれば `ImportError` が発生します。(Contributed by Christian Heimes.)

- Several functions return information about the platform's floating-point support. `PyFloat_GetMax()` returns the maximum representable floating-point value, and `PyFloat_GetMin()` returns the minimum positive value. `PyFloat_GetInfo()` returns an object containing more information from the `float.h` file, such as `"mant_dig"` (number of digits in the mantissa), `"epsilon"` (smallest difference between 1.0 and the next largest value representable), and several others. (Contributed by Christian Heimes; bpo-1534.)

- `PyComplex_AsCComplex()` を使う C 関数とメソッドが `__complex__()` メソッドを持つ引数を受け付けるようになっています。特に、 `cmath` モジュールにある関数は、このメソッドを持つオブジェクトを受け付けます。これは Python 3.0 での変更のバックポートです。 (Contributed by Mark Dickinson; bpo-1675423.)

- Python C API に 2 つの大文字小文字を区別しない文字列比較関数 `PyOS_stricmp(char*, char*)` と `PyOS_strnicmp(char*, char*, Py_ssize_t)` が追加されました。 (Contributed by Christian Heimes; bpo-1635.)

- 多くの C 拡張が、 `init*` 関数内でモジュール辞書に整数と文字列定数を追加するために独自の小さなマクロを定義しています。 Python 2.6 ではついにモジュールに値を追加する標準マクロを定義しました。 `PyModule_AddStringMacro` と `PyModule_AddIntMacro()` です。 (Contributed by Christian Heimes.)

- Some macros were renamed in both 3.0 and 2.6 to make it clearer that they are macros, not functions. `Py_Size()` became `Py_SIZE()`, `Py_Type()` became `Py_TYPE()`, and `Py_Refcnt()` became `Py_REFCNT()`. The mixed-case macros are still available in Python 2.6 for backward compatibility. (bpo-1629)

- Distutils は C 拡張を、デバッグバージョンの Python 実行時に別のディレクトリにビルドするようになりました。 (Contributed by Collin Winter; bpo-1530959.)

- いくつかの基本データ型、例えば数値や文字列型は、あとで再利用されるオブジェクトのフリーリスト(---訳注: メモリ管理での alloc/free の free。---)を内部的に管理しています。それらデータ構造はこのフリーリストに関して、命名規約に従うようにしました; その変数名は常に `free_list` 、カウンタは常に `numfree` 、そしてマクロ `Py<typename>_MAXFREELIST` が必ず定義されます。

- 新たに追加された Makefile のターゲット "make patchcheck" は、Python ソースツリーに対してパッチを作る準備をします: 修正された `.py` ファイル全てに含まれる末尾の余分な空白を取り除き、ドキュメンテーションが変更されているかをチェックし、そして `Misc/ACKS` と `Misc/NEWS` が更新されているかどうかを報告します。 (Contributed by Brett Cannon.)

  もう一つの新しいターゲット "make profile-opt" は、GCC の profile-guided 最適化を使った Python バイナリをビルドします。これは Python をプロファイリングを有効にしてビルドし、プロファイル結果のセットを得るためのテストスイートを実施し、そして最適化のためにそれら結果を使ってビルドします。 (Contributed by Gregory P. Smith.)

### ポート特有の変更: Windows

- Windows 95, 98, ME, NT4 のサポートはとりやめられました。 Python 2.6 は最低でも Windows 2000 SP4 が必要です。

- Windows での新しいデフォルトコンパイラが Visual Studio 2008 (version 9.0) になっています。Visual Studio 2003 (version 7.1) と 2005 (version 8.0) のビルドディレクトリは PC/ に移動しました。新しい `PCbuild` ディレクトリは X64, デバッグビルド、Profile Guided Optimization (PGO) をサポートしています。PGO ビルドは通常ビルドに較べておよそ 10% 高速化になります。 (Contributed by Christian Heimes with help from Amaury Forgeot d'Arc and Martin von Löwis.)

- The `msvcrt` module now supports both the normal and wide char variants of the console I/O API. The `getwch()` function reads a keypress and returns a Unicode value, as does the `getwche()` function. The `putwch()` function takes a Unicode character and writes it to the console. (Contributed by Christian Heimes.)

- `os.path.expandvars()` は "%var%" 形式を環境変数で置換し、 "~user" をユーザのホームディレクトリパスに置換します(---訳注: 上のほうの訳注参照。---)。 (Contributed by Josiah Carlson; bpo-957650.)

- The `socket` module's socket objects now have an `ioctl()` method that provides a limited interface to the `WSAIoctl()` system interface.

- The `_winreg` module now has a function, `ExpandEnvironmentStrings()`, that expands environment variable references such as `%NAME%` in an input string. The handle objects provided by this module now support the context protocol, so they can be used in `with` statements. (Contributed by Christian Heimes.)

  `_winreg` also has better support for x64 systems, exposing the `DisableReflectionKey()`, `EnableReflectionKey()`, and `QueryReflectionKey()` functions, which enable and disable registry reflection for 32-bit processes running on 64-bit systems. (bpo-1753245)

- The `msilib` module's `Record` object gained `GetInteger()` and `GetString()` methods that return field values as an integer or a string. (Contributed by Floris Bruynooghe; bpo-2125.)

### ポート特有の変更: Mac OS X

- Python をフレームワークビルドでコンパイルする際に、 configure スクリプトに `--with-framework-name` オプションでフレームワーク名を指定出来るようになりました。

- The `macfs` module has been removed. This in turn required the `macostools.touched()` function to be removed because it depended on the `macfs` module. (bpo-1490190)

- Many other Mac OS modules have been deprecated and will be removed in 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`, and `terminalcommand`.

### ポート特有の変更: IRIX

A number of old IRIX-specific modules were deprecated and will be removed in Python 3.0: `al` and `AL`, `cd`, `cddb`, `cdplayer`, `CL` and `cl`, `DEVICE`, `ERRNO`, `FILE`, `FL` and `fl`, `flp`, `fm`, `GET`, `GLWS`, `GL` and `gl`, `IN`, `IOCTL`, `jpeg`, `panelparser`, `readcd`, `SV` and `sv`, `torgb`, `videoreader`, and `WAIT`.

## Python 2.6 への移植

このセクションでは前述の変更とバグフィックスにより必要となるかもしれないコードの変更を列挙します:

- ハッシュ化をサポートしないクラスはその定義内でその事実を示すために、 `__hash__ = None` をセットすべきです。

- 文字列を例外として送出することは出来なくなりました。これをすると `TypeError` を起こします。

- `collections.deque` の `__init__()` メソッドが、イテラブルから要素を追加する前に全ての deque の既存の内容をクリアするようになっています。この変更は `list.__init__()` の振る舞いと一致します(---訳注: 当たり前のことにしか思えないのですが詳細がわかりません。これ以前のバージョンでは deque はシングルトンのように振舞っていたのでしょうか。---)。

- `object.__init__()` は以前は任意の引数とキーワード引数を受け取り、そして無視していました。Python 2.6 ではもうこれは許されません。 `TypeError` を起こします。これは結果的に `object` の対応するメソッドを呼ぶ(おそらく `super()` を介して) `__init__()` メソッドに影響します。 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` を通じてそれのサブクラスです。 (Implemented by Gregory P. Smith; bpo-1706815.)

- The `xmlrpclib` module no longer automatically converts `datetime.date` and `datetime.time` to the `xmlrpclib.DateTime` type; the conversion semantics were not necessarily correct for all applications. Code using `xmlrpclib` should convert `date` and `time` instances. (bpo-1330538)

- (3.0 警告モード) `Exception` クラスはスライスやインデクスアクセスで警告を出します; `Exception` のタプルのような振る舞いはのちに取り除かれます。

- (3.0 警告モード) 2 つの辞書や 2 つの比較メソッドを実装しないオブジェクトの不等号比較は警告されます。 `dict1 == dict2` はまだ動作しますが、 `dict1 < dict2` はのちに取り除かれます。

  Python のスコープルールの実装の詳細であるセル間の比較も、警告を引き起こします。なぜならこれは、3.0 ではそのような比較は完全に禁止されているからです。

Python を埋め込んだアプリケーションでは:

- The `PySys_SetArgvEx()` function was added in Python 2.6.6, letting applications close a security hole when the existing `PySys_SetArgv()` function was used. Check whether you're calling `PySys_SetArgv()` and carefully consider whether the application should be using `PySys_SetArgvEx()` with updatepath set to false.

## 謝辞

著者は提案の申し出や修正、様々なこの記事の草稿の助けをしてくれた以下の人々に感謝します: Georg Brandl, Steve Brown, Nick Coghlan, Ralph Corderoy, Jim Jewett, Kent Johnson, Chris Lambacher, Martin Michlmayr, Antoine Pitrou, Brian Warner.