Python 2.7 基本チュートリアル: モジュール

.. _tut-modules:

************************

モジュールモジュール

*********** ******* *************

Pythonインタプリタを終了して再度入力すると、

作成した定義(関数や変数)は失われます。

少し長いプログラムを書きたい場合は、テキストエディタを使用してインタプリタ用の

入力を準備し、代わりにそのファイルを入力として実行する方が良いです。これは*スクリプトの作成として知られています。 *. プログラムが長くなるにつれて、メンテナンスを容易にするために

複数のファイルに分割することもできます。また、

定義をそれぞれにコピーせずに、複数のプログラムで作成した便利な関数を使用することもできます。 Program.

終了した場合 Python インタプリタが再起動すると、以前に作成されたすべての定義 (変数と関数) が失われます。したがって、長期間保存できるプログラムを作成したい場合は、テキストエディタを使用してプログラムを作成し、保存したファイルをインタプリタに入力するのが最善です。これを *スクリプト* の作成と呼びます。または、プログラムが長くなり、メンテナンスを容易にするために複数のファイルに分割することもあります。また、いくつかの

プログラムで一般的に使用される関数を使用したいが、その定義を各プログラムにコピーしたくない場合もあります。

これをサポートするために、Python には、

スクリプトまたはインタープリターの対話型インスタンスで定義を使用する方法があります。このようなファイルは、モジュールからの定義を

*モジュール*と呼びます。他のモジュールまたは *メイン* モジュール (トップレベルおよび電卓モードで実行される

スクリプトでアクセスできる変数のコレクション) に *インポート* できます。

これらのニーズを満たすために、Pythonスクリプトまたは

インタープリターの対話型インスタンスで使用するためにファイルから定義を取得するメソッドを提供します。このようなファイルは *モジュール* と呼ばれ、モジュール内の定義は別のモジュールまたはメイン モジュールに

インポート*

することができます (スクリプトの実行時に呼び出すことができる変数のセットは最上位にあり、

電卓モード) にあります。

モジュールは、Pythonの定義とステートメントを含むファイルです。ファイル名

は、拡張子:file:`.py`が付加されたモジュール名です。モジュール内では、

モジュールの名前が(文字列として)利用可能です。たとえば、お気に入りのテキストエディタを使用して、現在のディレクトリに次の内容の :file:`fibo.py` というファイル

を作成します。 Python の定義と宣言を含むファイルです。ファイル名は、モジュール名に :file:`.py` 接尾辞を加えたものです。モジュール

ブロックのモジュール名 (文字列として) は、グローバル変数 ``__name__`` から取得できます。たとえば、お気に入りのファイル エディタを使用して、現在のディレクトリに file:`fibo.py` というファイルを作成し、次の内容を入力します::

# フィボナッチ数 module

def fib(n ): # write nまでのフィボナッチ数列

a, b = 0, 1

while b < n:

print b,

a, b = b, a+b

def fib2(n ): # フィボナッチ数列を返すn

まで use using using using using ' ‐ ' s ‐ ‐ ‐ result.append(b)

a, b = 0, 1

結果を返します

次に、Python インタープリターに入り、これをインポートします次の

コマンドを使用してモジュールをインポートします:

次に、Python インタープリタに入り、次のコマンドを使用してこのモジュールをインポートします::

>>> import fibo

これでは、「」で定義された関数の名前は入力されません。 fibo`` を現在のシンボルテーブルに直接インポートします。そこにモジュール名 ``fibo`` を入力するだけです。モジュール名を使用すると、次の関数にアクセスできます。 fibo`` を現在のセマンティックテーブルにインポートします。モジュール名

``fibo`` をインポートするだけです。次のようにモジュール名を通じてこの関数にアクセスできます::

>>> fibo.fib(1000)

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

>> ;> fibo.fib2(100)

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

>>> fibo.__name__

関数を頻繁に使用する場合は、ローカル名を割り当てることができます:

関数を直接呼び出す場合は、通常、ローカル名を割り当てることができます::

>>> fibo .fib

>>> fib(500)

1 1 2 3 5 8 13 21 34 55 89 144 233 377

.. _tut-moremodules:

モジュールの詳細

================================

モジュールには、関数定義だけでなく実行可能なステートメントを含めることができます。

これらステートメントはモジュールを初期化することを目的としています。モジュールがどこかにインポートされたときのみ実行されます。[#]_

モジュールには関数定義と同様に実行ステートメントを含めることができます。これらのステートメントは通常、モジュールを初期化するために使用されます。これらは、モジュールが「最初」にインポートされるときに 1 回だけ実行されます。 [#]_

各モジュールには独自のプライベート シンボル テーブルがあり、モジュール内で定義されているすべての関数によってグローバル シンボル

テーブルとして使用されるため、モジュールの作成者は、モジュール内でグローバル変数を使用することができます

。一方、ユーザーのグローバル変数との偶発的な衝突

を心配する必要はありませんが、自分が何をしようとしているのかを知っていれば、その関数を参照するのと同じ表記法でモジュールのグローバル変数を操作できます

。 itemname``.

は、モジュール内のすべての関数を定義するグローバル セマンティック テーブルに対応し、各モジュールは独自のプライベート セマンティック テーブルを持ちます。したがって、モジュール作成者は、ユーザーのグローバル変数との競合によるエラーを引き起こすことなく、モジュール内の一部のグローバル変数を使用できます。一方、これが確実に必要な場合は、モジュール内の関数を参照するのと同じように、モジュール内のグローバル変数に次のようにアクセスできます: ``modname.itemname``。

モジュールは他のモジュールをインポートできます。慣習的ではありますが、すべての

:keyword:`import` ステートメントをモジュール (またはスクリプト) の先頭に配置する必要はありません。インポートされたモジュール名は に配置されます。インポートするモジュールのグローバル

シンボルテーブル。

モジュールは他のモジュールをインポート ( :keyword:`import` ) できます。すべての import ステートメントをモジュール (または

スクリプトなど) の先頭に配置するのが通例ですが、これは必須ではありません。インポートされたモジュール名は、このモジュールのグローバル構文に入力されます。

:keyword:`import` ステートメントには、

モジュールからインポートするモジュールのシンボル テーブルに名前を直接インポートするバリアントがあります。 例:

:keyword:`import` ステートメント インポートされたモジュールは、名前をこのモジュールのセマンティック テーブル。

例::

>>> from fibo import fib, fib2

>>> fib(500)

1 1 2 3 5 8 13 21 34 55 89 144 233 377

これは、

ローカルシンボルテーブルにインポートが取得されるモジュール名を導入しません (したがって、この例では、 ``fibo`` は定義されていません)。 上に示したように、 ``fibo`` は定義されていません。

モジュールが定義するすべての名前をインポートするバリアントもあります:

モジュール内のすべての定義をインポートする方法もあります::

>>> from fibo import *

>> ;> ; fib(500)

1 1 2 3 5 8 13 21 34 55 89 144 233 377

これは、アンダースコア (``_``) で始まる名前を除くすべての名前をインポートします。アンダースコア (``_``) で始まる名前。

一般に、モジュールまたはパッケージから ``*`` をインポートする行為は、コードが読みにくくなることがよくあるため、嫌われています

。しかし、対話型セッションでの入力を節約するためにこれを使用することは問題ありません

。

実際には、モジュールまたはパッケージからすべてをインポートするために ``*`` を使用することは、多くの場合推奨されないことに注意してください。これは、コードが読みにくくなるからです。ただし、対話型セッションで使用すると便利で簡単です。

.. note::

.. [#] 効率上の理由から、各モジュールはインタープリター

セッションごとに 1 回だけインポートされるため、モジュールを変更した場合は、

インタープリターを再起動する必要があります。これは対話的にテストしたい 1 つのモジュールにすぎません。

:func:`reload` を使用します。例: ``reload(modulename)``.

.. [#] パフォーマンス上の理由から、各インタープリタの各モジュールは 1 回につき 1 回だけインポートします。セッション。したがって、モジュールを変更する場合は、インタープリタを再起動する必要があります。または、単にそのようなモジュールを対話的にテストしたい場合は、 :func:`reload` を使用してリロードすることができます (たとえば、 `` reload(modulename)`` )。 。

.. _tut-modulesasscripts:

モジュールをスクリプトとして実行 モジュールをスクリプトとして実行

---------------------------- -- ---------------------

次のメソッドで Python モジュールを実行する場合:

次のメソッドを使用して Python モジュールを実行します::

python fibo .py < argument>

インポートした場合と同じようにモジュール内のコードが実行されますが、

``__name__`` が ``"__main__"`` に設定されていることを意味します。モジュールの最後にあるコード:

モジュール内のコードはインポートされたかのように実行されますが、__name____ は

``"__main__"`` に設定されています。これは、 module::

if __name__ == "__main__":

の後に次のコードを追加した場合と同じです。Y Import Sysm Fib (int (sys.argv [1]))

ファイルを SAN インポート可能モジュールとしてスクリプトとして使用できるようにすることができます。 is

は「メイン」ファイルとして実行されます:

は、モジュールとしてインポートされたときと同じように、このファイルをスクリプトとして実行できます。このコードは、モジュールが

"メイン" ファイルとして実行される場合にのみ呼び出されます::

$ python fibo.py 50

1 1 2 3 5 8 13 21 34

モジュールがインポートされる場合、コードは次のようになります実行されません:

モジュールがインポートされると、このコードは実行されません::

>>> import fibo

>>>

これは、便利なユーザー インターフェイスを提供するためによく使用されます。

テスト目的 (スクリプトとしてモジュールを実行すると、テスト スイートが実行されます)。

これは通常、テストを容易にするためにモジュールにユーザー インターフェイスを提供するために使用されます (スクリプトとしてモジュールを実行すると、テスト要件が実行されます)。 ）。

.. _tut-searchpath:

モジュール検索パスモジュール検索パス

---------------------------- --- ---------------

.. Index:: Triple: module; search; path

:mod:`spam` という名前のモジュールがインポートされると、インタープリターは検索します。現在のディレクトリにある :file:`spam.py` という名前のファイル

、そして環境変数 :envvar:`PYTHONPATH` で指定されたディレクトリのリスト

の場合、この

の構文はシェルと同じです。変数 :envvar: `PATH`、つまり

ディレクトリ名のリスト :envvar:`PYTHONPATH` が設定されていない場合、またはそこにファイルが見つからない場合、検索はインストールに依存するデフォルトで続行されます。パス;

Unix では、これは通常 :file:`.:/usr/local/lib/python` です。

:mod:`spam` というモジュールをインポートするとき、インタープリターは最初に

という名前のモジュールを検索します。現在のディレクトリ file:`spam.py` で、環境変数:envvar:`PYTHONPATH` で表されるディレクトリのリストを検索し、次に環境変数:envvar:`PATH` のパスのリストを検索します。

:envvar:`PYTHONPATH` が設定されていない場合、またはファイルが見つからない場合は、インストール ディレクトリを検索します。

Unix では、これは通常 :file:`.:/usr/local/lib/python` です。

実際には、モジュールは、入力スクリプト

を含むディレクトリ(または現在のディレクトリ)、:envvar:`PYTHONPATH`から初期化される変数

``sys.path``によって与えられるディレクトリのリスト内で検索されます。これにより、実行中の

スクリプトを含むディレクトリが検索パス上にあるため、実行内容を認識している Python プログラムがモジュールの検索パスを変更したり置き換えたりできることに注意してください。スクリプトの名前が標準モジュールと同じでないことが重要です。そうしないと、モジュールがインポートされるときに Python がスクリプトをモジュールとしてロードしようとします。これは通常、エラーになります。セクション :ref: を参照してください。詳細については、`tut-standardmodules` を参照してください。

実際、インタプリタは、sys.path 変数で指定されたパス ディレクトリでモジュールを検索します。このディレクトリには、デフォルトで入力スクリプト (または現在のディレクトリ) が含まれています。初期化されます

: envvar:`PYTHONPATH` とインストールディレクトリ。

これにより、Python プログラムはモジュール検索ディレクトリを変更または置換する方法を知ることができます。これらのディレクトリには検索パスで実行されるスクリプトが含まれているため、これらのスクリプトは標準モジュールと同じ名前であってはなりません。そうしないと、Python はモジュールのインポート時にこれらのスクリプトをモジュールとしてロードしようとします。通常、これによりエラーが発生します。詳細については、:ref:`tut-standardmodules` を参照してください。

「コンパイルされた」Python ファイル「コンパイルされた」Python ファイル

---------------------------------- -- -----------------

多くの標準モジュール

を使用する短いプログラムの起動時間の重要な高速化として、:file というファイルがある場合:`spam.pyc` は、:file:`spam.py` が見つかるディレクトリ

に存在します。これには、モジュール :mod:`spam ` のすでに「バイトコンパイルされた」バージョンが含まれていると想定されます。 :file:`spam.pyc` の作成に使用された :file:`spam.py` のバージョンの変更時刻

は、

:file:`spam.pyc` と :file:` .pyc に記録されます。これらが一致しない場合、` ファイルは無視されます。

多数の標準モジュールを参照する短いプログラムの場合、

:file:`spam ディレクトリにある場合、起動速度を向上させる重要な方法があります。 py` が見つかります :file:`spam.pyc` という名前のファイルが存在します。これは、:mod:`spam` モジュールの「バイトコンパイル済み」(バイトコンパイル済み) バージョンとして扱われます。 :file:`spam.pyc` の作成に使用された :file:`spam.py` のこのバージョンの変更時刻は、 :file:`spam.pyc` ファイルに記録されます。 2 つが一致しない場合、 :file: `.pyc` ファイルは無視されます。

通常、:file:`spam.pyc` ファイルを作成するために何もする必要はありません。

:file:`spam.py` が正常にコンパイルされると、書き込みが試行されます

コンパイルされたバージョンを :file:`spam.pyc` に書き込みます。この試みが失敗してもエラーではありません

。何らかの理由でファイルが完全に書き込まれなかった場合、結果として生成される

:file:`spam.pyc` ファイル:file:`spam.pyc` ファイルの内容は無効であると認識されるため、後で無視されます。そのため、Python

モジュール ディレクトリは、異なるアーキテクチャのマシンで共有できます。 't :file:`spam.pyc` ファイルを作成するために作業を行う必要はありません。 :file:`spam.py` が正常にコンパイルされると、対応するバージョンの :file:`spam.pyc` の生成が試行されます。何らかの理由で書き込みが失敗した場合、

によって生成された :file:`spam.pyc` ファイルは無効とみなされ、その後無視されます。 :file:`spam.pyc` ファイルの内容はプラットフォームに依存しないため、Python モジュール ディレクトリは異なるアーキテクチャのマシン間で共有できます。

専門家向けのヒント:

高度なヒント:

* :option:`-O` フラグを使用して Python インタープリターを呼び出すと、最適化された

コードが生成され、:file:`.pyo` ファイルに保存されますオプティマイザーは現在、あまり役に立ちません。 :keyword:`assert` ステートメントを削除するだけです。 :option:`-O` が使用されると、 *all* :term:`bytecode` が最適化されます。 pyc`` ファイルは無視され、``.py`` ファイルは最適化されたバイトコードにコンパイルされます。

:option:`-O` パラメータを使用して Python インタープリタを呼び出すと、最適化されたコードが生成され、次の場所に保存されます。ファイル: `.pyo` ファイル。現在のオプティマイザはあまり役に立ちません。アサーション ( :keyword:`assert` ) ステートメントを削除するだけです。 :option:`-O` 引数を使用すると、 *すべての* バイトコード ( :term:`bytecode` ) が最適化され、 ``.pyc`` ファイルは無視され、 ``.py` ` ファイルは最適化されたコードにコンパイルされます。 。

* 2 つの :option:`-O` フラグを Python インタプリタ (:option:`-OO`) に渡すと、バイトコード コンパイラーが最適化を実行し、まれにプログラムが誤動作する可能性があります

。 ``__doc__`` 文字列のみがバイトコードから削除され、よりコンパクトな :file:`.pyo` ファイルが生成されます。一部のプログラムでは、これらの文字列が利用可能であることに依存しているため、このオプションは次の場合にのみ使用してください。

2 つの :option:`-O` 引数 ( :option:`-OO` ) を Python インタプリタに渡すと、完全に最適化されたバイナリ コンパイルが実行されますが、これにより、エラー プログラムが生成されることがあります。現在のオプティマイザは、よりコンパクトな :file:`.pyo` ファイルを生成するために、文字

セクション コードから ``__doc__`` 文字列のみを削除します。

一部のプログラムはこれらの変数の可用性に依存しているため、このオプションは確実に使用できる場合にのみ使用してください。

* :file:`.pyc` または

:file:`.pyo` ファイルから読み取られた場合、プログラムは :file:`.py` ファイルから読み取られた場合よりも速く実行されません。 ; :file:`.pyc` または :file:`.pyo` ファイルの方が速い唯一の点は、ロードされる速度です

from:file:`.pyc` ファイルまたは :file :`.pyo` ファイル内のプログラムは、

:file:`.py` ファイルのプログラムよりも高速には実行されません。:file:`.pyc` または :file:`.pyo` ファイルは、

より高速にロードされるだけです。

* コマンドラインで名前を指定してスクリプトを実行する場合、

スクリプトのバイトコードは :file:`.pyc` または :file:`.pyo` ファイルに書き込まれることはありません。

スクリプトの起動時間は、コードの大部分をモジュールに移動し

、そのモジュールをインポートする小さなブートストラップ スクリプトを用意することで短縮できます。また、:file:`.pyc` または :file という名前を付けることも可能です

。 :`.pyo` ファイルをコマンド

ラインで直接実行します。

コマンドラインでその名前を指定してスクリプトを実行する場合、スクリプト用に作成されたバイナリ コードは :file:`.pyc` または :file に書き込まれません。 :`.pyo` ファイル。もちろん、スクリプトのメイン コードをモジュール

ブロックに移動し、このモジュールを小さな起動スクリプトとともにインポートすると、スクリプトの起動速度を向上させることができます。

コマンドラインで :file:`.pyc` または :file:`.pyo` ファイルを直接指定することもできます。

* ファイル :file:`spam を持たずに、 :file:`spam.pyc` (または :option:`-O` が使用されている場合は :file:`spam.pyo`

) という名前のファイルを持つことも可能です。同じモジュールの .py`。

これを使用すると、

リバース エンジニアリングが適度に難しい形式で Python コードのライブラリを配布できます。

同じモジュールの場合 (ここでは、ルーチン: file:` を参照します) spam .py` - 翻訳者)、:file:`spam.pyc` ファイル (

:option:`-O` パラメーターを使用する場合は :file:`spam.pyc`) のみを持つことができますが、 :file:` は持つことができませんspam.py` ファイル。このようにしてパッケージ化して公開することができます

リバースエンジニアリングが難しい Python コードベース。

..index:: module: COMPILEALL

* モジュール :mod:`compileall` は、:file:`.pyc` ファイル (または、:option:`-O の場合は :file:`.pyo`

ファイル) を作成できます。 ` は、ディレクトリ内のすべてのモジュールに対して使用されます)。

:mod:`compileall` モジュールは、指定されたディレクトリ内のすべてのモジュールに対して :file:`.pyc` ファイルを作成できます (または :file:`.pyo` を使用します)。 :file:`.pyo` ファイル)。

.. _tut-standardmodules:

標準モジュール 標準モジュール

================================

..index:: module: sys

Python には、別のドキュメントである Python ライブラリ リファレンス (以下、「ライブラリ リファレンス」) で説明されている標準モジュールのライブラリが付属しています。一部の

モジュールは、これらのインタープリタに組み込まれています。言語のコアの一部ではないが、

効率化のため、または

システムコールなどのオペレーティングシステムのプリミティブへのアクセスを提供する

操作へのアクセスを提供する。そのようなモジュールのセットは構成である。このオプションは基礎となるプラットフォームにも依存します

たとえば、:mod:`winreg` モジュールは Windows システムでのみ提供されます

1 つの特定のモジュールには注意が必要です:

:mod:`sys` に組み込まれています。すべての Python インタープリターの変数

``sys.ps1`` と ``sys.ps2`` は、プライマリおよびセカンダリとして使用される文字列を定義します

プロンプト:

Python には標準モジュール ライブラリが付属しており、スタンドアロンで配布されます。 Python ライブラリ リファレンス マニュアル

というタイトルのドキュメント (以降、「ライブラリ リファレンス マニュアル」と呼びます)。インタプリタにはいくつかのモジュールが組み込まれています。これらの操作のためのアクセス インターフェイスは言語コアの一部ではありませんが、すでにインタプリタに組み込まれています。これは効率を向上させるためだけでなく、システム コールなどのオペレーティング システムへのネイティブ アクセスのためのインターフェイスを提供するためでもあります。このタイプのモジュール コレクションは、基盤となるプラットフォームに依存する構成オプションです。たとえば、:mod:`winreg` モジュールは Windows システムでのみ使用できます

。注目に値する特定のモジュールが 1 つあります::mod:`sys`。このモジュールはすべての

Python インタープリターに組み込まれています。変数 sys.ps1 と sys.ps2 は、プライマリ プロンプト文字列とセカンダリ プロンプト文字列を定義します::

>>> '>>

>>> sys.ps2

'... '

>>> '

C> 'Yuck!'

C>

これら 2 つの変数は、インタープリターが対話モードの場合にのみ定義されます。

これら 2 つの変数は、インタープリターの対話モードでのみ意味を持ちます。

変数 ``sys.path`` は、インタープリタのモジュールの検索パスを決定する文字列のリストです。これは、

環境変数 :envvar:`PYTHONPATH` から取得されたデフォルトのパスに初期化されます。組み込みのデフォルト if

:envvar:`PYTHONPATH` は設定されていません。標準の list

operations:

を使用して変更できます。変数 ``sys.path`` は、インタープリタ モジュール検索用の文字列のリストです。パス。環境変数 :envvar:`PYTHONPATH` によって初期化されます。 :envvar:`PYTHONPATH` が設定されていない場合は、組み込みのデフォルト値によって初期化されます。標準の文字列操作::

>>> sys.path.append('/ufs/guido/lib/python')

を使用して変更できます。 -dir:

:func:`dir` 関数 :func:`dir` 関数

========================== == ==========================

組み込み関数 :func:`dir` はモジュールの名前を調べるために使用されます

文字列のソートされたリストを返します:

組み込み関数: func:`dir` はモジュール名でモジュール定義を検索するために使用されます

Table::

>> ;>>> fibo、sys

>>> dir(fibo)

['__name__', 'fib', 'fib2']

>>> dir(sys) __displayhook__'、'__doc__'、'__Excepthook__'、'__name__'、'__stderr__'、

'__stdin__'、'__stdout__'、'_getframe'、'api_version'、'argv'、

'builtin_module_names'、'byteorder' , 'callstats', 'copyright',

'displayhook', 'exc_clear', 'exc_info', 'exc_type', 'Excepthook',

'exec_prefix', 'executable', 'exit', 'getdefaultencoding', ' getdlopenflags',

'getrecursionlimit', 'getrefcount', 'hexversion', 'maxint', 'maxunicode',

'meta_path'、'modules'、'path'、'path_hooks'、'path_importer_cache'、

'platform'、'prefix'、'ps1'、'ps2'、'setcheckinterval'、'setdlopenflags'、

' setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout',

'version', 'version_info', 'warnoptions']

引数なしで、:func:`dir` は現在定義されている名前:

パラメータなしで呼び出された場合、:func:`dir` 関数は現在定義されている名前を返します::

>>> a = [1, 2, 3, 4, 5]

>> 、'a'、'fib'、'fibo'、'sys']

変数、モジュール、関数など、すべての種類の名前がリストされていることに注意してください。 : 変数、モジュール、関数など。

..index:: module: __builtin__

:func:`dir` には組み込み関数と変数の名前がリストされていません

それらのリストが必要な場合は、標準モジュールで定義されています

。 :mod:`__builtin__`:

:func:`dir` は組み込み関数と変数の名前をリストしません。これらをリストしたい場合は、標準モジュール

:mod:`__builtin__` ::

>>> import __builtin__

>>> dir(__builtin__)

[' ArithmeticError'、'AssertionError'、'AttributeError'、'DeprecationWarning'、

'EOFError'、'Ellipsis'、'EnvironmentError'、'Exception'、'False'、

'FloatingPointError'、'FutureWarning'、'IOError' 、'ImportError'、

'IndentationError'、'IndexError'、'KeyError'、'KeyboardInterrupt'、

'LookupError'、'MemoryError'、'NameError'、'None'、'NotImplemented'、

'NotImplementedError' 、'OSError'、'OverflowError'、

'PendingDeprecationWarning'、'ReferenceError'、'RuntimeError'、

'RuntimeWarning'、'StandardError'、'StopIteration'、'SyntaxError'、

'SyntaxWarning'、'SystemError' 、'SystemExit'、'TabError'、'True'、

'TypeError'、'UnboundLocalError'、'UnicodeDecodeError'、

'UnicodeEncodeError'、'UnicodeError'、'UnicodeTranslateError'、

'UserWarning'、'ValueError' 、'警告'、'WindowsError'、

'ZeroDivisionError'、'_'、'__debug__'、'__doc__'、'__import__'、

'__name__'、'abs'、'apply'、'basestring'、' bool', 'buffer',

'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile',

'complex', 'copyright', 'credits', 'delattr' 、'dict'、'dir'、'divmod'、

'enumerate'、'eval'、'execfile'、'exit'、'file'、'filter'、'float'、

'frozenset'、' getattr', 'globals', 'hasattr', 'hash', 'help', 'hex',

'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', ' iter',

'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview',

'min', 'object', 'oct' 、'open'、'ord'、'pow'、'property'、'quit'、'range'、

'raw_input'、'reduce'、'reload'、'repr'、'reversed'、'round' 、'set'、

'setattr'、'slice'、'sorted'、'staticmethod'、'str'、'sum'、'super'、

'tuple'、'type'、'unichr'、' unicode', 'vars', 'xrange', 'zip']

.. _tut-packages:

Packages パッケージ

==============

パッケージは、「ドット付き

モジュール名」を使用して Python のモジュール名前空間を構造化する方法です。たとえば、モジュール名 :mod:`A.B` は、 「A」という名前のパッケージ内の「B」という名前のサブモジュール

。 モジュールを使用すると、異なるモジュールの作成者がお互いのグローバル変数名を気にする必要がなくなるのと同じように、ドット付き変数を使用すると、モジュール名を使用すると、NumPy や Python Imaging Library などのマルチモジュール

パッケージの作成者が、お互いのモジュール名について心配する必要がなくなります。

パッケージは通常、「ドット モジュール名」を使用した構造化モジュール名前空間を使用します。たとえば、

:mod:`A.B` という名前のモジュールは、``B`` という名前のパッケージ内の ``A`` という名前のサブモジュールを表します。

モジュールを使用して異なるモジュール アーキテクチャを保存するとグローバル変数間の競合を回避できるのと同じように、ドット モジュール名

を使用して NumPy や Python Imaging Library などの異なるライブラリ アーキテクチャを保存すると、モジュール間の競合

の名前の競合を回避できます。

サウンド ファイルとサウンド データを統一

処理するためのモジュールのコレクション (「パッケージ」) を設計したいとします。さまざまなサウンド ファイル

形式 (通常は拡張子によって認識されます。例: :) file:`.wav`,

:file:`.aiff`, :file:`.au`) なので、さまざまなファイル形式の間で変換するためのモジュールのコレクションを作成し、維持する必要があるかもしれません。

サウンド データに対して実行したいさまざまな操作もたくさんあります

(ミキシング、エコーの追加、イコライザー関数の適用、

人工的なステレオ効果の作成など)。これらの操作を実行するためのモジュールのストリームの終了

パッケージの考えられる構造 (階層ファイルシステムの観点から表現) を次に示します。

統合処理用のモジュール セット (「パッケージ」) を設計したいとします。音声ファイルと音声データ。

いくつかの異なるサウンド形式が存在します (多くの場合、拡張子によって識別されます。例: :file:`.wav`

、:file:`.aiff`、:file:`.au`)。さまざまな種類のファイル形式の間で、増加するパッケージのコレクションを維持する必要があります。また、サウンド データに対してさまざまな

操作 (ミックス、エコーの追加、バランス関数の適用、人工的なエフェクトの作成など) を実行したい場合もあるため、これらの操作を実行するための無限ストリーム モジュールを

追加します。あなたのバッグは次のようになります (採点テキスト

システムによるグループ化) ::

サウンド/トップレベル パッケージ

__init__.py サウンド パッケージ

フォーマット/変換された Fire フォーマット用のサブパッケージを初期化します

_ __Init __。

Wavread.py

Wavwrite.py

Aiffread.py

Aiffwrite.py

auread.py

auwrite.py

...

publicTs のエフェクト/サブパッケージ

__init___________init________ .py

エコー.py

filters/ フィルターのサブパッケージ

__init__.py

qualizer.py

vocoder.py

Karaoke.py

...

パッケージをインポートするとき、Python は

` のディレクトリを検索します。 `sys.path` はパッケージのサブディレクトリを探します。

モジュールをインポートするとき、Python は `sys.path` リスト内のディレクトリを検索して、パッケージが保存されているサブディレクトリを検索します。

Python でディレクトリを処理するには、:file:`__init__.py` ファイルが必要です

パッケージを含むため、これは、共通名を持つディレクトリ

が、後でモジュール検索パス上に現れる

の有効なモジュールを意図せず隠蔽することを防ぐために行われます。 `__init__.py` は単に空のファイルにすることもできますが、パッケージの初期化コードを実行したり、後述する __all__ 変数を設定したりすることもできます。

:file:`__init__ が必要です。 .py` ファイルが存在すると、Python はディレクトリをパッケージとして認識する可能性があります。これは、一部のディレクトリが ``string`` のような一般的な名前を使用し、それが後続のモジュール検索パスに誤って含まれるのを防ぐためです。最も単純なケースでは、

:file:`__init__.py` は単なる空のファイルにすることができますが、パッケージの初期化コードが含まれていたり、後で紹介する ``__all__`` 変数を設定したりすることもできます。

パッケージのユーザーは、パッケージから個々のモジュールをインポートできます。例:

パッケージのユーザーは、パッケージから合法的なモジュールをインポートできます。例:::

import sound.Effects.echo

これは、サブモジュール: mod:`sound.Effects.echo`。完全名で参照する必要があります:

これにより、:mod:`Sound.Effects.echo` サブモジュールがインポートされます。完全な名前で参照する必要があります。 ::

Sound.Effects.echo.echofilter(input, output,lay=0.7, atten=4)

サブモジュールをインポートする別の方法は次のとおりです:

パッケージをインポートする別の方法があります::

from sound.Effects import echo

これは、サブモジュール :mod:`echo` もロードし、

パッケージのプレフィックスなしで利用できるようにするため、次のように使用できます:

` サブモジュール、パッケージなしで利用できるようにするプレフィックスが付いているので、次のように呼び出すことができます::

echo.echofilter(input, Output,lay=0.7, atten=4)

さらに別のバリエーションは、目的の関数または変数を直接インポートすることです:

別のバリエーションもあります目的の関数または変数を直接インポートするには::

from sound.Effects.echo import echofilter

繰り返しますが、これはサブモジュール :mod: `echo` をロードしますが、これによりその function

:func:`echofilter` が直接利用可能になります:

これは :mod:`echo` サブモジュールを再度ロードしますが、これによりその function

:func: `echofilter` function::

echofilter(input, Output, laten=0.7, atten=4)

注``from package import item`` を使用する場合、項目はパッケージの

サブモジュール (またはサブパッケージ)、または関数、クラス、変数などの

パッケージで定義された他の名前のいずれかになります。 `import` ステートメントは、最初に項目がパッケージ内に定義されているかどうかをテストします。定義されていない場合は、それが

モジュールであると想定し、それが見つからない場合は :exc:`ImportError`

が発生します。

例外が発生します。

パッケージをインポートするために ``from package import item`` メソッドを使用する場合、このアイテムはパッケージ内のサブモジュール (またはサブパッケージ)、またはで定義された他の名前のいずれかであることに注意してください。関数、クラス、変数などのパッケージ。 import ステートメントは、最初にサブキーがパッケージ内に存在するかどうかを確認し、存在しない場合は、これがモジュールであると想定してロードを試みます。見つからない場合は、ImportError 例外が発生します。

逆に、「import item.subitem.subsubitem」のような構文を使用する場合、最後の項目を除く各項目

はパッケージである必要があります。最後の項目はモジュールまたは

パッケージにすることができます。前の

項目で定義されたクラス、関数、または変数。

対照的に、``import item.subitem.subsubitem`` のような構文を使用する場合、これらのサブ項目はパッケージである必要があり、最後のサブ項目はパッケージまたはモジュールにすることができますが、そうではありません。前のサブ項目で定義されたクラス、関数、または変数。

.. _tut-pkg-import-star:

/* パッケージからインポート中

-------------------------------------

..index::single: __all__

さて、ユーザーが ``from sound.Effects import *`` と書くとどうなるでしょうか? 理想的には、

これが何らかの形でファイルシステムに送られ、どの

サブモジュールが見つかるかを期待するでしょう。がパッケージ内に存在し、それらをすべてインポートすると

時間がかかり、サブモジュールのインポートには望ましくない副作用が生じる可能性があります。これは、サブモジュールが明示的にインポートされた場合にのみ発生するはずです。 ”from sound.Effects import *”?理想的には、ファイル システム内のパッケージ内のすべてのサブモジュールを検索してインポートする必要があります。これには

長い時間がかかり、予期せぬエッジ効果が発生し、明示的にインポートすることしかできなかったパッケージがエクスポートされる可能性があります。

唯一の解決策は、パッケージ作成者が

パッケージの明示的なインデックスを提供することです。:keyword:`import` ステートメントでは、次の規則を使用します: if a package's

:file:`__init__.py` コードが``__all__`` という名前のリストは、``from package import *`` が

のときにインポートされるべきモジュール名のリスト

とみなされます。

新しいバージョンのパッケージがリリースされたときに、このリストを最新の状態に保つのはパッケージ作成者の責任です。パッケージから /* をインポートするために使用します。たとえば、ファイル :file:`sounds/Effects/__init__.py` には次のコードが含まれる可能性があります:

パッケージ作成者にとっての唯一の解決策は、明示的に提供することです。パッケージインデックス。

:keyword:`import` ステートメントは次の条件に従って変換されます: ``from package import

*`` を実行するとき、パッケージ内の :file:`__init__.py` コードが `` という名前のファイルを定義している場合__all__` `

のリストは、リストに指定されたモジュール名に従ってインポートされます。作成者は、パッケージの新しいバージョンがリリースされたときに、このリストを自由に更新できます。パッケージ作成者が import * のときにパッケージ内のすべてのモジュールをインポートしたくない場合は、それをサポートしないことを決定する可能性があります (import /*)。たとえば、

:file:`Sounds/Effects/__init__.py` このファイルには次のコードが含まれる場合があります::

__all__ = ["echo", "surround", "reverse"]

これは ` `from sound.Effects import *`` は、:mod:`sound` パッケージの 3 つの

名前付きサブモジュールをインポートします。

これは、`from Sound.Effects import *`` が :mod:`sound` をインポートすることを意味します。上記の 3 つの名前付きサブモジュールをインポートします。

``__all__`` が定義されていない場合、ステートメント ``from sound.Effects import *``

は、すべてのサブモジュールをパッケージ :mod:`sound.Effects` から

現在の名前空間に *インポートしません * ; :mod:`sound.Effects` パッケージがインポートされていることを確認するだけです (おそらく :file:`__init__.py` で初期化コードが実行されます)

そして、パッケージ内で定義されている名前をすべてインポートします。 :file:`__init__.py` によって定義されたすべての

名 (および明示的にロードされたサブモジュール) が含まれます。また、

前の :keyword:`import` ステートメントによって明示的にロードされたパッケージのサブモジュールもすべて含まれます。 code:

``__all__`` が定義されていない場合、``from Sound.Effects import *`` ステートメントは

:mod:`sound.Effects` パッケージからすべてのサブモジュールをインポートしません。パッケージ内で定義されている名前の数に関係なく、唯一判断できるのは、:mod:`sound.Effects` パッケージがインポートされ (__init__.py の初期化コードが実行される可能性がある)、すべての命名規則が定義されていることだけです。パッケージ内にあるのでインポートします。これにより、すべての名前付き (および明示的にインポートされたサブモジュール) が ``__init__.py``

からインポートされます。また、前述の

:keyword:`import` ステートメントによってパッケージから明示的にインポートされるサブモジュールも含まれています。次のコードを考えてみましょう。 . Effects import *

この例では、:mod:`echo` モジュールと :mod:`surround` モジュールは、:mod:`sound.Effects` パッケージで定義されているため、

現在の名前空間にインポートされます

``from...import`` ステートメントが実行されるとき (これは

``__all__`` が定義されている場合にも機能します。)

この例では、 :mod:`echo` と :mod:`surround` が使用されます。モジュールは現在の名前空間

をインポートします。これは、モジュールが

:mod:`sound.Effects` パッケージで既に定義されているためです (`from...import` ステートメントを実行するときに __all__` を定義することも同じように機能します)。 。

特定のモジュールは ``import *`` を使用するときに特定の

パターンに従う名前のみをエクスポートするように設計されていますが、import *`` を使用する場合、

実稼働コードでは次のような名前のみをエクスポートすることは依然として悪い習慣と考えられています。ただし、この記述方法を実稼働コードで使用することはお勧めできません。

覚えておいてください、「from Package import

specific_submodule」を使用することは何も問題ありません! 実際、

インポートモジュールが異なる

パッケージからの同じ名前のサブモジュールを使用する必要がない限り、これが推奨される表記法です。

「from Package import specific_submodule」にはエラーがないことに注意してください。実際、

を除いて、インポートされていないモジュールは他のパッケージで同じ名前のサブモジュールを使用する必要があります。それ以外の場合は、これが推奨される記述方法です。

パッケージ内参照 パッケージ参照

-----------------------------------------------------

サブモジュールは相互に参照する必要があることがよくあります。たとえば、

:mod:`surround` モジュールは :mod:`echo` モジュールを使用することがあります。 :` import` ステートメントは、標準モジュールの検索パスを調べる前に、まず

を含むパッケージを調べます。 したがって、

:mod:`surround` モジュールは単に ``import echo`` または ``from echo import

'' を使用できます。

echofilter ``。インポートされたモジュールが現在のパッケージ (現在のモジュールがサブモジュールである

パッケージ) で見つからない場合、:keyword:`import`

ステートメントは、指定された名前 .

サブモジュールは、多くの場合、相互参照する必要があります。たとえば、 :mod:`surround` モジュールは

を参照する可能性があります。

:mod:`echo` モジュール。実際、そのような参照は非常に一般的であるため、:keyword:`import`

ステートメントは最初にパッケージ内を検索し、次に標準モジュールの検索パスが続きます。したがって、:mod:`surround` モジュールは単に `import echo` または `from echo import echofilter`

を呼び出すことができます。インポートするモジュールが現在のパッケージ内に見つからない場合、:keyword:`import` ステートメントは指定された名前に基づいてトップレベルのモジュールを検索します。

パッケージがサブパッケージに構造化されている場合(例の:mod:`sound`パッケージ

のように)、絶対インポートを使用して兄弟

パッケージのサブモジュールを参照できます。たとえば、モジュール:mod: `sound.filters.vocoder` は :mod:`sound.Effects` パッケージ内の :mod:`echo` モジュールを使用する必要があります

、 `from

sound.Effects import echo` を使用できます

パッケージ内でサブパッケージ構造が使用されている場合 (例の :mod:`sound` パッケージのように)、サブモジュールは絶対位置によって隣接するパッケージからインポートできます

。たとえば、:mod:`sound.filters.vocoder` パッケージが :mod:`sound.Effects` パッケージの :mod:`echo` モジュールを

使用する必要がある場合、Sound.Effects から

``エコー` `をインポートします。

Python 2.5 以降では、上記

で説明した暗黙的な相対インポートに加えて、 import ステートメントの ``from module import

name`` 形式で明示的な相対インポートを記述することができます。これらの明示的な相対インポートでは先頭を使用します

。相対

インポートに関係する現在のパッケージと親パッケージを示すドット。たとえば、:mod:`surround` モジュールから次のように使用できます。

Python 2.5 以降では、前述の内部明示的な相対インポートが改良され、次のように記述できますこのように「from module import name」という形式を使用して明示的な相対インポートを行います。これらの明示的なインポートは、現在のパッケージと親パッケージの間の関係を示すためにドットでマークされています。 :mod:`surround` モジュールを例に挙げると、次のように使用できます::

from . import echo

from .. import formats

from ..filters import イコライザー

明示的と暗黙的の両方に注意してください。相対インポートは現在のモジュールの名前に基づいています

メインモジュールの名前は常に ``"__main__"`` であるため、Python アプリケーションのメインモジュールとして使用することを目的としたモジュールは常に

を使用する必要があります。絶対インポート。

明示的または暗黙的な相対位置インポートは、現在のモジュールの名前に基づいていることに注意してください。メインモジュールの名前は常に ``"__main__"`` であるため、Python アプリケーションのメインモジュールは常に絶対にインポートする必要があります。

複数のディレクトリ内のパッケージ

----------------------------------------------------- -- ----------------

パッケージは、もう 1 つの特別な属性、:attr:`__path__` をサポートします。これは、

を保持するディレクトリの名前を含むリストになるように初期化されます。ファイル内のコードが実行される前に、

パッケージの :file:`__init__.py` を変更できます。変更すると、パッケージに含まれるモジュールと

サブパッケージの将来の検索に影響します。 `__path__` 。 この変数は、パッケージの

:file:`__init__.py`

ファイル コードが実行される前に、ディレクトリ名のリストを初期化します。この変数は変更でき、

パッケージ内のサブパッケージとモジュールの検索機能に作用します。

この機能はあまり必要ではありませんが、パッケージに含まれる

モジュールのセットを拡張するために使用できます。

この機能は、パッケージに含まれるモジュールのセットを拡張するために使用できますが、一般的には使用されません使用済み。

..rubric:: Footnotes

.. [#] 実際、関数定義は「実行」される「ステートメント」でもあり、モジュールレベルの関数の

実行は、モジュールの

グローバルに関数名を入力します。シンボル table.

.. [#] 実際、関数定義は「宣言」と「実行可能本体」の両方であり、実行可能本体はモジュールのグローバル セマンティック テーブル内の関数の名前によってインポートされます。

上記は Python 2.7 の基本的なチュートリアルです: モジュールの内容 詳細については、PHP 中国語 Web サイト (www.php.cn) をご覧ください。