3. データモデル
***************


3.1. オブジェクト、値、および型
===============================

Python における *オブジェクト (object)* とは、データを抽象的に表したも
のです。Python プログラムにおけるデータは全て、オブジェクトまたはオブ
ジェクト間の関係として表されます。(ある意味では、プログラムコードもま
たオブジェクトとして表されます。これはフォン・ノイマン: Von Neumann の
"プログラム記憶方式コンピュータ: stored program computer" のモデルに適
合します。)

すべてのオブジェクトは、同一性 (identity)、型、値をもっています。 *同
一性* は生成されたあとは変更されません。これはオブジェクトのアドレスの
ようなものだと考えられるかもしれません。 '"is"' 演算子は2つのオブジェ
クトの同一性を比較します。 "id()" 関数は同一性を表す整数を返します。

**CPython 実装の詳細:** CPython では、"id(x)" は "x" が格納されている
メモリ上のアドレスを返します。

オブジェクトの型はオブジェクトがサポートする操作 (例: "len()" をサポー
トするか) と、オブジェクトが取りうる値を決定します。 "type()" 関数はオ
ブジェクトの型 (型自体もオブジェクトです) を返します。同一性と同じく、
オブジェクトの型(*type*) も変更不可能です。 [1]

オブジェクトによっては *値* を変更することが可能です。値を変更できるオ
ブジェクトのことを *mutable* と呼びます。生成後に値を変更できないオブ
ジェクトのことを *immutable* と呼びます。(mutable なオブジェクトへの参
照を格納している immutableなコンテナオブジェクトの値は、その格納してい
るオブジェクトの値が変化した時に変化しますが、コンテナがどのオブジェク
トを格納しているのかが変化しないのであれば immutable だと考えることが
できます。したがって、immutable かどうかは値が変更可能かどうかと完全に
一致するわけではありません) オブジェクトが mutable かどうかはその型に
よって決まります。例えば、数値型、文字列型とタプル型のインスタンスは
immutable で、dict や list は mutable です。

オブジェクトを明示的に破壊することはできません; しかし、オブジェクトに
到達不能 (unreachable) になると、ガベージコレクション (garbage-
collection) によって処理されるかもしれません。ガベージコレクションを遅
らせたり、全く行わない実装も許されています --- 到達可能なオブジェクト
を処理してしまわないかぎり、ガベージコレクションをどう実装するかは実装
品質の問題です。

**CPython 実装の詳細:** 現在の CPython 実装では参照カウント
(reference-counting) 方式を使っており、(オプションとして) 循環参照を行
っているガベージオブジェクトを遅延検出します。この実装ではほとんどのオ
ブジェクトを到達不能になると同時に処理することができますが、循環参照を
含むガベージオブジェクトの収集が確実に行われるよう保証しているわけでは
ありません。循環参照を持つガベージオブジェクト収集の制御については、
"gc" モジュールを参照してください。 CPython以外の実装は別の方式を使っ
ており、CPythonも将来は別の方式を使うかもしれません。オブジェクトが到
達不能になったときに即座に終了処理されることに頼らないでください (です
からファイルは必ず明示的に閉じてください)。

実装のトレース機能やデバッグ機能を使えば、通常は収集されてしまうような
オブジェクトを生存させることがあるので注意してください。また、
'"try"..."except"' 文を使って例外を捕捉できるようにすると、オブジェク
トを生存させることがあります。

オブジェクトには、開かれたファイルやウィンドウといった、 "外部の
(external) " リソースへの参照を含むものがあります。これらのリソースは
、オブジェクトがガベージコレクションされた際に解放されるものと理解され
ていますが、ガベージコレクションが行われる保証はないので、こうしたオブ
ジェクトは外部リソースを明示的に解放する方法、大抵は "close()" メソッ
ドも提供しています。こうしたオブジェクトは明示的に close するよう強く
推奨されます。この操作をする際には、'"try"..."finally"' 文や、
'"with"' 文を使うと便利です。

他のオブジェクトに対する参照をもつオブジェクトもあります; これらは *コ
ンテナ (container)* と呼ばれます。コンテナオブジェクトの例として、タプ
ル、リスト、および辞書が挙げられます。オブジェクトへの参照自体がコンテ
ナの値の一部です。ほとんどの場合、コンテナの値というと、コンテナに入っ
ているオブジェクトの値のことを指し、それらオブジェクトのアイデンティテ
ィではありません; しかしながら、コンテナの変更可能性について述べる場合
、今まさにコンテナに入っているオブジェクトのアイデンティティのことを指
します。したがって、 (タプルのように) 変更不能なオブジェクトが変更可能
なオブジェクトへの参照を含む場合、その値が変化するのは変更可能なオブジ
ェクトが変更された時、ということになります。

型はオブジェクトの動作のほとんど全てに影響します。オブジェクトのアイデ
ンティティが重要かどうかでさえ、ある意味では型に左右されます: 変更不能
な型では、新たな値を計算するような操作を行うと、実際には同じ型と値を持
った既存のオブジェクトへの参照を返すことがありますが、変更可能なオブジ
ェクトではそのような動作は起こりえません。例えば、 "a = 1; b = 1" とす
ると、 "a" と "b" は値 1 を持つ同じオブジェクトを参照するときもあるし
、そうでないときもあります。これは実装に依存します。しかし、 "c = [];
d = []" とすると、 "c" と "d" はそれぞれ二つの異なった、互いに一意な、
新たに作成された空のリストを参照することが保証されています。 ("c = d =
[]" とすると、 "c" と "d" の両方に同じオブジェクトを代入します)


3.2. 標準型の階層
=================

以下は Python に組み込まれている型のリストです。(実装によって、C、Java
、またはその他の言語で書かれた) 拡張モジュールで、その他の型が定義され
ていることがあります。新たな型 (有理数や、整数を効率的に記憶する配列、
など) の追加は、たいてい標準ライブラリを通して提供されますが、将来のバ
ージョンの Python では、型の階層構造にこのような追加がなされるかもしれ
ません。

以下に説明する型のいくつかには、 '特殊属性 (special attribute)' を列挙
した段落があります。これらの属性は実装へのアクセス手段を提供するもので
、一般的な用途に利用するためのものではありません。特殊属性の定義は将来
変更される可能性があります。

None
   この型には単一の値しかありません。この値を持つオブジェクトはただ一
   つしか存在しません。このオブジェクトは組み込み名 "None" でアクセス
   されます。このオブジェクトは、様々な状況で値が存在しないことをしめ
   します。例えば、明示的に値を返さない関数は "None" を返します。
   "None" の真値 (truth value) は偽 (false) です。

NotImplemented
   この型には単一の値しかありません。 この値を持つオブジェクトはただ一
   つしか存在しません。 このオブジェクトは、 "NotImplemented" という
   Pythonで決められている名前でアクセスされます。 数値メソッドと拡張比
   較メソッドに渡された被演算子を処理する演算子が実装されていない場合
   、この値を返すべきです。 (この次にインタープリタは被演算子を反転さ
   せて演算をするか、その演算子に依存する他のフォールバックの処理を試
   します。) この処理では真偽値コンテキストでの評価はしてはいけません
   。

   詳細は 算術演算の実装 を参照してください。

   バージョン 3.9 で変更: "NotImplemented" の評価は非推奨です。 現時点
   で真と評価されていても "DeprecationWarning" が出ます。 この警告は将
   来のバージョンの Python で "TypeError" を送出します。

Ellipsis
   この型には単一の値しかありません。この値を持つオブジェクトはただ一
   つしか存在しません。このオブジェクトはリテラル "..." またはPythonで
   決められている名前 "Ellipsis" でアクセスされます。真理値は真 (true)
   です。

"numbers.Number"
   数値リテラルによって作成されたり、算術演算や組み込みの算術関数によ
   って返されるオブジェクトです。数値オブジェクトは変更不能です; 一度
   値が生成されると、二度と変更されることはありません。Python の数値オ
   ブジェクトはいうまでもなく数学で言うところの数値と強く関係していま
   すが、コンピュータ内で数値を表現する際に伴う制限を受けています。

   "__repr__()"  と "__str__()" から計算された数値クラスの文字列表現に
   は次のような特性があります:

   * その文字列は、クラスコンストラクタに渡したときに、元の数値の値を
     持つオブジェクトを生成する有効な数値リテラルです。

   * できるなら、10を底として表現されます。

   * 小数点の前にある 1 つのゼロを除いて、上に連なるゼロは表示されませ
     ん。

   * 小数点の後にある 1 つのゼロを除いて、下に連なるゼロは表示されませ
     ん。

   * 符号は数値が負数のときのみ表示されます。

   Python は整数、浮動小数点数、複素数の間で区別を行っています:

   "numbers.Integral" (整数)
      整数型は、整数(正の数および負の数)を表す数学的集合内における要素
      を表現する型です。

      整数には 2 種類あります:

      整数 ("int")
         無制限の範囲の数を表現しますが、利用可能な (仮想) メモリサイ
         ズの制限のみを受けます。シフト演算やマスク演算のために2進数表
         現を持つと想定されます。負の数は符号ビットが左に無限に延びて
         いるような錯覚を与える 2 の補数表現の変型で表されます。

      ブール値 ("bool")
         真偽値の False と True を表します。"False" と "True" を表す 2
         つのオブジェクトのみがブール値オブジェクトです。ブール型は整
         数型の派生型であり、ほとんどの状況でそれぞれ 0 と 1 のように
         振る舞いますが、例外として文字列に変換されたときはそれぞれ
         ""False"" および ""True"" という文字列が返されます。

      整数表現に関する規則は、負の整数を含むシフト演算やマスク演算にお
      いて、最も有意義な解釈ができるように意図されています。

   "numbers.Real" ("float") (実数)
      この型は計算機レベルの倍精度浮動小数点数を表現します。表現可能な
      値の範囲やオーバーフローの扱いは計算機のアーキテクチャ（および、
      CやJavaによる実装）に従います。Pythonは単精度浮動小数点数をサポ
      ートしません。一般的に単精度浮動小数点数を使う理由はプロセッサー
      とメモリの使用を節約するためと説明されます。しかし、こうした節約
      はPythonでオブジェクトを扱う際のオーバーヘッドに比べれば微々たる
      ものです。また、2種類の浮動小数点数型を持つことで複雑になる理由
      はありません。

   "numbers.Complex" ("complex")
      この型は、計算機レベルで倍精度とされている浮動小数点を 2 つ一組
      にして複素数を表現します。浮動小数点について述べたのと同じ性質が
      当てはまります。複素数 "z" の実数部および虚数部は、それぞれ読み
      出し専用属性 "z.real" および "z.imag" で取り出すことができます。

シーケンス型 (sequence)
   この型は、有限の順序集合 (ordered set) を表現します。要素は非負の整
   数でインデクス化されています。組み込み関数 "len()" を使うと、シーケ
   ンスの要素数を返します。シーケンスの長さが *n* の場合、インデクスは
   0, 1, ..., *n* -1 からなる集合です。シーケンス *a* の要素 *i* は
   "a[i]" で選択します。

   シーケンスはスライス操作 (slice) もサポートしています: "a[i:j]" と
   すると、 *i* "<=" *k* "<" *j* であるインデクス *k* をもつ全ての要素
   を選択します。式表現としてスライスを用いた場合、スライスは同じ型を
   もつ新たなシーケンスを表します。新たなシーケンス内では、インデクス
   集合が 0 から始まるようにインデクスの値を振りなおします。

   シーケンスによっては、第三の "ステップ (step)" パラメタを持つ "拡張
   スライス (extended slice)" もサポートしています: "a[i:j:k]" は、 "x
   = i + n*k", *n* ">=" "0" かつ *i* "<=" *x* "<" *j* であるようなイン
   デクス *x* を持つような *a* 全ての要素を選択します。

   シーケンスは、変更可能なものか、そうでないかで区別されています:

   変更不能なシーケンス (immutable sequence)
      変更不能なシーケンス型のオブジェクトは、一度生成されるとその値を
      変更することができません。 (オブジェクトに他のオブジェクトへの参
      照が入っている場合、参照されているオブジェクトは変更可能なオブジ
      ェクトでもよく、その値は変更される可能性があります; しかし、変更
      不能なオブジェクトが直接参照しているオブジェクトの集合自体は、変
      更することができません。)

      以下の型は変更不能なシーケンス型です:

      文字列型 (string)
         文字列はUnicodeコードポイントを表現する値の配列です。文字列中
         のどのコードポイントも "U+0000 - U+10FFFF" の範囲で表現される
         ことができます。Pythonは "char" 型を持ちません。代わりに、文
         字列中のどのコードポイントも長さ ''1'' の文字列オブジェクトと
         して表現することができます。組み込み関数 "ord()" は文字列形式
         を "U+0000 - U+10FFFF" の範囲の整数に変換します。また、組み込
         み関数 "chr()" は "0 - 10FFFF" の範囲の整数を対応する長さ "1"
         の文字列に変換します。"str.encode()" はテキストエンコーディン
         グを使うことで "str" を "bytes" に変換するために使うことがで
         きます。また、"bytes.decode()" によりその逆が実行することがで
         きます。

      タプル型 (tuple)
         タプルの要素は任意の Python オブジェクトです。二つ以上の要素
         からなるタプルは、個々の要素を表現する式をカンマで区切って構
         成します。単一の要素からなるタプル (単集合 'singleton') を作
         るには、要素を表現する式の直後にカンマをつけます (単一の式だ
         けではタプルを形成しません。これは、式をグループ化するのに丸
         括弧を使えるようにしなければならないからです)。要素の全くない
         丸括弧の対を作ると空のタプルになります。

      bytes
         bytes オブジェクトは不変な配列です。要素は 8-bit バイトで、 0
         <= x < 256 の範囲の整数で表現されます。 ("b'abc'" のような)
         bytes リテラルや組み込みの "bytes()" コンストラクタを使って
         bytes オブジェクトを作成できます。また、 bytes オブジェクトは
         "decode()" メソッドを通して文字列にデコードできます。

   変更可能なシーケンス型 (mutable sequence)
      変更可能なシーケンスは、作成した後で変更することができます。変更
      可能なシーケンスでは、添字表記やスライス表記を使って指定された要
      素に代入を行うことができ、 "del" (delete) 文を使って要素を削除す
      ることができます。

      Python に最初から組み込まれている変更可能なシーケンス型は、今の
      ところ二つです:

      リスト型 (list)
         リストの要素は任意の Python オブジェクトにできます。リストは
         、角括弧の中にカンマで区切られた式を並べて作ります。 (長さが
         0 や 1 のシーケンスを作るために特殊な場合分けは必要ないことに
         注意してください。)

      バイト配列
         bytearray オブジェクトは変更可能な配列です。組み込みの
         "bytearray()" コンストラクタによって作成されます。変更可能な
         ことを除けば (つまりハッシュ化できない)、 byte array は変更不
         能な "bytes" オブジェクトと同じインターフェースと機能を提供し
         ます。

      拡張モジュール "array" や、 "collections" モジュールには、さらな
      るミュータブルなシーケンス型の例があります。

集合型
   集合型は、順序のない、ユニークで不変なオブジェクトの有限集合を表現
   します。そのため、(配列の)添字を使ったインデックスアクセスはできま
   せん。ただし、イテレートは可能で、組み込み関数 "len()" は集合の要素
   数を返します。集合型の一般的な使い方は、集合に属しているかの高速な
   テスト、シーケンスからの重複の排除、共通集合・和集合・差・対称差と
   いった数学的な演算の計算です。

   集合の要素には、辞書のキーと同じ普遍性に関するルールが適用されます
   。数値型は通常の数値比較のルールに従うことに注意してください。もし2
   つの数値の比較結果が同値である(例えば、 "1" と "1.0")なら、そのうち
   の1つのみを集合に含めることができます。

   現在、2つの組み込み集合型があります:

   集合型
      可変な集合型です。組み込みの "set()" コンストラクタで作成され、
      後から "add()" などのいくつかのメソッドで更新できます。

   Frozen set 型
      不変な集合型です。組み込みの "frozenset()" コンストラクタによっ
      て作成されます。 frozenset は不変で *ハッシュ可能* なので、別の
      集合型の要素になったり、辞書のキーにすることができます。

マッピング型 (mapping)
   任意のインデクス集合でインデクス化された、オブジェクトからなる有限
   の集合を表現します。添字表記 "a[k]" は、 "k" でインデクス指定された
   要素を "a" から選択します; 選択された要素は式の中で使うことができ、
   代入や "del" 文の対象にすることができます。組み込み関数 "len()" は
   、マッピング内の要素数を返します。

   Python に最初から組み込まれているマッピング型は、今のところ一つだけ
   です:

   辞書型 (dictionary)
      ほぼ任意の値でインデクスされたオブジェクトからなる有限の集合を表
      します。 キー (key) として使えない値の唯一の型は、リストや辞書、
      そしてオブジェクトの同一性でなく値で比較されるその他の変更可能な
      型です。 これは、辞書型を効率的に実装する上で、キーのハッシュ値
      が不変である必要があるためです。 数値型をキーに使う場合、キー値
      は通常の数値比較における規則に従います: 二つの値が等しくなる場合
      (例えば "1" と "1.0")、互いに同じ辞書のエントリを表すインデクス
      として使うことができます。

      辞書は挿入の順序を保持します。つまり、キーは辞書に追加された順番
      に生成されていきます。既存のキーを置き換えても、キーの順序は変わ
      りません。キーを削除したのちに再挿入すると、元の場所ではなく辞書
      の最後に追加されます。

      辞書は変更可能な型です; 辞書は "{...}" 表記で生成します (辞書表
      示 を参照してください)。

      拡張モジュール "dbm.ndbm" 、 "dbm.gnu" は、 "collections" モジュ
      ールのように、別のマッピング型の例を提供しています。

      バージョン 3.7 で変更: Pythonのバージョン3.6では、辞書は挿入順序
      を保持しませんでした。CPython 3.6では挿入順序は保持されましたが
      、それは策定された言語の仕様というより、その当時の実装の細部とみ
      なされていました。

呼び出し可能型 (callable type)
   関数呼び出し操作 (呼び出し (call) 参照) を行うことができる型です:

   ユーザ定義関数 (user-defined function)
      ユーザ定義関数オブジェクトは、関数定義を行うことで生成されます (
      関数定義 参照)。関数は、仮引数 (formal parameter) リストと同じ数
      の要素が入った引数リストとともに呼び出されます。

      特殊属性:

      +---------------------------+---------------------------------+-------------+
      | 属性                      | 意味                            |             |
      |===========================|=================================|=============|
      | "__doc__"                 | 関数のドキュメンテーション文字  | 書き込み可  |
      |                           | 列で、ドキュメンテーションがな  | 能          |
      |                           | い場 合は "None" になります。サ |             |
      |                           | ブクラスに継承されません。      |             |
      +---------------------------+---------------------------------+-------------+
      | "__name__"                | 関数の名前です。                | 書き込み可  |
      |                           |                                 | 能          |
      +---------------------------+---------------------------------+-------------+
      | "__qualname__"            | 関数の *qualified name* です。  | 書き込み可  |
      |                           | バージョン 3.3 で追加.          | 能          |
      +---------------------------+---------------------------------+-------------+
      | "__module__"              | 関数が定義されているモジュール  | 書き込み可  |
      |                           | の名前です。モジュール名がない  | 能          |
      |                           | 場合 は "None" になります。     |             |
      +---------------------------+---------------------------------+-------------+
      | "__defaults__"            | デフォルト値を持つ引数に対する  | 書き込み可  |
      |                           | デフォルト値が収められたタプル  | 能          |
      |                           | で、 デフォルト値を持つ引数がな |             |
      |                           | い場合には "None" になります    |             |
      +---------------------------+---------------------------------+-------------+
      | "__code__"                | コンパイルされた関数本体を表現  | 書き込み可  |
      |                           | するコードオブジェクトです。    | 能          |
      +---------------------------+---------------------------------+-------------+
      | "__globals__"             | 関数のグローバル変数の入った辞  | 読み出し専  |
      |                           | 書 (への参照) です --- この辞書 | 用          |
      |                           | は 、関数が定義されているモジュ |             |
      |                           | ールのグローバルな名前空間を決  |             |
      |                           | 定しま す。                     |             |
      +---------------------------+---------------------------------+-------------+
      | "__dict__"                | 任意の関数属性をサポートするた  | 書き込み可  |
      |                           | めの名前空間が収められています  | 能          |
      |                           | 。                              |             |
      +---------------------------+---------------------------------+-------------+
      | "__closure__"             | "None" または関数の個々の自由変 | 読み出し専  |
      |                           | 数 (引数以外の変数) に対して値  | 用          |
      |                           | を 束縛しているセル (cell) 群か |             |
      |                           | らなるタプルになります。        |             |
      |                           | "cell_contents" 属性についての  |             |
      |                           | 情報は下を参照してください。    |             |
      +---------------------------+---------------------------------+-------------+
      | "__annotations__"         | パラメータの注釈が入った辞書で  | 書き込み可  |
      |                           | す。辞書のキーはパラメータ名で  | 能          |
      |                           | 、返 り値の注釈がある場合は、   |             |
      |                           | "'return'" がそのキーとなります |             |
      |                           | 。この属 性を使って作業すること |             |
      |                           | の情報は Annotations Best       |             |
      |                           | Practices を参照 してください。 |             |
      +---------------------------+---------------------------------+-------------+
      | "__kwdefaults__"          | キーワード専用パラメータのデフ  | 書き込み可  |
      |                           | ォルト値を含む辞書です。        | 能          |
      +---------------------------+---------------------------------+-------------+

      「書き込み可能」とラベルされている属性のほとんどは、代入された値
      の型をチェックします。

      関数オブジェクトはまた、任意の属性を設定したり取得したりできます
      。この機能は、例えば関数にメタデータを付与したい場合などに使えま
      す。関数の get や set には、通常のドット表記を使います。 *現在の
      実装では、ユーザ定義の関数でのみ属性をサポートしているので注意し
      て下さい。組み込み関数の属性は将来サポートする予定です。*

      セルオブジェクトは属性 "cell_contents" を持っています。 これはセ
      ルの値を設定するのに加えて、セルの値を得るのにも使えます。

      関数定義に関するその他の情報は関数のコードオブジェクトから得られ
      ます。後述の内部型 (internal type) に関する説明を参照してくださ
      い。 "cell" 型には "types" モジュールからアクセスできます。

   インスタンスメソッド
      インスタンスメソッドオブジェクトは、クラス、クラスインスタンスと
      任意の呼び出し可能オブジェクト (通常はユーザ定義関数) を結びつけ
      ます。

      読み出し専用の特殊属性: "__self__" はクラスインスタンスオブジェ
      クトで、 "__func__" は関数オブジェクトです; "__doc__" はメソッド
      のドキュメンテーション文字列 ("__func__.__doc__" と同じ) です;
      "__name__" はメソッドの名前 ("__func__.__name__" と同じ) です;
      "__module__" はメソッドが定義されたモジュールの名前か、モジュー
      ル名がない場合は "None" になります。

      メソッドもまた、根底にある関数オブジェクトの任意の関数属性に (値
      の設定はできませんが) アクセスできます。

      クラスの属性を (場合によってはそのクラスのインスタンスを介して)
      取得するとき、その属性がユーザ定義の関数オブジェクトまたはクラス
      メソッドオブジェクトであれば、ユーザ定義メソッドオブジェクトが生
      成されることがあります。

      クラスからインスタンスを経由してユーザ定義関数オブジェクトを取得
      することによってインスタンスメソッドオブジェクトが生成されたとき
      、 "__self__" 属性はそのインスタンスで、このメソッドオブジェクト
      は束縛されている (bound) といいます。新しいメソッドの "__func__"
      属性はもとの関数オブジェクトです。

      クラスやインスタンスからクラスメソッドオブジェクトを取得すること
      によってインスタンスメソッドオブジェクトが生成されたとき、
      "__self__" 属性はクラスそのもので、 "__func__" 属性はクラスメソ
      ッドの根底にある関数オブジェクトです。

      インスタンスメソッドオブジェクトが呼び出される際、根底にある関数
      ("__func__") が呼び出されます。このとき、クラスインスタンス
      ("__self__") が引数リストの先頭に挿入されます。例えば、 "C" を関
      数 "f()" の定義を含むクラス、 "x" を "C" のインスタンスとすると
      、 "x.f(1)" の呼び出しは "C.f(x, 1)" の呼び出しと同じです。

      クラスメソッドオブジェクトからインスタンスメソッドオブジェクトが
      導出される際、 "__self__" に記憶されている "クラスインスタンス"
      は実際はクラスそのものなので、 "x.f(1)" や "C.f(1)" の呼び出しは
      、根底にある関数を "f" として "f(C,1)" の呼び出しと等価です。

      なお、関数オブジェクトからインスタンスメソッドオブジェクトへの変
      換は、インスタンスから属性が取り出されるたびに行われます。場合に
      よっては、属性をローカル変数に代入しておき、そのローカル変数を呼
      び出すようにするのが効果的な最適化になります。また、上記の変換は
      ユーザ定義関数に対してのみ行われます; その他の呼び出し可能オブジ
      ェクト (および呼び出し可能でない全てのオブジェクト) は、変換され
      ずに取り出されます。それから、クラスインスタンスの属性になってい
      るユーザ定義関数は、束縛メソッドに変換されません; 変換されるのは
      、関数がクラスの属性である場合 *だけ* です。

   ジェネレータ関数 (generator function)
      "yield" 文 (yield 文 の節を参照) を使う関数もしくはメソッドは *
      ジェネレータ関数* と呼ばれます。 そのような関数が呼び出されたと
      きは常に、関数の本体を実行するのに使える *イテレータ* オブジェク
      トを返します: イテレータの "iterator.__next__()" メソッドを呼び
      出すと、 "yield" 文を使って値が提供されるまで関数を実行します。
      関数の "return" 文を実行するか終端に達したときは、
      "StopIteration" 例外が送出され、イテレータが返すべき値の最後まで
      到達しています。

   コルーチン関数 (coroutine function)
      "async def" を使用して定義された関数やメソッドを *コルーチン関数
      (coroutine function)* と呼びます。 呼び出された時、そのような関
      数は *coroutine* オブジェクトを返します。 コルーチン関数は
      "async with" や "async for" 文だけでなく "await" 式を持つことが
      出来ます。 コルーチンオブジェクト を参照してください。

   非同期ジェネレータ関数 (asynchronous generator function)
      "async def" を使って定義され、 "yield" 文を使用している関数やメ
      ソッドを *asynchronous generator function* と呼びます。 そのよう
      な関数は、呼び出されたとき、*非同期イテレータ* オブジェクトを返
      します。 このオブジェクトは "async for" 文で関数の本体を実行する
      のに使えます。

      非同期イテレータの "aiterator.__anext__" メソッドを呼び出すと、
      他の処理が待たされているときに、 "yield" 式を使い値を提供すると
      ころまで処理を進める *awaitable* を返します。 その関数が空の
      "return" 文を実行する、もしくは処理の終わりに到達したときは、
      "StopAsyncIteration" 例外が送出され、非同期イテレータは出力すべ
      き値の最後に到達したことになります。

   組み込み関数 (built-in function)
      組み込み関数オブジェクトはC関数へのラッパーです。 組み込み関数の
      例は "len()" や "math.sin()" ("math" は標準の組み込みモジュール)
      です。 引数の数や型は C 関数で決定されています。 読み出し専用の
      特殊属性: "__doc__" は関数のドキュメンテーション文字列です。 ド
      キュメンテーションがない場合は "None" になります; "__name__" は
      関数の名前です; "__self__" は "None" に設定されています (組み込
      みメソッドの節も参照してください); "__module__" は、関数が定義さ
      れているモジュールの名前です。 モジュール名がない場合は "None"
      になります。

   組み込みメソッド (built-in method)
      実際には組み込み関数を別の形で隠蔽したもので、こちらの場合には C
      関数に渡される何らかのオブジェクトを非明示的な外部引数として持っ
      ています。組み込みメソッドの例は、 *alist* をリストオブジェクト
      としたときの "alist.append()" です。この場合には、読み出し専用の
      属性 "__self__" は *alist* で表されるオブジェクトになります。

   クラス
      クラスは呼び出し可能です。そのオブジェクトは通常、そのクラスの新
      たなインスタンスのファクトリとして振舞いますが、 "__new__()" を
      オーバーライドして、バリエーションを持たせることもできます。呼び
      出しに使われた引数は、 "__new__()" と、典型的な場合では
      "__init__()" に渡され、新たなインスタンスの初期化に使われます。

   クラスのインスタンス
      任意のクラスのインスタンスは、クラスで "__call__()" メソッドを定
      義することで呼び出し可能になります。

モジュール
   モジュールは Python コードの基礎的な構成単位で、 "import" 文あるい
   は "importlib.import_module()" や組み込みの "__import__()" のような
   関数を呼び出すことで起動される import system によって作成されます。
   モジュールオブジェクトは、辞書オブジェクト (これは、モジュール内で
   定義された関数の "__globals__" 属性から参照される辞書です) で実装さ
   れた名前空間を持っています。属性の参照は、この辞書の検索に翻訳され
   ます。例えば、 "m.x" は "m.__dict__["x"]" と等価です。モジュールオ
   ブジェクトは、モジュールの初期化に使われるコードオブジェクトを含ん
   でいません (初期化が終わればもう必要ないからです)。

   属性の代入を行うと、モジュールの名前空間辞書の内容を更新します。例
   えば、 "m.x = 1" は "m.__dict__["x"] = 1" と同じです。

   定義済みの (書き込み可能な) 属性:

      "__name__"
         モジュールの名前。

      "__doc__"
         モジュールのドキュメントで、文字列か、もし利用できない場合は
         "None" です。

      "__file__"
         ロードされたモジュールファイルのパス名です。インタプリタに静
         的にリンクされている C モジュールのような特定の種類のモジュー
         ルでは、 "__file__" 属性は存在しないかもしれません。共有ライ
         ブラリから動的にロードされた拡張モジュールの場合、この属性は
         共有ライブラリファイルのパス名になります。

      "__annotations__"
         モジュールの本体の実行中に収集した *変数アノテーション* を格
         納する辞書です。 "__annotations__" を利用するベストプラクティ
         スについては、 アノテーションのHOWTO を参照してください。

   読み出し専用の特殊属性: "__dict__" はモジュールの名前空間で、辞書オ
   ブジェクトです。

   **CPython 実装の詳細:** CPython がモジュール辞書を削除する方法によ
   り、モジュール辞書が生きた参照を持っていたとしてもその辞書はモジュ
   ールがスコープから外れた時に削除されます。これを避けるには、辞書を
   コピーするか、辞書を直接使っている間モジュールを保持してください。

カスタムクラス型
   カスタムクラス型は通常、クラス定義 (クラス定義 参照) で生成されます
   。クラスは辞書オブジェクトで実装された名前空間を持っています。クラ
   ス属性の参照は、この辞書に対する探索 (lookup) に翻訳されます。例え
   ば、 "C.x" は "C.__dict__["x"]" に翻訳されます (ただし、属性参照の
   意味を変えられる幾つかのフックがあります)。属性がこの探索で見つから
   ないとき、その基底クラスで探索が続けられます。基底クラスのこの探索
   は、C3 メソッド解決順序 (MRO=method resolution order) を利用してい
   て、複数の継承経路が共通の祖先につながる「ダイアモンド」継承構造が
   あっても正しく動作します。 C3 MRO についてのより詳細な情報は、 2.3
   リリースに付属するドキュメント
   https://www.python.org/download/releases/2.3/mro/ にあります。

   クラス ("C" とします) 属性参照がクラスメソッドオブジェクトを返そう
   とするときには、 そのオブジェクトは "__self__" 属性が "C" であるよ
   うなインスタンスメソッドオブジェクトに変換されます。 静的メソッドオ
   ブジェクトを返そうとするときには、静的メソッドオブジェクトでラップ
   されたオブジェクトに変換されます。 デスクリプタ (descriptor) の実装
   節を参照すると、また別の理由でクラスから取り出した属性と実際に
   "__dict__" に保存されているものが異なることがあるのが分かります。

   クラス属性を代入すると、そのクラスの辞書だけが更新され、基底クラス
   の辞書は更新しません。

   クラスオブジェクトを呼び出す (上記を参照) と、クラスインスタンスを
   生成します (下記を参照)。

   特殊属性:

      "__name__"
         クラス名。

      "__module__"
         クラスが定義されているモジュールの名前。

      "__dict__"
         クラスの名前空間を格納している辞書。

      "__bases__"
         ベースクラスリストに現れる順序でベースクラスを格納しているタ
         プル。

      "__doc__"
         クラスのドキュメントで、文字列か、もし未定義の場合は "None"
         です。

      "__annotations__"
         クラスの本体の実行中に収集した *変数アノテーション* を格納す
         る辞書です。 "__annotations__" を利用するベストプラクティスに
         ついては、 アノテーションのHOWTO を参照してください。

クラスインスタンス (class instance)
   クラスインスタンスは、クラスオブジェクト (上記参照) を呼び出して生
   成します。 クラスインスタンスは辞書で実装された名前空間を持っており
   、属性参照の時にはまずこの辞書が探索されます。 ここで属性が見つから
   ず、インスタンスのクラスにその名前の属性があるときは、続けてクラス
   属性を検索します。 見つかったクラス属性がユーザ定義関数オブジェクト
   だった場合、クラスインスタンスを "__self__" 属性とするインスタンス
   メソッドオブジェクトに変換します。 静的メソッドオブジェクトやクラス
   メソッドオブジェクトも同様に変換されます; 上記の "クラス" を参照し
   てください。 デスクリプタ (descriptor) の実装 節を参照すると、また
   別の理由でインスタンスを通してクラスから取り出した属性と実際に
   "__dict__" に保存されているものが異なることがあるのが分かります。
   クラス属性が見つからず、かつオブジェクトのクラスが "__getattr__()"
   メソッドを持っている場合は、探索の義務を果たすためにこのメソッドが
   呼び出されます。

   属性の代入や削除を行うと、インスタンスの辞書を更新しますが、クラス
   の辞書を更新することはありません。クラスで "__setattr__()" や
   "__delattr__()" メソッドが定義されている場合、直接インスタンスの辞
   書を更新する代わりにこれらのメソッドが呼び出されます。

   クラスインスタンスは、ある特定の名前のメソッドを持っている場合、数
   値型やシーケンス型、あるいはマップ型のように振舞うことができます。
   特殊メソッド名 を参照してください。

   特殊属性: "__dict__" は属性の辞書です; "__class__" はインスタンスの
   クラスです。

I/O オブジェクト (ファイルオブジェクトの別名)
   *file object* は開かれたファイルを表します。ファイルオブジェクトを
   作るための様々なショートカットがあります: "open()" 組み込み関数、
   "os.popen()" 、 "os.fdopen()" 、ソケットオブジェクトの "makefile()"
   メソッド (あるいは拡張モジュールから提供される他の関数やメソッド)
   。

   オブジェクト "sys.stdin" 、 "sys.stdout" および "sys.stderr" は、イ
   ンタプリタの標準入力、標準出力、および標準エラー出力ストリームに対
   応するファイルオブジェクトに初期化されます。これらはすべてテキスト
   モードで開かれ、 "io.TextIOBase" 抽象クラスによって定義されたインタ
   ーフェースに従います。

内部型 (internal type)
   インタプリタが内部的に使っているいくつかの型は、ユーザに公開されて
   います。これらの定義は将来のインタプリタのバージョンでは変更される
   可能性がありますが、ここでは記述の完全性のために触れておきます。

   コードオブジェクト
      コードオブジェクトは *バイトコンパイルされた (byte-compiled)* 実
      行可能な Python コード、別名 *バイトコード* を表現します。コード
      オブジェクトと関数オブジェクトの違いは、関数オブジェクトが関数の
      グローバル変数 (関数を定義しているモジュールのグローバル) に対し
      て明示的な参照を持っているのに対し、コードオブジェクトにはコンテ
      キストがないということです; また、関数オブジェクトではデフォルト
      引数値を記憶できますが、コードオブジェクトではできません (実行時
      に計算される値を表現するため)。関数オブジェクトと違い、コードオ
      ブジェクトは変更不可能で、変更可能なオブジェクトへの参照を (直接
      、間接に関わらず) 含みません。

      読み出し専用の特殊属性: "co_name" は関数名、 "co_argcount" は位
      置引数 (位置専用引数とデフォルト値を持つ引数を含む) の総数、
      "co_posonlyargcount" は位置専用引数 (デフォルト値を持つ引数を含
      む) の数、 "co_nlocals" は関数が使う (引数を含めた) ローカル変数
      の数、 "co_varnames" はローカル変数名を格納したタプル (引数名か
      ら始まる)、 "co_cellvars" はネストされた関数で参照されているロー
      カル変数の名前を格納したタプル、 "co_freevars" は自由変数の名前
      を格納したタプル、 "co_code" はバイトコード列を表現している文字
      列、 "co_consts" はバイトコードで使われているリテラルを格納した
      タプル、 "co_names" はバイトコードで使われている名前の入ったタプ
      ル、 "co_filename" はバイトコードのコンパイルが行われたファイル
      名、 "co_firstlineno" は関数の最初の行番号、 "co_lnotab" はバイ
      トコードオフセットから行番号への対応付けをコード化した文字列 (詳
      細についてはインタープリタのソースコードを参照してください)、
      "co_stacksize" は関数で必要なスタックサイズ、 "co_flags" はイン
      タプリタ用の様々なフラグをコード化した整数。

      以下のフラグビットが "co_flags" で定義されています: "0x04" ビッ
      トは、関数が "*arguments" 構文を使って任意の数の位置引数を受理で
      きる場合に立てられます; "0x08" ビットは、関数が "**keywords" 構
      文を使ってキーワード引数を受理できる場合に立てられます; "0x20"
      ビットは、関数がジェネレータである場合に立てられます。

      将来機能 (future feature) 宣言 ("from __future__ import
      division") もまた、 "co_flags" のビットを立てることで、コードオ
      ブジェクトが特定の機能を有効にしてコンパイルされていることを示し
      ます: "0x2000" ビットは、関数が将来機能を有効にしてコンパイルさ
      れている場合に立てられます; 以前のバージョンの Python では、
      "0x10" および "0x1000" ビットが使われていました。

      "co_flags" のその他のビットは将来に内部的に利用するために予約さ
      れています。

      コードオブジェクトが関数を表現している場合、 "co_consts" の最初
      の要素は関数のドキュメンテーション文字列になります。ドキュメンテ
      ーション文字列が定義されていない場合には "None" になります。

   フレーム (frame) オブジェクト
      フレームオブジェクトは実行フレーム (execution frame) を表します
      。 実行フレームはトレースバックオブジェクト (下記参照) 内に出現
      し、登録されたトレース関数に渡されます。

      読み出し専用の特殊属性: "f_back" は直前のスタックフレーム (呼び
      出し側の方向) で、それがスタックフレームの最下段なら "None" です
      ; "f_code" はそのフレームで実行されているコードオブジェクトです;
      "f_locals" はローカル変数の探索に使われる辞書です; "f_globals"
      はグローバル変数に使われます; "f_builtins" は組み込みの (Python
      固有の) 名前に使われます; "f_lasti" は厳密な命令コード (コードオ
      ブジェクトのバイトコード文字列へのインデックス) です。

      "f_code" へのアクセスは "object.__getattr__" に "obj" と
      ""f_code"" を渡して行いますが、 監査イベント を送出します。

      特別な書き込み可能な属性: "f_trace" は "None" でない場合は、コー
      ドの実行中に様々なイベントで呼び出される関数です (デバッガが利用
      します)。 通常は、ソースの新しい行ごとにイベントが発行されますが
      、 "f_trace_lines" を "False" に設定することでイベントの発行を無
      効化できます。

      実装は "f_trace_opcodes" を "True" に設定して、命令コードごとの
      イベントの要求を許可している *かもしれません* 。 これは、トレー
      ス関数によって送出された例外がトレースされている関数に漏れ出た場
      合、未定義なインタープリタの振る舞いにつながるかもしれないことに
      注意してください。

      "f_lineno" はフレーム中における現在の行番号です --- トレース関数
      (trace function) 側でこの値に書き込みを行うと、指定した行にジャ
      ンプします (最下段の実行フレームにいるときのみ)。デバッガでは、
      f_fileno を書き込むことで、ジャンプ命令 (Set Next Statement 命令
      とも) を実装できます。

      フレームオブジェクトはメソッドを一つサポートします:

      frame.clear()

         このメソッドはフレームが保持しているローカル変数への参照を全
         て削除します。 また、フレームがジェネレータに属していた場合は
         、ジェネレータにも終了処理が行われます。 これによってフレーム
         オブジェクトを含んだ循環参照が解消されるようになります (例え
         ば、例外を捕捉し、後で使うためにトレースバックを保存する場合)
         。

         フレームが現在実行中の場合 "RuntimeError" が送出されます。

         バージョン 3.4 で追加.

   トレースバック (traceback) オブジェクト
      トレースバックオブジェクトは例外のスタックトレースを表現します。
      トレースバックオブジェクトは例外が起きたときに暗黙的に作成された
      り、 "types.TracebackType" を呼び出して明示的にも作成されたりし
      ます。

      暗黙的に作成されたトレースバックでは、例外ハンドラの検索が実行ス
      タックを戻っていく際、戻ったレベル毎に、トレースバックオブジェク
      トが現在のトレースバックの前に挿入されます。 例外ハンドラに入る
      と、スタックトレースをプログラム側で利用できるようになります。
      (try 文 を参照。) トレースバックは、 "sys.exc_info()" が返すタプ
      ルの三番目の要素や、捕捉した例外の "__traceback__" 属性として得
      られます。

      プログラムに適切なハンドラがないとき、スタックトレースは (うまく
      書式化されて) 標準エラーストリームに書き出されます; インタプリタ
      が対話的に実行されている場合、 "sys.last_traceback" として得るこ
      ともできます。

      明示的に作成されたトレースバックでは、 "tb_next" 属性がリンクさ
      れスタックトレース全体を形成する方法の決定は、トレースバックの作
      成者に任されます。

      読み出し専用の特殊属性: "tb_frame" は現在のレベルにおける実行フ
      レームを指します; "tb_lineno" は例外の発生した行番号です;
      "tb_lasti" は厳密な命令コードです。トレースバック内の行番号や最
      後に実行された命令は、 "try" 文内で例外が発生し、かつ対応する
      "except" 節や "finally" 節がない場合には、フレームオブジェクト内
      の行番号とは異なるかもしれません。

      "tb_frame" へのアクセスは "object.__getattr__" に "obj" と
      ""tb_frame"" を渡して行いますが、 監査イベント を送出します。

      書き込み可能な特殊属性: "tb_next" はスタックトレースの次のレベル
      (例外が発生したフレームの方向) か、あるいは次のレベルが無い場合
      は "None" です。

      バージョン 3.7 で変更: トレースバックオブジェクトは Python コー
      ドから明示的にインスタンス化できるようになり、既存のインスタンス
      の "tb_next" 属性は更新できるようになりました。

   スライス (slice) オブジェクト
      スライスオブジェクトは、 "__getitem__()" メソッドのためのスライ
      スを表すのに使われます。スライスオブジェクトは組み込みの
      "slice()" 関数でも生成されます。

      読み出し専用の特殊属性: "start" は下限です; "stop" は上限です;
      "step" はステップの値です; それぞれ省略された場合は "None" とな
      っています。これらの属性は任意の型を持てます。

      スライスオブジェクトはメソッドを一つサポートします:

      slice.indices(self, length)

         このメソッドは単一の整数引数 *length* を取り、スライスオブジ
         ェクトが *length* 要素のシーケンスに適用されたときに表現する
         、スライスに関する情報を計算します。このメソッドは 3 つの整数
         からなるタプルを返します; それぞれ *start* および *stop* のイ
         ンデックスと、*step* すなわちスライスのまたぎ幅です。インデッ
         クス値がないか、範囲外の値であれば、通常のスライスと変わらな
         いやりかたで扱われます。

   静的メソッド (static method) オブジェクト
      静的メソッドは、上で説明したような関数オブジェクトからメソッドオ
      ブジェクトへの変換を阻止するための方法を提供します。静的メソッド
      オブジェクトは他の何らかのオブジェクト、通常はユーザ定義メソッド
      オブジェクトを包むラッパです。静的メソッドをクラスやクラスインス
      タンスから取得すると、実際に返されるオブジェクトはラップされたオ
      ブジェクトになり、それ以上は変換の対象にはなりません。静的メソッ
      ドオブジェクトは通常呼び出し可能なオブジェクトをラップしますが、
      静的オブジェクト自体は呼び出し可能です。静的オブジェクトは組み込
      みコンストラクタ "staticmethod()" で生成されます。

   クラスメソッドオブジェクト
      クラスメソッドオブジェクトは、静的メソッドオブジェクトに似て、別
      のオブジェクトを包むラッパーであり、そのオブジェクトをクラスやク
      ラスインスタンスから取り出す方法を代替します。このようにして取得
      したクラスメソッドオブジェクトの動作については、上の "ユーザ定義
      メソッド (user-defined method)" で説明されています。クラスメソッ
      ドオブジェクトは組み込みのコンストラクタ "classmethod()" で生成
      されます。


3.3. 特殊メソッド名
===================

クラスは、特殊な名前のメソッドを定義して、特殊な構文 (算術演算や添え字
表記、スライス表記など) による特定の演算を実装できます。これは、Python
の演算子オーバロード (*operator overloading*) へのアプローチです。これ
により、クラスは言語の演算子に対する独自の振る舞いを定義できます。例え
ば、あるクラスが "__getitem__()" という名前のメソッドを定義しており、
"x" がこのクラスのインスタンスであるとすると、 "x[i]" は
"type(x).__getitem__(x, i)" とほぼ等価です。特に注釈のない限り、適切な
メソッドが定義されていないとき、このような演算を試みると例外 (たいてい
は "AttributeError" か "TypeError") が送出されます。

特殊メソッドに "None" を設定することは、それに対応する演算が利用できな
いことを意味します。 例えば、クラスの "__iter__()" を "None" に設定し
た場合、そのクラスはイテラブルにはならず、そのインスタンスに対し
"iter()" を呼び出すと ("__getitem__()" に処理が戻されずに) "TypeError"
を送出します。 [2]

組み込み型をエミュレートするクラスを実装するときは、模範とされるオブジ
ェクトにとって意味がある範囲に実装をとどめるのが重要です。例えば、ある
シーケンスは個々の要素の取得はきちんと動くかもしれませんが、スライスの
展開が意味をなさないかもしれません。 (W3C のドキュメントオブジェクトモ
デルにある "NodeList" インターフェースがその一例です。)


3.3.1. 基本的なカスタマイズ
---------------------------

object.__new__(cls[, ...])

   クラス *cls* の新しいインスタンスを作るために呼び出されます。
   "__new__()" は静的メソッドで (このメソッドは特別扱いされているので
   、明示的に静的メソッドと宣言する必要はありません)、インスタンスを生
   成するよう要求されているクラスを第一引数にとります。残りの引数はオ
   ブジェクトのコンストラクタの式 (クラスの呼び出し文) に渡されます。
   "__new__()" の戻り値は新しいオブジェクトのインスタンス (通常は
   *cls* のインスタンス) でなければなりません。

   典型的な実装では、クラスの新たなインスタンスを生成するときには
   "super().__new__(cls[, ...])" に適切な引数を指定してスーパクラスの
   "__new__()" メソッドを呼び出し、新たに生成されたインスタンスに必要
   な変更を加えてから返します。

   もし "__new__()" が オブジェクトの作成中に呼び出され、*cls* のイン
   スタンスを返した場合には、 "__init__(self[, ...])" のようにして新し
   いインスタンスの "__init__()" が呼び出されます。このとき、 *self*
   は新たに生成されたインスタンスで、残りの引数はオブジェクトコンスト
   ラクタに渡された引数と同じになります。

   "__new__()" が *cls* のインスタンスを返さない場合、インスタンスの
   "__init__()" メソッドは呼び出されません。

   "__new__()" の主な目的は、変更不能な型 (int, str, tuple など) のサ
   ブクラスでインスタンス生成をカスタマイズすることにあります。また、
   クラス生成をカスタマイズするために、カスタムのメタクラスでよくオー
   バーライドされます。

object.__init__(self[, ...])

   インスタンスが ("__new__()" によって) 生成された後、それが呼び出し
   元に返される前に呼び出されます。引数はクラスのコンストラクタ式に渡
   したものです。基底クラスとその派生クラスがともに "__init__()" メソ
   ッドを持つ場合、派生クラスの "__init__()" メソッドは基底クラスの
   "__init__()" メソッドを明示的に呼び出して、インスタンスの基底クラス
   部分が適切に初期化されること保証しなければなりません。例えば、
   "super().__init__([args...])" 。

   "__new__()" と "__init__()" は連携してオブジェクトを構成する
   ("__new__()" が作成し、 "__init__()" がそれをカスタマイズする) ので
   、 "__init__()" から非 "None" 値を返してはいけません; そうしてしま
   うと、実行時に "TypeError" が送出されてしまいます。

object.__del__(self)

   インスタンスが破棄されるときに呼び出されます。 これはファイナライザ
   や (適切ではありませんが) デストラクタとも呼ばれます。 基底クラスが
   "__del__()" メソッドを持っている場合は、派生クラスの "__del__()" メ
   ソッドは何であれ、基底クラスの "__del__()"  メソッドを明示的に呼び
   出して、インスタンスの基底クラス部分をきちんと確実に削除しなければ
   なりません。

   "__del__()" メソッドが破棄しようとしているインスタンスへの新しい参
   照を作り、破棄を送らせることは (推奨されないものの) 可能です。 これ
   はオブジェクトの *復活* と呼ばれます。 復活したオブジェクトが再度破
   棄される直前に "__del__()" が呼び出されるかどうかは実装依存です; 現
   在の *CPython* の実装では最初の一回しか呼び出されません。

   インタプリタが終了したときに、残存しているオブジェクトの
   "__del__()" メソッドが呼び出される保証はありません。

   注釈:

     "del x" は直接 "x.__del__()" を呼び出しません --- 前者は "x" の参
     照カウントを 1 つ減らし、後者は "x" の参照カウントが 0 まで落ちた
     ときのみ呼び出されます。

   **CPython 実装の詳細:** It is possible for a reference cycle to
   prevent the reference count of an object from going to zero.  In
   this case, the cycle will be later detected and deleted by the
   *cyclic garbage collector*.  A common cause of reference cycles is
   when an exception has been caught in a local variable.  The frame's
   locals then reference the exception, which references its own
   traceback, which references the locals of all frames caught in the
   traceback.

   参考: "gc" モジュールのドキュメント。

   警告:

     メソッド "__del__()" は不安定な状況で呼び出されるため、実行中に発
     生した例外は無視され、代わりに "sys.stderr" に警告が表示されます
     。特に:

     * "__del__()" は、任意のコードが実行されているときに、任意のスレ
       ッドから呼び出せます。 "__del__()" で、ロックを取ったり、ブロッ
       クするリソースを呼び出したりする必要がある場合、 "__del__()" の
       実行により中断されたコードにより、そのリソースが既に取得されて
       いて、デッドロックが起きるかもしれません。

     * "__del__()" は、インタプリタのシャットダウン中に実行できます。
       従って、(他のモジュールも含めた) アクセスする必要があるグローバ
       ル変数はすでに削除されているか、 "None" に設定されているかもし
       れません。 Python は、単一のアンダースコアで始まる名前のグロー
       バルオブジェクトは、他のグローバル変数が削除される前にモジュー
       ルから削除されることを保証します; そのようなグローバル変数への
       他からの参照が存在しない場合、"__del__()" メソッドが呼ばれた時
       点で、インポートされたモジュールがまだ利用可能であることを保証
       するのに役立つかもしれません。

object.__repr__(self)

   "repr()" 組み込み関数によって呼び出され、オブジェクトを表す「公式の
   (official)」文字列を計算します。可能なら、これは (適切な環境が与え
   られれば) 同じ値のオブジェクトを再生成するのに使える、有効な Python
   式のようなものであるべきです。できないなら、 "<...some useful
   description...>" 形式の文字列が返されるべきです。戻り値は文字列オブ
   ジェクトでなければなりません。クラスが "__repr__()" を定義していて
   "__str__()" は定義していなければ、そのクラスのインスタンスの「非公
   式の (informal)」文字列表現が要求されたときにも "__repr__()" が使わ
   れます。

   この関数はデバッグの際によく用いられるので、たくさんの情報を含み、
   あいまいでないような表記にすることが重要です。

object.__str__(self)

   オブジェクトの「非公式の (informal)」あるいは表示に適した文字列表現
   を計算するために、 "str(object)" と組み込み関数 "format()",
   "print()" によって呼ばれます。戻り値は string オブジェクトでなけれ
   ばなりません。

   "__str__()" が有効な Python 表現を返すことが期待されないという点で
   、このメソッドは "object.__repr__()" とは異なります: より便利な、ま
   たは簡潔な表現を使用することができます。

   組み込み型 "object" によって定義されたデフォルト実装は、
   "object.__repr__()" を呼び出します。

object.__bytes__(self)

   bytes によって呼び出され、オブジェクトのバイト文字列表現を計算しま
   す。これは "bytes" オブジェクトを返すべきです。

object.__format__(self, format_spec)

   "format()" 組み込み関数、さらには フォーマット済み文字列リテラル の
   評価、 "str.format()" メソッドによって呼び出され、オブジェクトの "
   フォーマット化された (formatted)" 文字列表現を作ります。
   *format_spec* 引数は、 必要なフォーマット化オプションの記述を含む文
   字列です。 *format_spec* 引数の解釈は、 "__format__()" を実装する型
   によりますが、 ほとんどのクラスは組み込み型のいずれかにフォーマット
   化を委譲したり、 同じようなフォーマット化オプション構文を使います。

   標準のフォーマット構文の解説は、 書式指定ミニ言語仕様 を参照してく
   ださい。

   戻り値は文字列オブジェクトでなければなりません。

   バージョン 3.4 で変更: 空でない文字列が渡された場合 "object" 自身の
   __format__ メソッドは "TypeError" を送出します。

   バージョン 3.7 で変更: "object.__format__(x, '')" は
   "format(str(x), '')" ではなく "str(x)" と等価になりました。

object.__lt__(self, other)
object.__le__(self, other)
object.__eq__(self, other)
object.__ne__(self, other)
object.__gt__(self, other)
object.__ge__(self, other)

   これらはいわゆる "拡張比較 (rich comparison)" メソッドです。演算子
   シンボルとメソッド名の対応は以下の通りです: "x<y" は "x.__lt__(y)"
   を呼び出します; "x<=y" は "x.__le__(y)" を呼び出します; "x==y" は
   "x.__eq__(y)" を呼び出します; "x!=y" は "x.__ne__(y)" を呼び出しま
   す; "x>y" は "x.__gt__(y)" を呼び出します; "x>=y" は "x.__ge__(y)"
   を呼び出します。

   拡張比較メソッドは与えられた引数のペアに対する演算を実装していない
   ときに、 シングルトン "NotImplemented" を返すかもしれません。 慣例
   として、正常に比較が行われたときには "False" か "True" を返します。
   しかし、これらのメソッドは任意の値を返すことができるので、比較演算
   子がブール値のコンテキスト (たとえば "if" 文の条件部分) で使われた
   場合、 Python はその値に対して "bool()" を呼び出して結果の真偽を判
   断します。

   "is" から利用される "object" の "__eq__()" メソッドのデフォルト実装
   では、比較して偽となる場合に、次のコードのように "NotImplemented"
   を返します:  "True if x is y else NotImplemented" 。 "__ne__()" メ
   ソッドは "__eq__()" に処理を委譲し、 "NotImplemented" でない場合に
   結果を反転させます。他の比較演算子やデフォルトの実装には暗黙の関係
   はありません。例えば "(x<y or x==y)" は "x<=y" とはなりません。一つ
   の元となる演算から比較演算子を自動生成するには
   "functools.total_ordering()" を参照してください。

   カスタムの比較演算をサポートしていて、辞書のキーに使うことができる
   *ハッシュ可能* オブジェクトを作るときの重要な注意点について、
   "__hash__()" のドキュメント内に書かれているので参照してください。

   これらのメソッドには (左引数が演算をサポートしないが、右引数はサポ
   ートする場合に用いられるような) 引数を入れ替えたバージョンは存在し
   ません。 むしろ、 "__lt__()" と "__gt__()" は互いの反射、
   "__le__()" と "__ge__()" は互いの反射、および "__eq__()" と
   "__ne__()" はそれら自身の反射です。 被演算子が異なる型で右の被演算
   子の型が左の被演算子の直接的または間接的サブクラスの場合、右被演算
   子の反射されたメソッドが優先されます。 そうでない場合左の被演算子の
   メソッドが優先されます。 仮想サブクラス化は考慮されません。

object.__hash__(self)

   組み込みの "hash()" 関数や、 "set", "frozenset", "dict" のようなハ
   ッシュを使ったコレクション型の要素に対する操作から呼び出されます。
   "__hash__()" メソッドは整数を返さなければなりません。 このメソッド
   に必要な性質は、比較結果が等しいオブジェクトは同じハッシュ値を持つ
   ということです; オブジェクトを比較するときでも利用される要素をタプ
   ルに詰めてハッシュ値を計算することで、それぞれの要素のハッシュ値を
   混合することをおすすめします。

      def __hash__(self):
          return hash((self.name, self.nick, self.color))

   注釈:

     "hash()" はオブジェクト独自の "__hash__()"  メソッドが返す値を
     "Py_ssize_t" のサイズに切り詰めます。 これは 64-bit でビルドされ
     ていると 8 バイトで、 32-bit でビルドされていると 4 バイトです。
     オブジェクトの "__hash__()" が異なる bit サイズのビルドでも可搬性
     が必要である場合は、必ず全てのサポートするビルドの bit 幅をチェッ
     クしてください。 そうする簡単な方法は "python -c "import sys;
     print(sys.hash_info.width)"" を実行することです。

   If a class does not define an "__eq__()" method it should not
   define a "__hash__()" operation either; if it defines "__eq__()"
   but not "__hash__()", its instances will not be usable as items in
   hashable collections.  If a class defines mutable objects and
   implements an "__eq__()" method, it should not implement
   "__hash__()", since the implementation of *hashable* collections
   requires that a key's hash value is immutable (if the object's hash
   value changes, it will be in the wrong hash bucket).

   ユーザー定義クラスはデフォルトで "__eq__()" と "__hash__()" メソッ
   ドを持っています。 このとき、(同一でない) すべてのオブジェクトは比
   較して異なり、 "x.__hash__()" は "x == y" が "x is y" と "hash(x)
   == hash(y)" の両方を意味するような適切な値を返します。

   "__eq__()" をオーバーライドしていて "__hash__()" を定義していないク
   ラスでは、 "__hash__()" は暗黙的に "None" に設定されます。 クラスの
   "__hash__()" メソッドが "None" の場合、そのクラスのインスタンスのハ
   ッシュ値を取得しようとすると適切な "TypeError" が送出され、
   "isinstance(obj, collections.abc.Hashable)" でチェックするとハッシ
   ュ不能なものとして正しく認識されます。

   "__eq__()" をオーバーライドしたクラスが親クラスからの "__hash__()"
   の 実装を保持したいなら、明示的に "__hash__ =
   <ParentClass>.__hash__" を設定することで、それをインタプリタに伝え
   なければなりません。

   "__eq__()" をオーバーライドしていないクラスがハッシュサポートを抑制
   したい場合、クラス定義に "__hash__ = None" を含めてください。クラス
   自身で明示的に "TypeError" を送出する "__hash__()" を定義すると、
   "isinstance(obj, collections.abc.Hashable)" 呼び出しで誤ってハッシ
   ュ可能と識別されるでしょう。

   注釈:

     デフォルトでは、文字列とバイト列の "__hash__()" 値は予測不可能な
     ランダム値で "ソルト" されます。 ハッシュ値は単独の Python プロセ
     ス内では定数であり続けますが、Python を繰り返し起動する毎に、予測
     できなくなります。この目的は、慎重に選ばれた入力で辞書挿入の最悪
     性能 O(n^2) 計算量を悪用することで引き起こされるサービス妨害
     (denial-of-service, DoS) に対する保護です。 詳細は
     http://www.ocert.org/advisories/ocert-2011-003.html を参照してく
     ださい。ハッシュ値の変更は、集合のイテレーション順序に影響します
     。Python はこの順序付けを保証していません (そして通常 32-bit と
     64-bit の間でも異なります)。"PYTHONHASHSEED" も参照してください。

   バージョン 3.3 で変更: ハッシュのランダム化がデフォルトで有効になり
   ました。

object.__bool__(self)

   真理値テストや組み込み演算 "bool()" を実装するために呼び出されます;
   "False" または "True" を返さなければなりません。このメソッドが定義
   されていないとき、 "__len__()" が定義されていれば呼び出され、その結
   果が非 0 であれば真とみなされます。クラスが "__len__()" も
   "__bool__()" も定義していないければ、そのクラスのインスタンスはすべ
   て真とみなされます。


3.3.2. 属性値アクセスをカスタマイズする
---------------------------------------

以下のメソッドを定義して、クラスインスタンスへの属性アクセス (
"x.name" の使用、 "x.name" への代入、 "x.name" の削除) の意味をカスタ
マイズすることができます。

object.__getattr__(self, name)

   デフォルトの属性アクセスが "AttributeError" で失敗したとき (*name*
   がインスタンスの属性または "self" のクラスツリーの属性でないために
   "__getattribute__()" が "AttributeError" を送出したか、 *name* プロ
   パティの "__get__()" が "AttributeError" を送出したとき) に呼び出さ
   れます。 このメソッドは (計算された) 属性値を返すか、
   "AttributeError" 例外を送出しなければなりません。

   なお、通常の過程で属性が見つかれば、 "__getattr__()" は呼び出されま
   せん。(これは、 "__getattr__()"  と "__setattr__()" が意図的に非対
   称にされている点です。) これは、効率のためと、こうしないと
   "__getattr__()" がインスタンスの他の属性値にアクセスする方法がなく
   なるためです。また、少なくともインスタンス変数に対しては、値をイン
   スタンスの属性値辞書に挿入しないことで (代わりに他のオブジェクトに
   挿入することで)、属性値を完全に制御しているふりができます。実際に属
   性アクセスを完全に制御する方法は、以下の "__getattribute__()" メソ
   ッドを参照してください。

object.__getattribute__(self, name)

   クラスのインスタンスに対する属性アクセスを実装するために、無条件に
   呼び出されます。クラスが "__getattr__()" も定義している場合、
   "__getattr__()" は、 "__getattribute__()" で明示的に呼び出すか、
   "AttributeError" 例外を送出しない限り呼ばれません。このメソッドは (
   計算された) 属性値を返すか、 "AttributeError" 例外を送出します。こ
   のメソッドが再帰的に際限なく呼び出されてしまうのを防ぐため、実装の
   際には常に、必要な属性全てへのアクセスで、例えば
   "object.__getattribute__(self, name)" のように基底クラスのメソッド
   を同じ属性名を使って呼び出さなければなりません。

   注釈:

     言語構文や組み込み関数から暗黙に呼び出された特殊メソッドの検索で
     は、このメソッドも回避されることがあります。 特殊メソッド検索 を
     参照してください。

   "object.__getattr__" に "obj" と "name" を渡して実行すると、 監査イ
   ベント を送出します。

object.__setattr__(self, name, value)

   属性の代入が試みられた際に呼び出されます。これは通常の代入の過程 (
   すなわち、インスタンス辞書への値の代入) の代わりに呼び出されます。
   *name* は属性名で、*value* はその属性に代入する値です。

   "__setattr__()" の中でインスタンス属性への代入が必要なら、基底クラ
   スのこれと同じ名前のメソッドを呼び出さなければなりません。例えば、
   "object.__setattr__(self, name, value)" とします。

   "object.__setattr__" に "obj" と "name" と "value" を渡して実行する
   と、 監査イベント を送出します。

object.__delattr__(self, name)

   "__setattr__()" に似ていますが、代入ではなく値の削除を行います。こ
   のメソッドを実装するのは、オブジェクトにとって "del obj.name" が意
   味がある場合だけにしなければなりません。

   "object.__delattr__" に "obj" と "name" を渡して実行すると、 監査イ
   ベント を送出します。

object.__dir__(self)

   オブジェクトに "dir()" が呼び出されたときに呼び出されます。シーケン
   スが返されなければなりません。 "dir()" は返されたシーケンスをリスト
   に変換し、ソートします。


3.3.2.1. モジュールの属性値アクセスをカスタマイズする
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

特殊な名前の "__getattr__" と "__dir__" も、モジュール属性へのアクセス
をカスタマイズするのに使えます。 モジュールレベルの "__getattr__" 関数
は属性名である 1 引数を受け取り、計算した値を返すか "AttributeError"
を送出します。 属性がモジュールオブジェクトから、通常の検索、つまり
"object.__getattribute__()" で見付からなかった場合は、
"AttributeError" を送出する前に、モジュールの "__dict__" から
"__getattr__" が検索されます。 見付かった場合は、その属性名で呼び出さ
れ、結果が返されます。

"__dir__" 関数は引数を受け取らず、モジュールのアクセス可能な名前を表す
文字列のシーケンスを返さなければなりません。存在する場合は、この関数は
モジュールの標準の "dir()" 検索を上書きします。

より細かい粒度でのモジュールの動作 (属性やプロパティの設定など) のカス
タマイズのために、モジュールオブジェクトの "__class__" 属性に
"types.ModuleType" のサブクラスが設定できます。 例えば次のようになりま
す:

   import sys
   from types import ModuleType

   class VerboseModule(ModuleType):
       def __repr__(self):
           return f'Verbose {self.__name__}'

       def __setattr__(self, attr, value):
           print(f'Setting {attr}...')
           super().__setattr__(attr, value)

   sys.modules[__name__].__class__ = VerboseModule

注釈:

  モジュールの "__getattr__" を定義したり "__class__" を設定したりして
  も、影響があるのは属性アクセスの構文が使われる検索だけです -- モジュ
  ールの globals への直接アクセスは (モジュール内のコードからとモジュ
  ールの globals のどちらでも) 影響を受けません。

バージョン 3.5 で変更: モジュールの属性 "__class__" が書き込み可能にな
りました。

バージョン 3.7 で追加: "__getattr__" モジュール属性と "__dir__" モジュ
ール属性。

参考:

  **PEP 562** - モジュールの __getattr__ と __dir__
     モジュールの "__getattr__" 関数および "__dir__" 関数の説明。


3.3.2.2. デスクリプタ (descriptor) の実装
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

以下のメソッドは、このメソッドを持つクラス (いわゆる *デスクリプタ
(descriptor)* クラス) のインスタンスが、 *オーナー (owner)* クラスに存
在するときにのみ適用されます (デスクリプタは、オーナーのクラス辞書か、
その親のいずれかのクラス辞書になければなりません)。 以下の例では、"属
性" とは、名前がオーナークラスの "__dict__" のプロパティ (porperty) の
キーであるような属性を指します。

object.__get__(self, instance, owner=None)

   オーナークラス（クラス属性アクセスの場合）や、クラスのインスタンス
   （インスタンス属性アクセスの場合）の属性取得時に呼び出されます。
   *instance*  を通じて属性をアクセスする時に、オプションの *owner* 引
   数はオーナークラスです。 *owner* を通じて属性アクセスするときは
   "None" です。

   このメソッドは、算出された属性値を返すか、 "AttributeError" 例外を
   送出します。

   **PEP 252** は "__get__()" は1つや2つの引数を持つ呼び出し可能オブジ
   ェクトであると定義しています。Pythonの組み込みのデスクリプタはこの
   仕様をサポートしていますが、サードパーティ製のツールの中には両方の
   引数を必要とするものもあります。Pythonの "__getattribute__()" 実装
   は必要かどうかに関わらず、両方の引数を常に渡します。

object.__set__(self, instance, value)

   オーナークラスのインスタンス *instance* 上の属性を新たな値 *value*
   に設定する際に呼び出されます。

   "__set__()" あるいは "__delete__()" を追加すると、デスクリプタは「
   データデスクリプタ」に変わります。詳細は デスクリプタの呼び出し を
   参照してください。

object.__delete__(self, instance)

   オーナークラスのインスタンス *instance* 上の属性を削除する際に呼び
   出されます。

"__objclass__" 属性は "inspect" モジュールによって解釈され、このオブジ
ェクトが定義されたクラスを特定するのに使われます (この属性を適切に設定
しておくと、動的なクラスの属性を実行時に調べる助けになります)。 呼び出
される側にとっては、この属性で指定されたクラス (もしくはそのサブクラス
) のインスタンスが1番目の位置引数として期待もしくは要求されていること
が示せます (例えば、 CPython は束縛されていない C で実行されたメソッド
にこの属性を設定します)。


3.3.2.3. デスクリプタの呼び出し
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

一般にデスクリプタとは、特殊な "束縛に関する動作 (binding behaviour)"
をもつオブジェクト属性のことです。デスクリプタは、デスクリプタプロトコ
ル (descriptor protocol) のメソッド: "__get__()", "__set__()", および
"__delete__()" を使って、属性アクセスをオーバーライドしているものです
。これらのメソッドのいずれかがオブジェクトに対して定義されている場合、
オブジェクトはデスクリプタであるといいます。

属性アクセスのデフォルトの動作は、オブジェクトの辞書から値を取り出した
り、値を設定したり、削除したりするというものです。例えば、 "a.x" によ
る属性の検索では、まず "a.__dict__['x']" 、次に
"type(a).__dict__['x']" 、そして "type(a)" の基底クラスでメタクラスで
ないものに続く、といった具合に連鎖が起こります。

しかし、検索対象の値が、デスクリプタメソッドのいずれかを定義しているオ
ブジェクトであれば、Python はデフォルトの動作をオーバーライドして、代
わりにデスクリプタメソッドを呼び出します。先述の連鎖の中のどこでデスク
リプタメソッドが呼び出されるかは、どのデスクリプタメソッドが定義されて
いて、どのように呼び出されたかに依存します。

デスクリプタ呼び出しの基点となるのは、属性名への束縛 (binding) 、すな
わち "a.x" です。引数がどのようにデスクリプタに結合されるかは "a" に依
存します:

直接呼び出し (Direct Call)
   最も単純で、かつめったに使われない呼び出し操作は、コード中で直接デ
   スクリプタメソッドの呼び出し: "x.__get__(a)" を行うというものです。

インスタンス束縛 (Instance Binding)
   オブジェクトインスタンスへ束縛すると、"a.x" は呼び出し
   "type(a).__dict__['x'].__get__(a, type(a))" に変換されます。

クラス束縛 (Class Binding)
   クラスへ束縛すると、"A.x" は呼び出し "A.__dict__['x'].__get__(None,
   A)" に変換されます。

super 束縛 (Super Binding)
   If "a" is an instance of "super", then the binding "super(B,
   obj).m()" searches "obj.__class__.__mro__" for the base class "A"
   immediately following "B" and then invokes the descriptor with the
   call: "A.__dict__['m'].__get__(obj, obj.__class__)".

インスタンス束縛では、デスクリプタ呼び出しの優先順位はどのデスクリプタ
が定義されているかに依存します。データデスクリプタは、 "__get__()" と
"__set__()" 、 "__delete__()" の任意の組合せを定義することができます。
"__get__()" が定義されない場合には、その属性にアクセスすると、そのオブ
ジェクトのインスタンス辞書にその値がある場合を除けば、デスクリプタオブ
ジェクト自身が返ってきます。デスクリプタが "__set__()" と
"__delete__()" またはそのどちらかを定義していれば、データデスクリプタ
となります; もし両方とも定義しなければ、非データデスクリプタです。通常
、データデスクリプタでは、 "__get__()" と "__set__()" を定義し、一方、
非データデスクリプタには "__get__()" メソッドしかありません。
"__set__()" と "__get__()" を定義したデータデスクリプタは、インスタン
ス辞書内で属性値が再定義されても、常にこの値をオーバライドします。対照
的に、非データデスクリプタの場合には、属性値はインスタンス側でオーバラ
イドされます。

("@staticmethod" や "@classmethod" を含む) Python メソッドは、非データ
デスクリプタとして実装されています。その結果、インスタンスではメソッド
を再定義したりオーバーライドできます。このことにより、個々のインスタン
スが同じクラスの他のインスタンスと互いに異なる動作を獲得することができ
ます。

"property()" 関数はデータデスクリプタとして実装されています。従って、
インスタンスはあるプロパティの動作をオーバーライドすることができません
。


3.3.2.4. __slots__
~~~~~~~~~~~~~~~~~~

*__slots__* を使うと、(プロパティのように) データメンバを明示的に宣言
し、 (明示的に *__slots__* で宣言しているか親クラスに存在しているかで
ない限り) "__dict__" や *__weakref__* を作成しないようにできます。

"__dict__" を使うのに比べて、節約できるメモリ空間はかなり大きいです。
属性探索のスピードもかなり向上できます。

object.__slots__

   このクラス変数には、インスタンスが用いる変数名を表す、文字列、イテ
   ラブル、または文字列のシーケンスを代入できます。*__slots__* は、各
   インスタンスに対して宣言された変数に必要な記憶領域を確保し、
   "__dict__" と *__weakref__* が自動的に生成されないようにします。


3.3.2.4.1. *__slots__* を利用する際の注意
"""""""""""""""""""""""""""""""""""""""""

* *__slots__* を持たないクラスから継承するとき、インスタンスの
  "__dict__" 属性と *__weakref__* 属性は常に利用可能です。

* "__dict__" 変数がない場合、 *__slots__* に列挙されていない新たな変数
  をインスタンスに代入することはできません。列挙されていない変数名を使
  って代入しようとした場合、 "AttributeError" が送出されます。新たな変
  数を動的に代入したいのなら、 *__slots__* を宣言する際に "'__dict__'"
  を変数名のシーケンスに追加してください。

* *__slots__* を定義しているクラスの各インスタンスに *__weakref__* 変
  数がない場合、インスタンスに対する弱参照 ("weak references") はサポ
  ートされません。弱参照のサポートが必要なら、 *__slots__* を宣言する
  際に "'__weakref__'" を変数名のシーケンスに追加してください。

* *__slots__* は、クラスのレベルで各変数に対する デスクリプタ を使って
  実装されます。その結果、 *__slots__* に定義されているインスタンス変
  数のデフォルト値はクラス属性を使って設定できなくなっています; そうし
  ないと、デスクリプタによる代入をクラス属性が上書きしてしまうからです
  。

* *__slots__* の宣言の作用は、それが定義されたクラスだけには留まりませ
  ん。 親クラスで宣言された *__slots__* は子クラスでも利用可能です。
  ただし、子クラスは、自身も *__slots__* (ここには *追加の* スロットの
  名前のみ含めるべき) を定義しない限り "__dict__" や *__weakref__* を
  持ちます。

* あるクラスで、基底クラスですでに定義されているスロットを定義した場合
  、基底クラスのスロットで定義されているインスタンス変数は (デスクリプ
  タを基底クラスから直接取得しない限り) アクセスできなくなります。これ
  により、プログラムの趣意が不定になってしまいます。将来は、この問題を
  避けるために何らかのチェックが追加されるかもしれません。

* "TypeError" will be raised if nonempty *__slots__* are defined for a
  class derived from a ""variable-length" built-in type" such as
  "int", "bytes", and "tuple".

* Any non-string *iterable* may be assigned to *__slots__*.

* If a "dictionary" is used to assign *__slots__*, the dictionary keys
  will be used as the slot names. The values of the dictionary can be
  used to provide per-attribute docstrings that will be recognised by
  "inspect.getdoc()" and displayed in the output of "help()".

* "__class__" への代入は、両方のクラスが同じ *__slots__* を持っている
  ときのみ動作します。

* 複数のスロットを持つ親クラスを使った 多重継承 はできますが、スロット
  で作成された属性を持つ親クラスは 1 つに限られます (他の基底クラスの
  スロットは空でなければなりません) - それに違反すると "TypeError" が
  送出されます。

* もし *__slots__* に対して *イテレータ* を使用すると、イテレータの値
  ごとに *デスクリプタ* が作られます。しかし、 *__slots__* 属性は空の
  イテレータとなります。


3.3.3. クラス生成をカスタマイズする
-----------------------------------

クラスが他のクラスを継承するときに必ず、親クラスの
"__init_subclass__()" が呼び出されます。これを利用すると、サブクラスの
挙動を変更するクラスを書くことができます。これは、クラスデコレータとと
ても良く似ていますが、クラスデコレータが、それが適用された特定のクラス
にのみに影響するのに対して、 "__init_subclass__" は、もっぱら、このメ
ソッドを定義したクラスの将来のサブクラスに適用されます。

classmethod object.__init_subclass__(cls)

   このメソッドは、それが定義されたクラスが継承された際に必ず呼び出さ
   れます。*cls* は新しいサブクラスです。もし、このメソッドがインスタ
   ンスメソッドとして定義されると、暗黙的にクラスメソッドに変換されま
   す。

   新しいクラスに与えられたキーワード引数は、親のクラスの
   "__init_subclass__" に渡されます。 "__init_subclass__" を利用してい
   る他のクラスとの互換性のために、以下のコードのように必要なキーワー
   ド引数を取得したら、他の引数は基底クラスに引き渡すべきです:

      class Philosopher:
          def __init_subclass__(cls, /, default_name, **kwargs):
              super().__init_subclass__(**kwargs)
              cls.default_name = default_name

      class AustralianPhilosopher(Philosopher, default_name="Bruce"):
          pass

   "object.__init_subclass__" のデフォルト実装は何も行いませんが、何ら
   かの引数とともに呼び出された場合は、エラーを送出します。

   注釈:

     メタクラスのヒント "metaclass" は残りの型機構によって消費され、
     "__init_subclass__" 実装に渡されることはありません。 実際のメタク
     ラス (明示的なヒントではなく) は、 "type(cls)" としてアクセスでき
     ます。

   バージョン 3.6 で追加.

When a class is created, "type.__new__()" scans the class variables
and makes callbacks to those with a "__set_name__()" hook.

object.__set_name__(self, owner, name)

   オーナーとなるクラス *owner* が作成された時点で自動的に呼び出されま
   す。 オブジェクトはそのクラスの *name* に割り当てられます。

      class A:
          x = C()  # Automatically calls: x.__set_name__(A, 'x')

   If the class variable is assigned after the class is created,
   "__set_name__()" will not be called automatically. If needed,
   "__set_name__()" can be called directly:

      class A:
         pass

      c = C()
      A.x = c                  # The hook is not called
      c.__set_name__(A, 'x')   # Manually invoke the hook

   詳細は クラスオブジェクトの作成 を参照してください。

   バージョン 3.6 で追加.


3.3.3.1. メタクラス
~~~~~~~~~~~~~~~~~~~

デフォルトでは、クラスは "type()" を使って構築されます。 クラス本体は
新しい名前空間で実行され、クラス名が "type(name, bases, namespace)" の
結果にローカルに束縛されます。

クラス生成プロセスはカスタマイズできます。 そのためにはクラス定義行で
"metaclass" キーワード引数を渡すか、そのような引数を定義行に含む既存の
クラスを継承します。 次の例で "MyClass" と "MySubclass" は両方とも
"Meta" のインスタンスです:

   class Meta(type):
       pass

   class MyClass(metaclass=Meta):
       pass

   class MySubclass(MyClass):
       pass

クラス定義の中で指定された他のキーワード引数は、後述するすべてのメタク
ラス操作に渡されます。

クラス定義が実行される際に、以下のステップが生じます:

* MRO エントリの解決が行われる;

* 適切なメタクラスが決定される;

* クラスの名前空間が準備される;

* クラスの本体が実行される;

* クラスオブジェクトが作られる。


3.3.3.2. MRO エントリの解決
~~~~~~~~~~~~~~~~~~~~~~~~~~~

クラス定義に現れる基底が "type" のインスタンスではない場合、そのインス
タンスの "__mro_entries__" メソッドが検索されます。 見付かった場合、そ
の基底そのものを要素に持つタプルを引数として、 "__mro_entries__" メソ
ッドが呼び出されます。 このメソッドは、この基底の代わりに使われるクラ
スのタプルを返さなければなりません。 このタプルは空であることもあり、
そのような場合ではその基底は無視されます。

参考: **PEP 560** - typing モジュールとジェネリック型に対する言語コアによ
    るサポート


3.3.3.3. 適切なメタクラスの決定
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

クラス定義に対して適切なメタクラスは、以下のように決定されます:

* 基底も明示的なメタクラスも与えられていない場合は、 "type()" が使われ
  ます;

* 明示的なメタクラスが与えられていて、それが "type()" のインスタンス *
  ではない* 場合、それをメタクラスとして直接使います;

* 明示的なメタクラスとして "type()" のインスタンスが与えられたか、基底
  が定義されていた場合は、最も派生した (継承関係で最も下の) メタクラス
  が使われます。

最も派生的なメタクラスは、(もしあれば) 明示的に指定されたメタクラスと
、指定されたすべてのベースクラスのメタクラスから選ばれます。最も派生的
なメタクラスは、これらのメタクラス候補のすべてのサブタイプであるような
ものです。メタクラス候補のどれもその基準を満たさなければ、クラス定義は
"TypeError" で失敗します。


3.3.3.4. クラスの名前空間の準備
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

適切なメタクラスが指定されると、クラスの名前空間が用意されます。もしメ
タクラスが "__prepare__" 属性を持っている場合、 "namespace =
metaclass.__prepare__(name, bases, **kwds)" が呼ばれます。追加のキーワ
ード引数は、もしクラス定義にあれば設定されます。 "__prepare__" メソッ
ドは "クラスメソッド" として実装する必要があります。 "__prepare__" が
作成して返した名前空間は "__new__" に渡されますが、最終的なクラスオブ
ジェクトは新しい "dict" にコピーして作成されます。

メタクラスに "__prepare__" 属性がない場合、クラスの名前空間は空の 順序
付きマッピングとして初期化されます。

参考:

  **PEP 3115** - Metaclasses in Python 3000
     "__prepare__" 名前空間フックの導入


3.3.3.5. クラス本体の実行
~~~~~~~~~~~~~~~~~~~~~~~~~

クラス本体が (大まかには) "exec(body, globals(), namespace)" として実
行されます。通常の呼び出しと "exec()" の重要な違いは、クラス定義が関数
内部で行われる場合、レキシカルスコープによってクラス本体 (任意のメソッ
ドを含む) が現在のスコープと外側のスコープから名前を参照できるという点
です。

しかし、クラス定義が関数内部で行われる時でさえ、クラス内部で定義された
メソッドはクラススコープで定義された名前を見ることはできません。クラス
変数はインスタンスメソッドかクラスメソッドの最初のパラメータからアクセ
スするか、次の節で説明する、暗黙的に静的スコープが切られている
"__class__" 参照からアクセスしなければなりません。


3.3.3.6. クラスオブジェクトの作成
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

クラス本体の実行によってクラスの名前空間が初期化されたら、
"metaclass(name, bases, namespace, **kwds)" を呼び出すことでクラスオブ
ジェクトが作成されます (ここで渡される追加のキーワードは "__prepare__"
に渡されるものと同じです)。

このクラスオブジェクトは、 "super()" の無引数形式によって参照されるも
のです。 "__class__" は、クラス本体中のメソッドが "__class__" または
"super" のいずれかを参照している場合に、コンパイラによって作成される暗
黙のクロージャー参照です。これは、メソッドに渡された最初の引数に基づい
て現在の呼び出しを行うために使用されるクラスまたはインスタンスが識別さ
れる一方、 "super()" の無引数形式がレキシカルスコープに基づいて定義さ
れているクラスを正確に識別することを可能にします。

**CPython 実装の詳細:** CPython 3.6 以降では、 "__class__" セルは、ク
ラス名前空間にある "__classcell__" エントリーとしてメタクラスに渡され
ます。 "__class__" セルが存在していた場合は、そのクラスが正しく初期化
されるために、 "type.__new__" の呼び出しに到達するまで上に伝搬されます
。 失敗した場合は、Python 3.8 では "RuntimeError" になります。

デフォルトのメタクラス "type" や最終的には "type.__new__" を呼び出すメ
タクラスを使っているときは、クラスオブジェクトを作成した後に次のカスタ
ム化の手順が起動されます:

1. "type.__new__" メソッドが "__set_name__()" が定義されているクラスの
   名前空間にある全ての属性を収集します;

2. それらの "__set_name__" メソッドが、そのメソッドが定義されているク
   ラス、およびそこに属する属性に割り当てられている名前を引数として呼
   び出されます;

3. 新しいクラスのメソッド解決順序ですぐ上に位置する親クラスで
   "__init_subclass__()" フックが呼び出されます。

クラスオブジェクトが作成された後には、クラス定義に含まれているクラスデ
コレータ (もしあれば) にクラスオブジェクトが渡され、デコレータが返すオ
ブジェクトがここで定義されたクラスとしてローカルの名前空間に束縛されま
す。

新しいクラスが "type.__new__" で生成されたときは、名前空間引数として与
えられたオブジェクトは新しい順序付きのマッピングに複製され、元のオブジ
ェクトは破棄されます。 新しく複製したものは読み出し専用のプロキシでラ
ップされ、クラスオブジェクトの "__dict__" 属性になります。

参考:

  **PEP 3135** - New super
     暗黙の "__class__" クロージャ参照について記述しています


3.3.3.7. メタクラスの用途
~~~~~~~~~~~~~~~~~~~~~~~~~

メタクラスは限りない潜在的利用価値を持っています。これまで試されてきた
アイデアには、列挙型、ログ記録、インターフェースのチェック、 自動デリ
ゲーション、自動プロパティ生成、プロキシ、フレームワーク、そして自動リ
ソースロック／同期といったものがあります。


3.3.4. インスタンスのカスタマイズとサブクラスチェック
-----------------------------------------------------

以下のメソッドは組み込み関数 "isinstance()" と "issubclass()" のデフォ
ルトの動作を上書きするのに利用します。

特に、 "abc.ABCMeta" メタクラスは、抽象基底クラス (ABCs) を"仮想基底ク
ラス (virtual base classes)" として、他の ABC を含む、任意のクラスや (
組み込み型を含む) 型に追加するために、これらのメソッドを実装しています
。

class.__instancecheck__(self, instance)

   *instance* が (直接、または間接的に) *class* のインスタンスと考えら
   れる場合に true を返します。定義されていれば、
   "isinstance(instance, class)" の実装のために呼び出されます。

class.__subclasscheck__(self, subclass)

   *subclass* が (直接、または間接的に) *class* のサブクラスと考えられ
   る場合に true を返します。定義されていれば、 "issubclass(subclass,
   class)" の実装のために呼び出されます。

なお、これらのメソッドは、クラスの型 (メタクラス) 上で検索されます。実
際のクラスにクラスメソッドとして定義することはできません。これは、イン
スタンスそれ自体がクラスであるこの場合にのみ、インスタンスに呼び出され
る特殊メソッドの検索と一貫しています。

参考:

  **PEP 3119** - 抽象基底クラスの導入
     抽象基底クラス ("abc" モジュールを参照) を言語に追加する文脈にお
     いての動機から、 "__instancecheck__()" と "__subclasscheck__()"
     を通して、 "isinstance()" と "issubclass()" に独自の動作をさせる
     ための仕様の記述があります。


3.3.5. ジェネリック型をエミュレートする
---------------------------------------

When using *type annotations*, it is often useful to *parameterize* a
*generic type* using Python's square-brackets notation. For example,
the annotation "list[int]" might be used to signify a "list" in which
all the elements are of type "int".

参考:

  **PEP 484** - 型ヒント
     Introducing Python's framework for type annotations

  Generic Alias Types
     Documentation for objects representing parameterized generic
     classes

  ジェネリクス, user-defined generics and "typing.Generic"
     実行時にパラメータ設定が可能であり、かつ静的な型チェッカーが理解
     できるジェネリッククラスを実装する方法のドキュメントです。

A class can *generally* only be parameterized if it defines the
special class method "__class_getitem__()".

classmethod object.__class_getitem__(cls, key)

   *key* にある型引数で特殊化されたジェネリッククラスを表すオブジェク
   トを返します。

   When defined on a class, "__class_getitem__()" is automatically a
   class method. As such, there is no need for it to be decorated with
   "@classmethod" when it is defined.


3.3.5.1. The purpose of *__class_getitem__*
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

The purpose of "__class_getitem__()" is to allow runtime
parameterization of standard-library generic classes in order to more
easily apply *type hints* to these classes.

To implement custom generic classes that can be parameterized at
runtime and understood by static type-checkers, users should either
inherit from a standard library class that already implements
"__class_getitem__()", or inherit from "typing.Generic", which has its
own implementation of "__class_getitem__()".

Custom implementations of "__class_getitem__()" on classes defined
outside of the standard library may not be understood by third-party
type-checkers such as mypy. Using "__class_getitem__()" on any class
for purposes other than type hinting is discouraged.


3.3.5.2. *__class_getitem__* versus *__getitem__*
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Usually, the subscription of an object using square brackets will call
the "__getitem__()" instance method defined on the object's class.
However, if the object being subscribed is itself a class, the class
method "__class_getitem__()" may be called instead.
"__class_getitem__()" should return a GenericAlias object if it is
properly defined.

Presented with the *expression* "obj[x]", the Python interpreter
follows something like the following process to decide whether
"__getitem__()" or "__class_getitem__()" should be called:

   from inspect import isclass

   def subscribe(obj, x):
       """Return the result of the expression `obj[x]`"""

       class_of_obj = type(obj)

       # If the class of obj defines __getitem__,
       # call class_of_obj.__getitem__(obj, x)
       if hasattr(class_of_obj, '__getitem__'):
           return class_of_obj.__getitem__(obj, x)

       # Else, if obj is a class and defines __class_getitem__,
       # call obj.__class_getitem__(x)
       elif isclass(obj) and hasattr(obj, '__class_getitem__'):
           return obj.__class_getitem__(x)

       # Else, raise an exception
       else:
           raise TypeError(
               f"'{class_of_obj.__name__}' object is not subscriptable"
           )

In Python, all classes are themselves instances of other classes. The
class of a class is known as that class's *metaclass*, and most
classes have the "type" class as their metaclass. "type" does not
define "__getitem__()", meaning that expressions such as "list[int]",
"dict[str, float]" and "tuple[str, bytes]" all result in
"__class_getitem__()" being called:

   >>> # list has class "type" as its metaclass, like most classes:
   >>> type(list)
   <class 'type'>
   >>> type(dict) == type(list) == type(tuple) == type(str) == type(bytes)
   True
   >>> # "list[int]" calls "list.__class_getitem__(int)"
   >>> list[int]
   list[int]
   >>> # list.__class_getitem__ returns a GenericAlias object:
   >>> type(list[int])
   <class 'types.GenericAlias'>

However, if a class has a custom metaclass that defines
"__getitem__()", subscribing the class may result in different
behaviour. An example of this can be found in the "enum" module:

   >>> from enum import Enum
   >>> class Menu(Enum):
   ...     """A breakfast menu"""
   ...     SPAM = 'spam'
   ...     BACON = 'bacon'
   ...
   >>> # Enum classes have a custom metaclass:
   >>> type(Menu)
   <class 'enum.EnumMeta'>
   >>> # EnumMeta defines __getitem__,
   >>> # so __class_getitem__ is not called,
   >>> # and the result is not a GenericAlias object:
   >>> Menu['SPAM']
   <Menu.SPAM: 'spam'>
   >>> type(Menu['SPAM'])
   <enum 'Menu'>

参考:

  **PEP 560** - typing モジュールとジェネリック型に対する言語コアによ
  るサポート
     Introducing "__class_getitem__()", and outlining when a
     subscription results in "__class_getitem__()" being called
     instead of "__getitem__()"


3.3.6. 呼び出し可能オブジェクトをエミュレートする
-------------------------------------------------

object.__call__(self[, args...])

   インスタンスが関数として "呼ばれた" 際に呼び出されます。このメソッ
   ドが定義されている場合、 "x(arg1, arg2, ...)" は大まかには
   "type(x).__call__(x, arg1, ...)" に変換されます。


3.3.7. コンテナをエミュレートする
---------------------------------

以下に挙げるメソッドを定義することで、コンテナオブジェクトを実装できま
す。コンテナは通常は ("リスト" や "タプル" のような) *シーケンス* や
("辞書" のような) *マッピング* ですが、他のコンテナも同じように表現す
ることができます。最初のメソッド群はシーケンスもしくはマッピングを模倣
するために使われます; 両者の違いは、シーケンスでキーとして使えるのは、
*N* をシーケンスの長さとして "0 <= k < N" を満たす整数 *k* 、もしくは
要素の範囲を定義する "slice" オブジェクトです。マッピングは、 Python
の標準の "辞書" オブジェクトのメソッドと似た振る舞いをするメソッド
"keys()" 、 "values()" 、 "items()" 、 "get()" 、 "clear()" 、
"setdefault()" 、 "pop()" 、 "popitem()" 、 "copy()" 、 "update()" を
提供することも推奨されています。 "collections" モジュールは、
"MutableMapping" *抽象基底クラス* を提供し、 "__getitem__()" 、
"__setitem__()" 、 "__delitem__()" 、 "keys()" という基礎となるメソッ
ド群から前文で挙げたメソッドを作成するのを助けてくれます。可変シーケン
スは、 Python の標準の "list" オブジェクトと同じように、メソッド
"append()" 、 "count()" 、 "index()" 、 "extend()" 、 "insert()" 、
"pop()" 、 "remove()" 、 "reverse()" 、 "sort()" を提供すべきです。最
後に、シーケンス型は (連結を意味する) 加算と (繰り返しを意味する) 乗算
を、以下に説明するメソッド "__add__()" 、 "__radd__()" 、 "__iadd__()"
、 "__mul__()" 、 "__rmul__()" 、 "__imul__()" を定義して実装すべきで
す; そして、それ以外の数値演算子は定義すべきではありません。マッピング
とシーケンスは両方とも、効率の良い "in" 演算子が使えるように
"__contains__()" メソッドを実装すべきです; マッピングでは "in" はマッ
ピングのキーを検索すべきです; シーケンスでは値を検索すべきです。マッピ
ングもシーケンスも、コンテナの効率の良い反復処理ができるよう
"__iter__()" メソッドを実装すべきです; マッピングでは "__iter__()" は
オブジェクトのキーに対して反復処理を; シーケンスでは値全体の反復処理を
行うべきです。

object.__len__(self)

   呼び出して組み込み関数 "len()" を実装します。 オブジェクトの長さを
   0 以上の整数で返さなければなりません。 また、 "__bool__()"  メソッ
   ドを定義しておらず、 "__len__()" メソッドが 0 を返すようなオブジェ
   クトは、ブール演算コンテキストでは偽とみなされます。

   **CPython 実装の詳細:** CPython では、オブジェクトの長さは最大でも
   "sys.maxsize" であることが要求されます。 長さが "sys.maxsize" を越
   える場合、("len()" のような) いくつかの機能は "OverflowError" を送
   出するでしょう。 真偽値としての判定で "OverflowError" を送出しない
   ようにするには、オブジェクトは "__bool__()" メソッドを定義していな
   ければなりません。

object.__length_hint__(self)

   呼び出して "operator.length_hint()" を実装します。オブジェクトの推
   定される長さ (実際のものより長かったり短かったりするかもしれません)
   を返さなければなりません。長さは 0 以上の整数でなければなりません。
   返り値は "NotImplemented" となる場合もありますが、その場合は
   "__length_hint__" メソッドがなかった場合と同じと扱われます。このメ
   ソッドは純粋に最適化であり、正確性は必要ではありません。

   バージョン 3.4 で追加.

注釈:

  スライシングは、以下の 3 メソッドによって排他的に行われます。次のよ
  うな呼び出しは

     a[1:2] = b

  次のように翻訳され

     a[slice(1, 2, None)] = b

  以下も同様です。存在しないスライスの要素は "None" で埋められます。

object.__getitem__(self, key)

   "self[key]" の値評価 (evaluation) を実現するために呼び出されます。*
   シーケンス* 型の場合、キーとして整数とスライスオブジェクトを受理で
   きなければなりません。 (*シーケンス* 型をエミュレートする場合) 負の
   インデクスの解釈は "__getitem__()" メソッド次第となります。 *key*
   が不適切な型であった場合、 "TypeError" を送出してもかまいません; (
   負のインデクス値に対して何らかの解釈を行った上で) *key* がシーケン
   スのインデクス集合外の値である場合、 "IndexError" を送出しなければ
   なりません。*マップ* 型の場合は、 *key* に誤りがある場合（コンテナ
   に含まれていない場合）、 "KeyError" を送出しなければなりません。

   注釈:

     "for" ループでは、シーケンスの終端を正しく検出できるようにするた
     めに、不正なインデクスに対して "IndexError" が送出されるものと期
     待しています。

   注釈:

     When subscripting a *class*, the special class method
     "__class_getitem__()" may be called instead of "__getitem__()".
     See __class_getitem__ versus __getitem__ for more details.

object.__setitem__(self, key, value)

   "self[key]" に対する代入を実装するために呼び出されます。
   "__getitem__()" と同じ注意事項があてはまります。このメソッドを実装
   できるのは、あるキーに対する値の変更をサポートしているか、新たなキ
   ーを追加できるようなマップの場合と、ある要素を置き換えることができ
   るシーケンスの場合だけです。不正な *key* に対しては、
   "__getitem__()" メソッドと同様の例外の送出を行わなければなりません
   。

object.__delitem__(self, key)

   "self[key]" の削除を実装するために呼び出されます。 "__getitem__()"
   と同じ注意事項があてはまります。このメソッドを実装できるのは、キー
   の削除をサポートしているマップの場合と、要素を削除できるシーケンス
   の場合だけです。不正な *key* に対しては、 "__getitem__()" メソッド
   と同様の例外の送出を行わなければなりません。

object.__missing__(self, key)

   "self[key]" の実装において辞書内にキーが存在しなかった場合に、 dict
   のサブクラスのために "dict"."__getitem__()" によって呼び出されます
   。

object.__iter__(self)

   このメソッドは、コンテナに対して *イテレータ* が要求された際に呼び
   出されます。このメソッドは、コンテナ内の全てのオブジェクトに渡って
   反復処理できるような、新たなイテレータオブジェクトを返さなければな
   りません。マッピングでは、コンテナ内のキーに渡って反復処理しなけれ
   ばなりません。

object.__reversed__(self)

   "reversed()" 組み込み関数が逆方向イテレーションを実装するために、(
   存在すれば)呼び出します。コンテナ内の全要素を逆順にイテレートする、
   新しいイテレータを返すべきです。

   "__reversed__()" メソッドが定義されていない場合、 "reversed()" 組込
   み関数は sequence プロトコル ("__len__()" と "__getitem__()") を使
   った方法にフォールバックします。 sequence プロトコルをサポートした
   オブジェクトは、 "reversed()" よりも効率のいい実装を提供できる場合
   にのみ "__reversed__()" を定義するべきです。

帰属テスト演算子 ("in" および "not in") は通常、コンテナの要素に対する
反復処理のように実装されます。しかし、コンテナオブジェクトで以下の特殊
メソッドを定義して、より効率的な実装を行ったり、オブジェクトがイテラブ
ルでなくてもよいようにできます。

object.__contains__(self, item)

   帰属テスト演算を実装するために呼び出されます。 *item* が *self* 内
   に存在する場合には真を、そうでない場合には偽を返さなければなりませ
   ん。マップオブジェクトの場合、値やキーと値の組ではなく、キーに対す
   る帰属テストを考えなければなりません。

   "__contains__()" を定義しないオブジェクトに対しては、メンバシップテ
   ストはまず、 "__iter__()" を使った反復を試みます、次に古いシーケン
   ス反復プロトコル "__getitem__()" を使います、 言語レファレンスのこ
   の節 を参照して下さい。


3.3.8. 数値型をエミュレートする
-------------------------------

以下のメソッドを定義して、数値型オブジェクトをエミュレートすることがで
きます。特定の種類の数値型ではサポートされていないような演算に対応する
メソッド (非整数の数値に対するビット単位演算など) は、未定義のままにし
ておかなければなりません。

object.__add__(self, other)
object.__sub__(self, other)
object.__mul__(self, other)
object.__matmul__(self, other)
object.__truediv__(self, other)
object.__floordiv__(self, other)
object.__mod__(self, other)
object.__divmod__(self, other)
object.__pow__(self, other[, modulo])
object.__lshift__(self, other)
object.__rshift__(self, other)
object.__and__(self, other)
object.__xor__(self, other)
object.__or__(self, other)

   これらのメソッドを呼んで二項算術演算子 ("+", "-", "*", "@", "/",
   "//", "%", "divmod()", "pow()", "**", "<<", ">>", "&", "^", "|") を
   実装します。 例えば *x* が "__add__()" メソッドのあるクラスのインス
   タンスである場合、式 "x + y" を評価すると "x.__add__(y)" が呼ばれま
   す。 "__divmod__()" メソッドは "__floordiv__()" と "__mod__()" を使
   用するのと等価でなければなりません。 "__truediv__()" と関連してはな
   りません。 組み込みの "pow()" 関数の三項のものがサポートされていな
   ければならない場合、 "__pow__()" はオプションの第三引数を受け取るも
   のとして定義されなければなりません。

   これらのメソッドのいずれかが渡された引数に対する操作を提供していな
   い場合、 "NotImplemented" を返すべきです。

object.__radd__(self, other)
object.__rsub__(self, other)
object.__rmul__(self, other)
object.__rmatmul__(self, other)
object.__rtruediv__(self, other)
object.__rfloordiv__(self, other)
object.__rmod__(self, other)
object.__rdivmod__(self, other)
object.__rpow__(self, other[, modulo])
object.__rlshift__(self, other)
object.__rrshift__(self, other)
object.__rand__(self, other)
object.__rxor__(self, other)
object.__ror__(self, other)

   これらのメソッドを呼んで二項算術演算 ("+", "-", "*", "@", "/",
   "//", "%", "divmod()", "pow()", "**", "<<", ">>", "&", "^", "|") の
   、被演算子が反射した (入れ替えられた) ものを実装します。 これらの関
   数は、左側の被演算子が対応する演算をサポートしておらず  [3]  、非演
   算子が異なる型の場合にのみ呼び出されます。 [4] 例えば、 *y* が
   "__rsub__()" メソッドのあるクラスのインスタンスである場合、 式 "x -
   y" を評価すると "x.__sub__(y)" が *NotImplemented* を返すときは
   "y.__rsub__(x)" が呼ばれます。

   ただし、三項演算子 "pow()" が "__rpow__()" を呼ぶことはないので注意
   してください (型強制の規則が非常に難解になるからです)。

   注釈:

     右側の被演算子の型が左側の被演算子の型のサブクラスであり、このサ
     ブクラスであるメソッドに対する反射メソッドと異なる実装が定義され
     ている場合には、左側の被演算子の非反射メソッドが呼ばれる前に、こ
     のメソッドが呼ばれます。この振る舞いにより、サブクラスが親の演算
     をオーバーライドすることが可能になります。

object.__iadd__(self, other)
object.__isub__(self, other)
object.__imul__(self, other)
object.__imatmul__(self, other)
object.__itruediv__(self, other)
object.__ifloordiv__(self, other)
object.__imod__(self, other)
object.__ipow__(self, other[, modulo])
object.__ilshift__(self, other)
object.__irshift__(self, other)
object.__iand__(self, other)
object.__ixor__(self, other)
object.__ior__(self, other)

   これらのメソッドを呼び出して累算算術代入 ("+=", "-=", "*=", "@=",
   "/=", "//=", "%=", "**=", "<<=", ">>=", "&=", "^=", "|=") を実装し
   ます。 これらのメソッドは演算をインプレースで (*self* を変更する)
   行うよう試み、その結果 (その必要はありませんが *self* でも構いませ
   ん) を返さなければなりません。 特定のメソッドが定義されていない場合
   、その累算算術演算は通常のメソッドにフォールバックされます。 例えば
   *x* が "__iadd__()" メソッドを持つクラスのインスタンスである場合、
   "x += y" は "x = x.__iadd__(y)" と等価です。 そうでない場合、"x +
   y" の評価と同様に "x.__add__(y)" と "y.__radd__(x)" が考慮されます
   。 特定の状況では、累算代入は予期しないエラーに終わるかもしれません
   (なぜ加算はされるのに a_tuple[i] += ['item'] は例外を送出するのです
   か? を参照してください) が、この挙動は実際はデータモデルの挙動の一
   部です。

object.__neg__(self)
object.__pos__(self)
object.__abs__(self)
object.__invert__(self)

   呼び出して単項算術演算 ("-", "+", "abs()" および "~") を実装します
   。

object.__complex__(self)
object.__int__(self)
object.__float__(self)

   組み込み関数の "complex()", "int()", "float()" の実装から呼び出され
   ます。 適切な型の値を返さなければなりません。

object.__index__(self)

   呼び出して "operator.index()" を実装します。 Python が数値オブジェ
   クトを整数オブジェクトに損失なく変換する必要がある場合 (たとえばス
   ライシングや、組み込みの "bin()" 、 "hex()" 、 "oct()" 関数) は常に
   呼び出されます。 このメソッドがあるとその数値オブジェクトが整数型で
   あることが示唆されます。 整数を返さなければなりません。

   もし "__int__()", "__float__()", "__complex__()" が定義されていない
   場合、組み込み関数の "int()", "float()", "complex()" は
   "__index__()" にフォールバックします。

object.__round__(self[, ndigits])
object.__trunc__(self)
object.__floor__(self)
object.__ceil__(self)

   組み込み関数の "round()" と "math" モジュール関数の "trunc()",
   "floor()", "ceil()" の実装から呼び出されます。 *ndigits* が
   "__round__()" に渡されない限りは、これらの全てのメソッドは
   "Integral" (たいていは "int") に切り詰められたオブジェクトの値を返
   すべきです。

   The built-in function "int()" falls back to "__trunc__()" if
   neither "__int__()" nor "__index__()" is defined.


3.3.9. with文とコンテキストマネージャ
-------------------------------------

コンテキストマネージャ(*context manager*) とは、 "with" 文の実行時にラ
ンタイムコンテキストを定義するオブジェクトです。コンテキストマネージャ
は、コードブロックを実行するために必要な入り口および出口の処理を扱いま
す。コンテキストマネージャは通常、 "with" 文（ with 文 の章を参照）に
より起動されますが、これらのメソッドを直接呼び出すことで起動することも
できます。

コンテキストマネージャの代表的な使い方としては、様々なグローバル情報の
保存および更新、リソースのロックとアンロック、ファイルのオープンとクロ
ーズなどが挙げられます。

コンテキストマネージャについてのさらなる情報については、 コンテキスト
マネージャ型 を参照してください。

object.__enter__(self)

   コンテキストマネージャのの入り口で実行される処理です。 "with" 文は
   、文の "as" 節で規定された値を返すこのメソッドを呼び出します。

object.__exit__(self, exc_type, exc_value, traceback)

   コンテキストマネージャの出口で実行される処理です。パラメータは、コ
   ンテキストが終了した原因となった例外について説明しています。コンテ
   キストが例外を送出せず終了した場合は、全ての引き数に "None" が設定
   されます。

   もし、例外が送出され、かつメソッドが例外を抑制したい場合（すなわち
   、例外が伝播されるのを防ぎたい場合）、このメソッドは True を返す必
   要があります。そうでなければ、このメソッドの終了後、例外は通常通り
   伝播することになります。

   "__exit__()" メソッドは受け取った例外を再度送出すべきではありません
   。これは、呼び出し側の責任でおこなってください。

参考:

  **PEP 343** - "with" ステートメント
     Python の "with" 文の仕様、背景、および例が記載されています。


3.3.10. クラスパターンマッチの位置引数のカスタマイズ
----------------------------------------------------

パターンの中でクラス名を利用する場合、位置引数はデフォルトでは利用でき
ません。 "MyClass" で特別なサポートがないと、 "case MyClass(x, y)" は
通常無効です。このようなパターンを利用するには、 *__match_args__* 属性
をクラスに定義する必要があります。

object.__match_args__

   このクラス変数には文字列のタプルがアサイン可能です。このクラスがク
   ラスパターンの位置引数の中で利用されると、それぞれの位置引数は対応
   する *__match_args__* の中の値をキーワードとする、キーワード引数に
   変換されます。この属性がない時は、 "()" が設定されているのと同義で
   す。

例えば、もし "MyClass.__match_args__" に "("left", "center", "right")"
が定義されていた場合、  "case MyClass(x, y)" は "case MyClass(left=x,
center=y)" と同義です。パターンの引数の数は、 *__match_args__* の要素
数と同等かそれ以下でなければならない点に注意してください。もし、多かっ
た場合には、パターンマッチは "TypeError" を送出します。

バージョン 3.10 で追加.

参考:

  **PEP 634** - 構造的パターンマッチ
     "match" 文の詳細。


3.3.11. 特殊メソッド検索
------------------------

カスタムクラスでは、特殊メソッドの暗黙の呼び出しは、オブジェクトのイン
スタンス辞書ではなく、オブジェクトの型で定義されているときにのみ正しく
動作することが保証されます。この動作のため、以下のコードは例外を送出し
ます:

   >>> class C:
   ...     pass
   ...
   >>> c = C()
   >>> c.__len__ = lambda: 5
   >>> len(c)
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: object of type 'C' has no len()

この動作の背景となる理由は、 "__hash__()" と "__repr__()" といった
type オブジェクトを含むすべてのオブジェクトで定義されている特殊メソッ
ドにあります。これらのメソッドの暗黙の検索が通常の検索プロセスを使った
場合、 type オブジェクト自体に対して実行されたときに失敗してしまいます
:

   >>> 1 .__hash__() == hash(1)
   True
   >>> int.__hash__() == hash(int)
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: descriptor '__hash__' of 'int' object needs an argument

クラスの非結合メソッドをこのようにして実行しようとすることは、
'metaclass confusion' と呼ばれることもあり、特殊メソッドを検索するとき
はインスタンスをバイパスすることで回避されます:

   >>> type(1).__hash__(1) == hash(1)
   True
   >>> type(int).__hash__(int) == hash(int)
   True

正確性のためにインスタンス属性をスキップするのに加えて、特殊メソッド検
索はオブジェクトのメタクラスを含めて、 "__getattribute__()" メソッドも
バイパスします:

   >>> class Meta(type):
   ...     def __getattribute__(*args):
   ...         print("Metaclass getattribute invoked")
   ...         return type.__getattribute__(*args)
   ...
   >>> class C(object, metaclass=Meta):
   ...     def __len__(self):
   ...         return 10
   ...     def __getattribute__(*args):
   ...         print("Class getattribute invoked")
   ...         return object.__getattribute__(*args)
   ...
   >>> c = C()
   >>> c.__len__()                 # Explicit lookup via instance
   Class getattribute invoked
   10
   >>> type(c).__len__(c)          # Explicit lookup via type
   Metaclass getattribute invoked
   10
   >>> len(c)                      # Implicit lookup
   10

このように "__getattribute__()" 機構をバイパスすることで、特殊メソッド
の扱いに関するある程度の自由度と引き換えに (特殊メソッドはインタプリタ
から一貫して実行されるためにクラスオブジェクトに設定 *しなければならな
い*)、インタープリタを高速化するための大きな余地が手に入ります。


3.4. コルーチン
===============


3.4.1. 待機可能オブジェクト (Awaitable Object)
----------------------------------------------

*awaitable* オブジェクトは一般的には "__await__()" メソッドが実装され
ています。 "async def" 関数が返す *Coroutineオブジェクト* は待機可能で
す。

注釈:

  The *generator iterator* objects returned from generators decorated
  with "types.coroutine()" or "asyncio.coroutine()" are also
  awaitable, but they do not implement "__await__()".

object.__await__(self)

   *iterator* を返さなければなりません。 このメソッドは *awaitable* オ
   ブジェクトを実装するのに使われるべきです。 簡単のために、
   "asyncio.Future" にはこのメソッドが実装され、 "await" 式と互換性を
   持つようになっています。

   注釈:

     The language doesn't place any restriction on the type or value
     of the objects yielded by the iterator returned by "__await__",
     as this is specific to the implementation of the asynchronous
     execution framework (e.g. "asyncio") that will be managing the
     *awaitable* object.

バージョン 3.5 で追加.

参考: 待機可能オブジェクトについてより詳しくは **PEP 492** を参照してくだ
    さい。


3.4.2. コルーチンオブジェクト
-----------------------------

*Coroutineオブジェクト* は *awaitable* オブジェクトです。"__await__()"
を呼び出し、その返り値に対し反復処理をすることでコルーチンの実行を制御
できます。コルーチンの実行が完了し制御を戻したとき、イテレータは
"StopIteration" を送出し、その例外の "value" 属性に返り値を持たせます
。コルーチンが例外を送出した場合は、イテレータにより伝搬されます。コル
ーチンから "StopIteration" 例外を外に送出すべきではありません。

コルーチンには以下に挙げるメソッドもあり、これらはジェネレータのメソッ
ドからの類似です (ジェネレータ-イテレータメソッド を参照してください)
。 ただし、ジェネレータと違って、コルーチンは反復処理を直接はサポート
していません。

バージョン 3.5.2 で変更: コルーチンで2回以上待機 (await) すると
"RuntimeError" となります。

coroutine.send(value)

   コルーチンの実行を開始したり再開したりします。 *value* が "None" の
   場合は、 "__await__()" から返されたイテレータを進めるのと同等です。
   *value* が "None" でない場合は、このコルーチンを一時停止させたイテ
   レータの "send()" メソッドに処理を委任します。 結果 (返り値か
   "StopIteration" かその他の例外) は、上で解説したような
   "__await__()" の返り値に対して反復処理を行ったときと同じです。

coroutine.throw(value)
coroutine.throw(type[, value[, traceback]])

   コルーチンで指定された例外を送出します。 このメソッドは、イテレータ
   にコルーチンを一時停止する "throw()" メソッドがある場合に処理を委任
   します。 そうでない場合には、中断した地点から例外が送出されます。
   結果 (返り値か "StopIteration" かその他の例外) は、上で解説したよう
   な "__await__()" の返り値に対して反復処理を行ったときと同じです。
   例外がコルーチンの中で捕捉されなかった場合、呼び出し元へ伝搬されま
   す。

coroutine.close()

   コルーチンが自分自身の後片付けをし終了します。 コルーチンが一時停止
   している場合は、コルーチンを一時停止させたイテレータに "close()" メ
   ソッドがあれば、まずはそれに処理を委任します。 そして一時停止した地
   点から "GeneratorExit" が送出され、ただちにコルーチンが自分自身の後
   片付けを行います。 最後に、実行が開始されていなかった場合でも、コル
   ーチンに実行が完了した印を付けます。

   コルーチンオブジェクトが破棄されるときには、上記の手順を経て自動的
   に閉じられます。


3.4.3. 非同期イテレータ (Asynchronous Iterator)
-----------------------------------------------

*非同期イテレータ* の "__anext__" メソッドからは非同期のコードが呼べま
す。

非同期イテレータは "async for" 文の中で使えます。

object.__aiter__(self)

   *非同期イテレータ* オブジェクトを返さなくてはなりません。

object.__anext__(self)

   イテレータの次の値を返す *待機可能オブジェクト* を返さなければなり
   ません。 反復処理が終了したときには "StopAsyncIteration" エラーを送
   出すべきです。

非同期イテラブルオブジェクトの例:

   class Reader:
       async def readline(self):
           ...

       def __aiter__(self):
           return self

       async def __anext__(self):
           val = await self.readline()
           if val == b'':
               raise StopAsyncIteration
           return val

バージョン 3.5 で追加.

バージョン 3.7 で変更: Python 3.7 より前では、 "__aiter__()" は *非同
期イテレータ* になる *awaitable* を返せました。Python 3.7 からは、
"__aiter__()" は非同期イテレータオブジェクトを返さなければなりません。
それ以外のものを返すと "TypeError" になります。


3.4.4. 非同期コンテキストマネージャ (Asynchronous Context Manager)
------------------------------------------------------------------

*非同期コンテキストマネージャ* は、 "__aenter__" メソッドと
"__aexit__" メソッド内部で実行を一時停止できる *コンテキストマネージャ
* です。

非同期コンテキストマネージャは "async with" 文の中で使えます。

object.__aenter__(self)

   文法的にはこのメソッドは "__enter__()" に似ていますが、 *待機可能オ
   ブジェクト* を返さなければならないところだけが異なります。

object.__aexit__(self, exc_type, exc_value, traceback)

   文法的にはこのメソッドは "__exit__()" に似ていますが、 *待機可能オ
   ブジェクト* を返さなければならないところだけが異なります。

非同期コンテキストマネージャクラスの例:

   class AsyncContextManager:
       async def __aenter__(self):
           await log('entering context')

       async def __aexit__(self, exc_type, exc, tb):
           await log('exiting context')

バージョン 3.5 で追加.

-[ 脚注 ]-

[1] 特定の条件が満たされた場合、オブジェクトの type を変更することが *
    できます* 。これは、正しく扱われなかった場合にとても奇妙な動作を引
    き起こすので、一般的には良い考えではありません。

[2] "__hash__()", "__iter__()", "__reversed__()", "__contains__()" メ
    ソッドはこのような特別な扱われ方をします; 他の特殊メソッドも
    "TypeError" を送出するかもしれませんが、これは "None" が呼び出し可
    能でないという振る舞いに基づいた動作です。

[3] ここでの "サポートしていない" というのは、クラスがそのメソッドを持
    っていないか、そのメソッドが "NotImplemented" を返すという意味です
    。 右の被演算子の対をなすメソッドへ処理を回したい場合には、メソッ
    ドに "None" を設定してはいけません—こうするとむしろ、処理を回すの
    を明示的に *妨げる* という正反対の効果を生みます。

[4] 同じ型の被演算子については、無反転のメソッド (たとえば
    "__add__()") が失敗した場合、その演算はサポートされていないとみな
    されます。これは、反射したメソッドが呼び出されない理由です。
