用語集
******

">>>"
   *対話型* シェルにおけるデフォルトの 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* で参照されます。

   オブジェクトには、 名前 (識別子とキーワード) で定義される識別子では
   ない名前の属性を与えることができます。たとえば "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 のフリースレッド対応 を参照してください。

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()" メソッドを定義しなければなりません。 ローダーは通
   常、*ファインダ* から返されます。 次の項目も参照してください:

   * ファインダーとローダー

   * "importlib.abc.Loader"

   * **PEP 302**

ロケールエンコーディング
   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 以降で使っているアルゴリズムの
   詳細については、Python 2.3 のメソッド解決順序 を参照してください。

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

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

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

   モジュール仕様 も参照してください。

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

   標準ライブラリのモジュール名として考えられるものすべての一覧につい
   ては、"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"" とするとこのリストを読めます。
