用語集
******

">>>"
   インタラクティブシェルにおけるデフォルトの Python プロンプトです。
   インタプリタでインタラクティブに実行されるコード例でよく出てきます
   。

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

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

   * 組み込みの定数 "Ellipsis" 。

2to3
   Python 2.x のコードを Python 3.x のコードに変換するツールです。ソー
   スコードを解析してその解析木を巡回 (traverse) することで検知できる
   、非互換性の大部分を処理します。

   2to3 は標準ライブラリの "lib2to3" として利用できます。単体のツール
   として使えるスクリプトが "Tools/scripts/2to3" として提供されていま
   す。 2to3 - Python 2 から 3 への自動コード変換 を参照してください。

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

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

   ローカル変数のアノテーションは実行時にはアクセスできませんが、グロ
   ーバル変数、クラス属性、関数のアノテーションはそれぞれモジュール、
   クラス、関数の "__annotations__" 特殊属性に保持されています。

   機能の説明がある *variable annotation*, *function annotation*,
   **PEP 484**, **PEP 526** を参照してください。

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 iterator* を返す関数で
   す。 "async def" で定義されたコルーチン関数に似ていますが、 "yield"
   式を持つ点で異なります。 "yield" 式は "async for" ループで使用でき
   る値の並びを生成するのに使用されます。

   通常は非同期ジェネレータ関数を指しますが、文脈によっては *非同期ジ
   ェネレータイテレータ* を指す場合があります。 意図された意味が明らか
   でない場合、 明瞭化のために完全な単語を使用します。

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

asynchronous generator iterator
   (非同期ジェネレータイテレータ) *asynchronous generator* 関数で生成
   されるオブジェクトです。

   これは、 "__anext__()" メソッドを使って呼び出されたときに awaitable
   オブジェクトを返す *asynchronous iterator* です。 この 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** で導入されました。

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

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* も参照してください。

bytes-like object
   バッファプロトコル (buffer Protocol) をサポートしていて、 C 言語の
   意味で *連続した contiguous* バッファーを提供可能なオブジェクト。
   "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 モジュール にあります。

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

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

class variable
   (クラス変数) クラス上に定義され、クラスレベルで (つまり、クラスのイ
   ンスタンス上ではなしに) 変更されることを目的としている変数です。

coercion
   (型強制) 同じ型の 2 引数を伴う演算の最中に行われる、ある型のインス
   タンスの別の型への暗黙の変換です。 例えば、 "int(3.15)" は浮動小数
   点数を整数 "3" に変換します。しかし "3+4.5" では、各引数は型が異な
   り(一つは整数、一つは浮動小数点数)、加算をする前に同じ型に変換でき
   なければ "TypeError" 例外が投げられます。 型強制がなかったら、すべ
   ての引数は、たとえ互換な型であっても、単に "3+4.5" ではなく
   "float(3)+4.5" というように、プログラマーが同じ型に正規化しなければ
   いけません。

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

context manager
   (コンテキストマネージャ) "__enter__()" と "__exit__()" メソッドを定
   義することで "with" 文内の環境を管理するオブジェクトです。**PEP
   343** を参照してください。

context variable
   (コンテキスト変数) コンテキストに依存して異なる値を持つ変数。 これ
   は、ある変数の値が各々の実行スレッドで異なり得るスレッドローカルス
   トレージに似ています。 しかしコンテキスト変数では、 1 つの実行スレ
   ッドにいくつかのコンテキストがあり得、コンテキスト変数の主な用途は
   並列な非同期タスクの変数の追跡です。 "contextvars" を参照してくださ
   い。

contiguous
   (隣接、連続) バッファが厳密に *C-連続* または *Fortran 連続* である
   場合に、そのバッファは連続しているとみなせます。 ゼロ次元バッファは
   C 連続であり Fortran 連続です。 一次元の配列では、その要素は必ずメ
   モリ上で隣接するように配置され、添字がゼロから始まり増えていく順序
   で並びます。 多次元の C-連続な配列では、メモリアドレス順に要素を巡
   る際には最後の添え字が最初に変わるのに対し、 Fortran 連続な配列では
   最初の添え字が最初に動きます。

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

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

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

decorator
   (デコレータ) 別の関数を返す関数で、通常、 "@wrapper" 構文で関数変換
   として適用されます。デコレータの一般的な利用例は、 "classmethod()"
   と "staticmethod()" です。

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

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

      @staticmethod
      def f(arg):
          ...

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

descriptor
   (デスクリプタ) メソッド "__get__()", "__set__()", あるいは
   "__delete__()" を定義しているオブジェクトです。あるクラス属性がデス
   クリプタであるとき、属性探索によって、束縛されている特別な動作が呼
   び出されます。通常、get,set,deleteのために *a.b* と書くと、 *a* の
   クラス辞書内でオブジェクト *b* を検索しますが、 *b* がデスクリプタ
   であればそれぞれのデスクリプタメソッドが呼び出されます。デスクリプ
   タの理解は、 Python を深く理解する上で鍵となります。というのは、デ
   スクリプタこそが、関数、メソッド、プロパティ、クラスメソッド、静的
   メソッド、そしてスーパクラスの参照といった多くの機能の基盤だからで
   す。

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

dictionary
   (辞書) 任意のキーを値に対応付ける連想配列です。 "__hash__()" メソッ
   ドと "__eq__()" メソッドを実装した任意のオブジェクトをキーにできま
   す。 Perl ではハッシュ (hash) と呼ばれています。

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

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

docstring
   クラス、関数、モジュールの最初の式である文字列リテラルです。そのス
   イートの実行時には無視されますが、コンパイラによって識別され、その
   クラス、関数、モジュールの "__doc__" 属性として保存されます。イント
   ロスペクションできる（訳注: 属性として参照できる）ので、オブジェク
   トのドキュメントを書く標準的な場所です。

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

EAFP
   「認可をとるより許しを請う方が容易  (easier to ask for forgiveness
   than permission、マーフィーの法則)」の略です。この Python で広く使
   われているコーディングスタイルでは、通常は有効なキーや属性が存在す
   るものと仮定し、その仮定が誤っていた場合に例外を捕捉します。この簡
   潔で手早く書けるコーディングスタイルには、 "try" 文および "except"
   文がたくさんあるのが特徴です。このテクニックは、C のような言語でよ
   く使われている *LBYL* スタイルと対照的なものです。

expression
   (式) 何かの値と評価される、一まとまりの構文 (a piece of syntax) で
   す。言い換えると、式とはリテラル、名前、属性アクセス、演算子や関数
   呼び出しなど、値を返す式の要素の積み重ねです。他の多くの言語と違い
   、Python では言語の全ての構成要素が式というわけではありません。
   "while" のように、式としては使えない *文* もあります。代入も式では
   なく文です。

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

f-string
   "'f'" や "'F'" が先頭に付いた文字列リテラルは "f-string" と呼ばれ、
   これは フォーマット済み文字列リテラル の短縮形の名称です。 **PEP
   498** も参照してください。

file object
   (ファイルオブジェクト) 下位のリソースへのファイル指向 API ("read()"
   や "write()" メソッドを持つもの) を公開しているオブジェクトです。フ
   ァイルオブジェクトは、作成された手段によって、実際のディスク上のフ
   ァイルや、その他のタイプのストレージや通信デバイス (例えば、標準入
   出力、インメモリバッファ、ソケット、パイプ、等) へのアクセスを媒介
   できます。ファイルオブジェクトは *file-like objects* や *streams*
   とも呼ばれます。

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

file-like object
   *file object* と同義です。

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

   Python 3.3 以降では 2 種類のファインダがあります。 "sys.meta_path"
   で使用される *meta path finder* と、 "sys.path_hooks" で使用される
   *path entry finder* です。

   詳細については **PEP 302**、**PEP 420** および **PEP 451** を参照し
   てください。

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

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

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

   関数アノテーションは、通常は *型ヒント* のために使われます: 例えば
   、この関数は 2 つの "int" 型の引数を取ると期待され、また "int" 型の
   返り値を持つと期待されています。

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

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

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

__future__
   A future statement, "from __future__ import <feature>", directs the
   compiler to compile the current module using syntax or semantics
   that will become standard in a future release of Python. The
   "__future__" module documents the possible values of *feature*.  By
   importing this module and evaluating its variables, you can see
   when a new feature was first added to the language and when it will
   (or did) become the default:

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

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

generator
   (ジェネレータ) *generator iterator* を返す関数です。 通常の関数に似
   ていますが、 "yield" 式を持つ点で異なります。 "yield" 式は、 for ル
   ープで使用できたり、"next()" 関数で値を 1 つずつ取り出したりできる
   、値の並びを生成するのに使用されます。

   通常はジェネレータ関数を指しますが、文脈によっては *ジェネレータイ
   テレータ* を指す場合があります。 意図された意味が明らかでない場合、
   明瞭化のために完全な単語を使用します。

generator iterator
   (ジェネレータイテレータ) *generator* 関数で生成されるオブジェクトで
   す。

   "yield" のたびに局所実行状態 (局所変数や未処理の try 文などを含む)
   を記憶して、処理は一時的に中断されます。 *ジェネレータイテレータ*
   が再開されると、中断した位置を取得します (通常の関数が実行のたびに
   新しい状態から開始するのと対照的です)。

generator expression
   (ジェネレータ式) イテレータを返す式です。 普通の式に、ループ変数を
   定義する "for" 節、範囲、そして省略可能な "if" 節がつづいているよう
   に見えます。 こうして構成された式は、外側の関数に向けて値を生成しま
   す:

      >>> sum(i*i for i in range(10))         # sum of squares 0, 1, 4, ... 81
      285

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

   *single dispatch*、"functools.singledispatch()" デコレータ、**PEP
   443** を参照してください。

generic type
   A *type* that can be parameterized; typically a container class
   such as "list" or "dict". Used for *type hints* and *annotations*.

   For more details, see generic alias types, **PEP 483**, **PEP
   484**, **PEP 585**, and the "typing" module.

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

global interpreter lock
   (グローバルインタプリタロック) *CPython* インタプリタが利用している
   、一度に Python の *バイトコード* を実行するスレッドは一つだけであ
   ることを保証する仕組みです。これにより ("dict" などの重要な組み込み
   型を含む) オブジェクトモデルが同時アクセスに対して暗黙的に安全にな
   るので、 CPython の実装がシンプルになります。インタプリタ全体をロッ
   クすることで、マルチプロセッサマシンが生じる並列化のコストと引き換
   えに、インタプリタを簡単にマルチスレッド化できるようになります。

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

   過去に "自由なマルチスレッド化" したインタプリタ (供用されるデータ
   を細かい粒度でロックする) が開発されましたが、一般的なシングルプロ
   セッサの場合のパフォーマンスが悪かったので成功しませんでした。この
   パフォーマンスの問題を克服しようとすると、実装がより複雑になり保守
   コストが増加すると考えられています。

hash-based pyc
   (ハッシュベース pyc ファイル) 正当性を判別するために、対応するソー
   スファイルの最終更新時刻ではなくハッシュ値を使用するバイトコードの
   キャッシュファイルです。

hashable
   (ハッシュ可能) *ハッシュ可能* なオブジェクトとは、生存期間中変わら
   ないハッシュ値を持ち ("__hash__()" メソッドが必要)、他のオブジェク
   トと比較ができる ("__eq__()" メソッドが必要) オブジェクトです。同値
   なハッシュ可能オブジェクトは必ず同じハッシュ値を持つ必要があります
   。

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

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

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

immutable
   (イミュータブル) 固定の値を持ったオブジェクトです。イミュータブルな
   オブジェクトには、数値、文字列、およびタプルなどがあります。これら
   のオブジェクトは値を変えられません。別の値を記憶させる際には、新た
   なオブジェクトを作成しなければなりません。イミュータブルなオブジェ
   クトは、固定のハッシュ値が必要となる状況で重要な役割を果たします。
   辞書のキーがその例です。

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

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

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

interactive
   (対話的) Python には対話的インタプリタがあり、文や式をインタプリタ
   のプロンプトに入力すると即座に実行されて結果を見ることができます。
   "python" と何も引数を与えずに実行してください。(コンピュータのメイ
   ンメニューから Pythonの対話的インタプリタを起動できるかもしれません
   。) 対話的インタプリタは、新しいアイデアを試してみたり、モジュール
   やパッケージの中を覗いてみる("help(x)" を覚えておいてください) のに
   非常に便利なツールです。

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

interpreter shutdown
   Python インタープリターはシャットダウンを要請された時に、モジュール
   やすべてのクリティカルな内部構造をなどの、すべての確保したリソース
   を段階的に開放する、特別なフェーズに入ります。 このフェーズは *ガベ
   ージコレクタ* を複数回呼び出します。 これによりユーザー定義のデスト
   ラクターや weakref コールバックが呼び出されることがあります。 シャ
   ットダウンフェーズ中に実行されるコードは、それが依存するリソースが
   すでに機能しない(よくある例はライブラリーモジュールや warning 機構
   です) ために様々な例外に直面します。

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

iterable
   (反復可能オブジェクト) 要素を一度に 1 つずつ返せるオブジェクトです
   。 反復可能オブジェクトの例には、("list", "str", "tuple" といった)
   全てのシーケンス型や、 "dict" や *ファイルオブジェクト* といった幾
   つかの非シーケンス型、 あるいは *Sequence* 意味論を実装した
   "__iter__()" メソッドか "__getitem__()" メソッドを持つ任意のクラス
   のインスタンスが含まれます。

   反復可能オブジェクトは "for" ループ内やその他多くのシーケンス (訳注
   : ここでのシーケンスとは、シーケンス型ではなくただの列という意味)が
   必要となる状況 ("zip()", "map()", ...) で利用できます。 反復可能オ
   ブジェクトを組み込み関数 "iter()" の引数として渡すと、 オブジェクト
   に対するイテレータを返します。 このイテレータは一連の値を引き渡す際
   に便利です。 通常は反復可能オブジェクトを使う際には、 "iter()" を呼
   んだりイテレータオブジェクトを自分で操作する必要はありません。
   "for" 文ではこの操作を自動的に行い、一時的な無名の変数を作成してル
   ープを回している間イテレータを保持します。 *イテレータ* 、 *シーケ
   ンス* 、 *ジェネレータ* も参照してください。

iterator
   (イテレータ) データの流れを表現するオブジェクトです。イテレータの
   "__next__()" メソッドを繰り返し呼び出す (または組み込み関数
   "next()" に渡す) と、流れの中の要素を一つずつ返します。データがなく
   なると、代わりに "StopIteration" 例外を送出します。その時点で、イテ
   レータオブジェクトは尽きており、それ以降は "__next__()" を何度呼ん
   でも "StopIteration" を送出します。イテレータは、そのイテレータオブ
   ジェクト自体を返す "__iter__()" メソッドを実装しなければならないの
   で、イテレータは他の iterable を受理するほとんどの場所で利用できま
   す。はっきりとした例外は複数の反復を行うようなコードです。 ("list"
   のような) コンテナオブジェクトは、自身を "iter()" 関数にオブジェク
   トに渡したり "for" ループ内で使うたびに、新たな未使用のイテレータを
   生成します。これをイテレータで行おうとすると、前回のイテレーション
   で使用済みの同じイテレータオブジェクトを単純に返すため、空のコンテ
   ナのようになってしまします。

   詳細な情報は イテレータ型 にあります。

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

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

   キー関数を作る方法はいくつかあります。 例えば "str.lower()" メソッ
   ドを大文字小文字を区別しないソートを行うキー関数として使うことが出
   来ます。 あるいは、"lambda r: (r[0], r[2])" のような "lambda" 式か
   らキー関数を作ることができます。 また、 "operator" モジュールは
   "attrgetter()", "itemgetter()", "methodcaller()" という 3 つのキー
   関数コンストラクタを提供しています。 キー関数の作り方と使い方の例は
   Sorting HOW TO を参照してください。

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 アプローチを使うことで解決できます。

list
   (リスト) Python の組み込みの *シーケンス* です。リストという名前で
   すが、リンクリストではなく、他の言語で言う配列 (array) と同種のもの
   で、要素へのアクセスは 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)" の全ての要素が処理されます。

loader
   モジュールをロードするオブジェクト。 "load_module()" という名前のメ
   ソッドを定義していなければなりません。ローダーは一般的に *finder*
   から返されます。詳細は **PEP 302** を、 *abstract base class* につ
   いては "importlib.abc.Loader" を参照してください。

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

mapping
   (マッピング) 任意のキー探索をサポートしていて、 "Mapping" か
   "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 が特別なのはカスタムのメタクラスを作成できる点です。ほとんど
   のユーザーに取って、メタクラスは全く必要のないものです。しかし、一
   部の場面では、メタクラスは強力でエレガントな方法を提供します。たと
   えば属性アクセスのログを取ったり、スレッドセーフ性を追加したり、オ
   ブジェクトの生成を追跡したり、シングルトンを実装するなど、多くの場
   面で利用されます。

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

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

method resolution order
   (メソッド解決順序) 探索中に基底クラスが構成要素を検索される順番です
   。 2.3 以降の Python インタープリタが使用するアルゴリズムの詳細につ
   いては The Python 2.3 Method Resolution Order を参照してください。

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

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

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

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

mutable
   (ミュータブル) ミュータブルなオブジェクトは、 "id()" を変えることな
   く値を変更できます。 *イミュータブル*) も参照してください。

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

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

      >>> sys.float_info[1]                   # indexed access
      1024
      >>> sys.float_info.max_exp              # named field access
      1024
      >>> isinstance(sys.float_info, tuple)   # kind of tuple
      True

   (上の例のように) いくつかの名前付きタプルは組み込み型になっています
   。 その他にも名前付きタプルは、通常のクラス定義で "tuple" を継承し
   、名前のフィールドを定義して作成できます。 そのようなクラスは手動で
   書いたり、 "collections.namedtuple()" ファクトリ関数で作成したりで
   きます。 後者の方法は、手動で書いた名前付きタプルや組み込みの名前付
   きタプルには無い付加的なメソッドを追加できます。

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

namespace package
   (名前空間パッケージ) サブパッケージのコンテナとしてのみ提供される
   **PEP 420** で定義された *package*  です。名前空間パッケージは物理
   的な表現を持たないことができ、 "__init__.py" ファイルを持たないため
   、 *regular package* とは異なります。

   *module* を参照してください。

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

new-style class
   (新スタイルクラス) 今では全てのクラスオブジェクトに使われている味付
   けの古い名前です。以前の Python のバージョンでは、新スタイルクラス
   のみが "__slots__" 、デスクリプタ、 "__getattribute__()" 、クラスメ
   ソッド、そして静的メソッド等の Python の新しい、多様な機能を利用で
   きました。

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

package
   (パッケージ) サブモジュールや再帰的にサブパッケージを含むことの出来
   る *module* のことです。専門的には、パッケージは "__path__" 属性を
   持つ Python オブジェクトです。

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

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** を参
   照してください。

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_hook" リストにある callable で、指定された *path entry*
   にあるモジュールを見つける方法を知っている場合に *path entry
   finder* を返します。

path based finder
   デフォルトの *meta path finder* の1つは、モジュールの *import path*
   を検索します。

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'

reference count
   (参照カウント) あるオブジェクトに対する参照の数。参照カウントが0に
   なったとき、そのオブジェクトは破棄されます。参照カウントは通常は
   Python のコード上には現れませんが、 *CPython* 実装の重要な要素です
   。 "sys" モジュールは、プログラマーが任意のオブジェクトの参照カウン
   トを知るための "getrefcount()" 関数を提供しています。

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

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

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

sequence
   (シーケンス) 整数インデクスによる効率的な要素アクセスを
   "__getitem__()" 特殊メソッドを通じてサポートし、長さを返す
   "__len__()" メソッドを定義した *iterable* です。組み込みシーケンス
   型には、 "list", "str", "tuple", "bytes" などがあります。 "dict" は
   "__getitem__()" と "__len__()" もサポートしますが、検索の際に整数で
   はなく任意の *immutable* なキーを使うため、シーケンスではなくマッピ
   ング (mapping) とみなされているので注意してください。

   The "collections.abc.Sequence" abstract base class defines a much
   richer interface that goes beyond just "__getitem__()" and
   "__len__()", adding "count()", "index()", "__contains__()", and
   "__reversed__()". Types that implement this expanded interface can
   be registered explicitly using "register()".

set comprehension
   A compact way to process all or part of the elements in an iterable
   and return a set with the results. "results = {c for c in
   'abracadabra' if c not in 'abc'}" generates the set of strings
   "{'r', 'd'}".  See リスト、集合、辞書の表示.

single dispatch
   *generic function* の一種で実装は一つの引数の型により選択されます。

slice
   (スライス) 一般に *シーケンス* の一部を含むオブジェクト。スライスは
   、添字表記 "[]" で与えられた複数の数の間にコロンを書くことで作られ
   ます。例えば、 "variable_name[1:3:5]" です。角括弧 (添字) 記号は
   "slice" オブジェクトを内部で利用しています。

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

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

text encoding
   A string in Python is a sequence of Unicode code points (in range
   "U+0000"--"U+10FFFF"). To store or transfer a string, it needs to
   be serialized as a sequence of bytes.

   Serializing a string into a sequence of bytes is known as
   "encoding", and recreating the string from the sequence of bytes is
   known as "decoding".

   There are a variety of different text serialization codecs, which
   are collectively referred to as "text encodings".

text file
   (テキストファイル) "str" オブジェクトを読み書きできる *file object*
   です。 しばしば、テキストファイルは実際にバイト指向のデータストリー
   ムにアクセスし、 *テキストエンコーディング* を自動的に行います。 テ
   キストファイルの例は、 "sys.stdin", "sys.stdout", "io.StringIO" イ
   ンスタンスなどをテキストモード ("'r'" or "'w'") で開いたファイルで
   す。

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

triple-quoted string
   (三重クォート文字列) 3つの連続したクォート記号(")かアポストロフィー
   (')で囲まれた文字列。通常の(一重)クォート文字列に比べて表現できる文
   字列に違いはありませんが、幾つかの理由で有用です。1つか2つの連続し
   たクォート記号をエスケープ無しに書くことができますし、行継続文字(\)
   を使わなくても複数行にまたがることができるので、ドキュメンテーショ
   ン文字列を書く時に特に便利です。

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 の仮想マシンは、バイトコードコンパイラが出力した *バイトコー
   ド* を実行します。

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