型オブジェクト
**************

新スタイルの型を定義する構造体: "PyTypeObject" 構造体は、おそらく
Python オブジェクトシステムの中で最も重要な構造体の1つでしょう。型オブ
ジェクトは "PyObject_*()" 系や "PyType_*()" 系の関数で扱えますが、ほと
んどの Python アプリケーションにとって、さして面白みのある機能を提供し
ません。型オブジェクトはオブジェクトがどのように振舞うかを決める基盤で
すから、インタプリタ自体や新たな型を定義する拡張モジュールでは非常に重
要な存在です。

型オブジェクトは標準の型 (standard type) に比べるとかなり大きな構造体
です。各型オブジェクトは多くの値を保持しており、そのほとんどは C 関数
へのポインタで、それぞれの関数はその型の機能の小さい部分を実装していま
す。この節では、型オブジェクトの各フィールドについて詳細を説明します。
各フィールドは、構造体内で出現する順番に説明されています。

以下のクイックリファレンスに加えて、 使用例 節では "PyTypeObject" の意
味と使い方を一目で理解できる例を載せています。


クイックリファレンス
====================


"tp slots"
----------

+--------------------+--------------------+--------------------+----+----+----+----+
| PyTypeObject Slot  | 型                 | 特殊メソッド/特殊  | Info [2]          |
| [1]                |                    | 属性               |                   |
|                    |                    |                    +----+----+----+----+
|                    |                    |                    | O  | T  | D  | I  |
|                    |                    |                    |    |    |    |    |
|====================|====================|====================|====|====|====|====|
| <R> "tp_name"      | const char *       | __name__           | X  | X  |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_basicsize"     | Py_ssize_t         |                    | X  | X  |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_itemsize"      | Py_ssize_t         |                    |    | X  |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_dealloc"       | "destructor"       |                    | X  | X  |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_vectorcall_of  | Py_ssize_t         |                    |    |    |    | ?  |
| fset"              |                    |                    |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| ("tp_getattr")     | "getattrfunc"      | __getattribute__,  |    |    |    | G  |
|                    |                    | __getattr__        |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| ("tp_setattr")     | "setattrfunc"      | __setattr__,       |    |    |    | G  |
|                    |                    | __delattr__        |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_as_async"      | "PyAsyncMethods" * | sub-slots          |    |    |    | %  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_repr"          | "reprfunc"         | __repr__           | X  | X  |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_as_number"     | "PyNumberMethods"  | sub-slots          |    |    |    | %  |
|                    | *                  |                    |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_as_sequence"   | "PySequenceMethod  | sub-slots          |    |    |    | %  |
|                    | s" *               |                    |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_as_mapping"    | "PyMappingMethods" | sub-slots          |    |    |    | %  |
|                    | *                  |                    |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_hash"          | "hashfunc"         | __hash__           | X  |    |    | G  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_call"          | "ternaryfunc"      | __call__           |    | X  |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_str"           | "reprfunc"         | __str__            | X  |    |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_getattro"      | "getattrofunc"     | __getattribute__,  | X  | X  |    | G  |
|                    |                    | __getattr__        |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_setattro"      | "setattrofunc"     | __setattr__,       | X  | X  |    | G  |
|                    |                    | __delattr__        |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_as_buffer"     | "PyBufferProcs" *  |                    |    |    |    | %  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_flags"         | unsigned long      |                    | X  | X  |    | ?  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_doc"           | const char *       | __doc__            | X  | X  |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_traverse"      | "traverseproc"     |                    |    | X  |    | G  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_clear"         | "inquiry"          |                    |    | X  |    | G  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_richcompare"   | "richcmpfunc"      | __lt__, __le__,    | X  |    |    | G  |
|                    |                    | __eq__, __ne__,    |    |    |    |    |
|                    |                    | __gt__, __ge__     |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_weaklistoffse  | Py_ssize_t         |                    |    | X  |    | ?  |
| t"                 |                    |                    |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_iter"          | "getiterfunc"      | __iter__           |    |    |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_iternext"      | "iternextfunc"     | __next__           |    |    |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_methods"       | "PyMethodDef" []   |                    | X  | X  |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_members"       | "PyMemberDef" []   |                    |    | X  |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_getset"        | "PyGetSetDef" []   |                    | X  | X  |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_base"          | "PyTypeObject" *   | __base__           |    |    | X  |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_dict"          | "PyObject" *       | __dict__           |    |    | ?  |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_descr_get"     | "descrgetfunc"     | __get__            |    |    |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_descr_set"     | "descrsetfunc"     | __set__,           |    |    |    | X  |
|                    |                    | __delete__         |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_dictoffset"    | Py_ssize_t         |                    |    | X  |    | ?  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_init"          | "initproc"         | __init__           | X  | X  |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_alloc"         | "allocfunc"        |                    | X  |    | ?  | ?  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_new"           | "newfunc"          | __new__            | X  | X  | ?  | ?  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_free"          | "freefunc"         |                    | X  | X  | ?  | ?  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_is_gc"         | "inquiry"          |                    |    | X  |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+
| <"tp_bases">       | "PyObject" *       | __bases__          |    |    | ~  |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| <"tp_mro">         | "PyObject" *       | __mro__            |    |    | ~  |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| ["tp_cache"]       | "PyObject" *       |                    |    |    |         |
+--------------------+--------------------+--------------------+----+----+----+----+
| ["tp_subclasses"]  | "PyObject" *       | __subclasses__     |    |    |         |
+--------------------+--------------------+--------------------+----+----+----+----+
| ["tp_weaklist"]    | "PyObject" *       |                    |    |    |         |
+--------------------+--------------------+--------------------+----+----+----+----+
| ("tp_del")         | "destructor"       |                    |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| ["tp_version_tag"] | unsigned int       |                    |    |    |         |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_finalize"      | "destructor"       | __del__            |    |    |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+

"COUNT_ALLOCS" が定義されている場合、次の (内部専用) フィールドも使え
ます:

* "tp_allocs"

* "tp_frees"

* "tp_maxalloc"

* "tp_prev"

* "tp_next"

[1] 丸括弧で囲われているスロット名は、それが (実質的に) 非推奨であるこ
    とを示しています。 山括弧で囲われているスロット名は、読み出し専用
    として扱われるべきです。 角括弧で囲われているスロット名は、内部で
    のみ使われます。 (接頭辞としての) "<R>" は、このフィールドが必須で
    あること ("NULL" でないこと) を意味します。

[2] 列:

    **"O"**:  set on "PyBaseObject_Type"

    **"T"**:  set on "PyType_Type"

    **"D"**:  default (if slot is set to "NULL")

       X - PyType_Ready sets this value if it is NULL
       ~ - PyType_Ready always sets this value (it should be NULL)
       ? - PyType_Ready may set this value depending on other slots

       Also see the inheritance column ("I").

    **"I"**:  inheritance

       X - type slot is inherited via PyType_Ready if defined with a NULL value
       % - the slots of the sub-struct are inherited individually
       G - inherited, but only in combination with other slots; see the slot's description
       ? - it's complicated; see the slot's description

    Note that some slots are effectively inherited through the normal
    attribute lookup chain.


sub-slots
---------

+----------------------------+-------------------+--------------+
| Slot                       | 型                | 特殊メソッド |
|============================|===================|==============|
| "am_await"                 | "unaryfunc"       | __await__    |
+----------------------------+-------------------+--------------+
| "am_aiter"                 | "unaryfunc"       | __aiter__    |
+----------------------------+-------------------+--------------+
| "am_anext"                 | "unaryfunc"       | __anext__    |
+----------------------------+-------------------+--------------+
|                                                               |
+----------------------------+-------------------+--------------+
| "nb_add"                   | "binaryfunc"      | __add__      |
|                            |                   | __radd__     |
+----------------------------+-------------------+--------------+
| "nb_inplace_add"           | "binaryfunc"      | __iadd__     |
+----------------------------+-------------------+--------------+
| "nb_subtract"              | "binaryfunc"      | __sub__      |
|                            |                   | __rsub__     |
+----------------------------+-------------------+--------------+
| "nb_inplace_subtract"      | "binaryfunc"      | __sub__      |
+----------------------------+-------------------+--------------+
| "nb_multiply"              | "binaryfunc"      | __mul__      |
|                            |                   | __rmul__     |
+----------------------------+-------------------+--------------+
| "nb_inplace_multiply"      | "binaryfunc"      | __mul__      |
+----------------------------+-------------------+--------------+
| "nb_remainder"             | "binaryfunc"      | __mod__      |
|                            |                   | __rmod__     |
+----------------------------+-------------------+--------------+
| "nb_inplace_remainder"     | "binaryfunc"      | __mod__      |
+----------------------------+-------------------+--------------+
| "nb_divmod"                | "binaryfunc"      | __divmod__   |
|                            |                   | __rdivmod__  |
+----------------------------+-------------------+--------------+
| "nb_power"                 | "ternaryfunc"     | __pow__      |
|                            |                   | __rpow__     |
+----------------------------+-------------------+--------------+
| "nb_inplace_power"         | "ternaryfunc"     | __pow__      |
+----------------------------+-------------------+--------------+
| "nb_negative"              | "unaryfunc"       | __neg__      |
+----------------------------+-------------------+--------------+
| "nb_positive"              | "unaryfunc"       | __pos__      |
+----------------------------+-------------------+--------------+
| "nb_absolute"              | "unaryfunc"       | __abs__      |
+----------------------------+-------------------+--------------+
| "nb_bool"                  | "inquiry"         | __bool__     |
+----------------------------+-------------------+--------------+
| "nb_invert"                | "unaryfunc"       | __invert__   |
+----------------------------+-------------------+--------------+
| "nb_lshift"                | "binaryfunc"      | __lshift__   |
|                            |                   | __rlshift__  |
+----------------------------+-------------------+--------------+
| "nb_inplace_lshift"        | "binaryfunc"      | __lshift__   |
+----------------------------+-------------------+--------------+
| "nb_rshift"                | "binaryfunc"      | __rshift__   |
|                            |                   | __rrshift__  |
+----------------------------+-------------------+--------------+
| "nb_inplace_rshift"        | "binaryfunc"      | __rshift__   |
+----------------------------+-------------------+--------------+
| "nb_and"                   | "binaryfunc"      | __and__      |
|                            |                   | __rand__     |
+----------------------------+-------------------+--------------+
| "nb_inplace_and"           | "binaryfunc"      | __and__      |
+----------------------------+-------------------+--------------+
| "nb_xor"                   | "binaryfunc"      | __xor__      |
|                            |                   | __rxor__     |
+----------------------------+-------------------+--------------+
| "nb_inplace_xor"           | "binaryfunc"      | __xor__      |
+----------------------------+-------------------+--------------+
| "nb_or"                    | "binaryfunc"      | __or__       |
|                            |                   | __ror__      |
+----------------------------+-------------------+--------------+
| "nb_inplace_or"            | "binaryfunc"      | __or__       |
+----------------------------+-------------------+--------------+
| "nb_int"                   | "unaryfunc"       | __int__      |
+----------------------------+-------------------+--------------+
| "nb_reserved"              | void *            |              |
+----------------------------+-------------------+--------------+
| "nb_float"                 | "unaryfunc"       | __float__    |
+----------------------------+-------------------+--------------+
| "nb_floor_divide"          | "binaryfunc"      | __floordiv__ |
+----------------------------+-------------------+--------------+
| "nb_inplace_floor_divide"  | "binaryfunc"      | __floordiv__ |
+----------------------------+-------------------+--------------+
| "nb_true_divide"           | "binaryfunc"      | __truediv__  |
+----------------------------+-------------------+--------------+
| "nb_inplace_true_divide"   | "binaryfunc"      | __truediv__  |
+----------------------------+-------------------+--------------+
| "nb_index"                 | "unaryfunc"       | __index__    |
+----------------------------+-------------------+--------------+
| "nb_matrix_multiply"       | "binaryfunc"      | __matmul__   |
|                            |                   | __rmatmul__  |
+----------------------------+-------------------+--------------+
| "nb_inplace_matrix_multip  | "binaryfunc"      | __matmul__   |
| ly"                        |                   |              |
+----------------------------+-------------------+--------------+
|                                                               |
+----------------------------+-------------------+--------------+
| "mp_length"                | "lenfunc"         | __len__      |
+----------------------------+-------------------+--------------+
| "mp_subscript"             | "binaryfunc"      | __getitem__  |
+----------------------------+-------------------+--------------+
| "mp_ass_subscript"         | "objobjargproc"   | __setitem__, |
|                            |                   | __delitem__  |
+----------------------------+-------------------+--------------+
|                                                               |
+----------------------------+-------------------+--------------+
| "sq_length"                | "lenfunc"         | __len__      |
+----------------------------+-------------------+--------------+
| "sq_concat"                | "binaryfunc"      | __add__      |
+----------------------------+-------------------+--------------+
| "sq_repeat"                | "ssizeargfunc"    | __mul__      |
+----------------------------+-------------------+--------------+
| "sq_item"                  | "ssizeargfunc"    | __getitem__  |
+----------------------------+-------------------+--------------+
| "sq_ass_item"              | "ssizeobjargproc" | __setitem__  |
|                            |                   | __delitem__  |
+----------------------------+-------------------+--------------+
| "sq_contains"              | "objobjproc"      | __contains__ |
+----------------------------+-------------------+--------------+
| "sq_inplace_concat"        | "binaryfunc"      | __iadd__     |
+----------------------------+-------------------+--------------+
| "sq_inplace_repeat"        | "ssizeargfunc"    | __imul__     |
+----------------------------+-------------------+--------------+
|                                                               |
+----------------------------+-------------------+--------------+
| "bf_getbuffer"             | "getbufferproc()" |              |
+----------------------------+-------------------+--------------+
| "bf_releasebuffer"         | "releasebufferpr  |              |
|                            | oc()"             |              |
+----------------------------+-------------------+--------------+


スロットの定義型 (typedef)
--------------------------

+-------------------------------+-------------------------------+------------------------+
| 定義型 (typedef)              | 引数型                        | 返り値型               |
|===============================|===============================|========================|
| "allocfunc"                   | "PyTypeObject" * Py_ssize_t   | "PyObject" *           |
+-------------------------------+-------------------------------+------------------------+
| "destructor"                  | void *                        | void                   |
+-------------------------------+-------------------------------+------------------------+
| "freefunc"                    | void *                        | void                   |
+-------------------------------+-------------------------------+------------------------+
| "traverseproc"                | void * "visitproc" void *     | int                    |
+-------------------------------+-------------------------------+------------------------+
| "newfunc"                     | "PyObject" * "PyObject" *     | "PyObject" *           |
|                               | "PyObject" *                  |                        |
+-------------------------------+-------------------------------+------------------------+
| "initproc"                    | "PyObject" * "PyObject" *     | int                    |
|                               | "PyObject" *                  |                        |
+-------------------------------+-------------------------------+------------------------+
| "reprfunc"                    | "PyObject" *                  | "PyObject" *           |
+-------------------------------+-------------------------------+------------------------+
| "getattrfunc"                 | "PyObject" * const char *     | "PyObject" *           |
+-------------------------------+-------------------------------+------------------------+
| "setattrfunc"                 | "PyObject" * const char *     | int                    |
|                               | "PyObject" *                  |                        |
+-------------------------------+-------------------------------+------------------------+
| "getattrofunc"                | "PyObject" * "PyObject" *     | "PyObject" *           |
+-------------------------------+-------------------------------+------------------------+
| "setattrofunc"                | "PyObject" * "PyObject" *     | int                    |
|                               | "PyObject" *                  |                        |
+-------------------------------+-------------------------------+------------------------+
| "descrgetfunc"                | "PyObject" * "PyObject" *     | "PyObject" *           |
|                               | "PyObject" *                  |                        |
+-------------------------------+-------------------------------+------------------------+
| "descrsetfunc"                | "PyObject" * "PyObject" *     | int                    |
|                               | "PyObject" *                  |                        |
+-------------------------------+-------------------------------+------------------------+
| "hashfunc"                    | "PyObject" *                  | Py_hash_t              |
+-------------------------------+-------------------------------+------------------------+
| "richcmpfunc"                 | "PyObject" * "PyObject" * int | "PyObject" *           |
+-------------------------------+-------------------------------+------------------------+
| "getiterfunc"                 | "PyObject" *                  | "PyObject" *           |
+-------------------------------+-------------------------------+------------------------+
| "iternextfunc"                | "PyObject" *                  | "PyObject" *           |
+-------------------------------+-------------------------------+------------------------+
| "lenfunc"                     | "PyObject" *                  | Py_ssize_t             |
+-------------------------------+-------------------------------+------------------------+
| "getbufferproc"               | "PyObject" * "Py_buffer" *    | int                    |
|                               | int                           |                        |
+-------------------------------+-------------------------------+------------------------+
| "releasebufferproc"           | "PyObject" * "Py_buffer" *    | void                   |
+-------------------------------+-------------------------------+------------------------+
| "inquiry"                     | void *                        | int                    |
+-------------------------------+-------------------------------+------------------------+
| "unaryfunc"                   | "PyObject" *                  | "PyObject" *           |
+-------------------------------+-------------------------------+------------------------+
| "binaryfunc"                  | "PyObject" * "PyObject" *     | "PyObject" *           |
+-------------------------------+-------------------------------+------------------------+
| "ternaryfunc"                 | "PyObject" * "PyObject" *     | "PyObject" *           |
|                               | "PyObject" *                  |                        |
+-------------------------------+-------------------------------+------------------------+
| "ssizeargfunc"                | "PyObject" * Py_ssize_t       | "PyObject" *           |
+-------------------------------+-------------------------------+------------------------+
| "ssizeobjargproc"             | "PyObject" * Py_ssize_t       | int                    |
+-------------------------------+-------------------------------+------------------------+
| "objobjproc"                  | "PyObject" * "PyObject" *     | int                    |
+-------------------------------+-------------------------------+------------------------+
| "objobjargproc"               | "PyObject" * "PyObject" *     | int                    |
|                               | "PyObject" *                  |                        |
+-------------------------------+-------------------------------+------------------------+

See Slot Type typedefs below for more detail.


PyTypeObject 定義
=================

"PyTypeObject" の構造体定義は "Include/object.h" で見つけられるはずで
す。参照の手間を省くために、ここでは定義を繰り返します:

   typedef struct _typeobject {
       PyObject_VAR_HEAD
       const char *tp_name; /* For printing, in format "<module>.<name>" */
       Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */

       /* Methods to implement standard operations */

       destructor tp_dealloc;
       Py_ssize_t tp_vectorcall_offset;
       getattrfunc tp_getattr;
       setattrfunc tp_setattr;
       PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2)
                                       or tp_reserved (Python 3) */
       reprfunc tp_repr;

       /* Method suites for standard classes */

       PyNumberMethods *tp_as_number;
       PySequenceMethods *tp_as_sequence;
       PyMappingMethods *tp_as_mapping;

       /* More standard operations (here for binary compatibility) */

       hashfunc tp_hash;
       ternaryfunc tp_call;
       reprfunc tp_str;
       getattrofunc tp_getattro;
       setattrofunc tp_setattro;

       /* Functions to access object as input/output buffer */
       PyBufferProcs *tp_as_buffer;

       /* Flags to define presence of optional/expanded features */
       unsigned long tp_flags;

       const char *tp_doc; /* Documentation string */

       /* call function for all accessible objects */
       traverseproc tp_traverse;

       /* delete references to contained objects */
       inquiry tp_clear;

       /* rich comparisons */
       richcmpfunc tp_richcompare;

       /* weak reference enabler */
       Py_ssize_t tp_weaklistoffset;

       /* Iterators */
       getiterfunc tp_iter;
       iternextfunc tp_iternext;

       /* Attribute descriptor and subclassing stuff */
       struct PyMethodDef *tp_methods;
       struct PyMemberDef *tp_members;
       struct PyGetSetDef *tp_getset;
       struct _typeobject *tp_base;
       PyObject *tp_dict;
       descrgetfunc tp_descr_get;
       descrsetfunc tp_descr_set;
       Py_ssize_t tp_dictoffset;
       initproc tp_init;
       allocfunc tp_alloc;
       newfunc tp_new;
       freefunc tp_free; /* Low-level free-memory routine */
       inquiry tp_is_gc; /* For PyObject_IS_GC */
       PyObject *tp_bases;
       PyObject *tp_mro; /* method resolution order */
       PyObject *tp_cache;
       PyObject *tp_subclasses;
       PyObject *tp_weaklist;
       destructor tp_del;

       /* Type attribute cache version tag. Added in version 2.6 */
       unsigned int tp_version_tag;

       destructor tp_finalize;

   } PyTypeObject;


PyObject スロット
=================

型オブジェクト構造体は "PyVarObject" 構造体を拡張したものです。
"ob_size" フィールドは、(通常 class 文が呼び出す "type_new()" で生成さ
れる) 動的な型に使います。 "PyType_Type" (メタタイプ) は "tp_itemsize"
を初期化するので注意してください。すなわち、 インスタンス (つまり型オ
ブジェクト) には "ob_size" フィールドが存在しなければ *なりません* 。

PyObject* PyObject._ob_next
PyObject* PyObject._ob_prev

   これらのフィールドはマクロ "Py_TRACE_REFS" が定義されている場合のみ
   存在します。 "PyObject_HEAD_INIT" マクロを使うと、フィールドを
   "NULL" に初期化します。静的にメモリ確保されているオブジェクトでは、
   これらのフィールドは常に "NULL" のままです。動的にメモリ確保される
   オブジェクトの場合、これら二つのフィールドは、ヒープ上の *全ての*
   存続中のオブジェクトからなる二重リンクリストでオブジェクトをリンク
   する際に使われます。このことは様々なデバッグ目的に利用できます; 現
   状では、環境変数 "PYTHONDUMPREFS" が設定されているときに、プログラ
   ムの実行終了時点で存続しているオブジェクトを出力するのが唯一の用例
   です。

   **継承:**

   サブタイプはこのフィールドを継承しません。

Py_ssize_t PyObject.ob_refcnt

   型オブジェクトの参照カウントで、 "PyObject_HEAD_INIT" はこの値を
   "1" に初期化します。静的にメモリ確保された型オブジェクトでは、型の
   インスタンス ("ob_type" が該当する型を指しているオブジェクト) は参
   照をカウントする対象には *なりません* 。動的にメモリ確保される型オ
   ブジェクトの場合、インスタンスは参照カウントの対象に *なります* 。

   **継承:**

   サブタイプはこのフィールドを継承しません。

PyTypeObject* PyObject.ob_type

   型自体の型、別の言い方をするとメタタイプです。 "PyObject_HEAD_INIT"
   マクロで初期化され、通常は "&PyType_Type" になります。しかし、(少な
   くとも) Windows で利用できる動的ロード可能な拡張モジュールでは、コ
   ンパイラは有効な初期化ではないと文句をつけます。そこで、ならわしと
   して、 "PyObject_HEAD_INIT" には "NULL" を渡して初期化しておき、他
   の操作を行う前にモジュールの初期化関数で明示的にこのフィールドを初
   期化することになっています。この操作は以下のように行います:

      Foo_Type.ob_type = &PyType_Type;

   上の操作は、該当する型のいかなるインスタンス生成よりも前にしておか
   なければなりません。 "PyType_Ready()" は "ob_type" が "NULL" かどう
   か調べ、 "NULL" の場合には基底クラスの "ob_type" フィールドで初期化
   します。 ob_type フィールドがゼロでない場合、 "PyType_Ready()" はこ
   のフィールドを変更しません。

   **継承:**

   サブタイプはこのフィールドを継承します。


PyVarObject スロット
====================

Py_ssize_t PyVarObject.ob_size

   静的にメモリ確保されている型オブジェクトの場合、このフィールドはゼ
   ロに初期化されます。動的にメモリ確保されている型オブジェクトの場合
   、このフィールドは内部使用される特殊な意味を持ちます。

   **継承:**

   サブタイプはこのフィールドを継承しません。


PyTypeObject スロット
=====================

Each slot has a section describing inheritance.  If "PyType_Ready()"
may set a value when the field is set to "NULL" then there will also
be a "Default" section.  (Note that many fields set on
"PyBaseObject_Type" and "PyType_Type" effectively act as defaults.)

const char* PyTypeObject.tp_name

   型の名前が入っている NUL 終端された文字列へのポインタです。モジュー
   ルのグローバル変数としてアクセスできる型の場合、この文字列は完全な
   モジュール名、ドット、そして型の名前と続く文字列になります; 組み込
   み型の場合、ただの型の名前です。モジュールがあるパッケージのサブモ
   ジュールの場合、完全なパッケージ名が完全なモジュール名の一部になっ
   ています。例えば、パッケージ "P" 内のサブモジュール "Q" に入ってい
   るモジュール "M" 内で定義されている "T" は、 "tp_name" を
   ""P.Q.M.T"" に初期化します。

   動的にメモリ確保される型オブジェクトの場合、このフィールドは単に型
   の名前になり、モジュール名は型の辞書内でキー "'__module__'" に対す
   る値として明示的に保存されます。

   静的にメモリ確保される型オブジェクトの場合、 tp_name フィールドには
   ドットが含まれているはずです。 最後のドットよりも前にある部分文字列
   全体は "__module__" 属性として、またドットよりも後ろにある部分は
   "__name__" 属性としてアクセスできます。

   ドットが入っていない場合、 "tp_name" フィールドの内容全てが
   "__name__" 属性になり、 "__module__" 属性は (前述のように型の辞書内
   で明示的にセットしないかぎり) 未定義になります。 このため、その型は
   pickle 化できないことになります。 さらに、 pydoc が作成するモジュー
   ルドキュメントのリストにも載らなくなります。

   This field must not be "NULL".  It is the only required field in
   "PyTypeObject()" (other than potentially "tp_itemsize").

   **継承:**

   サブタイプはこのフィールドを継承しません。

Py_ssize_t PyTypeObject.tp_basicsize
Py_ssize_t PyTypeObject.tp_itemsize

   これらのフィールドは、型インスタンスのバイトサイズを計算できるよう
   にします。

   型には二つの種類があります: 固定長インスタンスの型は、
   "tp_itemsize" フィールドがゼロで、可変長インスタンスの方は
   "tp_itemsize" フィールドが非ゼロの値になります。固定長インスタンス
   の型の場合、全てのインスタンスは等しく "tp_basicsize" で与えられた
   サイズになります。

   可変長インスタンスの型の場合、インスタンスには "ob_size"  フィール
   ドがなくてはならず、インスタンスのサイズは N をオブジェクトの "長さ
   " として、 "tp_basicsize" と "tp_itemsize" の N 倍を足したものにな
   ります。 N の値は通常、インスタンスの "ob_size"  フィールドに記憶さ
   れます。ただし例外がいくつかあります: 例えば、整数では負の値を
   "ob_size" に使って、インスタンスの表す値が負であることを示し、 N 自
   体は "abs(ob_size)" になります。また、 "ob_size" フィールドがあるか
   らといって、必ずしもインスタンスが可変長であることを意味しません (
   例えば、 リスト型の構造体は固定長のインスタンスになるにもかかわらず
   、インスタンスにはちゃんと意味を持った "ob_size" フィールドがありま
   す)。

   基本サイズには、 "PyObject_HEAD" マクロまたは  "PyObject_VAR_HEAD"
   マクロ (インスタンス構造体を宣言するのに使ったどちらかのマクロ) で
   宣言されているフィールドが入っています。さらに、 "_ob_prev" および
   "_ob_next" フィールドがある場合、これらのフィールドもサイズに加算さ
   れます。従って、 "tp_basicsize" の正しい初期化値を得るには、インス
   タンスデータのレイアウトを宣言するのに使う構造体に対して "sizeof"
   演算子を使うしかありません。基本サイズには、GC ヘッダサイズは入って
   いません。

   アラインメントに関する注釈: 変数の各要素を配置する際に特定のアライ
   ンメントが必要となる場合、 "tp_basicsize" の値に気をつけなければな
   りません。例: ある型が "double" の配列を実装しているとします。
   "tp_itemsize" は "sizeof(double)" です。 "tp_basicsize" が
   "sizeof(double)" (ここではこれを "double" のアラインメントが要求す
   るサイズと仮定する) の個数分のサイズになるようにするのはプログラマ
   の責任です。

   For any type with variable-length instances, this field must not be
   "NULL".

   **継承:**

   これらのフィールドはサブタイプに別々に継承されます。基底タイプが 0
   でない "tp_itemsize" を持っていた場合、基底タイプの実装に依存します
   が、一般的にはサブタイプで別の 0 で無い値を "tp_itemsize" に設定す
   るのは安全ではありません。

destructor PyTypeObject.tp_dealloc

   インスタンスのデストラクタ関数へのポインタです。この関数は (単量子
   "None" や "Ellipsis" の場合のように) インスタンスが決してメモリ解放
   されない型でない限り必ず定義しなければなりません。シグネチャは次の
   通りです:

      void tp_dealloc(PyObject *self);

   デストラクタ関数は、参照カウントが新たにゼロになった際に
   "Py_DECREF()" や "Py_XDECREF()" マクロから呼び出されます。呼び出さ
   れた時点では、インスタンスはまだ存在しますが、インスタンスに対する
   参照は全くない状態です。デストラクタ関数はインスタンスが保持してい
   る全ての参照を解放し、インスタンスが確保している全てのメモリバッフ
   ァを (バッファの確保時に使った関数に対応するメモリ解放関数を使って)
   解放し、その型の  "tp_free" 関数を呼び出します。ある型がサブタイプ
   を作成できない ("Py_TPFLAGS_BASETYPE" フラグがセットされていない)
   場合、 "tp_free" の代わりにオブジェクトのメモリ解放関数
   (deallocator) を直接呼び出してもかまいません。オブジェクトのメモリ
   解放関数は、インスタンスのメモリ確保を行う際に使った関数に対応した
   ものでなければなりません; インスタンスを "PyObject_New()" や
   "PyObject_VarNew()" でメモリ 確保した場合には、通常
   "PyObject_Del()" を使い、 "PyObject_GC_New()" や
   "PyObject_GC_NewVar()" で確保した場合には "PyObject_GC_Del()" を使
   います。

   Finally, if the type is heap allocated ("Py_TPFLAGS_HEAPTYPE"), the
   deallocator should decrement the reference count for its type
   object after calling the type deallocator. In order to avoid
   dangling pointers, the recommended way to achieve this is:

      static void foo_dealloc(foo_object *self) {
          PyTypeObject *tp = Py_TYPE(self);
          // free references and buffers here
          tp->tp_free(self);
          Py_DECREF(tp);
      }

   **継承:**

   サブタイプはこのフィールドを継承します。

Py_ssize_t PyTypeObject.tp_vectorcall_offset

   An optional offset to a per-instance function that implements
   calling the object using the *vectorcall* protocol, a more
   efficient alternative of the simpler "tp_call".

   This field is only used if the flag "_Py_TPFLAGS_HAVE_VECTORCALL"
   is set. If so, this must be a positive integer containing the
   offset in the instance of a "vectorcallfunc" pointer. The signature
   is the same as for "_PyObject_Vectorcall()":

      PyObject *vectorcallfunc(PyObject *callable, PyObject *const *args, size_t nargsf, PyObject *kwnames)

   The *vectorcallfunc* pointer may be zero, in which case the
   instance behaves as if "_Py_TPFLAGS_HAVE_VECTORCALL" was not set:
   calling the instance falls back to "tp_call".

   Any class that sets "_Py_TPFLAGS_HAVE_VECTORCALL" must also set
   "tp_call" and make sure its behaviour is consistent with the
   *vectorcallfunc* function. This can be done by setting *tp_call* to
   "PyVectorcall_Call":

   PyObject *PyVectorcall_Call(PyObject *callable, PyObject *tuple, PyObject *dict)

      Call *callable*'s *vectorcallfunc* with positional and keyword
      arguments given in a tuple and dict, respectively.

      This function is intended to be used in the "tp_call" slot. It
      does not fall back to "tp_call" and it currently does not check
      the "_Py_TPFLAGS_HAVE_VECTORCALL" flag. To call an object, use
      one of the "PyObject_Call" functions instead.

   注釈:

     It is not recommended for heap types to implement the vectorcall
     protocol. When a user sets "__call__" in Python code, only
     "tp_call" is updated, possibly making it inconsistent with the
     vectorcall function.

   注釈:

     The semantics of the "tp_vectorcall_offset" slot are provisional
     and expected to be finalized in Python 3.9. If you use
     vectorcall, plan for updating your code for Python 3.9.

   バージョン 3.8 で変更: This slot was used for print formatting in
   Python 2.x. In Python 3.0 to 3.7, it was reserved and named
   "tp_print".

   **継承:**

   This field is inherited by subtypes together with "tp_call": a
   subtype inherits "tp_vectorcall_offset" from its base type when the
   subtype’s "tp_call" is "NULL".

   Note that heap types (including subclasses defined in Python) do
   not inherit the "_Py_TPFLAGS_HAVE_VECTORCALL" flag.

getattrfunc PyTypeObject.tp_getattr

   オプションのポインタで、get-attribute-string を行う関数を指します。

   このフィールドは非推奨です。 このフィールドを定義するときは、
   "tp_getattro" 関数と同じように動作し、属性名は Python 文字列 オブジ
   ェクトではなく C 文字列で指定するような関数を指すようにしなければな
   りません。

   **継承:**

   Group: "tp_getattr", "tp_getattro"

   このフィールドは "tp_getattro" と共にサブタイプに継承されます: すな
   わち、サブタイプの "tp_getattr" および "tp_getattro" が共に "NULL"
   の場合、サブタイプは基底タイプから "tp_getattr" と "tp_getattro" を
   両方とも継承します。

setattrfunc PyTypeObject.tp_setattr

   オプションのポインタで、属性の設定と削除を行う関数を指します。

   このフィールドは非推奨です。 このフィールドを定義するときは、
   "tp_setattro" 関数と同じように動作し、属性名は Python 文字列 オブジ
   ェクトではなく C 文字列で指定するような関数を指すようにしなければな
   りません。

   **継承:**

   Group: "tp_setattr", "tp_setattro"

   このフィールドは "tp_setattro" と共にサブタイプに継承されます: すな
   わち、サブタイプの "tp_setattr" および "tp_setattro" が共に "NULL"
   の場合、サブタイプは基底タイプから "tp_setattr" と "tp_setattro" を
   両方とも継承します。

PyAsyncMethods* PyTypeObject.tp_as_async

   追加の構造体を指すポインタです。 この構造体は、 C レベルで
   *awaitable* プロトコルと *asynchronous iterator* プロトコルを実装す
   るオブジェクトだけに関係するフィールドを持ちます。 詳しいことは
   async オブジェクト構造体 を参照してください。

   バージョン 3.5 で追加: 以前は "tp_compare" や "tp_reserved" として
   知られていました。

   **継承:**

   "tp_as_async" フィールドは継承されませんが、これに含まれるフィール
   ドが個別に継承されます。

reprfunc PyTypeObject.tp_repr

   オプションのポインタで、組み込み関数 "repr()" を実装している関数を
   指します。

   The signature is the same as for "PyObject_Repr()":

      PyObject *tp_repr(PyObject *self);

   この関数は文字列オブジェクトか Unicode オブジェクトを返さなければな
   りません。理想的には、この関数が返す文字列は、適切な環境で "eval()"
   に渡した場合、同じ値を持つオブジェクトになるような文字列でなければ
   なりません。不可能な場合には、オブジェクトの型と値から導出した内容
   の入った "'<'" から始まって "'>'" で終わる文字列を返さなければなり
   ません。

   **継承:**

   サブタイプはこのフィールドを継承します。

   **デフォルト**

   このフィールドが設定されていない場合、 "<%s object at %p>" の形式を
   とる文字列が返されます。 "%s" は型の名前に、 "%p" はオブジェクトの
   メモリアドレスに置き換えられます。

PyNumberMethods* PyTypeObject.tp_as_number

   数値プロトコルを実装した追加の構造体を指すポインタです。これらのフ
   ィールドについては 数値オブジェクト構造体 で説明されています。

   **継承:**

   "tp_as_number" フィールドは継承されませんが、そこの含まれるフィール
   ドが個別に継承されます。

PySequenceMethods* PyTypeObject.tp_as_sequence

   シーケンスプロトコルを実装した追加の構造体を指すポインタです。これ
   らのフィールドについては シーケンスオブジェクト構造体 で説明されて
   います。

   **継承:**

   "tp_as_sequence" フィールドは継承されませんが、これに含まれるフィー
   ルドが個別に継承されます。

PyMappingMethods* PyTypeObject.tp_as_mapping

   マッピングプロトコルを実装した追加の構造体を指すポインタです。これ
   らのフィールドについては マップオブジェクト構造体 で説明されていま
   す。

   **継承:**

   "tp_as_mapping" フィールドは継承されませんが、これに含まれるフィー
   ルドが個別に継承されます。

hashfunc PyTypeObject.tp_hash

   オプションのポインタで、組み込み関数 "hash()" を実装している関数を
   指します。

   The signature is the same as for "PyObject_Hash()":

      Py_hash_t tp_hash(PyObject *);

   この関数は C の "long" 型の値を返さねばなりません。通常時には "-1"
   を戻り値にしてはなりません; ハッシュ値の計算中にエラーが生じた場合
   、関数は例外をセットして "-1" を返さねばなりません。

   When this field is not set (*and* "tp_richcompare" is not set), an
   attempt to take the hash of the object raises "TypeError". This is
   the same as setting it to "PyObject_HashNotImplemented()".

   このフィールドは明示的に "PyObject_HashNotImplemented()" に設定する
   ことで、親 type からのハッシュメソッドの継承をブロックすることがで
   きます。これは Python レベルでの "__hash__ = None" と同等に解釈され
   、 "isinstance(o, collections.Hashable)" が正しく "False" を返すよ
   うになります。逆もまた可能であることに注意してください - Python レ
   ベルで "__hash__ = None" を設定することで "tp_hash" スロットは
   "PyObject_HashNotImplemented()" に設定されます。

   **継承:**

   Group: "tp_hash", "tp_richcompare"

   このフィールドは "tp_richcompare" と共にサブタイプに継承されます:
   すなわち、サブタイプの "tp_richcompare" および "tp_hash" が両方とも
   "NULL" のとき、サブタイプは基底タイプから "tp_richcompare" と
   "tp_hash" を両方とも継承します。

ternaryfunc PyTypeObject.tp_call

   オプションのポインタで、オブジェクトの呼び出しを実装している関数を
   指します。オブジェクトが呼び出し可能でない場合には "NULL" にしなけ
   ればなりません。シグネチャは "PyObject_Call()" と同じです。

      PyObject *tp_call(PyObject *self, PyObject *args, PyObject *kwargs);

   **継承:**

   サブタイプはこのフィールドを継承します。

reprfunc PyTypeObject.tp_str

   オプションのポインタで、組み込みの演算 "str()" を実装している関数を
   指します。("str" が型の一つになったため、 "str()" は "str" のコンス
   トラクタを呼び出すことに注意してください。このコンストラクタは実際
   の処理を行う上で "PyObject_Str()" を呼び出し、さらに
   "PyObject_Str()" がこのハンドラを呼び出すことになります。)

   The signature is the same as for "PyObject_Str()":

      PyObject *tp_str(PyObject *self);

   この関数は文字列オブジェクトか Unicode オブジェクトを返さなければな
   りません。それはオブジェクトを "分かりやすく (friendly)" 表現した文
   字列でなければなりません。というのは、この文字列はとりわけ
   "print()" 関数で使われることになる表記だからです。

   **継承:**

   サブタイプはこのフィールドを継承します。

   **デフォルト**

   このフィールドが設定されていない場合、文字列表現を返すためには
   "PyObject_Repr()" が呼び出されます。

getattrofunc PyTypeObject.tp_getattro

   オプションのポインタで、get-attribute を実装している関数を指します
   。

   The signature is the same as for "PyObject_GetAttr()":

      PyObject *tp_getattro(PyObject *self, PyObject *attr);

   通常の属性検索を実装している "PyObject_GenericGetAttr()"  をこのフ
   ィールドに設定しておくとたいていの場合は便利です。

   **継承:**

   Group: "tp_getattr", "tp_getattro"

   このフィールドは "tp_getattr" と共にサブタイプに継承されます: すな
   わち、サブタイプの "tp_getattr" および "tp_getattro" が共に "NULL"
   の場合、サブタイプは基底タイプから "tp_getattr" と "tp_getattro" を
   両方とも継承します。

   **デフォルト**

   "PyBaseObject_Type" uses "PyObject_GenericGetAttr()".

setattrofunc PyTypeObject.tp_setattro

   オプションのポインタで、属性の設定と削除を行う関数を指します。

   The signature is the same as for "PyObject_SetAttr()":

      PyObject *tp_setattro(PyObject *self, PyObject *attr, PyObject *value);

   さらに、*value* に "NULL" を指定して属性を削除できるようにしなけれ
   ばなりません。 通常のオブジェクト属性設定を実装している
   "PyObject_GenericSetAttr()"  をこのフィールドに設定しておくとたいて
   いの場合は便利です。

   **継承:**

   Group: "tp_setattr", "tp_setattro"

   このフィールドは "tp_setattr" と共にサブタイプに継承されます: すな
   わち、サブタイプの "tp_setattr" および "tp_setattro" が共に "NULL"
   の場合、サブタイプは基底タイプから "tp_setattr" と "tp_setattro" を
   両方とも継承します。

   **デフォルト**

   "PyBaseObject_Type" uses "PyObject_GenericSetAttr()".

PyBufferProcs* PyTypeObject.tp_as_buffer

   バッファインタフェースを実装しているオブジェクトにのみ関連する、一
   連のフィールド群が入った別の構造体を指すポインタです。構造体内の各
   フィールドは バッファオブジェクト構造体 (buffer object structure)
   で説明します。

   **継承:**

   "tp_as_buffer" フィールド自体は継承されませんが、これに含まれるフィ
   ールドは個別に継承されます。

unsigned long PyTypeObject.tp_flags

   このフィールドは様々なフラグからなるビットマスクです。いくつかのフ
   ラグは、特定の状況において変則的なセマンティクスが適用されることを
   示します; その他のフラグは、型オブジェクト (あるいは "tp_as_number"
   、 "tp_as_sequence" 、 "tp_as_mapping" 、 および "tp_as_buffer" が
   参照している拡張機能構造体) の特定のフィールドのうち、過去から現在
   までずっと存在していたわけではないものが有効になっていることを示す
   ために使われます; フラグビットがクリアされていれば、フラグが保護し
   ているフィールドにはアクセスしない代わりに、その値はゼロか "NULL"
   になっているとみなさなければなりません。

   **継承:**

   このフィールドの継承は込み入っています。ほとんどのフラグは個別に継
   承されます。すなわち、基底タイプのフラグビットが設定されていたら、
   サブタイプのフラグビットもそれを引き継ぎます。拡張機能構造体が継承
   される場合は、拡張機能構造体に関係するフラグビットは厳密に継承され
   ます。すなわち、基底タイプのフラグビットの値は、拡張機能構造体への
   ポインタと共に、サブタイプにコピーされます。 "Py_TPFLAGS_HAVE_GC"
   フラグビットは "tp_traverse" フィールドと "tp_clear" フィールドと共
   に継承されます。すなわち、サブタイプにおいて、 "Py_TPFLAGS_HAVE_GC"
   フラグビットがクリアされていて、 "tp_traverse" フィールドと
   "tp_clear" フィールドが存在し "NULL" になっている場合に継承されます
   。

   **デフォルト**

   "PyBaseObject_Type" uses "Py_TPFLAGS_DEFAULT |
   Py_TPFLAGS_BASETYPE".

   **Bit Masks:**

   以下に挙げるビットマスクは現在定義されているものです; フラグは "|"
   演算子で論理和を取って "tp_flags" フィールドの値を作成できます。
   "PyType_HasFeature()" マクロは型とフラグ値、 *tp* および *f* をとり
   、 "tp->tp_flags & f" が非ゼロかどうか調べます。

   Py_TPFLAGS_HEAPTYPE

      This bit is set when the type object itself is allocated on the
      heap, for example, types created dynamically using
      "PyType_FromSpec()".  In this case, the "ob_type" field of its
      instances is considered a reference to the type, and the type
      object is INCREF'ed when a new instance is created, and
      DECREF'ed when an instance is destroyed (this does not apply to
      instances of subtypes; only the type referenced by the
      instance's ob_type gets INCREF'ed or DECREF'ed).

      **継承:**

      ???

   Py_TPFLAGS_BASETYPE

      型を別の型の基底タイプとして使える場合にセットされるビットです。
      このビットがクリアならば、この型のサブタイプは生成できません
      (Java における "final" クラスに似たクラスになります)。

      **継承:**

      ???

   Py_TPFLAGS_READY

      型オブジェクトが "PyType_Ready()" で完全に初期化されるとセットさ
      れるビットです。

      **継承:**

      ???

   Py_TPFLAGS_READYING

      "PyType_Ready()" による型オブジェクトの初期化処理中にセットされ
      るビットです。

      **継承:**

      ???

   Py_TPFLAGS_HAVE_GC

      オブジェクトがガベージコレクション (GC) をサポートする場合にセッ
      トされるビットです。このビットがセットされている場合、インスタン
      スは "PyObject_GC_New()" を使って生成し、 "PyObject_GC_Del()" を
      使って破棄しなければなりません。詳しい情報は 循環参照ガベージコ
      レクションをサポートする にあります。このビットは、GC に関連する
      フィールド "tp_traverse" および "tp_clear" が型オブジェクト内に
      存在することも示しています。

      **継承:**

      Group: "Py_TPFLAGS_HAVE_GC", "tp_traverse", "tp_clear"

      The "Py_TPFLAGS_HAVE_GC" flag bit is inherited together with the
      "tp_traverse" and "tp_clear" fields, i.e.  if the
      "Py_TPFLAGS_HAVE_GC" flag bit is clear in the subtype and the
      "tp_traverse" and "tp_clear" fields in the subtype exist and
      have "NULL" values.

   Py_TPFLAGS_DEFAULT

      型オブジェクトおよび拡張機能構造体の特定のフィールドの存在の有無
      に関連する全てのビットからなるビットマスクです。現状では、このビ
      ットマスクには以下のビット:
      "Py_TPFLAGS_HAVE_STACKLESS_EXTENSION" および
      "Py_TPFLAGS_HAVE_VERSION_TAG" が入っています。

      **継承:**

      ???

   Py_TPFLAGS_METHOD_DESCRIPTOR

      This bit indicates that objects behave like unbound methods.

      If this flag is set for "type(meth)", then:

      * "meth.__get__(obj, cls)(*args, **kwds)" (with "obj" not None)
        must be equivalent to "meth(obj, *args, **kwds)".

      * "meth.__get__(None, cls)(*args, **kwds)" must be equivalent to
        "meth(*args, **kwds)".

      This flag enables an optimization for typical method calls like
      "obj.meth()": it avoids creating a temporary "bound method"
      object for "obj.meth".

      バージョン 3.8 で追加.

      **継承:**

      This flag is never inherited by heap types. For extension types,
      it is inherited whenever "tp_descr_get" is inherited.

   Py_TPFLAGS_LONG_SUBCLASS

   Py_TPFLAGS_LIST_SUBCLASS

   Py_TPFLAGS_TUPLE_SUBCLASS

   Py_TPFLAGS_BYTES_SUBCLASS

   Py_TPFLAGS_UNICODE_SUBCLASS

   Py_TPFLAGS_DICT_SUBCLASS

   Py_TPFLAGS_BASE_EXC_SUBCLASS

   Py_TPFLAGS_TYPE_SUBCLASS

      これらのフラグは "PyLong_Check()" のような関数が、型がとある組み
      込み型のサブクラスかどうかを素早く判断するのに使われます; この専
      用のチェックは "PyObject_IsInstance()" のような汎用的なチェック
      よりも高速です。 組み込み型を継承した独自の型では "tp_flags" を
      適切に設定すべきで、そうしないとその型が関わるコードでは、どんな
      チェックの方法が使われるかによって振る舞いが異なってしまうでしょ
      う。

   Py_TPFLAGS_HAVE_FINALIZE

      型構造体に "tp_finalize" スロットが存在しているときにセットされ
      るビットです。

      バージョン 3.4 で追加.

      バージョン 3.8 で非推奨: This flag isn't necessary anymore, as
      the interpreter assumes the "tp_finalize" slot is always present
      in the type structure.

   _Py_TPFLAGS_HAVE_VECTORCALL

      This bit is set when the class implements the vectorcall
      protocol. See "tp_vectorcall_offset" for details.

      **継承:**

      This bit is set on *static* subtypes if "tp_flags" is not
      overridden: a subtype inherits "_Py_TPFLAGS_HAVE_VECTORCALL"
      from its base type when the subtype’s "tp_call" is "NULL" and
      the subtype's "Py_TPFLAGS_HEAPTYPE" is not set.

      Heap types do not inherit "_Py_TPFLAGS_HAVE_VECTORCALL".

      注釈:

        This flag is provisional and expected to become public in
        Python 3.9, with a different name and, possibly, changed
        semantics. If you use vectorcall, plan for updating your code
        for Python 3.9.

      バージョン 3.8 で追加.

const char* PyTypeObject.tp_doc

   オプションのポインタで、この型オブジェクトの docstring を与える NUL
   終端された C の文字列を指します。この値は型オブジェクトと型のインス
   タンスにおける "__doc__" 属性として公開されます。

   **継承:**

   サブタイプはこのフィールドを継承 *しません* 。

traverseproc PyTypeObject.tp_traverse

   An optional pointer to a traversal function for the garbage
   collector.  This is only used if the "Py_TPFLAGS_HAVE_GC" flag bit
   is set.  The signature is:

      int tp_traverse(PyObject *self, visitproc visit, void *arg);

   Pythonのガベージコレクションの仕組みについての詳細は、 循環参照ガベ
   ージコレクションをサポートする にあります。

   The "tp_traverse" pointer is used by the garbage collector to
   detect reference cycles. A typical implementation of a
   "tp_traverse" function simply calls "Py_VISIT()" on each of the
   instance's members that are Python objects that the instance owns.
   For example, this is function "local_traverse()" from the "_thread"
   extension module:

      static int
      local_traverse(localobject *self, visitproc visit, void *arg)
      {
          Py_VISIT(self->args);
          Py_VISIT(self->kw);
          Py_VISIT(self->dict);
          return 0;
      }

   "Py_VISIT()" が循環参照になる恐れのあるメンバにだけ呼び出されている
   ことに注目してください。 "self->key" メンバもありますが、それは
   "NULL" か Python文字列なので、循環参照の一部になることはありません
   。

   一方、メンバが循環参照の一部になり得ないと判っていても、デバッグ目
   的で巡回したい場合があるかもしれないので、 "gc" モジュールの
   "get_referents()" 関数は循環参照になり得ないメンバも返します。

   警告:

     When implementing "tp_traverse", only the members that the
     instance *owns* (by having strong references to them) must be
     visited. For instance, if an object supports weak references via
     the "tp_weaklist" slot, the pointer supporting the linked list
     (what *tp_weaklist* points to) must **not** be visited as the
     instance does not directly own the weak references to itself (the
     weakreference list is there to support the weak reference
     machinery, but the instance has no strong reference to the
     elements inside it, as they are allowed to be removed even if the
     instance is still alive).

   "Py_VISIT()" は "local_traverse()" が *visit* と *arg* という決まっ
   た名前の引数を持つことを要求します。

   **継承:**

   Group: "Py_TPFLAGS_HAVE_GC", "tp_traverse", "tp_clear"

   このフィールドは "tp_clear" および "Py_TPFLAGS_HAVE_GC" フラグビッ
   トと共にサブタイプに継承されます: すなわち、サブタイプの
   "tp_traverse" および "tp_clear" が両方ともゼロの場合、サブタイプは
   基底タイプから "tp_traverse" と "tp_clear" を両方とも継承します。

inquiry PyTypeObject.tp_clear

   オプションのポインタで、ガベージコレクタにおける消去関数 (clear
   function) を指します。 "Py_TPFLAGS_HAVE_GC" がセットされている場合
   にのみ使われます。シグネチャは次の通りです:

      int tp_clear(PyObject *);

   "tp_clear" メンバ関数は GC が検出した循環しているゴミの循環参照を壊
   すために用いられます。総合的な視点で考えると、システム内の全ての
   "tp_clear" 関数が連携して、全ての循環参照を破壊しなければなりません
   。 (訳注: ある型が "tp_clear" を実装しなくても全ての循環参照が破壊
   できるのであれば実装しなくても良い) これはとても繊細で、もし少しで
   も不確かな部分があるのであれば、 "tp_clear" 関数を提供するべきです
   。例えば、タプルは "tp_clear" を実装しません。なぜなら、タプルだけ
   で構成された循環参照がみつかることは無いからです。従って、タプル以
   外の型の "tp_clear" 関数だけで、タプルを含むどんな循環参照も必ず破
   壊できることになります。これは簡単に判ることではなく、 "tp_clear"
   の実装を避ける良い理由はめったにありません。

   次の例にあるように、 "tp_clear" の実装は、インスタンスから Python
   オブジェクトだと思われるメンバへの参照を外し、それらのメンバへのポ
   インタに "NULL" をセットすべきです:

      static int
      local_clear(localobject *self)
      {
          Py_CLEAR(self->key);
          Py_CLEAR(self->args);
          Py_CLEAR(self->kw);
          Py_CLEAR(self->dict);
          return 0;
      }

   参照のクリアはデリケートなので、 "Py_CLEAR()" マクロを使うべきです:
   ポインタを "NULL" にセットするまで、そのオブジェクトの参照カウント
   をデクリメントしてはいけません。参照カウントのデクリメントすると、
   そのオブジェクトが破棄されるかもしれず、 (そのオブジェクトに関連付
   けられたファイナライザ、弱参照のコールバックにより) 任意のPythonコ
   ードの実行を含む後片付け処理が実行されるかもしれないからです。もし
   そういったコードが再び *self* を参照することがあれば、すでに持って
   いたオブジェクトへのポインタは "NULL" になっているので、 *self* は
   所有していたオブジェクトをもう利用できないことを認識できます。
   "Py_CLEAR()" マクロはその手続きを安全な順番で実行します。

   "tp_clear" 関数の目的は参照カウントを破壊することなので、 Python 文
   字列や Python 整数のような、循環参照に含むことのできないオブジェク
   トをクリアする必要はありません。一方、所有する全ての Python オブジ
   ェクトをクリアするようにし、その型の "tp_dealloc" 関数が "tp_clear"
   関数を実行するようにすると実装が楽になるでしょう。

   Pythonのガベージコレクションの仕組みについての詳細は、 循環参照ガベ
   ージコレクションをサポートする にあります。

   **継承:**

   Group: "Py_TPFLAGS_HAVE_GC", "tp_traverse", "tp_clear"

   このフィールドは "tp_traverse" および "Py_TPFLAGS_HAVE_GC" フラグビ
   ットと共にサブタイプに継承されます: すなわち、サブタイプの
   "tp_traverse" および "tp_clear" が両方ともゼロの場合、サブタイプは
   基底タイプから "tp_traverse" と "tp_clear" を両方とも継承します。

richcmpfunc PyTypeObject.tp_richcompare

   オプションのポインタで、拡張比較関数を指します。シグネチャは次の通
   りです:

      PyObject *tp_richcompare(PyObject *self, PyObject *other, int op);

   The first parameter is guaranteed to be an instance of the type
   that is defined by "PyTypeObject".

   この関数は、比較結果を返すべきです。(普通は "Py_True" か "Py_False"
   です。) 比較が未定義の場合は、"Py_NotImplemented" を、それ以外のエ
   ラーが発生した場合には例外状態をセットして "NULL" を返さなければな
   りません。

   "tp_richcompare" および "PyObject_RichCompare()" 関数の第三引数に使
   うための定数としては以下が定義されています:

   +------------------+--------------+
   | 定数             | 比較         |
   |==================|==============|
   | "Py_LT"          | "<"          |
   +------------------+--------------+
   | "Py_LE"          | "<="         |
   +------------------+--------------+
   | "Py_EQ"          | "=="         |
   +------------------+--------------+
   | "Py_NE"          | "!="         |
   +------------------+--------------+
   | "Py_GT"          | ">"          |
   +------------------+--------------+
   | "Py_GE"          | ">="         |
   +------------------+--------------+

   拡張比較関数(rich comparison functions)を簡単に記述するためのマクロ
   が定義されています:

   Py_RETURN_RICHCOMPARE(VAL_A, VAL_B, op)

      比較した結果に応じて >>``<<Py_True` か *Py_False* を返します。
      VAL_A と VAL_B は C の比較演算によって順序付け可能でなければなり
      ません（例えばこれらは C言語の整数か浮動小数点数になるでしょう）
      。三番目の引数には "PyObject_RichCompare()" と同様に要求された演
      算を指定します。

      返り値の参照カウントは適切にインクリメントされます。

      エラー時には、例外を設定して、関数から "NULL" でリターンします。

      バージョン 3.7 で追加.

   **継承:**

   Group: "tp_hash", "tp_richcompare"

   このフィールドは "tp_hash" と共にサブタイプに継承されます: すなわち
   、サブタイプの "tp_richcompare" および "tp_hash" が両方とも "NULL"
   のとき、サブタイプは基底タイプから "tp_richcompare" と "tp_hash" を
   両方とも継承します。

   **デフォルト**

   "PyBaseObject_Type" provides a "tp_richcompare" implementation,
   which may be inherited.  However, if only "tp_hash" is defined, not
   even the inherited function is used and instances of the type will
   not be able to participate in any comparisons.

Py_ssize_t PyTypeObject.tp_weaklistoffset

   If the instances of this type are weakly referenceable, this field
   is greater than zero and contains the offset in the instance
   structure of the weak reference list head (ignoring the GC header,
   if present); this offset is used by "PyObject_ClearWeakRefs()" and
   the "PyWeakref_*()" functions.  The instance structure needs to
   include a field of type "PyObject*" which is initialized to "NULL".

   このフィールドを "tp_weaklist" と混同しないようにしてください; これ
   は型オブジェクト自身への弱参照からなるリストの先頭です。

   **継承:**

   このフィールドはサブタイプに継承されますが、以下の規則を読んでくだ
   さい。サブタイプはこのオフセット値をオーバライドすることがあります;
   従って、サブタイプでは弱参照リストの先頭が基底タイプとは異なる場合
   があります。リストの先頭は常に "tp_weaklistoffset" で分かるはずなの
   で、このことは問題にはならないはずです。

   "class" 文で定義された型に "__slots__" 宣言が全くなく、かつ基底タイ
   プが弱参照可能でない場合、その型を弱参照可能にするには弱参照リスト
   の先頭を表すスロットをインスタンスデータレイアウト構造体に追加し、
   スロットのオフセットを "tp_weaklistoffset" に設定します。

   型の "__slots__" の宣言に "__weakref__" という名前のスロットが含ま
   れているとき、スロットはその型のインスタンスにおける弱参照リストの
   先頭を表すスロットになり、スロットのオフセットが型の
   "tp_weaklistoffset" に入ります。

   型の "__slots__" 宣言が "__weakref__" という名前のスロットを含んで
   いないとき、その型は基底タイプから "tp_weaklistoffset" を継承します
   。

getiterfunc PyTypeObject.tp_iter

   オプションの変数で、そのオブジェクトのイテレータを返す関数へのポイ
   ンタです。この値が存在することは、通常この型のインスタンスがイテレ
   ート可能であることを示しています (しかし、シーケンスはこの関数がな
   くてもイテレート可能です)。

   この関数は "PyObject_GetIter()" と同じシグネチャを持っています:

      PyObject *tp_iter(PyObject *self);

   **継承:**

   サブタイプはこのフィールドを継承します。

iternextfunc PyTypeObject.tp_iternext

   オプションのポインタで、イテレーターの次の要素を返す関数を指します
   。シグネチャは次の通りです:

      PyObject *tp_iternext(PyObject *self);

   イテレータの要素がなくなると、この関数は "NULL" を返さなければなり
   ません。 "StopIteration" 例外は設定してもしなくても良いです。その他
   のエラーが発生したときも、 "NULL" を返さなければなりません。このフ
   ィールドがあると、この型のインスタンスがイテレータであることを示し
   ます。

   イテレータ型では、 "tp_iter" 関数も定義されていなければならず、その
   関数は (新たなイテレータインスタンスではなく) イテレータインスタン
   ス自体を返さねばなりません。

   この関数のシグネチャは "PyIter_Next()" と同じです。

   **継承:**

   サブタイプはこのフィールドを継承します。

struct PyMethodDef* PyTypeObject.tp_methods

   オプションのポインタで、この型の正規 (regular) のメソッドを宣言して
   いる "PyMethodDef" 構造体からなる、 "NULL" で終端された静的な配列を
   指します。

   配列の各要素ごとに、メソッドデスクリプタの入った、要素が型の辞書 (
   下記の "tp_dict" 参照) に追加されます。

   **継承:**

   サブタイプはこのフィールドを継承しません (メソッドは別個のメカニズ
   ムで継承されています)。

struct PyMemberDef* PyTypeObject.tp_members

   オプションのポインタで、型の正規 (regular) のデータメンバ (フィール
   ドおよびスロット) を宣言している "PyMemberDef" 構造体からなる、
   "NULL" で終端された静的な配列を指します。

   配列の各要素ごとに、メンバデスクリプタの入った要素が型の辞書 (下記
   の "tp_dict" 参照) に追加されます。

   **継承:**

   サブタイプはこのフィールドを継承しません (メンバは別個のメカニズム
   で継承されています)。

struct PyGetSetDef* PyTypeObject.tp_getset

   オプションのポインタで、インスタンスの算出属性 (computed attribute)
   を宣言している "PyGetSetDef" 構造体からなる、 "NULL" で終端された静
   的な配列を指します。

   配列の各要素ごとに、 getter/setter デスクリプタの入った、要素が型の
   辞書 (下記の "tp_dict" 参照) に追加されます。

   **継承:**

   サブタイプはこのフィールドを継承しません (算出属性は別個のメカニズ
   ムで継承されています)。

PyTypeObject* PyTypeObject.tp_base

   オプションのポインタで、型に関するプロパティを継承する基底タイプを
   指します。このフィールドのレベルでは、単継承 (single inheritance)
   だけがサポートされています; 多重継承はメタタイプの呼び出しによる動
   的な型オブジェクトの生成を必要とします。

   注釈:

     Slot initialization is subject to the rules of initializing
     globals. C99 requires the initializers to be "address constants".
     Function designators like "PyType_GenericNew()", with implicit
     conversion to a pointer, are valid C99 address constants.However,
     the unary '&' operator applied to a non-static variable like
     "PyBaseObject_Type()" is not required to produce an address
     constant.  Compilers may support this (gcc does), MSVC does not.
     Both compilers are strictly standard conforming in this
     particular behavior.Consequently, "tp_base" should be set in the
     extension module's init function.

   **継承:**

   (当たり前ですが) サブタイプはこのフィールドを継承しません。

   **デフォルト**

   このフィールドのデフォルト値は (Python プログラマは "object" 型とし
   て知っている) "&PyBaseObject_Type" になります。

PyObject* PyTypeObject.tp_dict

   型の辞書は "PyType_Ready()" によってこのフィールドに収められます。

   このフィールドは通常、 "PyType_Ready()" を呼び出す前に "NULL" に初
   期化しておかなければなりません; あるいは、型の初期属性の入った辞書
   で初期化しておいてもかまいません。 "PyType_Ready()" が型をひとたび
   初期化すると、型の新たな属性をこの辞書に追加できるのは、属性が
   ("__add__()" のような) オーバロード用演算でないときだけです。

   **継承:**

   サブタイプはこのフィールドを継承しません (が、この辞書内で定義され
   ている属性は異なるメカニズムで継承されます)。

   **デフォルト**

   If this field is "NULL", "PyType_Ready()" will assign a new
   dictionary to it.

   警告:

     "tp_dict" に "PyDict_SetItem()" を使ったり、辞書 C-API で編集する
     のは安全ではありません。

descrgetfunc PyTypeObject.tp_descr_get

   オプションのポインタで、デスクリプタの get 関数を指します。

   関数のシグネチャは次のとおりです

      PyObject * tp_descr_get(PyObject *self, PyObject *obj, PyObject *type);

   **継承:**

   サブタイプはこのフィールドを継承します。

descrsetfunc PyTypeObject.tp_descr_set

   オプションのポインタで、デスクリプタの値の設定と削除を行う関数を指
   します。

   関数のシグネチャは次のとおりです

      int tp_descr_set(PyObject *self, PyObject *obj, PyObject *value);

   値を削除するには、*value* 引数に "NULL" を設定します。

   **継承:**

   サブタイプはこのフィールドを継承します。

Py_ssize_t PyTypeObject.tp_dictoffset

   型のインスタンスにインスタンス変数の入った辞書がある場合、このフィ
   ールドは非ゼロの値になり、型のインスタンスデータ構造体におけるイン
   スタンス変数辞書へのオフセットが入ります; このオフセット値は
   "PyObject_GenericGetAttr()" が使います。

   このフィールドを "tp_dict" と混同しないようにしてください; これは型
   オブジェクト自身の属性の辞書です。

   このフィールドの値がゼロより大きければ、値はインスタンス構造体の先
   頭からの オフセットを表します。値がゼロより小さければ、インスタンス
   構造体の *末尾* からのオフセットを表します。負のオフセットを使うコ
   ストは比較的高くつくので、 インスタンス構造体に可変長部分があるとき
   のみ使うべきです。例えば、 "str" や "tuple" のサブタイプにインスタ
   ンス変数の辞書を追加する場合には、負のオフセットを使います。この場
   合、たとえ辞書が基本のオブジェクトレイアウトに含まれていなくても、
   "tp_basicsize" フィールドは追加された辞書を考慮にいれなければならな
   いことに注意してください。ポインタサイズが 4 バイトのシステムでは、
   構造体の最後尾に辞書が宣言されていることを示す場合、
   "tp_dictoffset" を "-4" にしなければなりません。

   負の "tp_dictoffset" から、インスタンスでの実際のオフセットを計算す
   るには以下のようにします:

      dictoffset = tp_basicsize + abs(ob_size)*tp_itemsize + tp_dictoffset
      if dictoffset is not aligned on sizeof(void*):
          round up to sizeof(void*)

   ここで、 "tp_basicsize"、 "tp_itemsize" および "tp_dictoffset" は型
   オブジェクトから取り出され、 "ob_size" はインスタンスから取り出され
   ます。 絶対値を取っているのは、整数は符号を記憶するのに "ob_size"
   の符号を使うためです。 (この計算を自分で行う必要はまったくありませ
   ん; 計算は "_PyObject_GetDictPtr()" がやってくれます。)

   **継承:**

   このフィールドはサブタイプに継承されますが、以下の規則を読んでくだ
   さい。サブタイプはこのオフセット値をオーバライドすることがあります;
   従って、サブタイプでは辞書のオフセットが基底タイプとは異なる場合が
   あります。辞書のオフセットは常に "tp_dictoffset" で分かるはずなので
   、このことは問題にはならないはずです。

   "class" 文で定義された型に "__slots__" 宣言がなく、かつ基底タイプの
   全てにインスタンス変数辞書がない場合、辞書のスロットをインスタンス
   データレイアウト構造体に追加し、スロットのオフセットを
   "tp_dictoffset" に設定します。

   "class" 文で定義された型に "__slots__" 宣言がある場合、この型は基底
   タイプから "tp_dictoffset" を継承します。

   ("__dict__" という名前のスロットを "__slots__" 宣言に追加しても、期
   待どおりの効果は得られず、単に混乱を招くだけになります。とはいえ、
   これは将来 "__weakref__" のように追加されるはずです。)

   **デフォルト**

   This slot has no default.  For static types, if the field is "NULL"
   then no "__dict__" gets created for instances.

initproc PyTypeObject.tp_init

   オプションのポインタで、インスタンス初期化関数を指します。

   この関数はクラスにおける "__init__()" メソッドに対応します。
   "__init__()" と同様、 "__init__()" を呼び出さずにインスタンスを作成
   できます。また、 "__init__()" を再度呼び出してインスタンスの再初期
   化もできます。

   関数のシグネチャは次のとおりです

      int tp_init(PyObject *self, PyObject *args, PyObject *kwds);

   *self* 引数は初期化するインスタンスです; *args* および *kwds* 引数
   は、 "__init__()" を呼び出す際の位置引数およびキーワード引数です。

   "tp_init" 関数のフィールドが "NULL" でない場合、通常の型を呼び出す
   方法のインスタンス生成において、型の "tp_new" 関数がインスタンスを
   返した後に呼び出されます。 "tp_new" が元の型のサブタイプでない別の
   型を返す場合、 "tp_init" は全く呼び出されません; "tp_new" が元の型
   のサブタイプのインスタンスを返す場合、サブタイプの "tp_init" が呼び
   出されます。

   成功のときには "0" を、エラー時には例外をセットして "-1" を返します
   。

   **継承:**

   サブタイプはこのフィールドを継承します。

   **デフォルト**

   For static types this field does not have a default.

allocfunc PyTypeObject.tp_alloc

   オプションのポインタで、インスタンスのメモリ確保関数を指します。

   関数のシグネチャは次のとおりです

      PyObject *tp_alloc(PyTypeObject *self, Py_ssize_t nitems);

   **継承:**

   This field is inherited by static subtypes, but not by dynamic
   subtypes (subtypes created by a class statement).

   **デフォルト**

   For dynamic subtypes, this field is always set to
   "PyType_GenericAlloc()", to force a standard heap allocation
   strategy.

   For static subtypes, "PyBaseObject_Type" uses
   "PyType_GenericAlloc()".  That is the recommended value for all
   statically defined types.

newfunc PyTypeObject.tp_new

   オプションのポインタで、インスタンス生成関数を指します。

   関数のシグネチャは次のとおりです

      PyObject *tp_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds);

   *subtype* 引数は生成するオブジェクトの型です; *args* および *kwds*
   引数は、型を呼び出すときの位置引数およびキーワード引数です。サブタ
   イプは "tp_new" 関数を呼び出すときに使う型と同じである必要はないこ
   とに注意してください; その型の (無関係ではない) サブタイプのことも
   あります。

   "tp_new" 関数は "subtype->tp_alloc(subtype, nitems)" を呼び出してオ
   ブジェクトのメモリ領域を確保し、初期化で絶対に必要とされる処理だけ
   を行います。省略したり繰り返したりしても問題のない初期化処理は
   "tp_init" ハンドラ内に配置しなければなりません。だいたいの目安とし
   ては、変更不能な型では初期化は全て "tp_new" で行い、一方、変更可能
   な型ではほとんどの初期化を "tp_init" に回すべきです。

   **継承:**

   サブタイプはこのフィールドを継承します。例外として、  "tp_base" が
   "NULL" か "&PyBaseObject_Type" になっている静的な型では継承しません
   。

   **デフォルト**

   For static types this field has no default.  This means if the slot
   is defined as "NULL", the type cannot be called to create new
   instances; presumably there is some other way to create instances,
   like a factory function.

freefunc PyTypeObject.tp_free

   オプションのポインタで、インスタンスのメモリ解放関数を指します。シ
   グネチャは以下の通りです:

      void tp_free(void *self);

   このシグネチャと互換性のある初期化子は "PyObject_Free()" です。

   **継承:**

   This field is inherited by static subtypes, but not by dynamic
   subtypes (subtypes created by a class statement)

   **デフォルト**

   In dynamic subtypes, this field is set to a deallocator suitable to
   match "PyType_GenericAlloc()" and the value of the
   "Py_TPFLAGS_HAVE_GC" flag bit.

   For static subtypes, "PyBaseObject_Type" uses PyObject_Del.

inquiry PyTypeObject.tp_is_gc

   オプションのポインタで、ガベージコレクタから呼び出される関数を指し
   ます。

   ガベージコレクタは、オブジェクトを回収して良いかどうかを知る必要が
   あります。通常は、オブジェクトの型の "tp_flags" フィールドを見て、
   "Py_TPFLAGS_HAVE_GC" フラグビットを調べるだけで十分です。しかし、あ
   る型では静的にメモリ確保されたインスタンスと動的にメモリ確保された
   インスタンスが混じっていて、静的にメモリ確保されたインスタンスは回
   収できません。こうした型では、関数を定義しなければなりません; 関数
   はインスタンスが回収可能の場合には "1" を、回収不能の場合には "0"
   を返さねばなりません。シグネチャは:

      int tp_is_gc(PyObject *self);

   (上記のような型の例は、型オブジェクト自体です。メタタイプ
   "PyType_Type" は、型のメモリ確保が静的か動的かを区別するためにこの
   関数を定義しています。)

   **継承:**

   サブタイプはこのフィールドを継承します。

   **デフォルト**

   This slot has no default.  If this field is "NULL",
   "Py_TPFLAGS_HAVE_GC" is used as the functional equivalent.

PyObject* PyTypeObject.tp_bases

   基底型からなるタプルです。

   "class" 文で生成されたクラスの場合このフィールドがセットされます。
   静的に定義されている型の場合には、このフィールドは "NULL" になりま
   す。

   **継承:**

   このフィールドは継承されません。

PyObject* PyTypeObject.tp_mro

   基底タイプ群を展開した集合が入っているタプルです。集合は該当する型
   自体からはじまり、 "object" で終わります。メソッド解決順序 (Method
   Resolution Order) に従って並んでいます。

   **継承:**

   このフィールドは継承されません; フィールドの値は "PyType_Ready()"
   で毎回計算されます。

PyObject* PyTypeObject.tp_cache

   未使用のフィールドです。内部でのみ利用されます。

   **継承:**

   このフィールドは継承されません。

PyObject* PyTypeObject.tp_subclasses

   サブクラスへの弱参照からなるリストです。内部で使用するためだけのも
   のです。

   **継承:**

   このフィールドは継承されません。

PyObject* PyTypeObject.tp_weaklist

   この型オブジェクトに対する弱参照からなるリストの先頭です。

   **継承:**

   このフィールドは継承されません。

destructor PyTypeObject.tp_del

   このフィールドは廃止されました。"tp_finalize" を代わりに利用してく
   ださい。

unsigned int PyTypeObject.tp_version_tag

   メソッドキャッシュへのインデックスとして使われます。内部使用だけの
   ための関数です。

   **継承:**

   このフィールドは継承されません。

destructor PyTypeObject.tp_finalize

   オプションのポインタで、インスタンスの終了処理関数を指します。シグ
   ネチャは以下の通りです:

      void tp_finalize(PyObject *self);

   "tp_finalize" が設定されている場合、インスタンスをファイナライズす
   るときに、インタプリタがこの関数を1回呼び出します。 ガベージコレク
   タ (このインスタンスが孤立した循環参照の一部だった場合) やオブジェ
   クトが破棄される直前にもこの関数は呼び出されます。 どちらの場合でも
   、循環参照を破壊しようとする前に呼び出されることが保証されていて、
   確実にオブジェクトが正常な状態にあるようにします。

   "tp_finalize" は現在の例外状態を変更すべきではありません; 従って、
   単純でないファイナライザを書くには次の方法が推奨されます:

      static void
      local_finalize(PyObject *self)
      {
          PyObject *error_type, *error_value, *error_traceback;

          /* Save the current exception, if any. */
          PyErr_Fetch(&error_type, &error_value, &error_traceback);

          /* ... */

          /* Restore the saved exception. */
          PyErr_Restore(error_type, error_value, error_traceback);
      }

   このフィールドを (継承した場合も含めて) 考慮から漏らさないように、
   "Py_TPFLAGS_HAVE_FINALIZE" フラグビットも設定しなければなりません。

   **継承:**

   サブタイプはこのフィールドを継承します。

   バージョン 3.4 で追加.

   参考: "オブジェクトの安全な終了処理" (**PEP 442**)

残りのフィールドは、機能テスト用のマクロである "COUNT_ALLOCS" が定義さ
れている場合のみ利用でき、内部で使用するためだけのものです。これらのフ
ィールドについて記述するのは単に完全性のためです。サブタイプはこれらの
フィールドを継承しません。

Py_ssize_t PyTypeObject.tp_allocs

   メモリ確保の回数です。

Py_ssize_t PyTypeObject.tp_frees

   メモリ解放の回数です。

Py_ssize_t PyTypeObject.tp_maxalloc

   同時にメモリ確保できる最大オブジェクト数です。

PyTypeObject* PyTypeObject.tp_prev

   Pointer to the previous type object with a non-zero "tp_allocs"
   field.

PyTypeObject* PyTypeObject.tp_next

   次のゼロでない "tp_allocs" フィールドを持つ型オブジェクトへのポイン
   タです。

また、 Python のガベージコレクションでは、 "tp_dealloc" を呼び出すのは
オブジェクトを生成したスレッドだけではなく、任意の Python スレッドかも
しれないという点にも注意して下さい。 (オブジェクトが循環参照の一部の場
合、任意のスレッドのガベージコレクションによって解放されてしまうかもし
れません)。Python API 側からみれば、 *tp_dealloc* を呼び出すスレッドは
グローバルインタプリタロック (GIL: Global Interpreter Lock) を獲得する
ので、これは問題ではありません。しかしながら、削除されようとしているオ
ブジェクトが何らかの C や C++ ライブラリ由来のオブジェクトを削除する場
合、 *tp_dealloc* を呼び出すスレッドのオブジェクトを削除することで、ラ
イブラリの仮定している何らかの規約に違反しないように気を付ける必要があ
ります。


Heap Types
==========

Traditionally, types defined in C code are *static*, that is, a static
"PyTypeObject" structure is defined directly in code and initialized
using "PyType_Ready()".

This results in types that are limited relative to types defined in
Python:

* Static types are limited to one base, i.e. they cannot use multiple
  inheritance.

* Static type objects (but not necessarily their instances) are
  immutable. It is not possible to add or modify the type object's
  attributes from Python.

* Static type objects are shared across sub-interpreters, so they
  should not include any subinterpreter-specific state.

Also, since "PyTypeObject" is not part of the stable ABI, any
extension modules using static types must be compiled for a specific
Python minor version.

An alternative to static types is *heap-allocated types*, or *heap
types* for short, which correspond closely to classes created by
Python's "class" statement.

This is done by filling a "PyType_Spec" structure and calling
"PyType_FromSpecWithBases()".


数値オブジェクト構造体
**********************

PyNumberMethods

   この構造体は数値型プロトコルを実装するために使われる関数群へのポイ
   ンタを保持しています。 以下のそれぞれの関数は 数値型プロトコル
   (number protocol) で解説されている似た名前の関数から利用されます。

   以下は構造体の定義です:

      typedef struct {
           binaryfunc nb_add;
           binaryfunc nb_subtract;
           binaryfunc nb_multiply;
           binaryfunc nb_remainder;
           binaryfunc nb_divmod;
           ternaryfunc nb_power;
           unaryfunc nb_negative;
           unaryfunc nb_positive;
           unaryfunc nb_absolute;
           inquiry nb_bool;
           unaryfunc nb_invert;
           binaryfunc nb_lshift;
           binaryfunc nb_rshift;
           binaryfunc nb_and;
           binaryfunc nb_xor;
           binaryfunc nb_or;
           unaryfunc nb_int;
           void *nb_reserved;
           unaryfunc nb_float;

           binaryfunc nb_inplace_add;
           binaryfunc nb_inplace_subtract;
           binaryfunc nb_inplace_multiply;
           binaryfunc nb_inplace_remainder;
           ternaryfunc nb_inplace_power;
           binaryfunc nb_inplace_lshift;
           binaryfunc nb_inplace_rshift;
           binaryfunc nb_inplace_and;
           binaryfunc nb_inplace_xor;
           binaryfunc nb_inplace_or;

           binaryfunc nb_floor_divide;
           binaryfunc nb_true_divide;
           binaryfunc nb_inplace_floor_divide;
           binaryfunc nb_inplace_true_divide;

           unaryfunc nb_index;

           binaryfunc nb_matrix_multiply;
           binaryfunc nb_inplace_matrix_multiply;
      } PyNumberMethods;

   注釈:

     二項関数と三項関数は、すべてのオペランドの型をチェックしなければ
     ならず、必要な変換を実装しなければなりません (すくなくともオペラ
     ンドの一つは定義している型のインスタンスです). もし与えられたオペ
     ランドに対して操作が定義されなければ、二項関数と三項関数は
     "Py_NotImplemented" を返さなければならず、他のエラーが起こった場
     合は、"NULL" を返して例外を設定しなければなりません。

   注釈:

     "nb_reserved" フィールドは常に "NULL" でなければなりません。以前
     は "nb_long" と呼ばれていて、 Python 3.0.1 で名前が変更されました
     。

binaryfunc PyNumberMethods.nb_add

binaryfunc PyNumberMethods.nb_subtract

binaryfunc PyNumberMethods.nb_multiply

binaryfunc PyNumberMethods.nb_remainder

binaryfunc PyNumberMethods.nb_divmod

ternaryfunc PyNumberMethods.nb_power

unaryfunc PyNumberMethods.nb_negative

unaryfunc PyNumberMethods.nb_positive

unaryfunc PyNumberMethods.nb_absolute

inquiry PyNumberMethods.nb_bool

unaryfunc PyNumberMethods.nb_invert

binaryfunc PyNumberMethods.nb_lshift

binaryfunc PyNumberMethods.nb_rshift

binaryfunc PyNumberMethods.nb_and

binaryfunc PyNumberMethods.nb_xor

binaryfunc PyNumberMethods.nb_or

unaryfunc PyNumberMethods.nb_int

void *PyNumberMethods.nb_reserved

unaryfunc PyNumberMethods.nb_float

binaryfunc PyNumberMethods.nb_inplace_add

binaryfunc PyNumberMethods.nb_inplace_subtract

binaryfunc PyNumberMethods.nb_inplace_multiply

binaryfunc PyNumberMethods.nb_inplace_remainder

ternaryfunc PyNumberMethods.nb_inplace_power

binaryfunc PyNumberMethods.nb_inplace_lshift

binaryfunc PyNumberMethods.nb_inplace_rshift

binaryfunc PyNumberMethods.nb_inplace_and

binaryfunc PyNumberMethods.nb_inplace_xor

binaryfunc PyNumberMethods.nb_inplace_or

binaryfunc PyNumberMethods.nb_floor_divide

binaryfunc PyNumberMethods.nb_true_divide

binaryfunc PyNumberMethods.nb_inplace_floor_divide

binaryfunc PyNumberMethods.nb_inplace_true_divide

unaryfunc PyNumberMethods.nb_index

binaryfunc PyNumberMethods.nb_matrix_multiply

binaryfunc PyNumberMethods.nb_inplace_matrix_multiply


マップオブジェクト構造体
************************

PyMappingMethods

   この構造体はマップ型プロトコルを実装するために使われる関数群へのポ
   インタを保持しています。 以下の3つのメンバを持っています:

lenfunc PyMappingMethods.mp_length

   この関数は "PyMapping_Size()" や "PyObject_Size()" から利用され、そ
   れらと同じシグネチャを持っています。オブジェクトが定義された長さを
   持たない場合は、このスロットは "NULL" に設定されることがあります。

binaryfunc PyMappingMethods.mp_subscript

   この関数は "PyObject_GetItem()" および "PySequence_GetSlice()" から
   利用され、"PySequence_GetSlice()" と同じシグネチャを持っています。
   このスロットは "PyMapping_Check()" が "1" を返すためには必要で、そ
   うでなければ "NULL" の場合があります。

objobjargproc PyMappingMethods.mp_ass_subscript

   この関数は "PyObject_SetItem()"、"PyObject_DelItem()"、
   "PyObject_SetSlice()" および "PyObject_DelSlice()" から利用されます
   。 "PyObject_SetItem()" と同じシグネチャを持ちますが、 *v* に
   "NULL" を設定して要素の削除もできます。このスロットが "NULL" の場合
   は、このオブジェクトはアイテムの代入と削除をサポートしません。


シーケンスオブジェクト構造体
****************************

PySequenceMethods

   この構造体はシーケンス型プロトコルを実装するために使われる関数群へ
   のポインタを保持しています。

lenfunc PySequenceMethods.sq_length

   This function is used by "PySequence_Size()" and "PyObject_Size()",
   and has the same signature.  It is also used for handling negative
   indices via the "sq_item" and the "sq_ass_item" slots.

binaryfunc PySequenceMethods.sq_concat

   この関数は "PySequence_Concat()" で利用され、同じシグネチャを持って
   います。また、 "+" 演算子でも、 "nb_add" スロットによる数値加算を試
   した後に利用されます。

ssizeargfunc PySequenceMethods.sq_repeat

   この関数は "PySequence_Repeat()" で利用され、同じシグネチャを持って
   います。また、 "*" 演算でも、 "nb_multiply" スロットによる数値乗算
   を試したあとに利用されます。

ssizeargfunc PySequenceMethods.sq_item

   This function is used by "PySequence_GetItem()" and has the same
   signature.  It is also used by "PyObject_GetItem()", after trying
   the subscription via the "mp_subscript" slot. This slot must be
   filled for the "PySequence_Check()" function to return "1", it can
   be "NULL" otherwise.

   負のインデックスは次のように処理されます: "sq_length" スロットが埋
   められていれば、それを呼び出してシーケンスの長さから正のインデック
   スを計算し、 "sq_item" に渡します。 "sq_length" が "NULL" の場合は
   、インデックスはそのままこの関数に渡されます。

ssizeobjargproc PySequenceMethods.sq_ass_item

   This function is used by "PySequence_SetItem()" and has the same
   signature.  It is also used by "PyObject_SetItem()" and
   "PyObject_DelItem()", after trying the item assignment and deletion
   via the "mp_ass_subscript" slot. This slot may be left to "NULL" if
   the object does not support item assignment and deletion.

objobjproc PySequenceMethods.sq_contains

   この関数は "PySequence_Contains()" から利用され、同じシグネチャを持
   っています。このスロットは "NULL" の場合があり、その時
   "PySequence_Contains()" はシンプルにマッチするオブジェクトを見つけ
   るまでシーケンスを巡回します。

binaryfunc PySequenceMethods.sq_inplace_concat

   This function is used by "PySequence_InPlaceConcat()" and has the
   same signature.  It should modify its first operand, and return it.
   This slot may be left to "NULL", in this case
   "PySequence_InPlaceConcat()" will fall back to
   "PySequence_Concat()".  It is also used by the augmented assignment
   "+=", after trying numeric in-place addition via the
   "nb_inplace_add" slot.

ssizeargfunc PySequenceMethods.sq_inplace_repeat

   This function is used by "PySequence_InPlaceRepeat()" and has the
   same signature.  It should modify its first operand, and return it.
   This slot may be left to "NULL", in this case
   "PySequence_InPlaceRepeat()" will fall back to
   "PySequence_Repeat()".  It is also used by the augmented assignment
   "*=", after trying numeric in-place multiplication via the
   "nb_inplace_multiply" slot.


バッファオブジェクト構造体 (buffer object structure)
****************************************************

PyBufferProcs

   この構造体は buffer プロトコル が要求する関数群へのポインタを保持し
   ています。 そのプロトコルは、エクスポーターオブジェクトが如何にして
   、その内部データをコンシューマオブジェクトに渡すかを定義します。

getbufferproc PyBufferProcs.bf_getbuffer

   この関数のシグネチャは以下の通りです:

      int (PyObject *exporter, Py_buffer *view, int flags);

   *flags* で指定された方法で *view* を埋めてほしいという *exporter*
   に対する要求を処理します。ステップ(3) を除いて、この関数の実装では
   以下のステップを行わなければなりません:

   1. リクエストが合致するか確認します。 合致しない場合は、
      "PyExc_BufferError" を送出し、 "view->obj" に "NULL" を設定し
      "-1" を返します。

   2. 要求されたフィールドを埋めます。

   3. エクスポートした回数を保持する内部カウンタをインクリメントします
      。

   4. "view->obj" に *exporter* を設定し、 "view->obj" をインクリメン
      トします。

   5. "0" を返します。

   *exporter* がバッファプロバイダのチェインかツリーの一部であれば、２
   つの主要な方式が使用できます:

   * 再エクスポート: ツリーの各要素がエクスポートされるオブジェクトと
     して振る舞い、自身への新しい参照を "view->obj" へセットします。

   * リダイレクト: バッファ要求がツリーのルートオブジェクトにリダイレ
     クトされます。ここでは、 "view->obj" はルートオブジェクトへの新し
     い参照になります。

   *view* の個別のフィールドは バッファ構造体 の節で説明されており、エ
   クスポートが特定の要求に対しどう対応しなければならないかの規則は、
   バッファ要求のタイプ の節にあります。

   "Py_buffer" 構造体の中から参照している全てのメモリはエクスポータに
   属し、コンシューマがいなくなるまで有効でなくてはなりません。
   "format" 、 "shape" 、 "strides" 、 "suboffsets" 、 "internal" はコ
   ンシューマからは読み出し専用です。

   "PyBuffer_FillInfo()" は、全てのリクエストタイプを正しく扱う際に、
   単純なバイトバッファを公開する簡単な方法を提供します。

   "PyObject_GetBuffer()" は、この関数をラップするコンシューマ向けのイ
   ンタフェースです。

releasebufferproc PyBufferProcs.bf_releasebuffer

   この関数のシグネチャは以下の通りです:

      void (PyObject *exporter, Py_buffer *view);

   バッファのリソースを開放する要求を処理します。もし開放する必要のあ
   るリソースがない場合、 "PyBufferProcs.bf_releasebuffer" は "NULL"
   にしても構いません。そうでない場合は、この関数の標準的な実装は、以
   下の任意の処理手順 (optional step) を行います:

   1. エクスポートした回数を保持する内部カウンタをデクリメントします。

   2. カウンタが "0" の場合は、*view* に関連付けられた全てのメモリを解
      放します。

   エクスポータは、バッファ固有のリソースを監視し続けるために
   "internal" フィールドを使わなければなりません。このフィールドは、コ
   ンシューマが *view* 引数としてオリジナルのバッファのコピーを渡して
   いるであろう間、変わらないことが保証されています。

   この関数は、"view->obj" をデクリメントしてはいけません、なぜならそ
   れは "PyBuffer_Release()" で自動的に行われるからです(この方式は参照
   の循環を防ぐのに有用です)。

   "PyBuffer_Release()" は、この関数をラップするコンシューマ向けのイン
   タフェースです。


async オブジェクト構造体
************************

バージョン 3.5 で追加.

PyAsyncMethods

   この構造体は *awaitable* オブジェクトと *asynchronous iterator* オ
   ブジェクトを実装するのに必要な関数へのポインタを保持しています。

   以下は構造体の定義です:

      typedef struct {
          unaryfunc am_await;
          unaryfunc am_aiter;
          unaryfunc am_anext;
      } PyAsyncMethods;

unaryfunc PyAsyncMethods.am_await

   この関数のシグネチャは以下の通りです:

      PyObject *am_await(PyObject *self);

   返されるオブジェクトはイテレータでなければなりません。 つまりこのオ
   ブジェクトに対して "PyIter_Check()" が "1" を返さなければなりません
   。

   オブジェクトが *awaitable* でない場合、このスロットを "NULL" に設定
   します。

unaryfunc PyAsyncMethods.am_aiter

   この関数のシグネチャは以下の通りです:

      PyObject *am_aiter(PyObject *self);

   *awaitable* オブジェクトを返さなければなりません。 詳しいことは
   "__anext__()" を参照してください。

   オブジェクトが非同期反復処理のプロトコルを実装していない場合、この
   スロットを "NULL" に設定します。

unaryfunc PyAsyncMethods.am_anext

   この関数のシグネチャは以下の通りです:

      PyObject *am_anext(PyObject *self);

   *awaitable* オブジェクトを返さなければなりません。 詳しいことは
   "__anext__()" を参照してください。 このスロットは "NULL" に設定され
   ていることもあります。


Slot Type typedefs
******************

PyObject *(*allocfunc)(PyTypeObject *cls, Py_ssize_t nitems)

   この関数の目的は、メモリ確保をメモリ初期化から分離することにありま
   す。この関数は、インスタンス用の的確なサイズ、適切なアラインメント
   、ゼロによる初期化がなされ、 "ob_refcnt" を "1" に、 "ob_type" を型
   引数 (type argument) にセットしたメモリブロックへのポインタを返さね
   ばなりません。型の "tp_itemsize" がゼロでない場合、オブジェクトの
   "ob_size" フィールドは *nitems* に初期化され、確保されるメモリブロ
   ックの長さは "tp_basicsize + nitems*tp_itemsize" を "sizeof(void*)"
   の倍数に切り上げた値になるはずです; それ以外の場合、 *nitems* の値
   は使われず、メモリブロックの長さは "tp_basicsize" になるはずです。

   この関数では他のいかなるインスタンス初期化も行ってはなりません。追
   加のメモリ割り当てすらも行ってはなりません。そのような処理は
   "tp_new" で行われるべきです。

void (*destructor)(PyObject *)

PyObject *(*vectorcallfunc)(PyObject *callable, PyObject *const *args, size_t nargsf, PyObject *kwnames)

   See "tp_vectorcall_offset".

   Arguments to "vectorcallfunc" are the same as for
   "_PyObject_Vectorcall()".

   バージョン 3.8 で追加.

void (*freefunc)(void *)

   "tp_free"  を参照してください。

PyObject *(*newfunc)(PyObject *, PyObject *, PyObject *)

   "tp_new" を参照してください。

int (*initproc)(PyObject *, PyObject *, PyObject *)

   "tp_init" を参照してください。

PyObject *(*reprfunc)(PyObject *)

   "tp_repr" を参照してください。

PyObject *(*getattrfunc)(PyObject *self, char *attr)

   オブジェクトの属性の値を返します。

int (*setattrfunc)(PyObject *self, char *attr, PyObject *value)

   オブジェクトの属性に値を設定します。属性を削除するには、 value 引数
   に "NULL" を設定します。

PyObject *(*getattrofunc)(PyObject *self, PyObject *attr)

   オブジェクトの属性の値を返します。

   "tp_getattro" を参照してください。

int (*setattrofunc)(PyObject *self, PyObject *attr, PyObject *value)

   オブジェクトの属性に値を設定します。属性を削除するには、 value 引数
   に "NULL" を設定します。

   "tp_setattro" を参照してください。

PyObject *(*descrgetfunc)(PyObject *, PyObject *, PyObject *)

   "tp_descrget" を参照してください。

int (*descrsetfunc)(PyObject *, PyObject *, PyObject *)

   "tp_descrset" を参照してください。

Py_hash_t (*hashfunc)(PyObject *)

   "tp_hash" を参照してください。

PyObject *(*richcmpfunc)(PyObject *, PyObject *, int)

   "tp_richcompare" を参照してください。

PyObject *(*getiterfunc)(PyObject *)

   "tp_iter" を参照してください。

PyObject *(*iternextfunc)(PyObject *)

   "tp_iternext" を参照してください。

Py_ssize_t (*lenfunc)(PyObject *)

int (*getbufferproc)(PyObject *, Py_buffer *, int)

void (*releasebufferproc)(PyObject *, Py_buffer *)

PyObject *(*unaryfunc)(PyObject *)

PyObject *(*binaryfunc)(PyObject *, PyObject *)

PyObject *(*ternaryfunc)(PyObject *, PyObject *, PyObject *)

PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t)

int (*ssizeobjargproc)(PyObject *, Py_ssize_t)

int (*objobjproc)(PyObject *, PyObject *)

int (*objobjargproc)(PyObject *, PyObject *, PyObject *)


使用例
******

ここでは Python の型定義の簡単な例をいくつか挙げます。これらの例にはあ
なたが遭遇する共通的な利用例を含んでいます。いくつかの例ではトリッキー
なコーナーケースを実演しています。より多くの例や実践的な情報、チュート
リアルが必要なら、拡張の型の定義: チュートリアル や 拡張の型の定義: 雑
多なトピック を参照してください。

基本的な静的型:

   typedef struct {
       PyObject_HEAD
       const char *data;
   } MyObject;

   static PyTypeObject MyObject_Type = {
       PyVarObject_HEAD_INIT(NULL, 0)
       .tp_name = "mymod.MyObject",
       .tp_basicsize = sizeof(MyObject),
       .tp_doc = "My objects",
       .tp_new = myobj_new,
       .tp_dealloc = (destructor)myobj_dealloc,
       .tp_repr = (reprfunc)myobj_repr,
   };

より冗長な初期化子を用いた古いコードを（特にCPythonのコードベース中で
）見かけることがあるかもしれません:

   static PyTypeObject MyObject_Type = {
       PyVarObject_HEAD_INIT(NULL, 0)
       "mymod.MyObject",               /* tp_name */
       sizeof(MyObject),               /* tp_basicsize */
       0,                              /* tp_itemsize */
       (destructor)myobj_dealloc,      /* tp_dealloc */
       0,                              /* tp_vectorcall_offset */
       0,                              /* tp_getattr */
       0,                              /* tp_setattr */
       0,                              /* tp_as_async */
       (reprfunc)myobj_repr,           /* tp_repr */
       0,                              /* tp_as_number */
       0,                              /* tp_as_sequence */
       0,                              /* tp_as_mapping */
       0,                              /* tp_hash */
       0,                              /* tp_call */
       0,                              /* tp_str */
       0,                              /* tp_getattro */
       0,                              /* tp_setattro */
       0,                              /* tp_as_buffer */
       0,                              /* tp_flags */
       "My objects",                   /* tp_doc */
       0,                              /* tp_traverse */
       0,                              /* tp_clear */
       0,                              /* tp_richcompare */
       0,                              /* tp_weaklistoffset */
       0,                              /* tp_iter */
       0,                              /* tp_iternext */
       0,                              /* tp_methods */
       0,                              /* tp_members */
       0,                              /* tp_getset */
       0,                              /* tp_base */
       0,                              /* tp_dict */
       0,                              /* tp_descr_get */
       0,                              /* tp_descr_set */
       0,                              /* tp_dictoffset */
       0,                              /* tp_init */
       0,                              /* tp_alloc */
       myobj_new,                      /* tp_new */
   };

弱酸庄屋、インスタンス辞書、ハッシュをサポートする型:

   typedef struct {
       PyObject_HEAD
       const char *data;
       PyObject *inst_dict;
       PyObject *weakreflist;
   } MyObject;

   static PyTypeObject MyObject_Type = {
       PyVarObject_HEAD_INIT(NULL, 0)
       .tp_name = "mymod.MyObject",
       .tp_basicsize = sizeof(MyObject),
       .tp_doc = "My objects",
       .tp_weaklistoffset = offsetof(MyObject, weakreflist),
       .tp_dictoffset = offsetof(MyObject, inst_dict),
       .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
       .tp_new = myobj_new,
       .tp_traverse = (traverseproc)myobj_traverse,
       .tp_clear = (inquiry)myobj_clear,
       .tp_alloc = PyType_GenericNew,
       .tp_dealloc = (destructor)myobj_dealloc,
       .tp_repr = (reprfunc)myobj_repr,
       .tp_hash = (hashfunc)myobj_hash,
       .tp_richcompare = PyBaseObject_Type.tp_richcompare,
   };

サブクラス化を許可せず、インスタンスを生成するのに呼び出せない（つまり
、別のファクトリー関数を呼び出す必要のある）str のサブクラス:

   typedef struct {
       PyUnicodeObject raw;
       char *extra;
   } MyStr;

   static PyTypeObject MyStr_Type = {
       PyVarObject_HEAD_INIT(NULL, 0)
       .tp_name = "mymod.MyStr",
       .tp_basicsize = sizeof(MyStr),
       .tp_base = NULL,  // set to &PyUnicode_Type in module init
       .tp_doc = "my custom str",
       .tp_flags = Py_TPFLAGS_DEFAULT,
       .tp_new = NULL,
       .tp_repr = (reprfunc)myobj_repr,
   };

もっとも単純な静的型(固定長のインスタンス):

   typedef struct {
       PyObject_HEAD
   } MyObject;

   static PyTypeObject MyObject_Type = {
       PyVarObject_HEAD_INIT(NULL, 0)
       .tp_name = "mymod.MyObject",
   };

もっとも単純な静的型（可変長インスタンス）

   typedef struct {
       PyObject_VAR_HEAD
       const char *data[1];
   } MyObject;

   static PyTypeObject MyObject_Type = {
       PyVarObject_HEAD_INIT(NULL, 0)
       .tp_name = "mymod.MyObject",
       .tp_basicsize = sizeof(MyObject) - sizeof(char *),
       .tp_itemsize = sizeof(char *),
   };
