# What's New in Python 2.6

著者: | A.M. Kuchling (amk at amk.ca)

この文書は Python 2.6 の新機能について解説します。 Python 2.6 は 2008 年 10 月 1 日にリリースされました。リリーススケジュールは PEP 361 に記述されています。

Python 2.6 の主要なテーマは、大幅な言語の再設計となる Python 3.0 移行への道筋を準備することです。可能な場合にはいつでも、Python 2.6 は、古い機能や文法を削除することなく既存のコードの互換性を保てるようにしながら、3.0 より新機能と新文法を組み込んでいます。そうすることが出来ない場合には、Python 2.6 は、出来ることを出来るだけ試みました。それには `future_builtins` モジュールに互換関数を、また、Python 3 でサポートされなくなる用法についての警告を出すための `-3` スイッチ を追加しています。

`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 はいくつかの新しい組み込み関数を追加し、また、いくつかの既存の組み込み関数では意味を変更しています。Python 3.0 での新しい組み込み関数、例えば `bin()` などは単純に 2.6 に追加されましたが、既存のものはそうせずに、代わりに `future_builtins` モジュールに 3.0 版のものを追加しています。3.0 と互換性を持ちたいコードでは、必要に応じて `from future_builtins import hex, map` などとすることが出来ます。

新しいコマンドラインオプション `-3` で、Python 3.0 で削除される機能についての警告を受け取ることが出来ます。このスイッチで、3.0 にコードを移植するためにはどの程度の仕事が必要になるのか知ることが出来るでしょう。この値は Python コードからもアクセス出来て、ブーリアン値 `sys.py3kwarning` と、C 拡張 API では `Py_Py3kWarningFlag` です。

参考

Python 3.0 についての提案を含む PEP は 3xxx シリーズにあります。 PEP 3000 は Python 3.0 の開発プロセスについて記述しています。Python 3.0 の全般的な目標について記述している PEP 3100 から始めて、個別の機能についての提案のこれより番号が高い PEP を探索してみてください。

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

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

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

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

そのようなわけで、Python Software Foundation のインフラ委員会はボランティアたちに課題トラッカーについて、異なるプロダクトのセットアップをし、SourceForge からバグ報告とパッチのインポートをする依頼の呼び掛けをしました。4 つのトラッカーが試されました: Jira, Launchpad, Roundup, Trac です。委員会は結果として Jira と Roundup の 2 つを候補に据えました。Jira はフリーソフトウェアプロジェクトの無償でのホストが可能な商用製品です; Roundup はそれを運営するボランティアとそれをホストするサーバが必要なオープンソースプロダクトです。

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

Python バグトラッカーのホスティングは、南アフリカの Stellenbosch による Upfront Systems が快く提供してくれています。Martin von Loewis が SourceForge からバグ報告とパッチをインポートするのに多大な労力を払いました; 彼によるこのインポート操作のためのスクリプトは http://svn.python.org/view/tracker/importer/ にあります。これは SourceForge から Roundup へ移行したいと考えているほかのプロジェクトにも役に立つでしょう。

参考

https://bugs.python.org
  Python のバグトラッカー。
http://bugs.jython.org:
  Jython のバグトラッカー。
http://roundup.sourceforge.net/
  Roundup のダウンロードとドキュメント。
http://svn.python.org/view/tracker/importer/
  Martin von Loewis の変換スクリプト。

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

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

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

2.6 の開発サイクルの期間に、Georg Brandl はドキュメンテーションの処理のための新たなツールチェインの構築に多大な労力を払いました。 その成果であるパッケージは Sphinx と呼ばれ、 http://sphinx-doc.org/ で入手出来ます。

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

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

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

    with expression [as variable]:
        with-block

expression は評価されて結果がコンテキスト管理プロトコルをサポートするオブジェクトにならなければなりません (具体的にはメソッド `__enter__()` と `__exit__()` を持つオブジェクト)。 ( 訳注: Python ドキュメント全体で context manager protocol と context management protocol とで不統一。同じものです。 )

with-block が呼び出される前に、 `__enter__()` が呼ばれるので、セットアップコードをそこで実行出来ます。それは variable 名(与えられた場合)に束縛されることになる値も返します(注意深く読んで下さい、つまり variable には expression の結果が代入される のではない のです)。

with-block ブロックの実行が終了後、ブロックが例外を送出する場合であろうとオブジェクトの `__exit__()` が呼び出されますので、ここで後片付けコードを実行出来ます。

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

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

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

注釈

このケースでは、 f は `open()` が作ったオブジェクトと同じです。これはファイルオブジェクトの `file.__enter__()` が self を返しているからです。

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

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

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

`decimal` モジュール内の `localcontext()` 関数は現在の decimal のコンテキスト (計算の望みの精度と丸め特性をカプセル化しています) を保存しておいてあとで元に戻すのを簡単にしてくれます:

    from decimal import Decimal, Context, localcontext

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

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

### コンテキストマネージャを書く

中身を紐解いてみれば、 '`with`' ステートメントはけっこう入り組んでいます。ほとんどの人にとっては、既存のオブジェクトを '`with`' とともに使うだけのことでその詳細は知らなくても良いので、そうしたいならこのセクションの残りの部分は読み飛ばして結構です。新しいオブジェクトの作者は基礎となる実装の詳細について知る必要があります。このまま読み進めるべきです。

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

- expression は評価されて、 "コンテキストマネージャ(context manager)" にならなければなりません。コンテキストマネージャは `__enter__()` メソッドと `__exit__()` メソッドを持っていなければなりません。
- コンテキストマネージャの `__enter__()` メソッドが呼び出されます。これの戻り値は VAR に代入されます。 `as VAR` 節がない場合は、この値は単に捨てられます。
- BLOCK 内のコードが実行されます。
- BLOCK が例外を起こした場合、コンテキストマネージャの `__exit__()` メソッドが 3 つの引数とともに呼び出されます。これは例外の詳細です (`type, value, traceback`, これは `sys.exc_info()` が返す値と同じで、例外が起こらなければ `None` です)。そのメソッドの戻り値は例外を再送出するかどうかを制御します: 全ての偽の値ではその例外が再送出され、 `True` では揉み消します。例外を揉み消すなど滅多なことでは欲しいと思わないでしょう。もしそうしてしまったら、 '`with`' ステートメントを含んだコードの作者は何か間違ったことが起こったことに決して気付かないですから。
- BLOCK が例外を起こさなかった場合も `__exit__()` メソッドが呼び出されます。ただし type, value, traceback は全て `None` です。

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

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

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

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

トランザクションはブロック内のコードがつつがなく終了すればコミットし、例外が発生すればロールバックすべきです。私が思い描いている `DatabaseConnection` の基本的なインターフェイスはこんなです:

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

`__enter__()` メソッドはとっても簡単で、トランザクションを開始する必要があるだけです。このアプリケーションでは、カーソルオブジェクトを結果とすることが有用なので、メソッドはそれを返しましょう。ユーザはこれにより `as cursor` をその '`with`' ステートメントにつけて、そのカーソルを変数名に束縛できます:

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

`__exit__()` メソッドはそれがほとんどの仕事をしなければならない場所なので、もっと複雑です。メソッドは例外が起こったのかどうかをチェックし、例外が起こっていなければトランザクションをコミットし、例外があればロールバックしなければいけません。

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

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

### contextlib モジュール

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

デコレータは `contextmanager()` という名前で、新たにクラスを書く代わりに一つジェネレータを書けば済むようにするものです。そのジェネレータは正確に一つの値を yield しなければなりません。 `yield` より上の部分のコードが `__enter__()` メソッドとして実行されます。yield した値は `__enter__()` メソッドの戻り値となって、 '`with`' ステートメントの `as` 節があれば、その変数に束縛されます。 `yield` に続くコードが `__exit__()` メソッド内で実行されます。ブロック内では任意の例外が `yield` ステートメントによって引き起こされます。

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

    from contextlib import contextmanager

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

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

`contextlib` モジュールには `nested(mgr1, mgr2, ...)` 関数もあって、これはたくさんのコンテキストマネージャを組み合わせることが出来るので、入れ子の '`with`' を書く必要性をなくしてくれます。この例では、単一の '`with`' でデータベーストランザクション開始とスレッドのロック獲得の両方をやってのけています:

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

最後になりますが、 `closing()` 関数はその与えた引数をそのまま返して変数に束縛出来るようにし、かつブロックの終了で、与えた引数が持つ `.close()` を呼び出します:

    import urllib, sys
    from contextlib import closing

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

参考

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

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

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

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

Python 2.6 でのそれについてのフィックスは、モジュールに `__package__` 属性を追加するというものです。この属性がある場合は相対インポートは `__name__` 属性の代わりにこの属性の値からの相対でインポートします。

PEP 302 スタイルのインポーターはその結果 `__package__` を必要に応じて設定出来ます。 `-m` スイッチを実装している `runpy` モジュールは今はこれをするので、パッケージ内のモジュール実行内の相対インポートは、今では正しく動作します。(--- 訳注: このセクションの言いたいことの結論がわからない方はいないと思いますが、細かいところでこの翻訳を行っている 2015 年ではわからなくなっているところがあるので補足しておきます。 `__package__` 属性のくだりですが、現在となっては「2.5 ではこれを設定していなかった」のかどうか簡単には確認は出来ないですが、言語リファレンスによればローダが `__package__` をセットするのはオプションだがセットすべき、と書かれています。2.6 で行われたのは、おそらく `__package__` の用法が `runpy` きっかけで整理された、ということではないかと思います。---)

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

Python を実行すると、モジュール検索パス `sys.path` にはパスが `"site-packages"` で終わるディレクトリが普通含まれます。このディレクトリは、ローカルにインストールされる機器を使う全てのユーザが使えるパッケージあるいは固有のサイトインストレーションを持つ場所として意図されています。

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

- Unix と Mac OS X: `~/.local/`
- Windows: `%APPDATA%/Python`

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

このデフォルトディレクトリが好きでないなら、この機能をサポートする全ての Python バージョンが使う環境変数 `PYTHONUSERBASE` にルートディレクトリを指定することで上書き出来ます。Windows ではアプリケーション固有データの場所を環境変数 `APPDATA` で変更出来ます。また、あなたの Python インストレーションについての `site.py` ファイルを修正することでも出来ます。

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

参考

PEP 370 - ユーザごとの `site-packages` ディレクトリ
  PEP 著と実装 Christian Heimes.

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

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

`multiprocessing` モジュールは、 `threading` モジュールがスレッドの代わりにプロセスを使ようになるだけのような、完全な模倣となるよう開始されました。その目標は Python 2.6 へ向かう道のりを経て捨て去られはしましたが、モジュールの一般的なアプローチはそれでも似ています。基礎的なクラスは `Process` です。これには呼び出し可能オブジェクトと引数のコレクションを渡します。その `start()` メソッドが渡された呼び出し可能オブジェクトをサブプロセスで実行するので、 `is_alive()` メソッドを呼び出せばサブプロセスが実行中かを知ることが出来、 `join()` メソッドでそのプロセスが終了するのを待つことが出来ます。

ここに、サブプロセスが階乗を計算する例を示します。その計算をする関数はヘンテコリンに書かれていて、入力が 4 の倍数だととっても時間がかかるように仕組んであります。

    import time
    from multiprocessing import Process, Queue

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

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

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

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

        N = 5

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

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

`Queue` が階乗の結果を通信して返すのに使われています。 `Queue` オブジェクトはグローバル変数に格納されています。子プロセスは、子プロセスが作成された時点のその変数の値を使うことになります; `Queue` なので、親子はそのオブジェクトを通信のために使うことが出来ます。(プロセス作成後に親がグローバル変数 queue を差し替えても、子の値は左右されませんし、逆もしかりです。)

2 つのほかのクラス `Pool` と `Manager` はハイレベルインターフェイスです。 `Pool` では固定数のワーカープロセスを作ってワーカープロセスにリクエストを配ることが出来ます。 `apply()` または `apply_async()` メソッドで単体のリクエストを追加出来、 `map()` または `map_async()` メソッドでたくさんのリクエストを追加出来ます。以下のコードでは `Pool` を使って 5 つのワーカープロセスにリクエストをばら撒き、結果のリストを回収します:

    from multiprocessing import Pool

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

これは以下のような出力をします:

    1
    39916800
    51090942171709440000
    8222838654177922817725562880000000
    33452526613163807108170062053440751665152000000000
    ...

もう一方の方のハイレベルインターフェイス `Manager` クラスは、Python データ構造のマスターコピーを保持出来る、独立したひとつのサーバプロセスを作ります。ほかのプロセスたちは、これらデータ構造の読み書きと修正をプロキシオブジェクトを使って行えます。続く例では、 `dict()` メソッドを呼ぶことにより共有辞書を作ります; ワーカープロセスはその辞書へ挿入します。(ロックは自動的には行われませんがこの例では問題ではありません。 `Manager` のメソッドには `Lock()`, `RLock()`, `Semaphore()` メソッドも含まれていて、共有ロックを作るのに使えます。)

    import time
    from multiprocessing import Pool, Manager

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

        # Store result in dictionary
        dictionary[N] = fact

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

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

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

        # Wait for tasks to exit
        p.join()

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

これはこんな出力をするでしょう:

    1 1
    11 39916800
    21 51090942171709440000
    31 8222838654177922817725562880000000
    41 33452526613163807108170062053440751665152000000000
    51 15511187532873822802242430164693032110632597200169861120000...

参考

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

PEP 371 - multiprocessing パッケージの追加
  PEP 著 Jesse Noller と Richard Oudkerk; 実装 Richard Oudkerk と Jesse Noller.

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

Python 3.0 では % 演算子を補う、より強力な文字列フォーマッティングメソッドの `format()` が作られました。これをサポートする `str.format()` メソッドが Python 2.6 にバックポートされています。

2.6 では 8 ビット文字列と Unicode 文字列の両方が .format() メソッドを持ち、文字列をテンプレートとみなして、フォーマットに使われるべき引数を受け取ります。フォーマッティングのテンプレートには波括弧 ({, }) が特殊文字として使われます:

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

波括弧自身は二重に書くことでエスケープ出来ます:

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

フィールド名は、位置引数に対応する整数による `{0}`, `{1}`, …、またはキーワード引数に対応する名前です。属性を読み出したり辞書のキーにアクセスするような合成フィールド名(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'`) でパーセント記号付きで表示されます。

クラスと型は、自身がどのように書式化されるかをコントロールするために `__format__()` メソッドを定義出来ます。単一の引数として書式指定子を受け取ります:

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

ビルトインの `format()` もあって、単一の値をフォーマット出来ます。これは型の `__format__()` メソッドを与えられた指定子とともに呼び出します:

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

参考

書式指定文字列の文法
  リファレンスドキュメント。
PEP 3101: 進化版文字列フォーマッティング
  PEP 著 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

C API のレベルでは、Python 3.0 は既存の 8 ビット文字列型の名前を変えます。Python 2.x での `PyStringObject` は `PyBytesObject` になります。Python 2.6 では `PyBytesObject()`, `PyBytes_Check()`, `PyBytes_FromStringAndSize()` をはじめとする全ての文字列関数とマクロを `#define` を使ってサポートしています(訳注: pure Python レベルと同じく単なる PyString_* の別名として)。

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

`bytearray` は `startswith()`/`endswith()`, `find()`/`rfind()` のような文字列型のほとんどのメソッド、 `append()`, `pop()`, `reverse()` のようなリストのいくつかのメソッドをサポートします。

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

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

参考

PEP 3112 - Python 3000 でのバイトリテラル
  PEP 著 Jason Orendorff; 2.6 へのバックポート Christian Heimes.

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

Python ビルトインのファイルオブジェクトはたくさんのメソッドをサポートしていますが、ファイルライクなオブジェクトは必ずしもそのすべてをサポートする必要はありません。ファイルのまねごとをするオブジェクトは大抵 `read()` と `write()` をサポートしますが、 `readline()` はサポートしないかもしれません、例えば。Python 3.0 は `io` モジュールに、階層化された I/O ライブラリを導入しています。それは基礎的な読み書き操作からバッファリング機能とテキスト処理を分離しています。

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

- `RawIOBase` は剥き身の I/O 操作を定義します: `read()`, `readinto()`, `write()`, `seek()`, `tell()`, `truncate()`, `close()` 。このクラスのほとんどのメソッドが多くの場合単一のシステムコールに対応するでしょう。 `readable()`, `writable()`, `seekable()` メソッドも利用可能で、オブジェクトでどの操作が許されるのかを知るのに使えます。

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

- `BufferedIOBase` はデータをメモリにバッファすることでシステムコール使用回数を減らし、I/O 処理をより効率的に行うための抽象基底クラスです。 `RawIOBase` の全てのメソッドをサポートし、追加で基底の剥き身のオブジェクトを保持する `raw` 属性を持ちます。

  5 つの具象クラスがこの ABC を実装しています。 `BufferedWriter` と `BufferedReader` はランダムアクセスのための `seek()` を持ち、書き込みオンリーまたは読み込みオンリーの用途をサポートするオブジェクトのためのものです。 `BufferedRandom` オブジェクトはこれらと同じ前提のストリームでの読み書きアクセスをサポートし、 `BufferedRWPair` は、TTY のような、連続していないデータのストリームの上で読み書き操作両方を演じるオブジェクトのためのものです。 `BytesIO` クラスはインメモリのバッファ上での読み、書き、シークをサポートします。

- `TextIOBase`: 文字列 (忘れないで、Python 3.0 では文字列は Unicode になります) の読み書き関数を提供し、 universal newlines をサポートします。 `TextIOBase` は `readline()` メソッドをサポートし、また、オブジェクトを渡るイテレーションをサポートします。

  2 つの具象実装があります。 `TextIOWrapper` はバッファ化 I/O オブジェクトをラップし、テキスト I/O の全てのメソッドをサポートし、追加で元となるオブジェクトへのアクセスのための `buffer` 属性を持ちます。 `StringIO` はディスクへの一切の書き込みをせずに単純にメモリ内に全てをバッファします。

  (Python 2.6 では `io.StringIO` は pure Python で書かれているので、かなり遅いです。ですから今のところは既存の `StringIO` モジュール か `cStringIO` モジュールに留まっておくべきです。Python 3.0 の `io` モジュールは、ある時点で速度のために C に書き直されます。そしておそらくその実装は 2.x リリースにバックポートされます ( 訳注: 2.7 で実現 ) 。)

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 Lownds, ほか.

## 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` はメモリが書き込み可能でなければならないことを指示します。
> - `PyBUF_LOCK` は読み取り専用もしくはメモリの排他ロックを要求します。
> - `PyBUF_C_CONTIGUOUS` と `PyBUF_F_CONTIGUOUS` は C-contiguous (最後の次元が最初に動きます) または Fortran-contiguous (最初の次元が最初に動きます) の行列レイアウトを要求します。 (訳注: 日本でも馴染みのある用語ではいわゆる column-major order (列優先)、 row-major order (行優先) です。)

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

参考

PEP 3118 - 改訂版バッファプロトコル
  PEP 著: Travis Oliphant, Carl Banks; 実装: Travis Oliphant.

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

ある種のオブジェクト指向言語、たとえば Java などは、クラスが持つメソッドの集合やサポートするアクセスプロトコルを宣言するための「インターフェイス」をサポートしています。抽象基底クラス (ABCs=Abstract Base Classes)は Python でのこれと等価な機能です。ABC サポートは、 `ABCMeta` と呼ばれるメタクラスを含む `abc` モジュール、ビルトイン `isinstance()` と `issubclass()` のそのメタクラスについての特殊処理、それに Python 開発者が広範囲にわたって使えると考えた基礎的な ABCs のコレクションから成ります。たぶん将来のバージョンの Python ではもっとたくさんの ABCs が追加されると思います。

あなたがなにか特別なクラスを持っていて、辞書スタイルのアクセスをサポートするのか知りたいとしましょう。「辞書スタイル」ってなんでしょうね、それにしても。たぶんアイテムにアクセスするのに `obj[1]` が使えるでしょう。それは `obj[2] = value` のように値をセットするのも含まれるでしょうね? あるいは `keys()`, `values()`, `items()` メソッドを持ちますかね? `iterkeys()`みたいな列挙系はいかがでしょう? `copy()` と `update()` は? オブジェクトを巡回するのに `iter()` で出来ます?

Python 2.6 の `collections` モジュールには、この手の区別を表現出来るたくさんの ABCs が含まれています。 `Iterable` は `__iter__()` を定義したクラスを示し、 `Container` は `__contains__()` メソッドを定義していて、なので `x in y` 式をサポートしていることを意味します。アイテム取得、アイテムセット、 `keys()`, `values()`, `items()` という品揃えの基礎的な辞書インターフェイスは `MutableMapping` ABC で定義されています。

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

    import collections

    class Storage(collections.MutableMapping):
        ...

別の方法としては、望みの ABC から派生するのではなく、その ABC の `register()` メソッドを呼び出して登録することでも出来ます:

    import collections

    class Storage:
        ...

    collections.MutableMapping.register(Storage)

あなたが書くクラスでは ABC から派生するのが、たぶん綺麗で良いと思います。既存の型やクラスを記述出来る新しい ABC が書けた場合や、なにかサードパーティのクラスが実装する ABC を宣言したい場合などには `register()` メソッドが有用です。例えば、 `PrintableType` ABC を定義したのなら、今がそのとき、です:

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

クラスは ABC が規定するセマンティクスに従うべきですが、Python はそれをチェックは出来ません；その ABC の要求を理解してコードを適切に実装するのはクラスの作者任せです。

オブジェクトが特定のインターフェイスをサポートするかどうかをチェックするのには、今やこう書けます:

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

これからはたくさんのこのようなチェックをしなければならないのだ、この例のように、などとは思わないように。Python は至極ダックタイピングな流儀なのであって明示的な型チェックは決してされませんし、コードは単純にオブジェクトのメソッドを、それらメソッドがそこにあるはずで、なければ例外になるのを信じて呼ぶだけです。ABC についてのチェックには分別を持ち、それが絶対的に必要な場合にだけそうするようにしましょう。

あなた自身の 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):
            ...

上の `Drawable` ABC では、 `draw_doubled()` メソッドがオブジェクトをその 2 倍のサイズで描画しますが、 `Drawable` で示されたほかのメソッドのやり方で実現されるのでしょう。この ABC を実装するクラスは `draw_doubled()` のそれ自身の実装を提供する必要はないわけですが、実装しても良いです。一方 `draw()` の実装は必要です。その ABC が役に立つ汎用的な実装が提供出来ていないので。

`draw()` のような、実装が必須のメソッドに対して `@abstractmethod` デコレータを適用することが出来ます; Python はそのメソッドを実装しないクラスに例外を喰らわせます。サブクラスにそのメソッドが欠けていたとしても、インスタンスを実際に作ろうと試みてはじめて例外となることに注意しましょう:

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

抽象データ属性を `@abstractproperty` を使って宣言出来ます:

    from abc import abstractproperty
    ...

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

この場合サブクラスは `readonly()` プロパティを定義することが必須です。

参考

PEP 3119 - 抽象基底クラスの導入
  PEP は Guido van Rossum と 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 。

R5RS Scheme 仕様の Scheme's number datatypes 。

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

浮動小数点数を有理数に変換するのに、浮動小数点数型に `as_integer_ratio()` メソッドが追加されています。これはそれを評価して分数の分子と分母を返します:

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

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

`fractions` モジュールは、ずっと長い間 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.)

- タプルがリストと同じく `index()` と `count()` メソッドを持つようになっています:

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

- インスタンスメソッドオブジェクトが、そのメソッドを包含するオブジェクトと関数のための新たな属性を持つようになっています; `im_self` への新しい別名が `__self__` です。また `im_func` も `__func__` として利用可能です。古い名前は Python 2.6 で引き続きサポートされますが、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 を使うことでメモリ使用が減りました。

- `with` ステートメントが `__exit__()` メソッドをスタック上に保存するようになり、ちょっとだけ高速化しました。 (Implemented by Jeffrey Yasskin.)

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

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

Python のほかの実装で使うために、2 つのコマンドラインオプションが予約されました。 `-J` スイッチは Jython 固有のオプションのために予約されました。前提となる JVM に渡すスイッチなどに使います。 `-X` スイッチは個別の Python 実装、たとえば CPython、Jython や IronPython のために予約されました。Python 2.6 でどちらかのオプションが使われると、インタプリタはそのオプションは現在使われていないことを報告します。

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

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

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

- `asyncore` と `asynchat` モジュールが再び活発に保守され、多数のパッチとバグ修正が適用されました。 (Maintained by Josiah Carlson; see bpo-1736190 for one patch.)

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

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

- `cgi` モジュールが HTTP POST リクエストのクエリ文字列を読み取るようになりました。これにより URL に "/cgi-bin/add.py?category=1" のようにクエリ文字列を含む form アクションに使えるようになります。 (Contributed by Alexandre Fiori and Nubis; bpo-1817.)

  `parse_qs()`, `parse_qsl()` 関数を `cgi` モジュールから `urlparse` モジュールに移動しました。もとのバージョンは `cgi` モジュールにまだいて、2.6 では呼び出すと `PendingDeprecationWarning` メッセージが報告されます。 (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' での一貫性のある方法で処理するようになりました。

- `collections` モジュールに新しいデータ型が追加されています: `namedtuple(typename, fieldnames)` は、添え字だけでなく名前でもアクセス出来るフィールドを持った標準タプルのサブクラスを作るファクトリ関数です。例えば:

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

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

  標準ライブラリのいくつかの箇所で `namedtuple` インスタンスを返すように修正されています。例えば `Decimal.as_tuple()` メソッドは `sign`, `digits`, `exponent` フィールドを持った名前付きタプルを返すようになりました。

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

- `Cookie` モジュールの `Morsel` オブジェクトが `httponly` 属性をサポートするようになりました。いくつかのブラウザでは、この属性を付けたクッキーは JavaScript コードからアクセスや操作が出来ません。 (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」です。---)

- `decimal` モジュールが the General Decimal Specification のバージョン 1.66 に更新されました。新しい機能には `exp()` や `log10()` のようないくつかの基礎的な数学関数が含まれます:

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

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

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

- 省略可能パラメータ `timeout` が `httplib.HTTPConnection` と `HTTPSConnection` クラスのコンストラクタに追加されました。タイムアウトを秒で指定します。 (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.)

- `rlcompleter` モジュールの `Completer.complete()` メソッドが名前の評価時に引き起こされた例外を無視するようになりました。 (Fixed by Lorenz Quack; bpo-2250.)

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

- `select` モジュールに新たに Linux システムコール `epoll()` と BSD システムコール `kqueue()` へのラッパー関数が追加されました。既存の `poll` オブジェクトには新たに `modify()` メソッドが追加されています。 `pollobj.modify(fd, eventmask)` はファイルデスクリプタかファイルオブジェクトとイベントマスクを取り、そのファイルの記録イベントのマスクを修正します。(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()` もあります。同じくファイルデスクリプタを渡します。

  イベントループはこれを、読み込み用と書き込み用の 2 つのデスクリプタを作るパイプをオープンして使うことになるでしょう。書き込み用デスクリプタは `set_wakeup_fd()` に渡し、読み込み用デスクリプタはイベントループから `select()` や `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.)

- `socket` モジュールが TIPC (http://tipc.sourceforge.net/) をサポートするようになりました。これは高性能な非 IP ベースのプロトコルで、クラスタ環境で使われるように設計されたものです。TIPC のアドレスは 4 または 5 要素のタプルです。 (Contributed by Alberto Bertogli; bpo-1646.)

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

- `SocketServer` モジュール内の基底クラスが、 `timeout` 属性で指定の無応答時間経過後に `handle_timeout()` メソッドを呼び出すようになっています。 (Contributed by Michael Pomraning.) `serve_forever()` メソッドは、オプションの秒指定のポーリング間隔を取るようになりました。これは、サーバがシャットダウン要求のチェックをどの程度の頻度で行えばよいのかを制御します。 (Contributed by Pedro Werneck and Jeffrey Yasskin; bpo-742598, bpo-1193577.)

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

- `struct` モジュールが C99 の `_Bool` 型をフォーマット文字 `'?'` でサポートするようになりました。 (Contributed by David Remahl.)

- `subprocess` モジュールの `Popen` オブジェクトに `terminate()`, `kill()`, `send_signal()` メソッドが追加されました。Windows では `send_signal()` は `SIGTERM` シグナルのみがサポートされ、またこれら全てのメソッドは Win32 API 関数の `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 エンコーディングです。)

  `TarFile.add()` メソッドが新たに `exclude` 引数を受け付けます。これはアーカイブから特定のファイル名を除外するために呼び出される呼び出し可能オブジェクトです。ファイル名を受け取って、除外すべきファイルの場合に真、そうでなければ偽を返してください。この呼び出し可能オブジェクトは `add()` に最初に追加される名前と再帰的に追加されるディレクトリの名前の両方に適用されます。

  (All changes contributed by Lars Gustäbel).

- 省略可能パラメータ `timeout` が `telnetlib.Telnet` クラスのコンストラクタに追加されました。タイムアウトを秒で指定します。 (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.)

- `test.test_support` に、テストを書くのに便利な多くのコンテキストマネージャが追加されています。 `EnvironmentVarGuard()` は環境変数を一時的に変更して自動的に元に戻すコンテキストマネージャです。

  もう一つのコンテキストマネージャ `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.)

- `textwrap` モジュールで、行頭と新たに作る行の末尾にもともと含まれている空白文字を保ったままにすることが出来るようになりました。 `drop_whitespace=False` を指定します:

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

  (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 により大幅に拡張されました。 モジュールの新しい機能は次の通りです:

  - 亀の移動と回転のアニメーションの改善。
  - Control over turtle movement using the new `delay()`, `tracer()`, and `speed()` methods.
  - 亀に新しい姿を設定できたり、新しい座標系を定義できるようになりました。
  - 亀に、動作を巻き戻せる `undo()` メソッドが増えました。
  - マウスやキーボードからの入力イベントに反応するための簡易なサポートが入り、簡単なゲームを書くことができるようになりました。
  - `turtle.cfg` を使って、turtle の画面の起動時の見た目をカスタマイズできるようになりました。
  - モジュールの docstring が、他の言語に翻訳された docstring に置き換えられるようになりました。

  (bpo-1513695)

- 省略可能パラメータ `timeout` が `urllib.urlopen()` 関数と `urllib.ftpwrapper` クラスのコンストラクタ、 `urllib2.urlopen()` 関数に追加されました。タイムアウトを秒で指定します。例えば:

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

  (Added by Facundo Batista.)

- `unicodedata` モジュールで提供される Unicode データベースが、バージョン 5.1.0 に更新されました。 (Updated by Martin von Loewis; 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` also has a `_send_traceback_header` attribute; if true, the exception and formatted traceback are returned as HTTP headers "X-Exception" and "X-Traceback". This feature is for debugging purposes only and should not be used on production servers because the tracebacks might reveal passwords or other sensitive information. (Contributed by Alan McIntyre as part of his project for Google's Summer of Code 2007.)

- `xmlrpclib` モジュールが自動的に `datetime.date` と `datetime.time` を `xmlrpclib.DateTime` 型に変換することはなくなりました; 変換のセマンティクスが必ずしも全てのアプリケーションで正しいわけではありませんでした。 (bpo-1330538) `xmlrpclib` を使うコードは自分で `date` インスタンスと `time` インスタンスを変換すべきです。 そうしておくと、 1900 年以前の日付 (contributed by Ralf Schmitt; bpo-2014) と、XML-RPC レスポンス内で `<i8>` を使った 64 ビット整数表現 (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` クラス、例えば行番号の変更などの共通的な変形を行う関数群が含まれています。

### `future_builtins` モジュール

Python 3.0 はビルトイン関数のレポジトリにたくさんの変更を加えていて、そのほとんどが互換性を破壊するため Python 2.x シリーズには導入出来ません。 `future_builtins` モジュールは 3.0 互換コードを書くのにインポート出来る 3.0 互換関数セットです。

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

- `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` を起こします。

- PEP 352 で指示される `Exception` インターフェイスの変更が続けられています。 2.6 では、 `args` 属性を採用するので `message` 属性が非推奨となります。

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

  非推奨モジュールのリストです: `audiodev`, `bgenlocations`, `buildtools`, `bundlebuilder`, `Canvas`, `compiler`, `dircache`, `dl`, `fpformat`, `gensuitemodule`, `ihooks`, `imageop`, `imgfile`, `linuxaudiodev`, `mhlib`, `mimetools`, `multifile`, `new`, `pure`, `statvfs`, `sunaudiodev`, `test.testall`, `toaiff`.

- `gopherlib` モジュールは削除されました。

- `MimeWriter` モジュールと `mimify` モジュール は非推奨となっています。代わりに `email` パッケージを使ってください。

- `md5` モジュールは非推奨となりました。代わりに `hashlib` モジュールを使ってください。

- `posixfile` モジュールは非推奨となりました。 `fcntl.lockf()` がより良いロッキングを提供しています。

- `popen2` モジュールは非推奨となっています。 `subprocess` モジュールを使ってください。

- `rgbimg` モジュールは削除されました。

- `sets` モジュールは非推奨となりました。代わりにビルトインの `set`, `frozenset` 型を使ってください。

- `sha` モジュールは非推奨となりました。代わりに `hashlib` モジュールを使ってください。

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

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

- Python はもはや、 C89 コンパイラでコンパイルされなければなりません (19 年も経ってる!)。ですので Python ソースツリーからは、 `memmove()` と `strerror()` の手前実装が削除されています。C89 標準ライブラリにあるものですから。

- Python 2.6 は Microsoft Visual Studio 2008 (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.)

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

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

- Python の C stdio ライブラリの使用は今では、スレッドセーフ、もしくは、最低でも基底のライブラリと同じ程度にはスレッドセーフです。ファイルをあるスレッドが別スレッドで読み書き最中にクローズするとマズイことが起こるのは、もう長いこと居座り続けた潜在的なバグでした。2.6 ではファイルオブジェクトが参照カウントを持っていて、 `PyFile_IncUseCount()`, `PyFile_DecUseCount()` 関数で操作します。ファイルオブジェクトは参照カウントがゼロにならない限りクローズ出来ません。GIL が獲得されている間に `FILE *` ポインタを使った I/O 操作を実行する前に `PyFile_IncUseCount()` が呼び出されなければなりません。また、GIL の再獲得後に即座に `PyFile_DecUseCount()` が呼び出されなければなりません。(---訳注: 伝わりづらいので別の言い方で言い直すと「Inc してから GIL 解放して FILE* を弄び、済んだら GIL 再獲得して Dec する」。リファレンスのコード例ですぐにわかります。---) (Contributed by Antoine Pitrou and Gregory P. Smith.)

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

- いくつかの関数が、プラットフォームの浮動小数点サポートについての情報を返します。 `PyFloat_GetMax()` は浮動小数点数で表現出来る最大値を返し、 `PyFloat_GetMin()` は正の最小値を返します。 `PyFloat_GetInfo()` は `float.h` からの情報を含むオブジェクトを返し、これには `"mant_dig"` (仮数部桁数)、 `"epsilon"` (1.0 とそれより大きい表現可能な最小値との差)やほかのいくつかの情報を含みます。 (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.)

- いくつかのマクロが 3.0 と 2.6 の両方でリネームされました。それが関数ではなくマクロであることを明確にするためです。 `Py_Size()` は `Py_SIZE()` となり、 `Py_Type()` は `Py_TYPE()` に、そして `Py_Refcnt()` が `Py_REFCNT()` になっています。元の大小文字混在版は後方互換のために Python 2.6 では利用可能なままです。 (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 Loewis.)

- `msvcrt` モジュールはいまでは通常文字系とワイド文字系の両方のコンソール I/O API をサポートします。 `getwch()` 関数と `getwche()` 関数は打鍵を読み取り、Unicode 値を返します。 `putwch()` 関数は Unicode 文字を受け取り、コンソールに書き出します。 (Contributed by Christian Heimes.)

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

- `socket` モジュールのソケットオブジェクトが `ioctl()` メソッドを持つようになりました。 `WSAIoctl()` インターフェイスへの限定的なインターフェイスを提供します。

- `_winreg` モジュールに新しい関数 `ExpandEnvironmentStrings()` が追加されています。これは入力文字列が `%NAME%` のように参照されている場合に環境変数を展開します。このモジュールで提供されるハンドルオブジェクトはコンテキスト管理プロトコルをサポートするようになったので、 `with` ステートメントで使えます。 (Contributed by Christian Heimes.)

  `_winreg` は x64 システムのためのより良いサポートが追加されています。 64 ビットシステムで動作する 32 ビットプロセスでレジストリリフレクションを有無効化をする `DisableReflectionKey()`, `EnableReflectionKey()`, `QueryReflectionKey()` 関数を公開しています。 (bpo-1753245)

- `msilib` モジュールの `Record` オブジェクトに `GetInteger()` と `GetString()` メソッドが追加されました。フィールド値をそれぞれ数値として、または文字列として返します。 (Contributed by Floris Bruynooghe; bpo-2125.)

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

- Python をフレームワークビルドでコンパイルする際に、 configure スクリプトに `--with-framework-name` オプションでフレームワーク名を指定出来るようになりました。
- `macfs` モジュールは削除されました。これは同様に `macostools.touched()` 関数の削除を必要としました。それが `macfs` モジュールに依存していたので。 (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

たくさんの古い IRIX 固有のモジュールが非推奨となり、Python 3.0 では削除されます: `al` と `AL`, `cd`, `cddb`, `cdplayer`, `CL` と `cl`, `DEVICE`, `ERRNO`, `FILE`, `FL` と `fl`, `flp`, `fm`, `GET`, `GLWS`, `GL` と `gl`, `IN`, `IOCTL`, `jpeg`, `panelparser`, `readcd`, `SV` と `sv`, `torgb`, `videoreader`, `WAIT` 。

## Python 2.6 への移植

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

- ハッシュ化をサポートしないクラスはその定義内でその事実を示すために、 `__hash__ = 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.)

- `xmlrpclib` モジュールが自動的に `datetime.date` と `datetime.time` を `xmlrpclib.DateTime` 型に変換することは、もう二度としません; 変換のセマンティクスは必ずしも全てのアプリケーションで正しいわけではなかったのです。 `xmlrpclib` を使うコードは自分で `date` と `time` インスタンスを変換すべきです。(bpo-1330538)

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

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

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

## 謝辞

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