형 객체
*******

아마도 파이썬 객체 시스템의 가장 중요한 구조체 중 하나는 새로운 형을
정의하는 구조체일 것입니다: "PyTypeObject" 구조체. "PyObject_*()"나
"PyType_*()" 함수를 사용하여 형 객체를 처리할 수 있지만, 대부분 파이썬
응용 프로그램이 흥미를 느낄 것은 많이 제공하지 않습니다. 이 객체는 객
체의 동작 방식의 기초를 이루므로, 인터프리터 자체와 새로운 형을 구현하
는 확장 모듈에 매우 중요합니다.

형 객체는 대부분 표준형보다 상당히 큽니다. 크기가 큰 이유는 각 형 객체
가 많은 수의 값을 저장하기 때문인데, 주로 C 함수 포인터이고 각기 형의
기능 중 작은 부분을 구현합니다. 이 섹션에서는 형 객체의 필드를 자세히
살펴봅니다. 필드는 구조체에서 나타나는 순서대로 설명됩니다.

다음의 간략 참조 외에도, 예 섹션은 "PyTypeObject"의 의미와 사용에 대한
통찰을 제공합니다.


간략 참조
=========


"tp 슬롯"
---------

+--------------------+--------------------+--------------------+----+----+----+----+
| PyTypeObject 슬롯  | 형                 | 특수 메서드/어트리 | 정보 [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" * | 서브 슬롯          |    |    |    | %  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_repr"          | "reprfunc"         | __repr__           | X  | X  |    | X  |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_as_number"     | "PyNumberMethods"  | 서브 슬롯          |    |    |    | %  |
|                    | *                  |                    |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_as_sequence"   | "PySequenceMethod  | 서브 슬롯          |    |    |    | %  |
|                    | s" *               |                    |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "tp_as_mapping"    | "PyMappingMethods" | 서브 슬롯          |    |    |    | %  |
|                    | *                  |                    |    |    |    |    |
+--------------------+--------------------+--------------------+----+----+----+----+
| "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] 괄호 안의 슬롯 이름은 슬롯이 (효과적으로) 폐지되었음을 나타냅니다.
    화살 괄호(angle brackets) 안에 있는 이름은 읽기 전용으로 취급해야
    합니다. 대괄호(square brackets) 안의 이름은 내부 전용입니다. (접두
    사일 때) "<R>"는 필드가 필수임을 뜻합니다 (반드시 "NULL"이 아니어
    야 합니다).

[2] 열:

    **"O"**: "PyBaseObject_Type"에 설정

    **"T"**: "PyType_Type"에 설정

    **"D"**: 기본값 (슬롯이 "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"**: 상속

       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

    일부 슬롯은 일반 어트리뷰트 조회 체인을 통해 효과적으로 상속됨에
    유의하십시오.


서브 슬롯
---------

+----------------------------+-------------------+--------------+
| 슬롯                       | 형                | 특수 메서드  |
|============================|===================|==============|
| "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" *                  |                        |
+-------------------------------+-------------------------------+------------------------+

자세한 내용은 아래 슬롯 형 typedef를 참조하십시오.


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" 필드는
동적 형("type_new()"에 의해 만들어집니다, 일반적으로 class 문에서 호출
됩니다)에 사용됩니다. "PyType_Type"(메타 형)은 "tp_itemsize"를 초기화
함에 유의하십시오, 인스턴스(즉, 형 객체)는 *반드시* "ob_size" 필드를
가져야 함을 뜻합니다.

PyObject* PyObject._ob_next
PyObject* PyObject._ob_prev

   이 필드는 매크로 "Py_TRACE_REFS"가 정의됐을 때만 존재합니다. "NULL"
   로의 초기화는 "PyObject_HEAD_INIT" 매크로에 의해 처리됩니다. 정적으
   로 할당된 객체의 경우, 이 필드는 항상 "NULL"로 유지됩니다. 동적으로
   할당된 객체의 경우, 이 두 필드는 객체를 힙에 있는 *모든* 라이브 객
   체의 이중 링크 리스트에 연결하는 데 사용됩니다. 이것은 다양한 디버
   깅 목적으로 사용될 수 있습니다; 현재 유일한 사용은 환경 변수
   "PYTHONDUMPREFS" 가 설정될 때 실행이 끝날 때 여전히 존재하는 객체를
   인쇄하는 것입니다.

   **계승:**

   이 필드는 서브 형에 의해 상속되지 않습니다.

Py_ssize_t PyObject.ob_refcnt

   이것은 "PyObject_HEAD_INIT" 매크로에 의해 "1"로 초기화된 형 객체의
   참조 횟수입니다. 정적으로 할당된 형 객체의 경우 형의 인스턴스
   ("ob_type"이 형을 다시 가리키는 객체)는 참조로 카운트되지 *않습니다
   *. 그러나 동적으로 할당된 형 객체의 경우, 인스턴스는 참조로 *카운트
   됩니다*.

   **계승:**

   이 필드는 서브 형에 의해 상속되지 않습니다.

PyTypeObject* PyObject.ob_type

   이것은 형의 형, 즉 메타 형(metatype)입니다. "PyObject_HEAD_INIT" 매
   크로에 대한 인자로 초기화되며, 값은 일반적으로 "&PyType_Type"이어야
   합니다. 그러나, (적어도) 윈도우에서 사용 가능해야 하는 동적으로 로
   드 가능한 확장 모듈의 경우, 컴파일러는 유효한 초기화자가 아니라고
   불평합니다. 따라서, 규칙은 "NULL"을 "PyObject_HEAD_INIT" 매크로로
   전달하고, 다른 작업을 수행하기 전에 모듈의 초기화 함수 시작에서 필
   드를 명시적으로 초기화하는 것입니다. 이것은 일반적으로 다음과 같이
   수행됩니다:

      Foo_Type.ob_type = &PyType_Type;

   형의 인스턴스를 만들기 전에 수행해야 합니다. "PyType_Ready()"는
   "ob_type"이 "NULL"인지 확인하고, 그렇다면 베이스 클래스의 "ob_type"
   필드로 초기화합니다. "PyType_Ready()"는 0이 아니면 이 필드를 변경하
   지 않습니다.

   **계승:**

   이 필드는 서브 형으로 상속됩니다.


PyVarObject 슬롯
================

Py_ssize_t PyVarObject.ob_size

   정적으로 할당된 형 객체의 경우, 0으로 초기화해야 합니다. 동적으로
   할당된 형 객체의 경우, 이 필드에는 특별한 내부 의미가 있습니다.

   **계승:**

   이 필드는 서브 형에 의해 상속되지 않습니다.


PyTypeObject 슬롯
=================

각 슬롯에는 상속을 설명하는 섹션이 있습니다. 필드가 "NULL"로 설정될 때
"PyType_Ready()"가 값을 설정할 수 있으면, "기본값" 섹션도 있습니다.
("PyBaseObject_Type"과 "PyType_Type"에 설정된 많은 필드가 효과적으로
기본값으로 작동함에 유의하십시오.)

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__" 어트리뷰트는 정의되지 않습니다 (위에서
   설명한 대로, 딕셔너리에 명시적으로 설정되지 않는 한). 이것은 여러분
   의 형을 피클 할 수 없다는 것을 뜻합니다. 또한, pydoc으로 만든 모듈
   설명서에 나열되지 않습니다.

   이 필드는 "NULL"이 아니어야 합니다. "PyTypeObject()"에서 유일하게
   필요한 필드입니다 (잠재적인 "tp_itemsize"를 제외하고).

   **계승:**

   이 필드는 서브 형에 의해 상속되지 않습니다.

Py_ssize_t PyTypeObject.tp_basicsize
Py_ssize_t PyTypeObject.tp_itemsize

   이 필드를 사용하면 형 인스턴스의 크기를 바이트 단위로 계산할 수 있
   습니다.

   두 가지 종류의 형이 있습니다: 고정 길이 인스턴스의 형은 0
   "tp_itemsize" 필드를 갖고, 가변 길이 인스턴스의 형에는 0이 아닌
   "tp_itemsize" 필드가 있습니다. 고정 길이 인스턴스의 형의 경우, 모든
   인스턴스는 "tp_basicsize"로 지정되는 같은 크기를 갖습니다.

   가변 길이 인스턴스의 형의 경우, 인스턴스에는 "ob_size" 필드가 있어
   야 하며, 인스턴스 크기는 "tp_basicsize"에 N 곱하기 "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 헤더 크기가 포함되지 않습니다.

   정렬(alignment)에 대한 참고 사항: 가변 길이 항목에 특정 정렬이 필요
   하면, "tp_basicsize" 값에서 고려되어야 합니다. 예: 형이 "double" 배
   열을 구현하는 형을 가정합시다. "tp_itemsize"는 "sizeof(double)"입니
   다. "tp_basicsize"가 "sizeof(double)"의 배수가 되도록 하는 것은 프
   로그래머의 책임입니다 (이것이 "double"의 정렬 요구 사항이라고 가정
   합니다).

   가변 길이 인스턴스가 있는 모든 형의 경우, 이 필드는 "NULL"이 아니어
   야 합니다.

   **계승:**

   이 필드는 서브 형에 의해 별도로 상속됩니다. 베이스형에 0이 아닌
   "tp_itemsize"가 있으면, 일반적으로 서브 형에서 "tp_itemsize"를 다른
   0이 아닌 값으로 설정하는 것은 안전하지 않습니다 (베이스형의 구현에
   따라 다르기는 합니다).

destructor PyTypeObject.tp_dealloc

   인스턴스 파괴자(destructor) 함수에 대한 포인터. (싱글톤 "None"과
   "Ellipsis"의 경우처럼) 형이 해당 인스턴스가 할당 해제되지 않도록 보
   장하지 않는 한, 이 함수를 정의해야 합니다. 함수 서명은 다음과 같습
   니다:

      void tp_dealloc(PyObject *self);

   파괴자 함수는 새로운 참조 횟수가 0일 때 "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()"입니다.

   마지막으로, 형이 힙 할당("Py_TPFLAGS_HEAPTYPE")이면, 할당 해제기는
   형 할당 해제기를 호출한 후 해당 형 객체의 참조 횟수를 줄여야 합니다
   . 매달린(dangling) 포인터를 피하고자, 이렇게 하는 권장 방법은 다음
   과 같습니다:

      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

   간단한 "tp_call"의 더 효율적인 대안인 *벡터콜(vectorcall)* 프로토콜
   을 사용하여 객체를 호출하는 것을 구현하는 인스턴스별 함수에 대한 선
   택적 오프셋입니다.

   이 필드는 플래그 "_Py_TPFLAGS_HAVE_VECTORCALL"이 설정되었을 때만 사
   용됩니다. 그럴 때, 이것은 "vectorcallfunc" 포인터의 인스턴스에서의
   오프셋을 포함하는 양의 정수여야 합니다. 서명은
   "_PyObject_Vectorcall()"과 같습니다:

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

   *vectorcallfunc* 포인터는 0일 수 있으며, 이때 인스턴스는
   "_Py_TPFLAGS_HAVE_VECTORCALL"이 설정되지 않은 것처럼 작동합니다: 인
   스턴스를 호출하면 "tp_call"로 폴백 됩니다.

   "_Py_TPFLAGS_HAVE_VECTORCALL"을 설정하는 모든 클래스는 "tp_call"도
   설정해야 하고, 해당 동작이 *vectorcallfunc* 함수와 일관되도록 만들
   어야 합니다. *tp_call*을 "PyVectorcall_Call"로 설정하면 됩니다:

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

      tuple과 dict에 각각 주어진 위치와 키워드 인자로 *callable*의
      *vectorcallfunc*를 호출합니다.

      이 함수는 "tp_call" 슬롯에서 사용하기 위한 것입니다. "tp_call"로
      폴백하지 않으며 현재 "_Py_TPFLAGS_HAVE_VECTORCALL" 플래그를 확인
      하지 않습니다. 객체를 호출하려면, "PyObject_Call" 함수 중 하나를
      대신 사용하십시오.

   참고:

     힙(heap) 형에 벡터콜 프로토콜을 구현하는 것은 권장하지 않습니다.
     사용자가 파이썬 코드에서 "__call__"을 설정하면, "tp_call"만 갱신
     되어 벡터콜 함수와 일치하지 않을 수 있습니다.

   참고:

     "tp_vectorcall_offset" 슬롯의 의미론은 잠정적이며 파이썬 3.9에서
     완성될 것으로 예상됩니다. 벡터콜을 사용한다면, 파이썬 3.9에서 코
     드를 갱신할 준비를 하십시오.

   버전 3.8에서 변경: 이 슬롯은 파이썬 2.x의 인쇄 포매팅에 사용되었습
   니다. 파이썬 3.0에서 3.7에서는, 예약되었고 "tp_print"로 명명되었습
   니다.

   **계승:**

   이 필드는 "tp_call"과 함께 서브 형에 의해 상속됩니다: 서브 형의
   "tp_call"이 "NULL"일 때 서브 형은 베이스형에서
   "tp_vectorcall_offset"을 상속합니다.

   힙 형(파이썬에서 정의된 서브 클래스를 포함합니다)은
   "_Py_TPFLAGS_HAVE_VECTORCALL" 플래그를 상속하지 않음에 유의하십시오
   .

getattrfunc PyTypeObject.tp_getattr

   get-attribute-string 함수에 대한 선택적 포인터.

   이 필드는 폐지되었습니다. 정의될 때, "tp_getattro" 함수와 같게 작동
   하지만, 어트리뷰트 이름을 제공하기 위해 파이썬 문자열 객체 대신 C
   문자열을 받아들이는 함수를 가리켜야 합니다.

   **계승:**

   그룹: "tp_getattr", "tp_getattro"

   이 필드는 "tp_getattro"와 함께 서브 형에 의해 상속됩니다: 서브 형은
   서브 형의 "tp_getattr"과 "tp_getattro"가 모두 "NULL"일 때 베이스형
   에서 "tp_getattr"과 "tp_getattro"를 모두 상속합니다.

setattrfunc PyTypeObject.tp_setattr

   어트리뷰트 설정과 삭제를 위한 함수에 대한 선택적 포인터.

   이 필드는 폐지되었습니다. 정의될 때, "tp_setattro" 함수와 같게 작동
   하지만, 어트리뷰트 이름을 제공하기 위해 파이썬 문자열 객체 대신 C
   문자열을 받아들이는 함수를 가리켜야 합니다.

   **계승:**

   그룹: "tp_setattr", "tp_setattro"

   이 필드는 "tp_setattro"와 함께 서브 형에 의해 상속됩니다. 서브 형은
   서브 형의 "tp_setattr"과 "tp_setattro"가 모두 "NULL"일 때 베이스형
   에서 "tp_setattr"과 "tp_setattro"를 모두 상속합니다.

PyAsyncMethods* PyTypeObject.tp_as_async

   C 수준에서 *어웨이터블*과 *비동기 이터레이터* 프로토콜을 구현하는
   객체에만 관련된 필드를 포함하는 추가 구조체에 대한 포인터. 자세한
   내용은 비동기 객체 구조체를 참조하십시오.

   버전 3.5에 추가: 이전에는 "tp_compare"와 "tp_reserved"라고 했습니다
   .

   **계승:**

   "tp_as_async" 필드는 상속되지 않지만, 포함된 필드는 개별적으로 상속
   됩니다.

reprfunc PyTypeObject.tp_repr

   내장 함수 "repr()"을 구현하는 함수에 대한 선택적 포인터.

   서명은 "PyObject_Repr()"과 같습니다:

      PyObject *tp_repr(PyObject *self);

   함수는 문자열이나 유니코드 객체를 반환해야 합니다. 이상적으로, 이
   함수는 "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()"를 구현하는 함수에 대한 선택적 포인터.

   서명은 "PyObject_Hash()"와 같습니다:

      Py_hash_t tp_hash(PyObject *);

   "-1" 값은 정상적인 반환 값으로 반환되지 않아야 합니다; 해시값을 계
   산하는 동안 에러가 발생하면 함수는 예외를 설정하고 "-1"을 반환해야
   합니다.

   이 필드가 설정되지 않으면 (*그리고* "tp_richcompare"가 설정되지 않
   으면), 객체의 해시를 취하려는 시도는 "TypeError"를 발생시킵니다. 이
   것은 "PyObject_HashNotImplemented()"로 설정하는 것과 같습니다.

   이 필드는 부모 형에서 해시 메서드의 상속을 차단하기 위해
   "PyObject_HashNotImplemented()"로 명시적으로 설정할 수 있습니다. 이
   것은 파이썬 수준에서의 "__hash__ = None"과 동등한 것으로 해석되어,
   "isinstance(o, collections.Hashable)"이 "False"를 올바르게 반환하게
   합니다. 반대의 경우도 마찬가지입니다 - 파이썬 수준의 클래스에서
   "__hash__ = None"을 설정하면 "tp_hash" 슬롯이
   "PyObject_HashNotImplemented()"로 설정됩니다.

   **계승:**

   그룹: "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()"은 그 형의 생성자를 호출함에 유의하십시오. 이 생
   성자는 "PyObject_Str()"를 호출하여 실제 작업을 수행하고,
   "PyObject_Str()"은 이 처리기를 호출합니다.)

   서명은 "PyObject_Str()"과 같습니다:

      PyObject *tp_str(PyObject *self);

   함수는 문자열이나 유니코드 객체를 반환해야 합니다. 다른 것 중에서도
   , "print()" 함수에 의해 사용될 표현이기 때문에, 객체의 "친숙한" 문
   자열 표현이어야 합니다.

   **계승:**

   이 필드는 서브 형으로 상속됩니다.

   **기본값:**

   이 필드를 설정하지 않으면, 문자열 표현을 반환하기 위해
   "PyObject_Repr()"이 호출됩니다.

getattrofunc PyTypeObject.tp_getattro

   어트리뷰트 읽기(get-attribute) 함수에 대한 선택적 포인터.

   서명은 "PyObject_GetAttr()"과 같습니다:

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

   일반적으로 이 필드를 "PyObject_GenericGetAttr()"로 설정하는 것이 편
   리합니다, 객체 어트리뷰트를 찾는 일반적인 방법을 구현합니다.

   **계승:**

   그룹: "tp_getattr", "tp_getattro"

   이 필드는 "tp_getattr"과 함께 서브 형에 의해 상속됩니다: 서브 형의
   "tp_getattr"과 "tp_getattro"가 모두 "NULL"일 때 서브 형은 베이스형
   에서 "tp_getattr"과 "tp_getattro"를 모두 상속합니다.

   **기본값:**

   "PyBaseObject_Type"은 "PyObject_GenericGetAttr()"을 사용합니다.

setattrofunc PyTypeObject.tp_setattro

   어트리뷰트 설정과 삭제를 위한 함수에 대한 선택적 포인터.

   서명은 "PyObject_SetAttr()"과 같습니다:

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

   또한, *value*를 "NULL"로 설정하여 어트리뷰트를 삭제하는 것을 반드시
   지원해야 합니다. 일반적으로 이 필드를 "PyObject_GenericSetAttr()"로
   설정하는 것이 편리합니다, 객체 어트리뷰트를 설정하는 일반적인 방법
   을 구현합니다.

   **계승:**

   그룹: "tp_setattr", "tp_setattro"

   이 필드는 "tp_setattr"과 함께 서브 형에 의해 상속됩니다: 서브 형의
   "tp_setattr"과 "tp_setattro"가 모두 "NULL"일 때, 서브 형은 베이스형
   에서 "tp_setattr"과 "tp_setattro"를 모두 상속합니다.

   **기본값:**

   "PyBaseObject_Type"은 "PyObject_GenericSetAttr()"을 사용합니다.

PyBufferProcs* PyTypeObject.tp_as_buffer

   버퍼 인터페이스를 구현하는 객체에만 관련된 필드를 포함하는 추가 구
   조체에 대한 포인터. 이 필드는 버퍼 객체 구조체에서 설명합니다.

   **계승:**

   "tp_as_buffer" 필드는 상속되지 않지만, 포함된 필드는 개별적으로 상
   속됩니다.

unsigned long PyTypeObject.tp_flags

   이 필드는 다양한 플래그의 비트 마스크입니다. 일부 플래그는 특정 상
   황에 대한 변형 의미론을 나타냅니다; 다른 것들은 역사적으로 항상 존
   재하지는 않았던 형 객체(또는 "tp_as_number", "tp_as_sequence",
   "tp_as_mapping" 및 "tp_as_buffer"를 통해 참조되는 확장 구조체)의 특
   정 필드가 유효함을 나타내는 데 사용됩니다; 이러한 플래그 비트가 없
   으면, 이것이 보호하는 형 필드에 액세스하지 말아야 하며 대신 0이나
   "NULL" 값을 갖는 것으로 간주해야 합니다.

   **계승:**

   이 필드의 상속은 복잡합니다. 대부분 플래그 비트는 개별적으로 상속됩
   니다, 즉, 베이스형에 플래그 비트가 설정되어 있으면, 서브 형이 이 플
   래그 비트를 상속합니다. 확장 구조체와 관련된 플래그 비트는 확장 구
   조체가 상속되면 엄격하게 상속됩니다, 즉, 플래그 비트의 베이스형의
   값이 확장 구조체에 대한 포인터와 함께 서브 형으로 복사됩니다.
   "Py_TPFLAGS_HAVE_GC" 플래그 비트는 "tp_traverse"와 "tp_clear" 필드
   와 함께 상속됩니다, 즉, 서브 형에서 "Py_TPFLAGS_HAVE_GC" 플래그 비
   트가 설정되지 않고 서브 형의 "tp_traverse"와 "tp_clear" 필드가 존재
   하고 "NULL" 값을 갖는 경우.

   **기본값:**

   "PyBaseObject_Type"은 "Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE"을
   사용합니다.

   **비트 마스크:**

   다음 비트 마스크가 현재 정의되어 있습니다; 이들은 "|" 연산자로 함께
   OR 하여 "tp_flags" 필드의 값을 형성할 수 있습니다. 매크로
   "PyType_HasFeature()"는 형과 플래그 값 *tp*와 *f*를 취하고
   "tp->tp_flags & f"가 0이 아닌지 확인합니다.

   Py_TPFLAGS_HEAPTYPE

      이 비트는 형 객체 자체가 힙에 할당될 때 설정됩니다, 예를 들어,
      "PyType_FromSpec()"을 사용하여 동적으로 만들어진 형. 이 경우, 인
      스턴스의 "ob_type" 필드는 형에 대한 참조로 간주하며, 새 인스턴스
      가 만들어질 때 형 객체가 INCREF되고, 인스턴스가 파괴될 때 DECREF
      됩니다 (이는 서브 형의 인스턴스에 적용되지 않습니다; 인스턴스의
      ob_type이 참조하는 형만 INCREF나 DECREF 됩니다).

      **계승:**

      ???

   Py_TPFLAGS_BASETYPE

      이 비트는 형을 다른 형의 베이스형으로 사용할 수 있을 때 설정됩니
      다. 이 비트가 설정되지 않으면 이 형으로 서브 형을 만들 수 없습니
      다 (Java의 "final" 클래스와 유사합니다).

      **계승:**

      ???

   Py_TPFLAGS_READY

      이 비트는 "PyType_Ready()"에 의해 형 객체가 완전히 초기화될 때
      설정됩니다.

      **계승:**

      ???

   Py_TPFLAGS_READYING

      이 비트는 "PyType_Ready()"가 형 객체를 초기화하는 동안 설정됩니
      다.

      **계승:**

      ???

   Py_TPFLAGS_HAVE_GC

      이 비트는 객체가 가비지 수집을 지원할 때 설정됩니다. 이 비트가
      설정되면, 인스턴스는 "PyObject_GC_New()"를 사용하여 만들어져야
      하고 "PyObject_GC_Del()"을 사용하여 파괴되어야 합니다. 순환 가비
      지 수집 지원 섹션에 추가 정보가 있습니다. 이 비트는 또한 GC 관련
      필드 "tp_traverse"와 "tp_clear"가 형 객체에 있음을 암시합니다.

      **계승:**

      그룹: "Py_TPFLAGS_HAVE_GC", "tp_traverse", "tp_clear"

      "Py_TPFLAGS_HAVE_GC" 플래그 비트는 "tp_traverse"와 "tp_clear" 필
      드와 함께 상속됩니다, 즉, 서브 형에서 "Py_TPFLAGS_HAVE_GC" 플래
      그 비트가 설정되지 않고 서브 형의 "tp_traverse"와 "tp_clear" 필
      드가 존재하고 "NULL" 값을 갖는 경우.

   Py_TPFLAGS_DEFAULT

      이것은 형 객체와 그 확장 구조체에서 특정 필드의 존재와 관련된 모
      든 비트의 비트 마스크입니다. 현재, 다음과 같은 필드를 포함합니다
      : "Py_TPFLAGS_HAVE_STACKLESS_EXTENSION",
      "Py_TPFLAGS_HAVE_VERSION_TAG".

      **계승:**

      ???

   Py_TPFLAGS_METHOD_DESCRIPTOR

      이 비트는 객체가 연결되지 않은 메서드(unbound method)처럼 동작함
      을 나타냅니다.

      이 플래그가 "type(meth)"에 설정되면:

      * "meth.__get__(obj, cls)(*args, **kwds)"("obj"가 None이 아닐 때
        )는 "meth(obj, *args, **kwds)"와 동등해야 합니다.

      * "meth.__get__(None, cls)(*args, **kwds)"는 "meth(*args,
        **kwds)"와 동등해야 합니다.

      이 플래그는 "obj.meth()"와 같은 일반적인 메서드 호출에 대한 최적
      화를 가능하게 합니다: "obj.meth"에 대한 임시 "연결된 메서드
      (bound method)" 객체를 만들지 않습니다.

      버전 3.8에 추가.

      **계승:**

      이 플래그는 힙 형에 의해 상속되지 않습니다. 확장형의 경우,
      "tp_descr_get"이 상속될 때마다 상속됩니다.

   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부터 폐지: 인터프리터는 "tp_finalize" 슬롯이 항상 형 구
      조체에 있다고 가정하기 때문에, 이 플래그는 더는 필요하지 않습니
      다.

   _Py_TPFLAGS_HAVE_VECTORCALL

      이 비트는 클래스가 벡터콜 프로토콜을 구현할 때 설정됩니다. 자세
      한 내용은 "tp_vectorcall_offset"을 참조하십시오.

      **계승:**

      이 비트는 "tp_flags"가 재정의되지 않으면 *정적(static)* 서브 형
      에 설정됩니다: 서브 형의 "tp_call"이 "NULL"이고 서브 형의
      "Py_TPFLAGS_HEAPTYPE"이 설정되지 않을 때 서브 형은 베이스형에서
      "_Py_TPFLAGS_HAVE_VECTORCALL"을 상속합니다.

      힙 형은 "_Py_TPFLAGS_HAVE_VECTORCALL"을 상속하지 않습니다.

      참고:

        이 플래그는 잠정적이며 파이썬 3.9에서 다른 이름과 변경된 의미
        론으로 공개되리라고 봅니다. 벡터콜을 사용하면, 파이썬 3.9 용으
        로 코드를 갱신할 준비를 하십시오.

      버전 3.8에 추가.

const char* PyTypeObject.tp_doc

   이 형 객체에 대한 독스트링을 제공하는 NUL-종료 C 문자열에 대한 선택
   적 포인터. 이는 형과 형의 인스턴스에서 "__doc__" 어트리뷰트로 노출
   됩니다.

   **계승:**

   이 필드는 서브 형에 의해 상속되지 *않습니다*.

traverseproc PyTypeObject.tp_traverse

   가비지 수집기의 탐색 함수에 대한 선택적 포인터.
   "Py_TPFLAGS_HAVE_GC" 플래그 비트가 설정된 경우에만 사용됩니다. 서명
   은 다음과 같습니다:

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

   파이썬의 가비지 수집 체계에 대한 자세한 정보는 섹션 순환 가비지 수
   집 지원에서 찾을 수 있습니다.

   "tp_traverse" 포인터는 가비지 수집기에서 참조 순환을 감지하는 데 사
   용됩니다. "tp_traverse" 함수의 일반적인 구현은 단순히 인스턴스가 소
   유하는 파이썬 객체인 각 인스턴스 멤버에 대해 "Py_VISIT()"를 호출합
   니다. 예를 들어, 다음은 "_thread" 확장 모듈의 함수
   "local_traverse()"입니다:

      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"이나 파이썬 문자열만
   가능해서 참조 순환의 일부가 될 수 없습니다.

   반면에, 멤버가 사이클의 일부가 될 수 없다는 것을 알고 있더라도, 디
   버깅 지원을 위해 "gc" 모듈의 "get_referents()" 함수가 그것을 포함하
   도록 어쨌거나 방문하고 싶을 수 있습니다.

   경고:

     "tp_traverse"를 구현할 때, 인스턴스가 *소유하는*(강한 참조를 유지
     하는) 멤버만 방문해야 합니다. 예를 들어, 객체가 "tp_weaklist" 슬
     롯을 통해 약한 참조를 지원하면, 인스턴스가 자신에 대한 약한 참조
     를 직접 소유하지 않기 때문에 링크드 리스트를 지원하는 포인터
     (*tp_weaklist*가 가리키는 것)를 방문해서는 **안됩니다** (약한 참
     조 리스트는 약한 참조 장치를 지원하기 위해 거기에 있습니다. 하지
     만 인스턴스가 아직 살아 있어도 제거할 수 있어서, 인스턴스는 그 안
     의 요소에 대한 강한 참조를 갖지 않습니다).

   "Py_VISIT()"는 "local_traverse()"의 *visit*와 *arg* 매개 변수가 이
   이름일 것을 요구합니다; 다른 이름을 붙이지 마십시오.

   **계승:**

   그룹: "Py_TPFLAGS_HAVE_GC", "tp_traverse", "tp_clear"

   이 필드는 "tp_clear"와 "Py_TPFLAGS_HAVE_GC" 플래그 비트와 함께 서브
   형에 의해 상속됩니다: 플래그 비트, "tp_traverse" 및 "tp_clear"가 서
   브 형에서 모두 0이면 모두 베이스형에서 상속됩니다.

inquiry PyTypeObject.tp_clear

   가비지 수집기의 정리 함수(clear function)에 대한 선택적 포인터.
   "Py_TPFLAGS_HAVE_GC" 플래그 비트가 설정된 경우에만 사용됩니다. 서명
   은 다음과 같습니다:

      int tp_clear(PyObject *);

   "tp_clear" 멤버 함수는 가비지 수집기에서 감지한 순환 가비지에서 참
   조 순환을 끊는 데 사용됩니다. 종합하여, 시스템의 모든 "tp_clear" 함
   수가 결합하여 모든 참조 순환을 끊어야 합니다. 이것은 미묘합니다, 확
   신이 서지 않으면 "tp_clear" 함수를 제공하십시오. 예를 들어, 튜플 형
   은 "tp_clear" 함수를 구현하지 않습니다. 튜플만으로는 참조 순환이 구
   성될 수 없음을 증명할 수 있기 때문입니다. 따라서 다른 형의
   "tp_clear" 함수만으로 튜플을 포함하는 순환을 끊기에 충분해야 합니다
   . 이것은 그리 자명하지 않으며, "tp_clear"를 구현하지 않아도 좋을 만
   한 이유는 거의 없습니다.

   "tp_clear"의 구현은 다음 예제와 같이 파이썬 객체일 수 있는 자신의
   멤버에 대한 인스턴스의 참조를 삭제하고 해당 멤버에 대한 포인터를
   "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"로 설정될 때까지 포함된 객체에
   대한 참조를 감소시키지 않아야 합니다. 이는 참조 횟수를 줄이면 포함
   된 객체가 버려지게 되어 임의의 파이썬 코드 호출을 포함하는 일련의
   교정 활동을 촉발할 수 있기 때문입니다 (포함된 객체와 연관된 파이널
   라이저나 약한 참조 콜백으로 인해). 그러한 코드가 *self*를 다시 참조
   할 수 있다면, 포함된 객체를 더는 사용할 수 없다는 것을 *self*가 알
   수 있도록, 포함된 객체에 대한 포인터가 그 시점에 "NULL"이 되는 것이
   중요합니다. "Py_CLEAR()" 매크로는 안전한 순서로 작업을 수행합니다.

   "tp_clear" 함수의 목표는 참조 순환을 끊는 것이기 때문에, 참조 순환
   에 참여할 수 없는 파이썬 문자열이나 파이썬 정수와 같은 포함된 객체
   를 정리할 필요는 없습니다. 반면에, 포함된 모든 파이썬 객체를 정리하
   고, 형의 "tp_dealloc" 함수가 "tp_clear"를 호출하도록 작성하는 것이
   편리할 수 있습니다.

   파이썬의 가비지 수집 체계에 대한 자세한 정보는 섹션 순환 가비지 수
   집 지원에서 찾을 수 있습니다.

   **계승:**

   그룹: "Py_TPFLAGS_HAVE_GC", "tp_traverse", "tp_clear"

   이 필드는 "tp_traverse"와 "Py_TPFLAGS_HAVE_GC" 플래그 비트와 함께
   서브 형에 의해 상속됩니다: 플래그 비트, "tp_traverse" 및 "tp_clear"
   가 서브 형에서 모두 0이면 모두 베이스형에서 상속됩니다.

richcmpfunc PyTypeObject.tp_richcompare

   풍부한 비교 함수(rich comparison function)에 대한 선택적 포인터. 서
   명은 다음과 같습니다:

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

   첫 번째 매개 변수는 "PyTypeObject"에 의해 정의된 형의 인스턴스임이
   보장됩니다.

   이 함수는 비교 결과(일반적으로 "Py_True"나 "Py_False")를 반환해야
   합니다. 비교가 정의되어 있지 않으면, "Py_NotImplemented"를 반환하고
   , 다른 에러가 발생하면 "NULL"을 반환하고 예외 조건을 설정해야 합니
   다.

   다음 상수는 "tp_richcompare"와 "PyObject_RichCompare()"의 세 번째
   인자로 사용되도록 정의됩니다:

   +------------------+--------------+
   | 상수             | 비교         |
   |==================|==============|
   | "Py_LT"          | "<"          |
   +------------------+--------------+
   | "Py_LE"          | "<="         |
   +------------------+--------------+
   | "Py_EQ"          | "=="         |
   +------------------+--------------+
   | "Py_NE"          | "!="         |
   +------------------+--------------+
   | "Py_GT"          | ">"          |
   +------------------+--------------+
   | "Py_GE"          | ">="         |
   +------------------+--------------+

   풍부한 비교 함수를 쉽게 작성할 수 있도록 다음 매크로가 정의됩니다:

   Py_RETURN_RICHCOMPARE(VAL_A, VAL_B, op)

      비교 결과에 따라, 함수에서 "Py_True"나 "Py_False"를 반환합니다.
      VAL_A와 VAL_B는 C 비교 연산자로 순서를 정할 수 있어야 합니다 (예
      를 들어, C int나 float일 수 있습니다). 세 번째 인자는
      "PyObject_RichCompare()"에서처럼 요청된 연산을 지정합니다.

      반환 값의 참조 횟수가 올바르게 증가합니다.

      에러가 발생하면, 예외를 설정하고 함수에서 "NULL"을 반환합니다.

      버전 3.7에 추가.

   **계승:**

   그룹: "tp_hash", "tp_richcompare"

   이 필드는 "tp_hash"와 함께 서브 형에 의해 상속됩니다. 서브 형의
   "tp_richcompare"와 "tp_hash"가 모두 "NULL"이면 서브 형은
   "tp_richcompare"와 "tp_hash"를 상속합니다.

   **기본값:**

   "PyBaseObject_Type"은 상속될 수 있는 "tp_richcompare" 구현을 제공합
   니다. 그러나, "tp_hash"만 정의하면, 상속된 함수조차 사용되지 않으며
   해당 형의 인스턴스는 비교에 참여할 수 없습니다.

Py_ssize_t PyTypeObject.tp_weaklistoffset

   이 형의 인스턴스가 약하게 참조할 수 있으면, 이 필드는 0보다 크고 약
   한 참조 리스트 헤드의 인스턴스 구조체에서의 오프셋을 포함합니다 (있
   다면 GC 헤더를 무시하고); 이 오프셋은 "PyObject_ClearWeakRefs()"와
   "PyWeakref_*()" 함수에서 사용됩니다. 인스턴스 구조체에는 "NULL"로
   초기화되는 "PyObject*" 형의 필드가 포함되어야 합니다.

   이 필드를 "tp_weaklist"와 혼동하지 마십시오; 그것은 형 객체 자체에
   대한 약한 참조의 리스트 헤드입니다.

   **계승:**

   이 필드는 서브 형에 의해 상속되지만, 아래 나열된 규칙을 참조하십시
   오. 서브 형이 이 오프셋을 재정의할 수 있습니다; 이는 서브 형이 베이
   스형과 다른 약한 참조 리스트 헤드를 사용함을 의미합니다. 리스트 헤
   드는 항상 "tp_weaklistoffset"을 통해 발견되므로, 문제가 되지 않습니
   다.

   클래스 문으로 정의된 형에 "__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

   이 형의 일반 메서드를 선언하는 "PyMethodDef" 구조체의 정적 "NULL"-
   종료 배열에 대한 선택적 포인터.

   배열의 항목마다, 메서드 디스크립터를 포함하는 형의 딕셔너리(아래
   "tp_dict"를 참조하십시오)에 항목이 추가됩니다.

   **계승:**

   이 필드는 서브 형에 의해 상속되지 않습니다 (메서드는 다른 메커니즘
   을 통해 상속됩니다).

struct PyMemberDef* PyTypeObject.tp_members

   이 형의 인스턴스의 일반 데이터 멤버(필드나 슬롯)를 선언하는
   "PyMemberDef" 구조체의 정적 "NULL"-종료 배열에 대한 선택적 포인터.

   배열의 항목마다, 멤버 디스크립터를 포함하는 형의 딕셔너리(아래
   "tp_dict"를 참조하십시오)에 항목이 추가됩니다.

   **계승:**

   이 필드는 서브 형에 의해 상속되지 않습니다 (멤버는 다른 메커니즘을
   통해 상속됩니다).

struct PyGetSetDef* PyTypeObject.tp_getset

   이 형의 인스턴스의 계산된 어트리뷰트를 선언하는 "PyGetSetDef" 구조
   체의 정적 "NULL"-종료 배열에 대한 선택적 포인터.

   배열의 항목마다, getset 디스크립터를 포함하는 형의 딕셔너리(아래
   "tp_dict"를 참조하십시오)에 항목이 추가됩니다.

   **계승:**

   이 필드는 서브 형에 의해 상속되지 않습니다 (계산된 어트리뷰트는 다
   른 메커니즘을 통해 상속됩니다).

PyTypeObject* PyTypeObject.tp_base

   형 속성이 상속되는 베이스형에 대한 선택적 포인터. 이 수준에서는, 단
   일 상속만 지원됩니다; 다중 상속은 메타 형을 호출하여 형 객체를 동적
   으로 작성해야 합니다.

   참고:

     슬롯 초기화에는 전역 초기화 규칙이 적용됩니다. C99에서는 초기화자
     가 "주소 상수(address constants)"여야 합니다. 포인터로 묵시적으로
     변환되는 "PyType_GenericNew()"와 같은 함수 지정자는 유효한 C99 주
     소 상수입니다.그러나, "PyBaseObject_Type()"과 같은 정적이지 않은
     변수에 적용된 단항 '&' 연산자는 주소 상수를 생성할 필요가 없습니
     다. 컴파일러는 이를 지원할 수 있으며 (gcc는 지원합니다), MSVC는
     지원하지 않습니다. 두 컴파일러 모두 이 특정 동작에서 엄격하게 표
     준을 준수합니다.결과적으로, "tp_base"는 확장 모듈의 초기화 함수에
     서 설정되어야 합니다.

   **계승:**

   이 필드는 서브 형에 의해 상속되지 않습니다 (명백히).

   **기본값:**

   이 필드의 기본값은 "&PyBaseObject_Type"입니다 (파이썬 프로그래머에
   게는 "object" 형으로 알려져 있습니다).

PyObject* PyTypeObject.tp_dict

   형의 딕셔너리는 "PyType_Ready()"에 의해 여기에 저장됩니다.

   이 필드는 일반적으로 PyType_Ready가 호출되기 전에 "NULL"로 초기화되
   어야 합니다; 형의 초기 어트리뷰트를 포함하는 딕셔너리로 초기화될 수
   도 있습니다. 일단 "PyType_Ready()"가 형을 초기화하면, 형에 대한 추
   가 어트리뷰트가 ("__add__()"와 같은) 오버로드된 연산에 해당하지 않
   는 경우에만 이 딕셔너리에 추가될 수 있습니다.

   **계승:**

   이 필드는 서브 형에 의해 상속되지 않습니다 (여기에 정의된 어트리뷰
   트는 다른 메커니즘을 통해 상속됩니다).

   **기본값:**

   이 필드가 "NULL"이면, "PyType_Ready()"는 새 딕셔너리를 할당합니다.

   경고:

     "PyDict_SetItem()"을 사용하거나 다른 식으로 딕셔너리 C-API로
     "tp_dict"를 수정하는 것은 안전하지 않습니다.

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

   이 형의 인스턴스에 인스턴스 변수를 포함하는 딕셔너리가 있으면, 이
   필드는 0이 아니며 인스턴스 변수 딕셔너리 형의 인스턴스에서의 오프셋
   을 포함합니다; 이 오프셋은 "PyObject_GenericGetAttr()"에서 사용됩니
   다.

   이 필드를 "tp_dict"와 혼동하지 마십시오; 그것은 형 객체 자체의 어트
   리뷰트에 대한 딕셔너리입니다.

   이 필드의 값이 0보다 크면, 인스턴스 구조체의 시작으로부터의 오프셋
   을 지정합니다. 값이 0보다 작으면, 인스턴스 구조체의 *끝*으로부터의
   오프셋을 지정합니다. 음수 오프셋은 사용하기네 더 비싸며, 인스턴스
   구조체에 가변 길이 부분이 포함될 때에만 사용해야 합니다. 예를 들어
   인스턴스 변수 딕셔너리를 "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"을 통해 발견되므로, 문제가 되지 않아
   야 합니다.

   클래스 문으로 정의된 형에 "__slots__" 선언이 없고, 인스턴스 변수 딕
   셔너리를 갖는 베이스형이 없을 때, 딕셔너리 슬롯이 인스턴스 배치에
   추가되고 "tp_dictoffset"은 해당 슬롯의 오프셋으로 설정됩니다.

   클래스 문으로 정의된 형에 "__slots__" 선언이 있으면, 형은 베이스형
   에서 "tp_dictoffset"을 상속합니다.

   ("__slots__" 선언에 "__dict__"라는 슬롯을 추가해도 기대하는 효과는
   없고, 단지 혼란을 초래합니다. 그러나 "__weakref__"처럼 기능으로 추
   가해야 할 수도 있습니다.)

   **기본값:**

   이 슬롯에는 기본값이 없습니다. 정적 형의 경우, 이 필드가 "NULL"이면
   인스턴스에 대해 "__dict__"가 만들어지지 않습니다.

initproc PyTypeObject.tp_init

   인스턴스 초기화 함수에 대한 선택적 포인터.

   이 함수는 클래스의 "__init__()" 메서드에 해당합니다. "__init__()"와
   마찬가지로, "__init__()"를 호출하지 않고 인스턴스를 작성할 수 있으
   며, "__init__()" 메서드를 다시 호출하여 인스턴스를 다시 초기화 할
   수 있습니다.

   함수 서명은 다음과 같습니다:

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

   self 인자는 초기화될 인스턴스입니다; *args*와 *kwds* 인자는
   "__init__()" 호출의 위치와 키워드 인자를 나타냅니다.

   "NULL"이 아닐 때, "tp_init" 함수는 형을 호출하여 인스턴스를 정상적
   으로 만들 때, 형의 "tp_new" 함수가 형의 인스턴스를 반환한 후 호출됩
   니다. "tp_new" 함수가 원래 형의 서브 형이 아닌 다른 형의 인스턴스를
   반환하면, 아무런 "tp_init" 함수도 호출되지 않습니다; "tp_new"가 원
   래 형의 서브 형 인스턴스를 반환하면, 서브 형의 "tp_init"가 호출됩니
   다.

   성공하면 "0"을 반환하고, 에러 시에는 "-1"을 반환하고 예외를 설정합
   니다.

   **계승:**

   이 필드는 서브 형으로 상속됩니다.

   **기본값:**

   정적 형의 경우 이 필드에는 기본값이 없습니다.

allocfunc PyTypeObject.tp_alloc

   인스턴스 할당 함수에 대한 선택적 포인터.

   함수 서명은 다음과 같습니다:

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

   **계승:**

   이 필드는 정적 서브 형에 의해 상속되지만, 동적 서브 형(클래스 문으
   로 만들어진 서브 형)에는 상속되지 않습니다.

   **기본값:**

   동적 서브 형의 경우, 이 필드는 표준 힙 할당 전략을 강제하기 위해 항
   상 "PyType_GenericAlloc()"으로 설정됩니다.

   정적 서브 형의 경우, "PyBaseObject_Type"은 "PyType_GenericAlloc()"
   을 사용합니다. 이것이 정적으로 정의된 모든 형에 권장되는 값입니다.

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"인 정적 형에
   의해 상속되지 않는 것을 제외하고 서브 형에 의해 상속됩니다.

   **기본값:**

   정적 형의 경우 이 필드에는 기본값이 없습니다. 이는 슬롯이 "NULL"로
   정의되었을 때, 새 인스턴스를 만들기 위해 형을 호출할 수 없음을 뜻합
   니다; 아마도 팩토리 함수와 같은, 인스턴스를 만드는 다른 방법이 있을
   것입니다.

freefunc PyTypeObject.tp_free

   인스턴스 할당 해제 함수에 대한 선택적 포인터. 서명은 다음과 같습니
   다:

      void tp_free(void *self);

   이 서명과 호환되는 초기화자는 "PyObject_Free()"입니다.

   **계승:**

   이 필드는 정적 서브 형에 의해 상속되지만, 동적 서브 형(클래스 문으
   로 만들어진 서브 형)에는 상속되지 않습니다.

   **기본값:**

   동적 서브 형에서, 이 필드는 "PyType_GenericAlloc()"과
   "Py_TPFLAGS_HAVE_GC" 플래그 비트의 값과 일치하기에 적합한 할당 해제
   기로 설정됩니다.

   정적 서브 형의 경우, "PyBaseObject_Type"은 PyObject_Del을 사용합니
   다.

inquiry PyTypeObject.tp_is_gc

   가비지 수집기에서 호출되는 함수에 대한 선택적 포인터.

   가비지 수집기는 특정 객체가 수집 가능한지를 알아야 합니다. 일반적으
   로, 객체 형의 "tp_flags" 필드를 보고, "Py_TPFLAGS_HAVE_GC" 플래그
   비트를 확인하면 충분합니다. 그러나 일부 형에는 정적과 동적으로 할당
   된 인스턴스가 혼합되어 있으며, 정적으로 할당된 인스턴스는 수집할 수
   없습니다. 이러한 형은 이 함수를 정의해야 합니다; 수집 가능한 인스턴
   스이면 "1"을, 수집 불가능한 인스턴스이면 "0"을 반환해야 합니다. 서
   명은 다음과 같습니다:

      int tp_is_gc(PyObject *self);

   (이것의 유일한 예는 형 자체입니다. 메타 형, "PyType_Type"은 이 함수
   를 정의하여 정적으로 할당된 형과 동적으로 할당된 형을 구별합니다.)

   **계승:**

   이 필드는 서브 형으로 상속됩니다.

   **기본값:**

   이 슬롯에는 기본값이 없습니다. 이 필드가 "NULL"이면,
   "Py_TPFLAGS_HAVE_GC"가 기능적 동등물로 사용됩니다.

PyObject* PyTypeObject.tp_bases

   베이스형의 튜플.

   이것은 클래스 문으로 만들어진 형에 대해 설정됩니다. 정적으로 정의된
   형의 경우 "NULL"이어야 합니다.

   **계승:**

   이 필드는 상속되지 않습니다.

PyObject* PyTypeObject.tp_mro

   형 자체에서 시작하여 "object"로 끝나는 확장된 베이스형 집합을 포함
   하는 튜플.

   **계승:**

   이 필드는 상속되지 않습니다; "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"가 설정되면, 인터프리터는 인스턴스를 파이널라이즈 할
   때 이를 한 번 호출합니다. 가비지 수집기(인스턴스가 격리된 참조 순환
   의 일부인 경우)나 객체가 할당 해제되기 직전에 호출됩니다. 어느 쪽이
   든, 참조 순환을 끊기 전에 호출되어 정상 상태에 있는 객체를 보도록
   보장합니다.

   "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

   0이 아닌 "tp_allocs" 필드를 가진 이전 형 객체를 가리키는 포인터.

PyTypeObject* PyTypeObject.tp_next

   0이 아닌 "tp_allocs" 필드를 가진 다음 형 객체를 가리키는 포인터.

또한, 가비지 수집된 파이썬에서, "tp_dealloc"은 객체를 만든 스레드뿐만
아니라, 모든 파이썬 스레드에서 호출될 수 있습니다 (객체가 참조 횟수 순
환의 일부가 되면, 해당 순환은 모든 스레드에서의 가비지 수집으로 수집될
수 있습니다). tp_dealloc이 호출되는 스레드는 GIL(전역 인터프리터 록 -
Global Interpreter Lock)을 소유하므로, 파이썬 API 호출에는 문제가 되지
않습니다. 그러나, 파괴되는 중인 객체가 다른 C나 C++ 라이브러리의 객체
를 파괴하면, tp_dealloc을 호출한 스레드에서 그 객체를 파괴해도 라이브
러리의 가정을 위반하지 않는지 주의해야 합니다.


힙 형
=====

전통적으로, C 코드에서 정의된 형은 *정적(static)*입니다. 즉 정적
"PyTypeObject" 구조체는 코드에서 직접 정의되고 "PyType_Ready()"를 사용
하여 초기화됩니다.

결과적으로 파이썬에서 정의된 형에 비해 형이 제한됩니다:

* 정적 형은 하나의 베이스로 제한됩니다. 즉, 다중 상속을 사용할 수 없습
  니다.

* 정적 형 객체(그러나 이들의 인스턴스는 아닙니다)는 불변입니다. 파이썬
  에서 형 객체의 어트리뷰트를 추가하거나 수정할 수 없습니다.

* 정적 형 객체는 서브 인터프리터에서 공유되므로, 서브 인터프리터 관련
  상태를 포함하지 않아야 합니다.

또한, "PyTypeObject"는 안정 ABI의 일부가 아니므로, 정적 형을 사용하는
확장 모듈은 특정 파이썬 부 버전(minir version)에 맞게 컴파일해야 합니
다.

정적 형에 대한 대안은 *힙 할당된 형(heap-allocated types)*, 또는 짧게
*힙 형(heap types)*, 인데 이는 파이썬의 "class" 문으로 작성된 클래스와
밀접한 관련이 있습니다.

"PyType_Spec" 구조체를 채우고 "PyType_FromSpecWithBases()"를 호출하면
됩니다.


숫자 객체 구조체
****************

PyNumberMethods

   이 구조체는 객체가 숫자 프로토콜을 구현하는 데 사용하는 함수에 대한
   포인터를 담습니다. 각 함수는 숫자 프로토콜 섹션에서 설명하는 유사한
   이름의 함수가 사용합니다.

   구조체 정의는 다음과 같습니다:

      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"
     라고 했으며, 파이썬 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

   이 구조체에는 객체가 매핑 프로토콜을 구현하는 데 사용하는 함수에 대
   한 포인터를 담습니다. 세 개의 멤버가 있습니다:

lenfunc PyMappingMethods.mp_length

   이 함수는 "PyMapping_Size()"와 "PyObject_Size()"에서 사용되며, 같은
   서명을 갖습니다. 객체에 길이가 정의되어 있지 않으면 이 슬롯을
   "NULL"로 설정할 수 있습니다.

binaryfunc PyMappingMethods.mp_subscript

   이 함수는 "PyObject_GetItem()"과 "PySequence_GetSlice()"에서 사용되
   며, "PyObject_GetItem()"과 같은 서명을 갖습니다.
   "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

   이 함수는 "PySequence_Size()"와 "PyObject_Size()"에서 사용되며, 같
   은 서명을 갖습니다. 또한 "sq_item"과 "sq_ass_item" 슬롯을 통해 음수
   인덱스를 처리하는 데 사용됩니다.

binaryfunc PySequenceMethods.sq_concat

   이 함수는 "PySequence_Concat()"에서 사용되며 같은 서명을 갖습니다.
   "nb_add" 슬롯을 통해 숫자 덧셈을 시도한 후, "+" 연산자에서도 사용됩
   니다.

ssizeargfunc PySequenceMethods.sq_repeat

   이 함수는 "PySequence_Repeat()"에서 사용되며 같은 서명을 갖습니다.
   "nb_multiply" 슬롯을 통해 숫자 곱셈을 시도한 후, "*" 연산자에서도
   사용됩니다.

ssizeargfunc PySequenceMethods.sq_item

   이 함수는 "PySequence_GetItem()"에서 사용되며 같은 서명을 갖습니다.
   "mp_subscript" 슬롯을 통해 서브스크립션(subscription)을 시도한 후,
   "PyObject_GetItem()"에서도 사용됩니다. "PySequence_Check()" 함수가
   "1"을 반환하려면, 이 슬롯을 채워야합니다, 그렇지 않으면 "NULL"일 수
   있습니다.

   음의 인덱스는 다음과 같이 처리됩니다: "sq_length" 슬롯이 채워지면,
   이를 호출하고 시퀀스 길이를 사용하여 "sq_item"에 전달되는 양의 인덱
   스를 계산합니다. "sq_length"가 "NULL"이면, 인덱스는 그대로 함수에
   전달됩니다.

ssizeobjargproc PySequenceMethods.sq_ass_item

   이 함수는 "PySequence_SetItem()"에서 사용되며 같은 서명을 갖습니다.
   "mp_ass_subscript" 슬롯을 통해 항목 대입과 삭제를 시도한 후,
   "PyObject_SetItem()"과 "PyObject_DelItem()"에서도 사용됩니다. 객체
   가 항목 대입과 삭제를 지원하지 않으면 이 슬롯은 "NULL"로 남겨 둘 수
   있습니다.

objobjproc PySequenceMethods.sq_contains

   이 함수는 "PySequence_Contains()"에서 사용될 수 있으며 같은 서명을
   갖습니다. 이 슬롯은 "NULL"로 남겨 둘 수 있습니다, 이때
   "PySequence_Contains()"는 일치하는 것을 찾을 때까지 시퀀스를 단순히
   탐색합니다.

binaryfunc PySequenceMethods.sq_inplace_concat

   이 함수는 "PySequence_InPlaceConcat()"에서 사용되며 같은 서명을 갖
   습니다. 첫 번째 피연산자를 수정하고 그것을 반환해야 합니다. 이 슬롯
   은 "NULL"로 남겨 둘 수 있으며, 이때 "PySequence_InPlaceConcat()"은
   "PySequence_Concat()"으로 폴백 됩니다. "nb_inplace_add" 슬롯을 통해
   숫자 제자리 덧셈을 시도한 후, 증분 대입 "+="에서 사용됩니다.

ssizeargfunc PySequenceMethods.sq_inplace_repeat

   이 함수는 "PySequence_InPlaceRepeat()"에서 사용되며 같은 서명을 갖
   습니다. 첫 번째 피연산자를 수정하고 그것을 반환해야 합니다. 이 슬롯
   은 "NULL"로 남겨 둘 수 있으며, 이때 "PySequence_InPlaceRepeat()"는
   "PySequence_Repeat()"로 폴백 됩니다. "nb_inplace_multiply" 슬롯을
   통해 숫자 제자리 곱셈을 시도한 후, 증분 대입 "*="에서도 사용됩니다.


버퍼 객체 구조체
****************

PyBufferProcs

   이 구조체는 버퍼 프로토콜에 필요한 함수에 대한 포인터를 담습니다.
   프로토콜은 제공자(exporter) 객체가 내부 데이터를 소비자 객체에 노출
   하는 방법을 정의합니다.

getbufferproc PyBufferProcs.bf_getbuffer

   이 함수의 서명은 다음과 같습니다:

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

   *view*를 채우기 위해 *exporter*에 대한 *flags*에 지정된 요청을 처리
   합니다. 포인트 (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"일 수 있습니다. 그렇지 않
   으면, 이 함수의 표준 구현은 다음과 같은 선택적 단계를 수행합니다:

   1. 내보내기 횟수에 대한 내부 카운터를 줄입니다.

   2. 카운터가 "0"이면, *view*와 관련된 모든 메모리를 해제합니다.

   제공자는 반드시 "internal" 필드를 사용하여 버퍼 특정 자원을 추적해
   야 합니다. 이 필드는 변경되지 않고 유지됨이 보장되지만, 소비자는 원
   래 버퍼의 사본을 *view* 인자로 전달할 수 있습니다.

   이 함수는 "PyBuffer_Release()"에서 자동으로 수행되므로 "view->obj"
   를 절대 감소시키지 않아야 합니다 (이 체계는 참조 순환을 끊는 데 유
   용합니다).

   "PyBuffer_Release()"는 이 기능을 감싸는 소비자 용 인터페이스입니다.


비동기 객체 구조체
******************

버전 3.5에 추가.

PyAsyncMethods

   이 구조체는 *어웨이터블*와 *비동기 이터레이터* 객체를 구현하는 데
   필요한 함수에 대한 포인터를 담습니다.

   구조체 정의는 다음과 같습니다:

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

unaryfunc PyAsyncMethods.am_await

   이 함수의 서명은 다음과 같습니다:

      PyObject *am_await(PyObject *self);

   반환된 객체는 이터레이터여야 합니다, 즉, "PyIter_Check()"는 반환된
   객체에 대해 "1"을 반환해야 합니다.

   객체가 *어웨이터블*이 아니면 이 슬롯을 "NULL"로 설정할 수 있습니다.

unaryfunc PyAsyncMethods.am_aiter

   이 함수의 서명은 다음과 같습니다:

      PyObject *am_aiter(PyObject *self);

   *어웨이터블* 객체를 반환해야 합니다. 자세한 내용은 "__anext__()"를
   참조하십시오.

   객체가 비동기 이터레이션 프로토콜을 구현하지 않으면 이 슬롯은
   "NULL"로 설정될 수 있습니다.

unaryfunc PyAsyncMethods.am_anext

   이 함수의 서명은 다음과 같습니다:

      PyObject *am_anext(PyObject *self);

   *어웨이터블* 객체를 반환해야 합니다. 자세한 내용은 "__anext__()"를
   참조하십시오. 이 슬롯은 "NULL"로 설정될 수 있습니다.


슬롯 형 typedef
***************

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

   이 함수의 목적은 메모리 초기화에서 메모리 할당을 분리하는 것입니다.
   인스턴스에 적합한 길이의, 적절하게 정렬되고, 0으로 초기화되지만,
   "ob_refcnt"는 "1"로 설정되고 "ob_type"은 형 인자로 설정된 메모리 블
   록에 대한 포인터를 반환해야 합니다. 형의 "tp_itemsize"가 0이 아니면
   , 객체의 "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)

   "tp_vectorcall_offset"을 참조하십시오.

   "vectorcallfunc"에 대한 인자는 "_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 *)


예
**

다음은 파이썬 형 정의의 간단한 예입니다. 여기에는 여러분이 만날 수 있
는 일반적인 사용법이 포함됩니다. 일부는 까다로운 코너 사례를 보여줍니
다. 더 많은 예제, 실용 정보 및 자습서는 확장형 정의하기: 자습서와 확장
형 정의하기: 여러 가지 주제를 참조하십시오.

기본 정적 형:

   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 *),
   };
