用語集¶

>>>¶

対話型シェルにおけるデフォルトの Python プロンプトです。インタープリターで対話的に実行されるコード例でよく見られます。

...¶

次のものが考えられます:

対話型 (interactive) シェルにおいて、インデントされたコードブロック、対応する左右の区切り文字の組 (丸括弧、角括弧、波括弧、三重引用符) の内側、デコレーターの後に、コードを入力する際に表示されるデフォルトの Python プロンプトです。

Ellipsis オブジェクトの、3 つのドットを使った表記。

abstract base class¶

(抽象基底クラス) 抽象基底クラスは duck-typing を補完するもので、 hasattr() などの別のテクニックでは不恰好であったり微妙に誤る (例えば magic methods の場合) 場合にインターフェースを定義する方法を提供します。ABC は仮想 (virtual) サブクラスを導入します。これは親クラスから継承しませんが、それでも isinstance() や issubclass() に認識されます; abc モジュールのドキュメントを参照してください。Python には、多くの組み込み ABC が同梱されています。その対象は、(collections.abc モジュールで) データ構造、(numbers モジュールで) 数、(io モジュールで) ストリーム、(importlib.abc モジュールで) インポートファインダ及びローダーです。 abc モジュールを利用して独自の ABC を作成できます。

annotate function¶

(annotate 関数) オブジェクトのアノテーションを取得するために呼び出せる呼び出し可能オブジェクトです。 annotate 関数は通常、関数、クラス、モジュールの __annotate__ 属性として自動生成される関数です。 annotate 関数は評価関数の一種です。

annotation¶

(アノテーション) 変数、クラス属性、関数のパラメータや返り値に関係するラベルです。慣例により type hint として使われています。

ローカル変数のアノテーションには実行時にアクセスできませんが、グローバル変数、クラス属性、関数のアノテーションは、それぞれモジュール、クラス、関数に対して annotationlib.get_annotations() を呼び出すことで取得できます。

機能の説明がある variable annotation, function annotation, PEP 484, PEP 526, PEP 649 を参照してください。また、アノテーションを利用するベストプラクティスとしてアノテーションのベストプラクティスも参照してください。

引数 (argument)¶

(実引数) 関数を呼び出す際に、関数 (またはメソッド) に渡す値です。実引数には２種類あります:

キーワード引数: 関数呼び出しの際に引数の前に識別子がついたもの (例: name=) や、 ** に続けた辞書の中の値として渡された引数。例えば、次の complex() の呼び出しでは、 3 と 5 がキーワード引数です:
```
complex(real=3, imag=5)
complex(**{'real': 3, 'imag': 5})
```
位置引数: キーワード引数以外の引数。位置引数は引数リストの先頭に書くことができ、また * に続けた iterable の要素として渡すことができます。例えば、次の例では 3 と 5 は両方共位置引数です:
```
complex(3, 5)
complex(*(3, 5))
```

実引数は関数の実体において名前付きのローカル変数に割り当てられます。割り当てを行う規則については呼び出し (call) を参照してください。シンタックスにおいて実引数を表すためにあらゆる式を使うことが出来ます。評価された値はローカル変数に割り当てられます。

仮引数、FAQ の実引数と仮引数の違いは何ですか? 、PEP 362 を参照してください。

asynchronous context manager¶

(非同期コンテキストマネージャ) __aenter__() と __aexit__() メソッドを定義することで async with 文内の環境を管理するオブジェクトです。 PEP 492 で導入されました。

asynchronous generator¶

文脈に応じて、非同期ジェネレータ関数または非同期ジェネレータイテレータのどちらかを指すために非公式に使われる語です。正式な用語である非同期ジェネレータ関数と非同期ジェネレータイテレータは、実際にはあまり使われません。ほとんどの場合、「非同期ジェネレータ」だけで十分です。

asynchronous generator function¶

(非同期ジェネレータ関数) 非同期ジェネレータイテレータを返す関数です。 async def で定義されたコルーチン関数に似ていますが、async for ループで使用できる一連の値を生成するための yield 式を含む点が異なります。 PEP 525 を参照してください。

非同期ジェネレータ関数には、 async for 文や async with 文だけでなく await 式もあることがあります。

asynchronous generator iterator¶

非同期ジェネレータ関数が作成するオブジェクトです。

これは asynchronous iterator で、 __anext__() メソッドを使って呼ばれると awaitable オブジェクトを返します。この awaitable オブジェクトは、次の yield 式まで非同期ジェネレータ関数の本体を実行します。

各 yield は処理を一時的に中断し、実行状態（ローカル変数や保留中の try 文を含む）を記憶します。 __anext__() が返す別の awaitable によって 非同期ジェネレータイテレータ の実行が実際に再開すると、中断した箇所から処理を続けます。 PEP 492 と PEP 525 を参照してください。

asynchronous iterable¶

(非同期イテラブル) async for 文の中で使用できるオブジェクトです。自身の __aiter__() メソッドから asynchronous iterator を返さなければなりません。 PEP 492 で導入されました。

asynchronous iterator¶

(非同期イテレータ) __aiter__() と __anext__() メソッドを実装したオブジェクトです。 __anext__() は awaitable オブジェクトを返さなければなりません。 async for は StopAsyncIteration 例外を送出するまで、非同期イテレータの __anext__() メソッドが返す awaitable を解決します。 PEP 492 で導入されました。

atomic operation¶

(アトミック操作) 分割できない単一のステップとして実行されるように見える操作です。ほかのスレッドから途中の状態は観測できず、その効果は一度に見えるようになります。 Python は、高水準の文がアトミックであることを保証しません（たとえば、x += 1 は複数のバイトコード操作を実行し、アトミックではありません）。アトミック性が保証されるのは、ドキュメントに明記されている場合だけです。競合状態とデータ競合も参照してください。

attached thread state¶

(アタッチされたスレッド状態) 現在の OS スレッドで有効なスレッド状態です。

スレッド状態がアタッチされていると、OS スレッドは Python C API の全機能にアクセスでき、バイトコードインタープリタを安全に呼び出せます。

関数の説明に明示的な例外の記載がない限り、スレッド状態がアタッチされていない状態で C API を呼び出そうとすると、致命的エラーまたは未定義の動作を引き起こします。スレッド状態は、利用者が C API を通じて明示的にアタッチしたりデタッチしたりできるほか、ランタイムが暗黙に行うこともあります。後者には、ブロックする C 関数の呼び出し中に行う場合や、バイトコードインタープリタが呼び出しと呼び出しの間に行う場合が含まれます。

ほとんどの Python ビルドでは、スレッド状態がアタッチされていることは、呼び出し元が現在のインタープリタの GIL を保持していることを意味します。そのため、ある時点でスレッド状態をアタッチできる OS スレッドは一つだけです。 Python のフリースレッドビルドでは、複数のスレッドがスレッド状態を同時にアタッチでき、バイトコードインタープリタの真の並列実行が可能になります。

属性¶

(属性) オブジェクトに関連付けられ、ドット表記式によって名前で通常参照される値です。例えば、オブジェクト o が属性 a を持っているとき、その属性は o.a で参照されます。

オブジェクトには、 Names (identifiers and keywords) で定義される識別子ではない名前の属性を与えることができます。たとえば setattr() を使い、オブジェクトがそれを許可している場合に行えます。このような属性はドット表記式ではアクセスできず、代わりに getattr() を使って取る必要があります。

awaitable¶

(待機可能) await 式で使用することが出来るオブジェクトです。 coroutine か、 __await__() メソッドがあるオブジェクトです。 PEP 492 を参照してください。

BDFL¶

慈悲深き終身独裁者 (Benevolent Dictator For Life) の略です。Python の作者、Guido van Rossum のことです。

binary file¶

(バイナリファイル) bytes-like オブジェクトの読み込みおよび書き込みができるファイルオブジェクトです。バイナリファイルの例は、バイナリモード ('rb', 'wb' or 'rb+') で開かれたファイル、sys.stdin.buffer、sys.stdout.buffer、 io.BytesIO や gzip.GzipFile. のインスタンスです。

str オブジェクトの読み書きができるファイルオブジェクトについては、 text file も参照してください。

borrowed reference¶

(借用参照) Python の C API で、オブジェクトを使うコードが所有していない、そのオブジェクトへの参照です。オブジェクトが破棄されると、ダングリングポインタになります。たとえば、ガベージコレクションによってオブジェクトへの最後の強参照が取り除かれ、オブジェクトが破棄されることがあります。

借用参照に対して Py_INCREF() を呼び出し、その場で強参照に変換することを推奨します。ただし、借用参照の最後の使用までオブジェクトが破棄され得ない場合は除きます。 Py_NewRef() 関数を使うと、新しい強参照を作成できます。

bytes-like object¶

バッファプロトコル (buffer Protocol) をサポートしていて、 C 言語の意味で連続したバッファーを提供可能なオブジェクト。 bytes, bytearray, array.array や、多くの一般的な memoryview オブジェクトがこれに当たります。 bytes-like オブジェクトは、データ圧縮、バイナリファイルへの保存、ソケットを経由した送信など、バイナリデータを要求するいろいろな操作に利用することができます。

操作によっては、バイナリデータが変更可能である必要があります。ドキュメントでは、そのようなデータを「読み書き可能な bytes-like オブジェクト」と呼ぶことがよくあります。変更可能なバッファオブジェクトには、bytearray や bytearray の memoryview があります。一方、別の操作では、バイナリデータが不変なオブジェクト（「読み出し専用の bytes-like オブジェクト」）に格納されている必要があります。そのようなオブジェクトには、bytes や bytes オブジェクトの memoryview があります。

bytecode¶

(バイトコード) Python のソースコードは、 Python プログラムの CPython インタプリタの内部表現であるバイトコードへとコンパイルされます。バイトコードは .pyc ファイルにキャッシュされ、同じファイルが二度目に実行されるときはより高速になります (ソースコードからバイトコードへの再度のコンパイルは回避されます)。この "中間言語 (intermediate language)" は、各々のバイトコードに対応する機械語を実行する仮想マシンで動作するといえます。重要な注意として、バイトコードは異なる Python 仮想マシン間で動作することや、Python リリース間で安定であることは期待されていません。

バイトコードの命令一覧は dis モジュールにあります。

callable¶

呼び出し可能オブジェクトは、次の構文で呼び出すことができるオブジェクトです。その際、実引数（実引数を参照）を渡すこともできます。

callable(argument1, argument2, argumentN)

関数もメソッドも、呼び出し可能オブジェクトです。 __call__() メソッドを実装したクラスのインスタンスも、呼び出し可能オブジェクトです。

callback¶

(コールバック) 将来のある時点で実行されるために引数として渡される関数

クラス¶

(クラス) ユーザー定義オブジェクトを作成するためのテンプレートです。クラス定義は普通、そのクラスのインスタンス上の操作をするメソッドの定義を含みます。

class variable¶

(クラス変数) クラス内で定義され、クラスレベルでのみ（つまり、クラスのインスタンスではなく）変更することを意図した変数です。

closure variable¶

(クロージャ変数) ネストされたスコープから参照される自由変数のうち、実行時にグローバル名前空間や組み込み名前空間から解決されるのではなく、外側のスコープで定義されているものです。書き込みを可能にするために nonlocal キーワードで明示的に定義する場合と、変数を読み取るだけで暗黙に定義される場合があります。

たとえば、次のコードの inner 関数では、x と print はどちらも自由変数ですが、クロージャ変数 は x だけです。

def outer():
    x = 0
    def inner():
        nonlocal x
        x += 1
        print(x)
    return inner

codeobject.co_freevars 属性には、その名前に反して、参照されるすべての自由変数ではなくクロージャ変数の名前だけが含まれます。このため、クロージャ変数だけを指す意図で、より一般的な用語である自由変数が使われることもあります。

complex number¶

(複素数) よく知られている実数系を拡張したもので、すべての数は実部と虚部の和として表されます。虚数は虚数単位 (-1 の平方根) に実数を掛けたもので、一般に数学では i と書かれ、工学では j と書かれます。Python は複素数に組み込みで対応し、後者の表記を取っています。虚部は末尾に j をつけて書きます。例えば 3+1j です。 math モジュールの複素数版を利用するには、 cmath を使います。複素数の使用はかなり高度な数学の機能です。必要性を感じなければ、ほぼ間違いなく無視してしまってよいでしょう。

concurrency¶

(並行性) コンピュータプログラムが複数のタスクを同時に実行する能力です。 Python は、さまざまな形の並行性を利用するプログラムを書くためのライブラリを提供します。 asyncio は非同期タスクやコルーチンを扱うためのライブラリです。 threading はオペレーティングシステムのスレッドへのアクセスを、multiprocessing はオペレーティングシステムのプロセスへのアクセスを提供します。マルチコアプロセッサは、異なる CPU コアでスレッドやプロセスを同時に実行できます（並列性を参照）。

concurrent modification¶

(並行変更) 複数のスレッドが共有データを同時に変更することです。適切な同期を行わずに並行変更すると、競合状態を引き起こすことがあり、さらにデータ競合、データの破損、またはその両方を引き起こす可能性もあります。

context¶

(コンテキスト) この語は、使われる場所や使い方によって意味が異なります。よく使われる意味には次のものがあります:

コンテキストマネージャが with 文を通じて設定する、一時的な状態または環境。
特定の contextvars.Context オブジェクトに関連付けられ、ContextVar オブジェクトを通じてアクセスされる、キーと値の束縛の集まり。コンテキスト変数も参照してください。
contextvars.Context オブジェクト。現在のコンテキストも参照してください。

コンテキスト管理プロトコル¶

with 文から呼び出される __enter__() メソッドと __exit__() メソッドです。 PEP 343 を参照してください。

context manager¶

コンテキスト管理プロトコルを実装し、with 文内の環境を管理するオブジェクトです。 PEP 343 を参照してください。

context variable¶

どのコンテキストが現在のコンテキストであるかによって値が変わる変数です。値には contextvars.ContextVar オブジェクトを通じてアクセスします。コンテキスト変数は主に、並行する非同期タスク間で状態を分離するために使われます。

contiguous¶

(隣接、連続) バッファが C-連続 または Fortran 連続 のいずれかである場合、かつその場合に限り、そのバッファは連続しているとみなされます。ゼロ次元バッファは C 連続であり、Fortran 連続でもあります。一次元配列では、要素はメモリ上で互いに隣接し、ゼロから始まる添字の昇順で並んでいなければなりません。多次元の C-連続配列では、メモリアドレス順に要素をたどると、最後の添字が最も速く変化します。一方、Fortran 連続配列では、最初の添字が最も速く変化します。

コルーチン¶

(コルーチン) コルーチンはサブルーチンのより一般的な形式です。サブルーチンには決められた地点から入り、別の決められた地点から出ます。コルーチンには多くの様々な地点から入る、出る、再開することができます。コルーチンは async def 文で実装できます。 PEP 492 を参照してください。

coroutine function¶

(コルーチン関数) coroutine オブジェクトを返す関数です。コルーチン関数は async def 文で実装され、await、async for、および async with キーワードを持つことが出来ます。これらは PEP 492 で導入されました。

CPython¶

python.org で配布されている、Python プログラミング言語の標準的な実装です。"CPython" という単語は、この実装を Jython や IronPython といった他の実装と区別する必要が有る場合に利用されます。

current context¶

(現在のコンテキスト) ContextVar オブジェクトがコンテキスト変数の値にアクセス（取得や設定）するために現在使っているコンテキスト <context>`（:class:`contextvars.Context オブジェクト）です。各スレッドには、それぞれ現在のコンテキストがあります。非同期タスクを実行するフレームワーク（asyncio を参照）は、各タスクにコンテキストを関連付けます。このコンテキストは、タスクが実行を開始または再開するたびに、現在のコンテキストになります。

cyclic isolate¶

(孤立した循環参照群) 循環参照によって互いを参照している一つ以上のオブジェクトからなる集まりで、外部のオブジェクトから参照されていないものです。循環ガベージコレクタの目的は、こうした集まりを特定し、循環参照を断ち切ってメモリを回収できるようにすることです。

data race¶

(データ競合) 複数のスレッドが同じメモリ位置に並行してアクセスし、そのうち少なくとも一つが書き込みであり、どのスレッドもアクセスを制御する同期を使っていない状況です。データ競合は非決定的な動作につながり、データの破損を引き起こすことがあります。ロックやその他の同期プリミティブを適切に使うと、データ競合を防げます。データ競合が起こり得るのはネイティブコード内だけですが、そのネイティブコードが Python API を通じて公開されている可能性があることに注意してください。競合状態とスレッドセーフも参照してください。

deadlock¶

(デッドロック) 二つ以上のタスク（スレッド、プロセス、コルーチン）が、互いにリソースを解放したり動作を完了したりするのを無期限に待ち、どのタスクも処理を進められない状況です。たとえば、スレッド A がロック 1 を保持したままロック 2 を待ち、スレッド B がロック 2 を保持したままロック 1 を待つと、両方のスレッドが無期限に待つことになります。 Python では、複数のロックを相反する順序で取得したり、join や await の依存関係が循環したりすると、よくこの状況が発生します。複数のロックを常に一貫した順序で取得すると、デッドロックを回避できます。ロックと再入可能も参照してください。

decorator¶

(デコレータ) 別の関数を返す関数で、通常は @wrapper 構文を使って関数を変換するために適用されます。デコレータの代表的な例には、@classmethod と @staticmethod があります。

デコレータの文法はシンタックスシュガーです。次の2つの関数定義は意味的に同じものです:

def f(arg):
    ...
f = staticmethod(f)

@staticmethod
def f(arg):
    ...

同じ概念がクラスにも存在しますが、あまり使われません。デコレータについて詳しくは、関数定義およびクラス定義のドキュメントを参照してください。

descriptor¶

(デスクリプタ) __get__()、__set__()、__delete__() のいずれかのメソッドを定義したオブジェクトです。クラス属性がデスクリプタの場合、属性の検索時に、デスクリプタ特有の束縛動作が起動します。通常、a.b を使って属性を取得、設定、削除すると、a のクラス辞書から b という名前のオブジェクトを検索しますが、b がデスクリプタなら、対応するデスクリプタのメソッドが呼び出されます。デスクリプタは、関数、メソッド、プロパティ、クラスメソッド、静的メソッド、スーパークラスへの参照など、多くの機能の基盤となっているため、これを理解することは Python を深く理解する鍵となります。

デスクリプタのメソッドに関しての詳細は、デスクリプタ (descriptor) の実装や Descriptor How To Guide を参照してください。

dictionary¶

(辞書) 任意のキーが値に対応付けられる連想配列です。キーには、__hash__() メソッドと __eq__() メソッドを持つ任意のオブジェクトを使えます。 Perl ではハッシュと呼ばれます。

dictionary comprehension¶

(辞書内包表記) iterable 内の全てあるいは一部の要素を処理して、その結果からなる辞書を返すコンパクトな書き方です。 results = {n: n ** 2 for n in range(10)} とすると、キー n を値 n ** 2 に対応付ける辞書を生成します。内包表記 (Comprehension) を参照してください。

dictionary view¶

(辞書ビュー) dict.keys()、dict.values()、dict.items() が返すオブジェクトです。辞書の項目の動的なビューを提供します。すなわち、辞書が変更されるとビューはそれを反映します。辞書ビューを強制的に完全なリストにするには list(dictview) を使用してください。辞書ビューオブジェクトを参照してください。

docstring¶

(ドキュメンテーション文字列) クラス、関数、モジュールの最初の式として現れる文字列リテラルです。スイートの実行時には無視されますが、コンパイラによって認識され、それを囲むクラス、関数、モジュールの __doc__ 属性に格納されます。イントロスペクションを通じて利用できるため、オブジェクトのドキュメントを書く標準的な場所となっています。

duck-typing¶

あるオブジェクトが正しいインターフェースを持っているかを決定するのにオブジェクトの型を見ないプログラミングスタイルです。代わりに、単純にオブジェクトのメソッドや属性が呼ばれたり使われたりします。（「アヒルのように見えて、アヒルのように鳴けば、それはアヒルである。」）インターフェースを型より重視することで、上手くデザインされたコードは、ポリモーフィックな代替を許して柔軟性を向上させます。ダックタイピングは type() や isinstance() による判定を避けます。 (ただし、ダックタイピングを抽象基底クラスで補完することもできます。) その代わり、典型的に hasattr() 判定や EAFP プログラミングを利用します。

dunder¶

「double underscore（二重アンダースコア）」を表す非公式な略語で、特殊メソッドについて話すときに使います。たとえば、__init__ はよく「dunder init」と発音されます。

EAFP¶

許可を求めるより、許しを請うほうが容易（Easier to ask for forgiveness than permission）の略です。 Python で一般的なこのコーディングスタイルでは、有効なキーや属性が存在すると仮定し、その仮定が誤っていた場合に例外を捕捉します。この簡潔で高速なスタイルは、try 文と except 文を多用することを特徴とします。この手法は、C などの多くの言語で一般的な LBYL スタイルと対照的です。

evaluate function¶

(評価関数) type 文で作成された型エイリアスの値など、オブジェクトの遅延評価される属性を評価するために呼び出せる関数です。

exhausted¶

(枯渇した) すべての値を生成し終えたイテレータを 枯渇した といいます。その後に次の値を取得しようとすると（たとえば next() を呼び出すと）、StopIteration`（:term:`非同期イテレータの場合は StopAsyncIteration）が送出されます。

expression¶

(式) 評価すると何らかの値になる構文の一部です。つまり、式は、リテラル、名前、属性アクセス、演算子、関数呼び出しなど、いずれも値を返す式の要素を組み合わせたものです。言語のすべての構成要素が式というわけではありません。 while のように、式として使えない文もあります。代入も式ではなく文です。

extension module¶

(拡張モジュール) C や C++ で書かれたモジュールで、Python の C API を利用して Python コアやユーザーコードとやりとりします。

f-string¶

f-strings¶

f または F を接頭辞に持つ文字列リテラルは、一般に「f-string」と呼ばれます。これはフォーマット済み文字列リテラルの略です。 PEP 498 も参照してください。

file object¶

(ファイルオブジェクト) 基になるリソースに対して、ファイル向けの API（read() や write() などのメソッド）を提供するオブジェクトです。作成方法に応じて、ディスク上の実際のファイル、または別の種類の記憶装置や通信装置（標準入出力、メモリ内バッファ、ソケット、パイプなど）へのアクセスを仲介できます。ファイルオブジェクトは、file-like オブジェクト や ストリーム とも呼ばれます。

ファイルオブジェクトには実際には 3 種類あります: 生のバイナリーファイル、バッファされたバイナリーファイル、そしてテキストファイルです。インターフェイスは io モジュールで定義されています。ファイルオブジェクトを作る標準的な方法は open() 関数を使うことです。

file-like object¶

file object と同義です。

filesystem encoding and error handler¶

(ファイルシステムのエンコーディングとエラーハンドラ) オペレーティングシステムから受け取ったバイト列のデコードと、オペレーティングシステムに渡す Unicode のエンコードに Python が使用する、エンコーディングとエラーハンドラです。

ファイルシステムのエンコーディングは、128 未満のすべてのバイト値を正常にデコードできることを保証しなければなりません。ファイルシステムのエンコーディングがこれを保証しない場合、API 関数が UnicodeError を送出することがあります。

sys.getfilesystemencoding() 関数と sys.getfilesystemencodeerrors() 関数を使うと、ファイルシステムのエンコーディングとエラーハンドラを取得できます。

ファイルシステムのエンコーディングとエラーハンドラは、Python の開始時に PyConfig_Read() 関数により設定されます。 PyConfig のメンバー filesystem_encoding と filesystem_errors を参照してください。

ロケールエンコーディングも参照してください。

finder¶

(ファインダ) インポートされているモジュールの loader の発見を試行するオブジェクトです。

ファインダには、sys.meta_path で使用するメタパスファインダと、sys.path_hooks で使用するパスエントリファインダの 2 種類があります。

詳しくは、ファインダーとローダーと importlib を参照してください。

floor division¶

(切り捨て除算) 一番近い整数に切り捨てる数学的除算。切り捨て除算演算子は // です。例えば、 11 // 4 は 2 になり、それとは対称に浮動小数点数の真の除算では 2.75 が返ってきます。 (-11) // 4 は -2.75 を 小さい方に 丸める (訳注: 負の無限大への丸めを行う) ので -3 になることに注意してください。 PEP 238 を参照してください。

free threading¶

(フリースレッディング) 同じインタープリタ内で、複数のスレッドが Python バイトコードを同時に実行できるスレッドモデルです。一度に一つのスレッドだけが Python バイトコードを実行できるグローバルインタープリタロックとは対照的です。 PEP 703 を参照してください。

free-threaded build¶

(フリースレッドビルド) コンパイル前に --disable-gil オプションで構成した、フリースレッディングに対応する CPython のビルドです。

Python support for free threading を参照してください。

free variable¶

(自由変数) 言語の実行モデルにおける正式な定義では、ある名前空間で使われる変数で、その名前空間のローカル変数ではないものを指します。例についてはクロージャ変数を参照してください。実際の用法では、codeobject.co_freevars 属性の名前に由来して、クロージャ変数の同義語として使われることもあります。

関数¶

(関数) 呼び出し側に値を返す一連の文のことです。関数には0以上の実引数を渡すことが出来ます。実体の実行時に引数を使用することが出来ます。仮引数、メソッド、関数定義を参照してください。

function annotation¶

(関数アノテーション) 関数のパラメータや返り値の annotation です。

関数アノテーションは通常、型ヒントに使用されます。たとえば、次の関数は二つの int 型の引数を受け取り、int 型の値を返すことを想定しています。

def sum_two_numbers(a: int, b: int) -> int:
   return a + b

関数アノテーションの文法は関数定義の節で解説されています。

機能の説明がある variable annotation, PEP 484,を参照してください。また、アノテーションを利用するベストプラクティスとしてアノテーションのベストプラクティスも参照してください。

__future__¶

from __future__ import <feature> という future 文は、コンパイラーに将来の Python リリースで標準となる構文や意味を使用して現在のモジュールをコンパイルするよう指示します。 __future__ モジュールでは、 feature のとりうる値をドキュメント化しています。このモジュールをインポートし、その変数を評価することで、新機能が最初に言語に追加されたのはいつかや、いつデフォルトになるか (またはなったか) を見ることができます:

>>> import __future__
>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

garbage collection¶

(ガベージコレクション) これ以降使われることのないメモリを解放する処理です。 Pythonは、参照カウントと、循環参照を検出し破壊する循環ガベージコレクタを使ってガベージコレクションを行います。ガベージコレクタは gc モジュールを使って操作できます。

ジェネレータ¶

文脈に応じて、ジェネレータ関数またはジェネレータイテレータのどちらかを指すために非公式に使われる語です。正式な用語であるジェネレータ関数とジェネレータイテレータは、実際にはあまり使われません。ほとんどの場合、「ジェネレータ」だけで十分です。

generator function¶

(ジェネレータ関数) ジェネレータオブジェクトを返す関数です。通常の関数に似ていますが、for ループで使用したり、next() 関数で一つずつ取得したりできる一連の値を生成するための yield 式を含む点が異なります。 Yield 式を参照してください。

generator iterator¶

ジェネレータ関数またはジェネレータ式によって作成されるオブジェクトです。

各 yield は処理を一時的に中断し、実行状態（ローカル変数や保留中の try 文を含む）を記憶します。 ジェネレータイテレータ は、実行を再開すると、中断した箇所から処理を続けます（呼び出しのたびに最初から実行する関数とは異なります）。

ジェネレータイテレータは、中断したジェネレータに値を送る send() メソッドと、ジェネレータが中断した箇所で例外を送出する throw() メソッドも実装します。ジェネレータイテレータを参照してください。

generator expression¶

(ジェネレータ式) イテレータを返す式です。通常の式の後に、ループ変数と範囲を定義する for 節、そして省略可能な if 節が続く形をしています。このように組み合わせた式は、外側の関数に渡す値を生成します。

>>> sum(i*i for i in range(10))         # 平方数 0, 1, 4, ... 81 の合計
285

generic function¶

(ジェネリック関数) 異なる型に対し同じ操作をする関数群から構成される関数です。呼び出し時にどの実装を用いるかはディスパッチアルゴリズムにより決定されます。

用語集の単一ディスパッチの項目、@functools.singledispatch デコレータ、および PEP 443 も参照してください。

generic type¶

(ジェネリック型) パラメータ化できる型で、通常は list や dict のようなコンテナクラスです。型ヒントやアノテーションに使用されます。

詳しくは、ジェネリックエイリアス型、PEP 483、PEP 484、PEP 585、typing モジュールを参照してください。

GIL¶

global interpreter lock を参照してください。

global interpreter lock¶

(グローバルインタプリタロック) CPython インタプリタが、一度に一つのスレッドだけが Python のバイトコードを実行することを保証するために使う仕組みです。この仕組みは、dict などの重要な組み込み型を含むオブジェクトモデルを、並行アクセスに対して暗黙に安全にすることで、CPython の実装を単純にします。インタプリタ全体をロックすると、マルチプロセッサマシンが可能にする並列性の多くを犠牲にする代わりに、インタプリタをマルチスレッド化しやすくなります。

ただし、標準あるいは外部のいくつかの拡張モジュールは、圧縮やハッシュ計算などの計算の重い処理をするときに GIL を解除するように設計されています。また、I/O 処理をする場合 GIL は常に解除されます。

As of Python 3.13, the GIL can be disabled using the --disable-gil build configuration. This feature enables improved performance for multi-threaded applications and makes it easier to use multi-core CPUs efficiently. For more details, see PEP 703.

以前の Python C API では、関数を使用するには GIL を保持する必要があると宣言されていることがありました。これは、スレッド状態がアタッチされていることを指します。

global state¶

(グローバル状態) モジュールレベルの変数、クラス変数、拡張モジュール内の C の静的変数など、プログラム全体からアクセスできるデータです。マルチスレッドプログラムでは、スレッド間で共有されるグローバル状態には通常、競合状態やデータ競合を避けるための同期が必要です。

hash-based pyc¶

(ハッシュベース pyc ファイル) 正当性を判別するために、対応するソースファイルの最終更新時刻ではなくハッシュ値を使用するバイトコードのキャッシュファイルです。キャッシュされたバイトコードの無効化を参照してください。

hashable¶

(ハッシュ可能) オブジェクトの生存期間を通して変わらないハッシュ値を持ち（__hash__() メソッドが必要です）、ほかのオブジェクトと比較できる（__eq__() メソッドが必要です）場合、そのオブジェクトは ハッシュ可能 です。比較で等しいと判定されるハッシュ可能オブジェクトは、同じハッシュ値を持たなければなりません。

ハッシュ可能なオブジェクトは辞書のキーや集合のメンバーとして使えます。辞書や集合のデータ構造は内部でハッシュ値を使っているからです。

Python のイミュータブルな組み込みオブジェクトは、ほとんどがハッシュ可能です。(リストや辞書のような) ミュータブルなコンテナはハッシュ不可能です。(タプルや frozenset のような) イミュータブルなコンテナは、要素がハッシュ可能であるときのみハッシュ可能です。ユーザー定義のクラスのインスタンスであるようなオブジェクトはデフォルトでハッシュ可能です。それらは全て (自身を除いて) 比較結果は非等価であり、ハッシュ値は id() より得られます。

IDLE¶

Python の統合開発環境 (Integrated DeveLopment Environment)及び学習環境 (Learning Environment) です。IDLE --- Python のエディタとシェルは Python の標準的な配布に同梱されている基本的な機能のエディタとインタプリタ環境です。

永続オブジェクト (immortal)¶

永続オブジェクト は、PEP 683 で導入された CPython の実装の詳細です。

オブジェクトが永続である場合、その参照カウントは決して変更されず、そのためインタープリタの実行中にメモリが解放されることはありません。たとえば、CPython では True と None が永続オブジェクトです。

永続オブジェクトは sys._is_immortal()、または C API の PyUnstable_IsImmortal() によって識別できます。

immutable¶

(不変) 値が固定されたオブジェクトです。不変オブジェクトには、数値、文字列、タプルがあります。このようなオブジェクトは変更できません。異なる値を格納するには、新しいオブジェクトを作成する必要があります。不変オブジェクトは、辞書のキーなど、ハッシュ値が一定である必要のある場面で重要な役割を果たします。作成後に状態を変更できないため、不変オブジェクトは本質的にスレッドセーフであり、不適切な同期による並行変更を心配する必要がありません。

import path¶

path based finder が import するモジュールを検索する場所 (または path entry) のリスト。 import 中、このリストは通常 sys.path から来ますが、サブパッケージの場合は親パッケージの __path__ 属性からも来ます。

importing¶

あるモジュールの Python コードが別のモジュールの Python コードで使えるようにする処理です。

importer¶

モジュールを探してロードするオブジェクト。 finder と loader のどちらでもあるオブジェクト。

index¶

(インデックス) シーケンス内の要素の位置を表す数値です。

Python のインデックスはゼロから始まります。たとえば、things[0] は things の最初の要素を、things[1] は 2 番目の要素を表します。

文脈によっては、Python はシーケンスの末尾から数えるための負のインデックスや、スライスを使ったインデックス指定を許可しています。

添字も参照してください。

interactive¶

(対話型) Python には対話型インタープリタがあり、そのプロンプトで文や式を入力して、すぐに実行し、結果を見ることができます。 python を引数なしで起動するだけで利用できます（コンピュータのメインメニューで選択して起動することもできます）。新しいアイデアを試したり、モジュールやパッケージを調べたりするための、とても強力な方法です（help(x) を思い出してください）。対話モードについて詳しくは、対話モードを参照してください。

interpreted¶

Python はインタプリタ形式の言語であり、コンパイラ言語の対極に位置します。 (バイトコードコンパイラがあるために、この区別は曖昧ですが。) ここでのインタプリタ言語とは、ソースコードのファイルを、まず実行可能形式にしてから実行させるといった操作なしに、直接実行できることを意味します。インタプリタ形式の言語は通常、コンパイラ形式の言語よりも開発／デバッグのサイクルは短いものの、プログラムの実行は一般に遅いです。対話的も参照してください。

interpreter shutdown¶

Python インタープリタは、シャットダウンを要求されると、モジュールや各種の重要な内部構造など、割り当てられたすべてのリソースを段階的に解放する特別な段階に入ります。また、ガベージコレクタを複数回呼び出します。これにより、ユーザー定義のデストラクタや weakref コールバックのコードが実行されることがあります。シャットダウン段階で実行されるコードでは、依存するリソースがすでに機能しなくなっている場合があるため（よくある例はライブラリモジュールや warnings の仕組みです）、さまざまな例外が発生することがあります。

インタープリタがシャットダウンする主な理由は __main__ モジュールや実行されていたスクリプトの実行が終了したことです。

iterable¶

(イテラブル) 要素を一つずつ返すことができるオブジェクトです。例として、すべてのシーケンス型（list、str、tuple など）や、dict、ファイルオブジェクトのような一部のシーケンスでない型があります。また、__iter__() メソッド、またはシーケンスの意味論を実装する __getitem__() メソッドを定義した任意のクラスのオブジェクトも該当します。

イテラブルは for ループや、シーケンスを必要とするほかの多くの場面（zip()、map() など）で使えます（訳注: ここでのシーケンスは、シーケンス型ではなく、単なる列という意味です）。組み込み関数 iter() にイテラブルオブジェクトを引数として渡すと、そのオブジェクトのイテレータが返されます。このイテレータで、一連の値を一度だけ走査できます。イテラブルを使う際には通常、iter() を呼び出したり、イテレータオブジェクトを自分で扱ったりする必要はありません。 for 文が自動的にこれを行い、一時的な無名の変数を作成して、ループの実行中にイテレータを保持します。イテレータ、シーケンス、ジェネレータも参照してください。

iterator¶

(イテレータ) データのストリームを表すオブジェクトです。イテレータの __next__() メソッドを繰り返し呼び出すと（または組み込み関数 next() に渡すと）、ストリーム内の要素が順に返されます。それ以上データがない場合、代わりに StopIteration 例外が送出されます。この時点でイテレータオブジェクトは枯渇した状態となり、その後 __next__() メソッドを呼び出しても、再び StopIteration が送出されるだけです。イテレータには、自身を返す __iter__() メソッドが必要です。したがって、すべてのイテレータはイテラブルでもあり、ほかのイテラブルを受け付けるほとんどの場面で使えます。主な例外は、複数回の反復を試みるコードです。コンテナオブジェクト（list など）は、iter() 関数に渡したり、for ループで使ったりするたびに、新しいイテレータを生成します。イテレータでこれを試みても、前の反復で使ったものと同じ枯渇したイテレータオブジェクトが返されるだけなので、空のコンテナのように見えます。

詳細な情報は反復に関連する型にあります。

CPython は、イテレータが __iter__() を定義するという要件を、一貫して適用しているわけではありません。また、フリースレッドの CPython は、イテレータ操作のスレッドセーフな動作を保証しない点にも注意してください。

キー¶

マッピング内の項目を識別する値です。添字も参照してください。

key function¶

(キー関数) キー関数、あるいは照合関数とは、ソートや順序比較のための値を返す呼び出し可能オブジェクト(callable)です。例えば、 locale.strxfrm() をキー関数に使えば、ロケール依存のソートの慣習にのっとったソートキーを返します。

Python の多くのツールはキー関数を受け取り要素の並び順やグループ化を管理します。 min(), max(), sorted(), list.sort(), heapq.merge(), heapq.nsmallest(), heapq.nlargest(), itertools.groupby() 等があります。

キー関数を作成する方法はいくつかあります。たとえば、str.casefold() メソッドは、大文字と小文字を区別しないソートのキー関数として使えます。また、lambda r: (r[0], r[2]) のような lambda 式からキー関数を作成することもできます。さらに、operator.attrgetter()、operator.itemgetter()、operator.methodcaller() という三つのキー関数のコンストラクタがあります。キー関数の作成と使用の例については、ソート HOWTO を参照してください。

keyword argument¶

実引数を参照してください。

lambda¶

(ラムダ) 無名のインライン関数で、関数が呼び出されたときに評価される 1 つの式を含みます。ラムダ関数を作る構文は lambda [parameters]: expression です。

LBYL¶

「ころばぬ先の杖 (look before you leap)」の略です。このコーディングスタイルでは、呼び出しや検索を行う前に、明示的に前提条件 (pre-condition) 判定を行います。 EAFP アプローチと対照的で、 if 文がたくさん使われるのが特徴的です。

マルチスレッド環境では、LBYL のアプローチは「確認」と「実行」の間に競合状態を生じさせる危険があります。たとえば、if key in mapping: return mapping[key] というコードでは、判定の後、検索する前に、別のスレッドが mapping から key を削除すると、失敗することがあります。この問題は、ロックまたは EAFP のアプローチを使うと解決できます。スレッドセーフも参照してください。

lexical analyzer¶

(字句解析器) トークナイザ の正式な名称です。トークンを参照してください。

list¶

Python の組み込みシーケンスです。要素へのアクセスが O(1) であるため、名前とは異なり、連結リストよりも、ほかの言語の配列に似ています。組み込み型の操作の時間計算量を参照してください。

list comprehension¶

(リスト内包表記) シーケンス中の全てあるいは一部の要素を処理して、その結果からなるリストを返す、コンパクトな方法です。 result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0] とすると、 0 から 255 までの偶数を 16進数表記 (0x..) した文字列からなるリストを生成します。 if 節はオプションです。 if 節がない場合、 range(256) の全ての要素が処理されます。

lock¶

(ロック) 一度に一つのスレッドだけが共有リソースにアクセスできるようにする同期プリミティブです。スレッドは、保護されたリソースにアクセスする前にロックを取得し、アクセス後に解放しなければなりません。ほかのスレッドがすでに保持しているロックを取得しようとすると、ロックが利用可能になるまでブロックします。 Python の threading モジュールは、~threading.Lock`（基本的なロック）と :class:`~threading.RLock`（:term:`再入可能なロック）を提供します。ロックは、競合状態を防ぎ、共有データへのスレッドセーフなアクセスを保証するために使われます。ロックの代わりに使える設計パターンとして、キュー、生産者と消費者のパターン、スレッドローカルな状態などがあります。デッドロックと再入可能も参照してください。

lock-free¶

(ロックフリー) ロックを取得せず、CPU のアトミック命令を使って正しさを保証する操作です。ロックフリーな操作は、互いをブロックせずに並行して実行でき、ロックを保持する操作によってブロックされることもありません。フリースレッドの Python では、dict や list のような組み込み型がロックフリーな読み取り操作を提供します。そのため、複数のステップからなる変更がオブジェクトごとのロックを保持していても、ほかのスレッドから途中の状態が観測されることがあります。

loader¶

(ローダー) モジュールをロードするオブジェクトです。 Loader インターフェースを実装するには、exec_module() メソッドと create_module() メソッドを定義しなければなりません。ローダーは通常、ファインダから返されます。次の項目も参照してください:

ロケールエンコーディング¶

Unix では、LC_CTYPE ロケールのエンコーディングです。 locale.setlocale(locale.LC_CTYPE, new_locale) で設定できます。

Windows では、ANSI コードページ（例: "cp1252"）です。

Android と VxWorks では、Python はロケールエンコーディングとして "utf-8" を使用します。

locale.getencoding() を使うと、ロケールエンコーディングを取得できます。

ファイルシステムのエンコーディングとエラーハンドラも参照してください。

magic method¶

special method のくだけた同義語です。

mapping¶

(マッピング) 任意のキー探索をサポートしていて、 collections.abc.Mapping か collections.abc.MutableMapping の抽象基底クラスで指定されたメソッドを実装しているコンテナオブジェクトです。例えば、 dict, collections.defaultdict, collections.OrderedDict, collections.Counter などです。

meta path finder¶

sys.meta_path を検索して得られた finder. meta path finder は path entry finder と関係はありますが、別物です。

meta path finder が実装するメソッドについては importlib.abc.MetaPathFinder を参照してください。

metaclass¶

(メタクラス) クラスのクラスです。クラス定義は、クラス名、クラスの辞書と、基底クラスのリストを作ります。メタクラスは、それら 3 つを引数として受け取り、クラスを作る責任を負います。ほとんどのオブジェクト指向言語は(訳注:メタクラスの)デフォルトの実装を提供しています。Python が特別なのはカスタムのメタクラスを作成できる点です。ほとんどのユーザーに取って、メタクラスは全く必要のないものです。しかし、一部の場面では、メタクラスは強力でエレガントな方法を提供します。たとえば属性アクセスのログを取ったり、スレッドセーフ性を追加したり、オブジェクトの生成を追跡したり、シングルトンを実装するなど、多くの場面で利用されます。

詳細はメタクラスを参照してください。

メソッド¶

(メソッド) クラス本体の中で定義された関数。そのクラスのインスタンスの属性として呼び出された場合、メソッドはインスタンスオブジェクトを第一引数として受け取ります (この第一引数は通常 self と呼ばれます)。関数とネストされたスコープも参照してください。

method resolution order¶

(メソッド解決順序) メンバーの検索時に基底クラスを調べる順序です。 Python インタープリタがリリース 2.3 以降で使っているアルゴリズムの詳細については、The Python 2.3 Method Resolution Order を参照してください。

module¶

(モジュール) Python コードの組織単位としてはたらくオブジェクトです。モジュールは任意の Python オブジェクトを含む名前空間を持ちます。モジュールは importing の処理によって Python に読み込まれます。

パッケージを参照してください。

module spec¶

モジュールをロードするのに使われるインポート関連の情報を含む名前空間です。 importlib.machinery.ModuleSpec のインスタンスです。

Module specs も参照してください。

MRO¶

method resolution order を参照してください。

mutable¶

(可変) プログラムの実行中に状態を変更できるオブジェクトです。マルチスレッドプログラムでは、スレッド間で共有する可変オブジェクトには、競合状態を避けるための慎重な同期が必要です。不変、スレッドセーフ、並行変更も参照してください。

named tuple¶

"名前付きタプル" という用語は、タプルを継承していて、インデックスが付く要素に対し属性を使ってのアクセスもできる任意の型やクラスに応用されています。その型やクラスは他の機能も持っていることもあります。

time.localtime() や os.stat() の返り値を含むいくつかの組み込み型は名前付きタプルです。他の例は sys.float_info です:

>>> sys.float_info[1]                   # インデックスによるアクセス
1024
>>> sys.float_info.max_exp              # 名前付きフィールドによるアクセス
1024
>>> isinstance(sys.float_info, tuple)   # タプルの一種
True

名前付きタプルの一部は、上の例のような組み込み型です。また、tuple を継承して名前付きフィールドを定義する、通常のクラス定義からも名前付きタプルを作成できます。このようなクラスは手作業で書くことも、typing.NamedTuple を継承したり、ファクトリ関数 collections.namedtuple() を使ったりして作成することもできます。後者の方法では、手書きの名前付きタプルや組み込みの名前付きタプルにはない場合がある、いくつかの追加メソッドも用意されます。

namespace¶

(名前空間) 変数が格納される場所です。名前空間は辞書として実装されます。名前空間にはオブジェクトの (メソッドの) 入れ子になったものだけでなく、局所的なもの、大域的なもの、そして組み込みのものがあります。名前空間は名前の衝突を防ぐことによってモジュール性をサポートする。例えば関数 builtins.open と os.open() は名前空間で区別されています。また、どのモジュールが関数を実装しているか明示することによって名前空間は可読性と保守性を支援します。例えば、random.seed() や itertools.islice() と書くと、それぞれモジュール random や itertools で実装されていることが明らかです。

namespace package¶

サブパッケージのコンテナとしてだけ機能するパッケージです。名前空間パッケージは物理的な実体を持たない場合があり、特に __init__.py ファイルを持たない点で通常のパッケージと異なります。

名前空間パッケージを使うと、個別にインストール可能な複数のパッケージが、共通の親パッケージを持てます。それ以外の場合は、通常のパッケージの使用を推奨します。

詳しくは、PEP 420 と名前空間パッケージを参照してください。

module を参照してください。

native code¶

(ネイティブコード) 機械語命令にコンパイルされ、プロセッサ上で直接実行されるコードです。インタープリタで解釈されたり、仮想マシン内で実行されたりするコードと対比されます。 Python の文脈では、ネイティブコードは通常、Python から呼び出せる拡張モジュール内の C、C++、Rust、Fortran のコードを指します。拡張モジュールも参照してください。

nested scope¶

(ネストされたスコープ) 外側で定義されている変数を参照する機能です。例えば、ある関数が別の関数の中で定義されている場合、内側の関数は外側の関数中の変数を参照できます。ネストされたスコープはデフォルトでは変数の参照だけができ、変数の代入はできないので注意してください。ローカル変数は、最も内側のスコープで変数を読み書きします。同様に、グローバル変数を使うとグローバル名前空間の値を読み書きします。 nonlocal で外側の変数に書き込めます。

new-style class¶

(新スタイルクラス) 現在すべてのクラスオブジェクトに使われている種類のクラスの、以前の名称です。古いバージョンの Python では、__slots__、デスクリプタ、プロパティ、__getattribute__()、クラスメソッド、静的メソッドといった、Python の新しく多様な機能を使えるのは新スタイルクラスだけでした。

non-deterministic¶

(非決定的) 同じ入力でも、実行ごとにプログラムの結果が変わり得る動作です。マルチスレッドプログラムでは、スレッドの相対的なタイミングや実行の入り交じり方が結果に影響する競合状態が原因で、非決定的な動作になることがよくあります。ロックやその他の同期プリミティブによる適切な同期は、決定的な動作の保証に役立ちます。

object¶

(オブジェクト) 状態 (属性や値) と定義された振る舞い (メソッド) をもつ全てのデータ。もしくは、全ての新スタイルクラスの究極の基底クラスのこと。

optimized scope¶

(最適化されたスコープ) コードのコンパイル時に、対象となるローカル変数名をコンパイラが確実に把握できるスコープです。これにより、その名前への読み書きを最適化できます。関数、ジェネレータ、コルーチン、内包表記、ジェネレータ式のローカル名前空間は、この方法で最適化されます。注意: インタープリタの最適化の大部分は、すべてのスコープに適用されます。最適化されたスコープだけに適用されるのは、ローカル変数名と非ローカル変数名の集合が既知であることに依存する最適化だけです。

optional module¶

(オプションモジュール) 標準ライブラリの一部である拡張モジュールのうち、一部の CPython ビルドでは含まれないことがあるものです。通常は、サードパーティライブラリが不足しているか、そのプラットフォームでモジュールを利用できないことが理由です。

サードパーティライブラリを必要とするオプションモジュールの一覧は、オプションのモジュールの要件を参照してください。

package¶

(パッケージ) サブモジュールや、再帰的にサブパッケージを含むことができる Python のモジュールです。厳密には、パッケージは __path__ 属性を持つ Python モジュールです。

regular package と namespace package を参照してください。

parallelism¶

(並列性) 複数の操作を（たとえば複数の CPU コアで）同時に実行することです。グローバルインタープリタロック（GIL）がある Python ビルドでは、一度に一つのスレッドだけが Python バイトコードを実行します。そのため、複数の CPU コアを活用するには通常、複数のプロセス（multiprocessing など）や、GIL を解放するネイティブ拡張を使います。フリースレッドの Python では、複数の Python スレッドが異なるコアで Python コードを同時に実行できます。

parameter¶

(仮引数) 名前付の実体で関数 (やメソッド ) の定義において関数が受ける実引数を指定します。仮引数には5種類あります:

位置またはキーワード: 位置であるいはキーワード引数として渡すことができる引数を指定します。これはたとえば以下の foo や bar のように、デフォルトの仮引数の種類です:
```
def func(foo, bar=None): ...
```

位置専用: 位置によってのみ与えられる引数を指定します。位置専用の引数は関数定義の引数のリストの中でそれらの後ろに / を含めることで定義できます。例えば下記の posonly1 と posonly2 は位置専用引数になります:
```
def func(posonly1, posonly2, /, positional_or_keyword): ...
```

キーワード専用: キーワードによってのみ与えられる引数を指定します。キーワード専用の引数を定義できる場所は、例えば以下の kw_only1 や kw_only2 のように、関数定義の仮引数リストに含めた可変長位置引数または裸の * の後です:
```
def func(arg, *, kw_only1, kw_only2): ...
```
可変長位置: (他の仮引数で既に受けられた任意の位置引数に加えて) 任意の個数の位置引数が与えられることを指定します。このような仮引数は、以下の args のように仮引数名の前に * をつけることで定義できます:
```
def func(*args, **kwargs): ...
```
可変長キーワード: (他の仮引数で既に受けられた任意のキーワード引数に加えて) 任意の個数のキーワード引数が与えられることを指定します。このような仮引数は、上の例の kwargs のように仮引数名の前に ** をつけることで定義できます。

仮引数はオプションと必須の引数のどちらも指定でき、オプションの引数にはデフォルト値も指定できます。

用語集の実引数の項目、FAQ の実引数と仮引数の違いは何ですか?、inspect.Parameter クラス、関数定義の節、および PEP 362 も参照してください。

per-object lock¶

(オブジェクトごとのロック) すべてのオブジェクトで共有されるグローバルなロックではなく、個別のオブジェクトインスタンスに関連付けられたロックです。フリースレッドの Python では、dict や list などの組み込み型はオブジェクトごとのロックを使い、同じオブジェクトへの操作を直列化しながら、異なるオブジェクトへの操作を並行して実行できるようにします。オブジェクトごとのロックを保持する操作は、同じオブジェクトをロックするほかの操作の進行を妨げますが、ロックフリーな操作はブロックしません。

path entry¶

path based finder が import するモジュールを探す import path 上の1つの場所です。

path entry finder¶

sys.path_hooks にある callable (つまり path entry hook) が返した finder です。与えられた path entry にあるモジュールを見つける方法を知っています。

パスエントリーファインダが実装するメソッドについては importlib.abc.PathEntryFinder を参照してください。

path entry hook¶

sys.path_hooks リスト内の呼び出し可能オブジェクトで、特定のパスエントリ上でモジュールを見つける方法を知っている場合に、パスエントリファインダを返すものです。

path based finder¶

モジュールを探すためにインポートパスを検索する、デフォルトのメタパスファインダの一つです。

path-like object¶

(path-like オブジェクト) ファイルシステムパスを表します。 path-like オブジェクトは、パスを表す str オブジェクトや bytes オブジェクト、または os.PathLike プロトコルを実装したオブジェクトのどれかです。 os.PathLike プロトコルをサポートしているオブジェクトは os.fspath() を呼び出すことで str または bytes のファイルシステムパスに変換できます。 os.fsdecode() と os.fsencode() はそれぞれ str あるいは bytes になるのを保証するのに使えます。 PEP 519 で導入されました。

PEP¶

Python Enhancement Proposal。PEP は、Python コミュニティに対して情報を提供する、あるいは Python の新機能やその過程や環境について記述する設計文書です。 PEP は、機能についての簡潔な技術的仕様と提案する機能の論拠 (理論) を伝えるべきです。

PEP は、主要な新機能を提案し、ある問題に対するコミュニティの意見を集め、Python に採用された設計上の決定を文書化するための、主要な仕組みとなることを意図しています。 PEP の著者には、コミュニティ内で合意を形成し、反対意見を文書化する責任があります。

PEP 1 を参照してください。

portion¶

PEP 420 で定義されている、namespace package に属する、複数のファイルが (zipファイルに格納されている場合もある) 1つのディレクトリに格納されたもの。

位置引数 (positional argument)¶

実引数を参照してください。

provisional API¶

(暫定 API) 標準ライブラリの後方互換性保証から計画的に除外されたものです。そのようなインターフェースへの大きな変更は、暫定であるとされている間は期待されていませんが、コア開発者によって必要とみなされれば、後方非互換な変更 (インターフェースの削除まで含まれる) が行われえます。このような変更はむやみに行われるものではありません -- これは API を組み込む前には見落とされていた重大な欠陥が露呈したときにのみ行われます。

暫定 API であっても、後方互換性のない変更は「最終手段」とみなされます。特定された問題に対しては、引き続き、後方互換性のある解決策を見つけるためにあらゆる努力を行います。

このプロセスにより、標準ライブラリは問題となるデザインエラーに長い間閉じ込められることなく、時代を超えて進化を続けられます。詳細は PEP 411 を参照してください。

provisional package¶

provisional API を参照してください。

Python 3000¶

Python 3.x リリースラインのニックネームです。(Python 3 が遠い将来の話だった頃に作られた言葉です。) "Py3k" と略されることもあります。

Pythonic¶

他の言語で一般的な考え方で書かれたコードではなく、Python の特に一般的なイディオムに従った考え方やコード片。例えば、Python の一般的なイディオムでは for 文を使ってイテラブルのすべての要素に渡ってループします。他の多くの言語にはこの仕組みはないので、Python に慣れていない人は代わりに数値のカウンターを使うかもしれません:

for i in range(len(food)):
    print(food[i])

これに対し、きれいな Pythonic な方法は:

for piece in food:
    print(piece)

qualified name¶

(修飾名) モジュールのグローバルスコープから、そのモジュールで定義されたクラス、関数、メソッドへの、 "パス" を表すドット名表記です。 PEP 3155 で定義されています。トップレベルの関数やクラスでは、修飾名はオブジェクトの名前と同じです:

>>> class C:
...     class D:
...         def meth(self):
...             pass
...
>>> C.__qualname__
'C'
>>> C.D.__qualname__
'C.D'
>>> C.D.meth.__qualname__
'C.D.meth'

モジュールへの参照で使われると、完全修飾名 (fully qualified name) はすべての親パッケージを含む全体のドット名表記、例えば email.mime.text を意味します:

>>> import email.mime.text
>>> email.mime.text.__name__
'email.mime.text'

race condition¶

(競合状態) 特にマルチスレッドプログラムにおいて、イベントの相対的なタイミングや順序によって動作が変わる、プログラムの状態です。競合状態は、非決定的な動作や、再現が難しいバグにつながることがあります。データ競合は、共有メモリへの同期されていないアクセスが関わる、競合状態の一種です。 LBYL コーディングスタイルは、マルチスレッドコードで特に競合状態が起こりやすいものです。ロックやその他の同期プリミティブを使うと、競合状態を防ぐのに役立ちます。

reference count¶

(参照カウント) あるオブジェクトに対する参照の数。参照カウントが0になったとき、そのオブジェクトは破棄されます。永続であり、参照カウントが決して変更されないために割り当てが解除されないオブジェクトもあります。参照カウントは通常は Python のコード上には現れませんが、 CPython 実装の重要な要素です。プログラマーは、任意のオブジェクトの参照カウントを知るために sys.getrefcount() 関数を呼び出すことが出来ます。

CPython では、参照カウントは安定した値や明確に定義された値とはみなされません。オブジェクトへの参照の数や、Python コードがその数に与える影響は、バージョンによって異なる場合があります。

regular package¶

伝統的な、 __init__.py ファイルを含むディレクトリとしての package。

namespace package を参照してください。

reentrant¶

(再入可能) 同じスレッドが複数回呼び出したり取得したりしても、エラーやデッドロックを引き起こさない、関数やロックの性質です。

関数の再入可能性は、前の呼び出しが完了する前に、安全にもう一度呼び出せることを意味します。関数が再帰的に、またはシグナルハンドラから呼び出される可能性がある場合に重要です。スレッドセーフでない関数は、マルチスレッドプログラムで再入的に呼び出すと、非決定的になる場合があります。

ロックでは、Python の threading.RLock`（再入可能なロック）が再入可能です。これは、すでにロックを保持しているスレッドが、ブロックせずにもう一度そのロックを取得できることを意味します。一方、:class:`threading.Lock は再入可能ではなく、同じスレッドから二度取得しようとすると、デッドロックになります。

ロックとデッドロックも参照してください。

REPL¶

"read–eval–print loop" の頭字語で、対話型インタープリターシェルの別名。

__slots__¶

クラス内での宣言で、インスタンス属性の領域をあらかじめ定義しておき、インスタンス辞書を排除することで、メモリを節約します。これはよく使われるテクニックですが、正しく扱うには少しトリッキーなので、稀なケース、例えばメモリが死活問題となるアプリケーションでインスタンスが大量に存在する、といったときを除き、使わないのがベストです。

sequence¶

(シーケンス) 整数インデックスを使った効率的な要素アクセスを __getitem__() 特殊メソッドでサポートし、シーケンスの長さを返す __len__() メソッドを定義するイテラブルです。組み込みのシーケンス型には、list、str、tuple、bytes などがあります。 dict も __getitem__() と __len__() をサポートしますが、検索には整数ではなく任意のハッシュ可能なキーを使うため、シーケンスではなくマッピングとみなされます。

collections.abc.Sequence 抽象基底クラスは、__getitem__() と __len__() に加え、count()、index()、__contains__()、__reversed__() を含む、さらに豊富なインターフェースを定義します。この拡張されたインターフェースを実装する型は、register() で明示的に登録できます。シーケンスのメソッド全般について詳しくは、共通のシーケンス演算を参照してください。

set comprehension¶

(集合内包表記) イテラブルのすべて、または一部の要素を処理し、その結果からなる集合を返す簡潔な書き方です。 results = {c for c in 'abracadabra' if c not in 'abc'} は、文字列の集合 {'r', 'd'} を生成します。内包表記 (Comprehension) を参照してください。

single dispatch¶

(単一ディスパッチ) ジェネリック関数のディスパッチの一形態で、一つの引数の型に基づいて実装を選びます。

slice¶

(スライス) シーケンスの一部を表すために使う、slice 型のオブジェクトです。 variable_name[1:3:5] のように、角括弧内にコロンを含む添字表記のスライス形式を使うと、スライスオブジェクトが作成されます。

soft deprecated¶

(ソフト非推奨) ソフト非推奨の API は、新しいコードでは使うべきではありませんが、既存のコードで使い続けても安全です。その API のドキュメントの掲載とテストは続けられますが、それ以上の機能拡張は行われません。

通常の非推奨とは異なり、ソフト非推奨では API の削除は予定されておらず、警告も出力されません。

PEP 387: Soft Deprecation を参照してください。

special method¶

(特殊メソッド) ある型に特定の操作、例えば加算をするために Python から暗黙に呼び出されるメソッド。この種類のメソッドは、メソッド名の最初と最後にアンダースコア 2 つがついています。特殊メソッドについては特殊メソッド名で解説されています。

standard library¶

(標準ライブラリ) 公式の Python インタープリタパッケージの一部として配布される、パッケージ、モジュール、拡張モジュールの集まりです。具体的に何が含まれるかは、プラットフォーム、利用可能なシステムライブラリ、その他の条件によって変わる場合があります。ドキュメントは The Python standard library にあります。

標準ライブラリのモジュール名として考えられるものすべての一覧については、sys.stdlib_module_names も参照してください。

statement¶

(文) 文はスイート (コードの"ブロック") に不可欠な要素です。文は式かキーワードから構成されるもののどちらかです。後者には if、while、for があります。

static type checker¶

(静的型チェッカー) Python コードを読み込んで解析し、型の誤りなどの問題を探す外部ツールです。型ヒントと typing モジュールも参照してください。

stdlib¶

標準ライブラリの略です。

steal¶

(参照を盗む) Python の C API で実引数を「盗む」とは、実引数の所有権が呼び出された関数に移ることを意味します。呼び出し元は、呼び出し後にその参照を使ってはなりません。一般に、実引数を「盗む」関数は、失敗した場合でも所有権を受け取ります。

詳しい説明は、参照カウントの詳細を参照してください。

strong reference¶

(強参照) Python の C API で、オブジェクトへの参照のうち、それを保持するコードが所有するものです。強参照は、参照を作成するときに Py_INCREF() を呼び出すことで取得され、参照を削除するときに Py_DECREF() で解放されます。

Py_NewRef() 関数を使うと、オブジェクトへの強参照を作成できます。通常は、参照が一つリークするのを避けるために、強参照のスコープを抜ける前に、その強参照に対して Py_DECREF() 関数を呼び出さなければなりません。

借用参照も参照してください。

添字¶

添字式の角括弧内の式です。たとえば、items[3] の 3 が該当します。通常、コンテナの要素を選ぶために使います。マッピングに添字を指定する場合はキー、シーケンスに添字を指定する場合はインデックスとも呼ばれます。

synchronization primitive¶

(同期プリミティブ) 複数のスレッドの実行を調整（同期）し、共有リソースへのスレッドセーフなアクセスを保証するための基本的な構成要素です。 Python の threading モジュールは、Lock、RLock、Semaphore、Condition、Event、Barrier など、いくつかの同期プリミティブを提供します。さらに、queue モジュールは、複数の生産者と複数の消費者をサポートするキューを提供し、マルチスレッドプログラムで特に役立ちます。これらのプリミティブは、競合状態を防いだり、スレッドの実行を調整したりするのに役立ちます。ロックも参照してください。

t-string¶

t-strings¶

t または T を接頭辞に持つ文字列リテラルは、一般に「t-string」と呼ばれます。これはテンプレート文字列リテラルの略です。

text encoding¶

Python の文字列は、Unicode コードポイントの列（U+0000--U+10FFFF の範囲）です。文字列を保存または転送するには、バイト列としてシリアライズする必要があります。

文字列をバイト列にシリアライズすることを「エンコード」、バイト列から文字列を復元することを「デコード」といいます。

文字列をシリアライズするためのコーデックはさまざまあり、総称して「テキストエンコーディング」と呼ばれます。

text file¶

(テキストファイル) str オブジェクトを読み書きできるファイルオブジェクトです。テキストファイルは、多くの場合、実際にはバイト指向のデータストリームにアクセスし、テキストエンコーディングを自動的に処理します。例として、テキストモード（'r' または 'w'）で開いたファイル、sys.stdin、sys.stdout、io.StringIO のインスタンスがあります。

bytes-like オブジェクトを読み書きできるファイルオブジェクトについては、バイナリファイルも参照してください。

thread state¶

(スレッド状態) CPython ランタイムが OS スレッド内で実行するために使う情報です。たとえば、現在の例外（あれば）や、バイトコードインタープリタの状態が含まれます。

各スレッド状態は、一つの OS スレッドに結び付けられますが、スレッドには複数のスレッド状態が用意されている場合があります。一度にアタッチされるのは、そのうち最大一つです。

関数のドキュメントに明示的な例外の記載がない限り、Python の C API の大部分を呼び出すにはアタッチされたスレッド状態が必要です。バイトコードインタープリタは、スレッド状態がアタッチされている場合だけ動作します。

各スレッド状態は一つのインタープリタに属しますが、各インタープリタは、同じ OS スレッドに対応する複数の状態も含めて、多数のスレッド状態を持つことができます。複数のインタープリタのスレッド状態を同じスレッドに結び付けられますが、ある時点でそのスレッドにアタッチできるのは一つだけです。

詳しくは、スレッド状態とグローバルインタープリタロックを参照してください。

thread-safe¶

(スレッドセーフ) 複数のスレッドから並行して使っても正しく動作するモジュール、関数、クラスです。スレッドセーフなコードは、ロックのような適切な同期プリミティブを使って共有される可変状態を保護するか、共有される可変状態をまったく持たないように設計されています。フリースレッドのビルドでは、dict、list、set のような組み込み型は、内部でロックを使って多くの操作をスレッドセーフにしていますが、スレッドセーフであることが必ずしも保証されているわけではありません。スレッドセーフでないコードをマルチスレッドプログラムで使うと、競合状態やデータ競合が発生することがあります。

トークン¶

字句解析器（トークナイザ とも呼ばれます）が生成する、ソースコードの小さな単位です。名前、数値、文字列、演算子、改行などは、トークンで表されます。

tokenize モジュールは、Python の字句解析器を公開します。 token モジュールは、さまざまな種類のトークンについての情報を含みます。

triple-quoted string¶

(三重クォート文字列) クォート記号（"）またはアポストロフィー（'）を三つ並べて囲んだ文字列です。一重クォート文字列にない機能を提供するわけではありませんが、いくつかの理由で便利です。文字列の中にシングルクォートやダブルクォートをエスケープせずに含めることができ、行継続文字を使わずに複数行にまたがることもできるため、ドキュメンテーション文字列を書く際に特に役立ちます。

type¶

(型) Python オブジェクトの型は、それがどのような種類のオブジェクトかを決めます。すべてのオブジェクトには型があります。オブジェクトの型には __class__ 属性としてアクセスでき、type(obj) でも取得できます。

type alias¶

(型エイリアス) 型の別名で、型を識別子に代入して作成します。

型エイリアスは型ヒントを単純化するのに有用です。例えば:

def remove_gray_shades(
        colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:
    pass

これは次のようにより読みやすくできます:

Color = tuple[int, int, int]

def remove_gray_shades(colors: list[Color]) -> list[Color]:
    pass

機能の説明がある typing と PEP 484 を参照してください。

type hint¶

(型ヒント) 変数、クラス属性、関数のパラメータや返り値の期待される型を指定する annotation です。

型ヒントは省略可能で、Python によって強制されませんが、静的型チェッカーに役立ちます。 IDE によるコード補完やリファクタリングにも役立ちます。

グローバル変数、クラス属性、関数で、ローカル変数でないものの型ヒントは typing.get_type_hints() で取得できます。

機能の説明がある typing と PEP 484 を参照してください。

universal newlines¶

テキストストリームの解釈法の一つで、以下のすべてを行末と認識します: Unix の行末規定 '\n'、Windows の規定 '\r\n'、古い Macintosh の規定 '\r'。利用法について詳しくは、 PEP 278 と PEP 3116 、さらに bytes.splitlines() も参照してください。

variable annotation¶

(変数アノテーション) 変数あるいはクラス属性の annotation 。

変数あるいはクラス属性に注釈を付けたときは、代入部分は任意です:

class C:
    field: 'annotation'

変数アノテーションは通常は型ヒントのために使われます: 例えば、この変数は int の値を取ることを期待されています:

count: int = 0

変数アノテーションの構文については注釈付き代入文 (annotated assignment statements) 節で解説しています。

機能の説明がある function annotation, PEP 484 , PEP 526 を参照してください。また、アノテーションを利用するベストプラクティスとしてアノテーションのベストプラクティスも参照してください。

virtual environment¶

(仮想環境) 協調的に切り離された実行環境です。これにより Python ユーザとアプリケーションは同じシステム上で動いている他の Python アプリケーションの挙動に干渉することなく Python パッケージのインストールと更新を行うことができます。

venv を参照してください。

virtual machine¶

(仮想マシン) 完全にソフトウェアにより定義されたコンピュータ。 Python の仮想マシンは、バイトコードコンパイラが出力したバイトコードを実行します。

walrus operator¶

(セイウチ演算子) 代入式の演算子 := を指すユーモラスな呼び方です。頭を傾けると、少しセイウチに似て見えることに由来します。

Zen of Python¶

(Pythonの悟り) Python を理解し利用する上での導きとなる、Python の設計原則と哲学をリストにしたものです。対話プロンプトで "import this" とするとこのリストを読めます。

用語集¶

前のトピックへ

次のトピックへ

このページ