类型对象¶

也许Python对象系统最重要的结构之一是定义新类型的结构： PyTypeObject 结构。类型对象可以使用 PyObject_* 或 PyType_* 函数，但对于大多数Python应用程序来说，它提供的内容并不多。这些对象是对象行为的基础，因此它们对于解释器本身和实现新类型的任何扩展模块都非常重要。

与大多数标准类型相比，类型对象相当大。大小的原因是每个类型对象存储大量的值，主要是C函数指针，每个指针实现类型功能的一小部分。在本节中，将详细检查类型对象的字段。这些字段将按它们在结构中出现的顺序进行描述。

除了以下快速参考外，实例本节简要介绍了 PyTypeObject .

快速引用¶

“TP插槽”¶

pytypeobject槽 1	Type	特殊方法/注意事项	信息 2
pytypeobject槽 1	Type	特殊方法/注意事项	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_offset`	Py_ssize_t			X		X
(`tp_getattr` ）	`getattrfunc`	__getattribute__, __getattr__				G
(`tp_setattr` ）	`setattrfunc`	__setattr__, __delattr__				G
`tp_as_async`	`PyAsyncMethods` *	子槽				%
`tp_repr`	`reprfunc`	__repr__	X	X		X
`tp_as_number`	`PyNumberMethods` *	子槽				%
`tp_as_sequence`	`PySequenceMethods` *	子槽				%
`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__, __getattr__	X	X		G
`tp_setattro`	`setattrofunc`	__setattr__, __delattr__	X	X		G
`tp_as_buffer`	`PyBufferProcs` *					%
`tp_flags`	无符号长		X	X		是吗？
`tp_doc`	const char *	__doc__	X	X
`tp_traverse`	`traverseproc`			X		G
`tp_clear`	`inquiry`			X		G
`tp_richcompare`	`richcmpfunc`	__lt__, __le__, __eq__, __ne__, __gt__, __ge__	X			G
`tp_weaklistoffset`	Py_ssize_t			X		是吗？
`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__, __delete__				X
`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`]	无符号整型
`tp_finalize`	`destructor`	__del__				X
`tp_vectorcall`	`vectorcallfunc`

1

括号中的槽名表示（实际上）已弃用。尖括号中的名称应视为只读。方括号中的名称仅供内部使用。”<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

请注意，一些槽是通过普通属性查找链有效继承的。

子槽¶

狭槽	Type	特殊方法
`am_await`	`unaryfunc`	__await__
`am_aiter`	`unaryfunc`	__aiter__
`am_anext`	`unaryfunc`	__anext__
`am_send`	`sendfunc`

`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`	空洞*
`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_multiply`	`binaryfunc`	__matmul__

`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`	`releasebufferproc()`

插槽类型¶

类型定义	参数类型	返回类型
`allocfunc`	`PyTypeObject` * Py_ssize_t	`PyObject` *
`destructor`	空洞*	无效
`freefunc`	空洞*	无效
`traverseproc`	空洞* `visitproc` 空洞*	int
`newfunc`	`PyObject` * `PyObject` * `PyObject` *	`PyObject` *
`initproc`	`PyObject` * `PyObject` * `PyObject` *	int
`reprfunc`	`PyObject` *	`PyObject` *
`getattrfunc`	`PyObject` * const char *	`PyObject` *
`setattrfunc`	`PyObject` * const char * `PyObject` *	int
`getattrofunc`	`PyObject` * `PyObject` *	`PyObject` *
`setattrofunc`	`PyObject` * `PyObject` * `PyObject` *	int
`descrgetfunc`	`PyObject` * `PyObject` * `PyObject` *	`PyObject` *
`descrsetfunc`	`PyObject` * `PyObject` * `PyObject` *	int
`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` *	无效
`inquiry`	空洞*	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` * `PyObject` *	int

见槽类型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;

PyObjor槽¶

类型对象结构扩展了 PyVarObject 结构。这个 ob_size 字段用于动态类型（由 type_new() ，通常从类语句调用）。注意 PyType_Type （元类型）初始化 tp_itemsize ，这意味着它的实例（即类型对象） must 有 ob_size 字段。

PyObject *PyObject._ob_next¶

PyObject *PyObject._ob_prev¶

只有当宏 Py_TRACE_REFS 定义。它们的初始化为 NULL 由 PyObject_HEAD_INIT 宏。对于静态分配的对象，这些字段始终保留 NULL . 对于动态分配的对象，这两个字段用于将对象链接到 all 堆中的活动对象。这可以用于各种调试目的；当前唯一的用途是打印在运行结束时仍处于活动状态的对象，当环境变量 PYTHONDUMPREFS 被设置。

继承：

这些字段不是子类型继承的。

Py_ssize_t PyObject.ob_refcnt¶

这是类型对象的引用计数，初始化为 1 由 PyObject_HEAD_INIT 宏。注意，对于静态分配的类型对象，类型的实例（对象 ob_type 指向类型）do not 作为引用计数。但是对于动态分配的类型对象，实例 do 作为引用计数。

继承：

子类型不继承此字段。

PyTypeObject *PyObject.ob_type¶

这是类型的类型，换句话说就是它的元类型。它由参数初始化为 PyObject_HEAD_INIT 宏，其值通常应为 &PyType_Type . 但是，对于必须在Windows上可用的动态可加载扩展模块（至少），编译器会抱怨这不是有效的初始值设定项。因此，公约将通过 NULL 到 PyObject_HEAD_INIT 宏并在模块初始化函数开始时显式初始化此字段，然后再执行其他操作。通常这样做：

Foo_Type.ob_type = &PyType_Type;

这应该在创建类型的任何实例之前完成。 PyType_Ready() 检查是否 ob_type 是 NULL ，如果是，则将其初始化为 ob_type 基类的字段。 PyType_Ready() 如果该字段为非零，则不会更改该字段。

继承：

此字段由子类型继承。

PyvarObject插槽¶

Py_ssize_t PyVarObject.ob_size¶

对于静态分配的类型对象，应该将其初始化为零。对于动态分配的类型对象，此字段具有特殊的内部含义。

继承：

子类型不继承此字段。

pytypeobject插槽¶

每个槽都有一个描述继承的部分。如果 PyType_Ready() 当字段设置为时可以设置值 NULL 然后还有一个“默认”部分。（请注意，在 PyBaseObject_Type 和 PyType_Type 有效地作为默认值。）

const char *PyTypeObject.tp_name¶

指向包含类型名称的以nul结尾的字符串的指针。对于可以作为模块全局变量访问的类型，字符串应该是完整的模块名，后跟一个点，后跟类型名；对于内置类型，它应该只是类型名。如果模块是包的子模块，则完整包名称是完整模块名称的一部分。例如，名为 T 在模块中定义 M 分包 Q 包内 P 应该有 tp_name 初始化器 "P.Q.M.T" .

对于动态分配的类型对象，这应该只是类型名，模块名显式存储在类型dict中作为键的值。 '__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¶

这些字段允许以字节为单位计算类型实例的大小。

有两种类型：具有固定长度实例的类型具有零 tp_itemsize 字段，具有可变长度实例的类型具有非零 tp_itemsize 字段。对于具有固定长度实例的类型，所有实例的大小都相同，如 tp_basicsize .

对于具有可变长度实例的类型，实例必须具有 ob_size 字段，实例大小为 tp_basicsize 加N次 tp_itemsize ，其中n是对象的“长度”。n的值通常存储在实例的 ob_size 字段。有例外：例如，ints使用负 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 ）

对于具有可变长度实例的任何类型，此字段不能是 NULL .

继承：

这些字段由子类型单独继承。如果基类型具有非零 tp_itemsize ，一般不安全 tp_itemsize 子类型中的另一个非零值（尽管这取决于基类型的实现）。

destructor PyTypeObject.tp_dealloc¶

指向实例析构函数的指针。必须定义此函数，除非类型保证永远不会释放其实例（对于单例实例也是如此） None 和 Ellipsis ）函数签名为：

void tp_dealloc(PyObject *self);

析构函数由 Py_DECREF() 和 Py_XDECREF() 新引用计数为零时的宏。此时，实例仍然存在，但没有引用它。析构函数应该释放实例拥有的所有引用，释放实例拥有的所有内存缓冲区（使用与用于分配缓冲区的分配函数相对应的释放函数），并调用类型的 tp_free 功能。如果类型不是子类型（没有 Py_TPFLAGS_BASETYPE 标志位集），允许直接调用对象dealLocator而不是via tp_free . 对象释放定位器应该是用于分配实例的对象；这通常是 PyObject_Del() 如果使用 PyObject_New() 或 PyObject_VarNew() 或 PyObject_GC_Del() 如果使用 PyObject_GC_New() 或 PyObject_GC_NewVar() .

最后，如果类型是堆分配的 (Py_TPFLAGS_HEAPTYPE )，在调用类型deallocator之后，deallocator应减少其类型对象的引用计数。为了避免指针悬空，建议的方法是：

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¶

每个实例函数的可选偏移量，该函数使用 vectorcall protocol ，更有效的替代方案 tp_call .

只有当标志 Py_TPFLAGS_HAVE_VECTORCALL 已设置。如果是这样，则它必须是一个正整数，其中包含 vectorcallfunc 指针。

这个 矢量调用函数 指针可以是 NULL ，在这种情况下，实例的行为就像 Py_TPFLAGS_HAVE_VECTORCALL 未设置：调用实例将回滚到 tp_call .

任何设置的类 Py_TPFLAGS_HAVE_VECTORCALL 还必须设置 tp_call 并确保其行为与 矢量调用函数 功能。这可以通过设置 tp_call 到 PyVectorcall_Call() .

警告

不建议用于 heap types 实现VectorCall协议。当用户设置 __call__ 仅在python代码中 tp_call 更新，可能使其与vectorcall函数不一致。

注解

的语义 tp_vectorcall_offset 槽是临时的，预计将在python 3.9中完成。如果使用vectorcall，请计划更新python 3.9的代码。

在 3.8 版更改: 在版本3.8之前，这个插槽被命名为 tp_print . 在Python2.x中，它用于打印到文件。在Python3.0到3.7中，它是未使用的。

继承：

此字段始终被继承。然而 Py_TPFLAGS_HAVE_VECTORCALL 标志并不总是继承的。如果不是，那么子类就不会使用 vectorcall ，除非 PyVectorcall_Call() 被显式调用。尤其是 heap types （包括在Python中定义的子类）。

getattrfunc PyTypeObject.tp_getattr¶

指向get attribute string函数的可选指针。

此字段已弃用。当它被定义时，它应该指向一个与 tp_getattro 函数，但使用C字符串而不是python字符串对象来给出属性名。

继承：

组： tp_getattr ， tp_getattro

此字段与子类型一起继承 tp_getattro ：子类型同时继承 tp_getattr 和 tp_getattro 当子类型 tp_getattr 和 tp_getattro 都是 NULL .

setattrfunc PyTypeObject.tp_setattr¶

指向函数的可选指针，用于设置和删除属性。

此字段已弃用。当它被定义时，它应该指向一个与 tp_setattro 函数，但使用C字符串而不是python字符串对象来给出属性名。

继承：

组： tp_setattr ， tp_setattro

此字段与子类型一起继承 tp_setattro ：子类型同时继承 tp_setattr 和 tp_setattro 当子类型 tp_setattr 和 tp_setattro 都是 NULL .

PyAsyncMethods *PyTypeObject.tp_as_async¶

指向包含仅与实现的对象相关的字段的附加结构的指针 awaitable 和 asynchronous iterator C级协议。见异步对象结构有关详细信息。

3.5 新版功能: 以前称为 tp_compare 和 tp_reserved .

继承：

这个 tp_as_async 字段不是继承的，但包含的字段是单独继承的。

reprfunc PyTypeObject.tp_repr¶

指向实现内置函数的函数的可选指针 repr() .

签名与 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() .

签名与 PyObject_Hash() ：：

Py_hash_t tp_hash(PyObject *);

价值 -1 不应作为正常返回值返回；在计算hash值期间发生错误时，函数应设置异常并返回 -1 .

未设置此字段时（ and tp_richcompare 未设置），尝试获取对象的hash引发 TypeError . 这与将其设置为 PyObject_HashNotImplemented() .

此字段可以显式设置为 PyObject_HashNotImplemented() 阻止父类型的hash方法继承。这被解释为等同于 __hash__ = None 在python级别，导致 isinstance(o, collections.Hashable) 正确返回 False . 请注意，相反的设置也是正确的。 __hash__ = None 在python级别的类上，将导致 tp_hash 插槽设置为 PyObject_HashNotImplemented() .

继承：

组： tp_hash ， tp_richcompare

此字段与子类型一起继承 tp_richcompare ：子类型继承了 tp_richcompare 和 tp_hash ，当子类型 tp_richcompare 和 tp_hash 都是 NULL .

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);

函数必须返回字符串或Unicode对象。它应该是对象的“友好”字符串表示，因为这是一种表示，将由 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 当子类型 tp_getattr 和 tp_getattro 都是 NULL .

违约：

PyBaseObject_Type 使用 PyObject_GenericGetAttr() .

setattrofunc PyTypeObject.tp_setattro¶

指向函数的可选指针，用于设置和删除属性。

签名与 PyObject_SetAttr() ：：

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

此外，设置价值到 NULL 必须支持删除属性。通常将此字段设置为 PyObject_GenericSetAttr() 实现了设置对象属性的正常方式。

继承：

组： tp_setattr ， tp_setattro

此字段与子类型一起继承 tp_setattr ：子类型同时继承 tp_setattr 和 tp_setattro 当子类型 tp_setattr 和 tp_setattro 都是 NULL .

违约：

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 ）历史上并不总是存在的类型是有效的；如果这样的标志位是清晰的，那么它所保护的类型字段就不能被访问，并且必须被认为是零或 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 .

位口罩：

当前定义了以下位掩码；可以使用 | 运算符以形成 tp_flags 字段。宏 PyType_HasFeature() 获取类型和标志值， tp 和 f ，并检查 tp->tp_flags & f 为非零。

Py_TPFLAGS_HEAPTYPE¶

当类型对象本身被分配到堆上时（例如，使用 PyType_FromSpec() . 在这种情况下， ob_type 其实例的字段被视为对类型的引用，在创建新实例时增加类型对象，在销毁实例时减少类型对象（这不适用于子类型的实例；只有实例的ob类型引用的类型才会增加或减少）。

继承：

？？？？

Py_TPFLAGS_BASETYPE¶

当类型可以用作其他类型的基类型时，将设置此位。如果此位是明确的，则该类型不能是子类型的（类似于Java中的“最终”类）。

继承：

？？？？

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¶

此位表示对象的行为类似于未绑定的方法。

如果此标志设置为 type(meth) 然后：

meth.__get__(obj, cls)(*args, **kwds) （与 obj 不是无）必须等于 meth(obj, *args, **kwds) .
meth.__get__(None, cls)(*args, **kwds) 必须等于 meth(*args, **kwds) .

此标志可优化典型方法调用，如 obj.meth() ：它避免为创建临时“绑定方法”对象 obj.meth .

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¶

当类实现 vectorcall protocol . 见 tp_vectorcall_offset 有关详细信息。

继承：

此位继承用于 静止的 子类型如果 tp_call 也是遗传的。 Heap types 不继承 Py_TPFLAGS_HAVE_VECTORCALL .

3.9 新版功能.

Py_TPFLAGS_HAVE_AM_SEND¶: 此位在以下情况下设置 am_send 条目位于 tp_as_async 字型结构的槽。

3.10 新版功能.

const char *PyTypeObject.tp_doc¶

指向以nul结尾的c字符串的可选指针，为该类型对象提供docstring。这暴露为 __doc__ 类型和类型实例的属性。

继承：

这个字段是 not 由子类型继承。

traverseproc PyTypeObject.tp_traverse¶

指向垃圾收集器遍历函数的可选指针。只有当 Py_TPFLAGS_HAVE_GC 标志位已设置。签名是：

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

有关python垃圾收集方案的更多信息，请参见支持循环垃圾收集 .

这个 tp_traverse 垃圾收集器使用指针来检测引用循环。一个典型的 tp_traverse 函数只是调用 Py_VISIT() 在实例的每个成员（实例拥有的Python对象）上。例如，这是函数 local_traverse() 从 _thread 扩展模块：

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() 功能将包括它。

警告

在实施时 tp_traverse ，仅实例 owns (通过拥有 strong references 对他们来说)必须被访问。例如，如果对象通过 tp_weaklist 槽，支持链表的指针(什么 tp_weaklist 指向)必须 not 因为实例不直接拥有对其自身的弱引用(弱引用列表在那里是为了支持弱引用机制，但是实例没有对其内部元素的强引用，因为即使实例仍然活着，也允许移除这些元素)，所以可以访问这些元素。

注意 Py_VISIT() 需要参观和 arg 参数到 local_traverse() 要有这些特定的名字，不要随便给它们命名。

堆分配类型 (Py_TPFLAGS_HEAPTYPE ，例如 PyType_FromSpec() 以及类似的api）保存对其类型的引用。因此，它们的遍历函数必须访问 Py_TYPE(self) ，或通过调用 tp_traverse 属于另一个堆分配类型（例如堆分配的超类）。如果没有，类型对象可能不会被垃圾回收。

在 3.9 版更改: 堆分配类型应访问 Py_TYPE(self) 在里面 tp_traverse . 在早期版本的Python中，由于 bug 40217 ，这样做可能会导致子类崩溃。

继承：

组： Py_TPFLAGS_HAVE_GC ， tp_traverse ， tp_clear

此字段与子类型一起继承 tp_clear 以及 Py_TPFLAGS_HAVE_GC 标志位：标志位， tp_traverse 和 tp_clear 如果子类型中都为零，则都继承自基类型。

inquiry PyTypeObject.tp_clear¶

指向垃圾收集器清除函数的可选指针。只有当 Py_TPFLAGS_HAVE_GC 标志位已设置。签名是：

int tp_clear(PyObject *);

这个 tp_clear 成员函数用于中断垃圾收集器检测到的循环垃圾中的引用循环。所有人合二为一 tp_clear 系统中的函数必须组合在一起以中断所有参考循环。这是微妙的，如果有任何疑问，请提供 tp_clear 功能。例如，tuple类型不实现 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代码（由于与包含的对象关联的终结器或weakref回调）。如果这种代码可以引用的话 self 同样，指向所包含对象的指针 NULL 当时，所以 self 知道所包含的对象不能再使用。这个 Py_CLEAR() 宏按安全顺序执行操作。

因为目标是 tp_clear 函数是为了打破引用循环，不需要清除包含的对象，如不能参与引用循环的python字符串或python整数。另一方面，清除所有包含的python对象并编写类型的 tp_dealloc 要调用的函数 tp_clear .

有关python垃圾收集方案的更多信息，请参见支持循环垃圾收集 .

继承：

组： Py_TPFLAGS_HAVE_GC ， tp_traverse ， tp_clear

此字段与子类型一起继承 tp_traverse 以及 Py_TPFLAGS_HAVE_GC 标志位：标志位， tp_traverse 和 tp_clear 如果子类型中都为零，则都继承自基类型。

richcmpfunc PyTypeObject.tp_richcompare¶

指向富比较函数的可选指针，其签名为：

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 当子类型 tp_richcompare 和 tp_hash 都是 NULL .

违约：

PyBaseObject_Type 提供了一个 tp_richcompare 实现，可以继承。但是，如果只有 tp_hash 已定义，甚至不使用继承的函数，并且类型的实例将无法参与任何比较。

Py_ssize_t PyTypeObject.tp_weaklistoffset¶

如果此类型的实例是弱引用的，则此字段大于零，并且包含弱引用列表头的实例结构中的偏移量（如果存在，则忽略GC头）；此偏移量由 PyObject_ClearWeakRefs() 以及 PyWeakref_* 功能。实例结构需要包含类型为的字段 PyObject* 初始化为 NULL .

不要将此字段与 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 A StopIteration 可以设置例外，也可以不设置例外。当发生另一个错误时，它必须返回 NULL 也是。它的存在表示这种类型的实例是迭代器。

迭代器类型还应定义 tp_iter 函数，该函数应返回迭代器实例本身（而不是新的迭代器实例）。

此函数的签名与 PyIter_Next() .

继承：

此字段由子类型继承。

struct PyMethodDef *PyTypeObject.tp_methods¶

指向静态的可选指针 NULL -终止的数组 PyMethodDef 结构，声明此类型的常规方法。

对于数组中的每个条目，都会向类型的字典中添加一个条目（请参见 tp_dict 下面）包含一个方法描述符。

继承：

此字段不是由子类型继承的（方法是通过其他机制继承的）。

struct PyMemberDef *PyTypeObject.tp_members¶

指向静态的可选指针 NULL -终止的数组 PyMemberDef 结构，声明此类型实例的常规数据成员（字段或槽）。

对于数组中的每个条目，都会向类型的字典中添加一个条目（请参见 tp_dict 下面）包含成员描述符。

继承：

此字段不由子类型继承（成员通过其他机制继承）。

struct PyGetSetDef *PyTypeObject.tp_getset¶

指向静态的可选指针 NULL -终止的数组 PyGetSetDef 结构，声明此类型实例的计算属性。

对于数组中的每个条目，都会向类型的字典中添加一个条目（请参见 tp_dict 下面）包含getset描述符。

继承：

此字段不是由子类型继承的（计算属性是通过其他机制继承的）。

PyTypeObject *PyTypeObject.tp_base¶

指向从中继承类型属性的基类型的可选指针。在此级别上，只支持单个继承；多个继承需要通过调用元类型动态创建类型对象。

注解

插槽初始化遵循全局初始化规则。C99要求初始值设定项为“地址常量”。函数指示符 PyType_GenericNew() 对于隐式转换为指针，是有效的C99地址常量。

但是，一元“&”运算符应用于非静态变量，例如 PyBaseObject_Type() 不需要生成地址常量。编译器可能支持这个（gcc支持），而msvc不支持。这两个编译器在这个特定行为中都是严格标准的。

因此， tp_base 应该在扩展模块的init函数中设置。

继承：

此字段不由子类型继承（显然）。

违约：

此字段默认为 &PyBaseObject_Type （对于python程序员来说，它被称为类型 object ）

PyObject *PyTypeObject.tp_dict¶

类型的字典存储在此处 PyType_Ready() .

此字段通常应初始化为 NULL 在调用pytype_ready之前，它还可以初始化为包含该类型的初始属性的字典。一次 PyType_Ready() 已经初始化了类型，只有当类型的额外属性与重载操作（如 __add__() ）

继承：

此字段不是由子类型继承的（尽管此处定义的属性是通过其他机制继承的）。

违约：

如果此字段是 NULL ， PyType_Ready() 将为其分配新词典。

警告

使用不安全 PyDict_SetItem() 在或以其他方式修改 tp_dict 使用字典C-API。

descrgetfunc PyTypeObject.tp_descr_get¶

指向“descriptor 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);

这个价值参数设置为 NULL 删除值。

继承：

此字段由子类型继承。

Py_ssize_t PyTypeObject.tp_dictoffset¶

如果此类型的实例具有包含实例变量的字典，则此字段为非零，并且包含实例变量字典类型的实例中的偏移量；此偏移量由 PyObject_GenericGetAttr() .

不要将此字段与 tp_dict ；这是类型对象本身属性的字典。

如果此字段的值大于零，则指定从实例结构开始的偏移量。如果该值小于零，则指定从 end 实例结构的。负偏移量的使用成本更高，并且只应在实例结构包含可变长度部分时使用。例如，它用于将实例变量字典添加到的子类型 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 从实例中获取。取绝对值是因为ints使用了 ob_size 储存号码的符号。（没有必要自己计算；它是由 _PyObject_GetDictPtr() ）

继承：

此字段由子类型继承，但请参见下面列出的规则。子类型可以重写此偏移量；这意味着子类型实例将字典存储在与基类型不同的偏移量处。因为字典总是通过 tp_dictoffset ，这应该不是问题。

当类语句定义的类型没有 __slots__ 声明，并且它的任何基类型都没有实例变量字典，字典槽将添加到实例布局和 tp_dictoffset 设置为该插槽的偏移量。

当类语句定义的类型具有 __slots__ 声明，类型继承其 tp_dictoffset 从它的基类型。

（添加名为 __dict__ 到 __slots__ 声明没有预期的效果，只会引起混乱。也许这应该作为一个特性添加，就像 __weakref__ 虽然）

违约：

这个插槽没有默认值。对于静态类型，如果字段是 NULL 那么没有 __dict__ 为实例创建。

initproc PyTypeObject.tp_init¶

指向实例初始化函数的可选指针。

此函数对应于 __init__() 类的方法。类似于 __init__() ，可以在不调用的情况下创建实例 __init__() ，并且可以通过调用 __init__() 再次方法。

函数签名为：

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

自变量是要初始化的实例；自变量 args 和 kwds 参数表示调用的位置参数和关键字参数 __init__() .

这个 tp_init 功能，如果不是 NULL ，在通常通过在类型的 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);

这个亚型参数是要创建的对象的类型；参数 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() .

继承：

此字段由静态子类型继承，而不是由动态子类型继承（由Class语句创建的子类型）

违约：

在动态子类型中，此字段设置为适合匹配的释放定位器 PyType_GenericAlloc() 以及 Py_TPFLAGS_HAVE_GC 标志位。

对于静态子类型， PyBaseObject_Type 使用PyObject属性。

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 ）

vectorcallfunc PyTypeObject.tp_vectorcall¶

用于此类型对象的调用的矢量调用函数。换句话说，它用于实现 vectorcall 对于 type.__call__ .如果 tp_vectorcall 是 NULL ，默认调用实现使用 __new__ 和 __init__ 使用。

继承：

此字段从不继承。

3.9 新版功能: （该字段从3.8开始存在，但仅从3.9开始使用）

另外，请注意，在垃圾收集的python中， tp_dealloc 可以从任何python线程调用，而不仅仅是创建该对象的线程（如果该对象成为refcount循环的一部分，则该循环可能由任何线程上的垃圾收集收集收集）。这对python api调用来说不是问题，因为调用tp_dealloc的线程将拥有全局解释器锁（gil）。然而，如果被破坏的对象反过来又破坏了来自其他C或C++库的对象，则应注意确保销毁线程上称为Tpl DELoLc的那些对象不会违反库的任何假设。

堆类型¶

传统上，在C代码中定义的类型是 静止的 也就是说，静态 PyTypeObject 结构直接在代码中定义并使用 PyType_Ready() .

这会导致类型相对于在python中定义的类型受到限制：

静态类型仅限于一个基，即它们不能使用多个继承。
静态类型对象（但不一定是它们的实例）是不可变的。不能从python添加或修改类型对象的属性。
静态类型对象在 sub-interpreters ，因此它们不应包括任何子解释器特定的状态。

还有，因为 PyTypeObject 不是 stable ABI ，任何使用静态类型的扩展模块都必须针对特定的Python次要版本进行编译。

静态类型的另一种选择是 heap-allocated types 或 堆类型 简而言之，它与python创建的类紧密对应 class 语句。

这是通过填充 PyType_Spec 结构和调用 PyType_FromSpecWithBases() .

数字对象结构¶

type 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 ，并在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¶

映射对象结构¶

type 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 ，对象不支持项分配和删除。

序列对象结构¶

type 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() 并且有相同的签名。它也被 PyObject_GetItem() ，在尝试通过 mp_subscript 狭槽。必须为 PySequence_Check() 要返回的函数 1 它可以是 NULL 否则。

负索引的处理方式如下：如果 sq_length 槽已填充，将调用它，并使用序列长度计算传递给 sq_item . 如果 sq_length 是 NULL ，索引按原样传递给函数。

ssizeobjargproc PySequenceMethods.sq_ass_item¶: 此函数由使用 PySequence_SetItem() 并且有相同的签名。它也被 PyObject_SetItem() 和 PyObject_DelItem() ，在尝试通过 mp_ass_subscript 狭槽。这个槽可以留给 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 狭槽。

缓冲区对象结构¶

type PyBufferProcs¶: 此结构保存指向 Buffer protocol . 该协议定义导出器对象如何向使用者对象公开其内部数据。

getbufferproc PyBufferProcs.bf_getbuffer¶

此函数的签名为：

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

处理请求 出口商 填写 view 按规定 flags . 除第（3）点外，此功能的实现必须采取以下步骤：

检查是否可以满足请求。如果没有，提高 PyExc_BufferError ，集合 view->obj 到 NULL 然后返回 -1 .
填写请求的字段。
为导出数增加一个内部计数器。
集合 view->obj 到 出口商 增量 view->obj .
返回 0 .

如果 出口商 作为缓冲区提供者链或树的一部分，可以使用两种主要方案：

重新导出：树的每个成员都充当导出对象和集 view->obj 对自身的新引用。
重定向：缓冲区请求被重定向到树的根对象。在这里， view->obj 将是对根对象的新引用。

个人领域 view 在第节中描述 Buffer structure ，有关出口商必须如何应对特定请求的规则，请参见第节。 Buffer request types .

所有的记忆都指向 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 . 否则，此功能的标准实现将采取以下可选步骤：

减少出口数量的内部计数器。
如果计数器是 0 ，释放所有与 view .

出口商必须使用 internal 用于跟踪缓冲区特定资源的字段。此字段保证保持不变，而使用者可以将原始缓冲区的副本作为 view 参数。

此函数不能递减 view->obj ，因为这是在 PyBuffer_Release() （此方案可用于中断参考循环）。

PyBuffer_Release() 是封装此功能的使用者的接口。

异步对象结构¶

3.5 新版功能.

type PyAsyncMethods¶

此结构保留指向实现所需函数的指针 awaitable 和 asynchronous iterator 物体。

结构定义如下：

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

unaryfunc PyAsyncMethods.am_await¶

此函数的签名为：

PyObject *am_await(PyObject *self);

返回的对象必须是迭代器，即 PyIter_Check() 必须返回 1 为了它。

此插槽可以设置为 NULL 如果对象不是 awaitable .

unaryfunc PyAsyncMethods.am_aiter¶

此函数的签名为：

PyObject *am_aiter(PyObject *self);

必须返回 awaitable 对象。参见 __anext__() 有关详细信息。

此插槽可以设置为 NULL 如果对象不实现异步迭代协议。

unaryfunc PyAsyncMethods.am_anext¶

此函数的签名为：

PyObject *am_anext(PyObject *self);

必须返回 awaitable 对象。参见 __anext__() 详情。此插槽可以设置为 NULL .

sendfunc PyAsyncMethods.am_send¶

此函数的签名为：

PySendResult am_send(PyObject *self, PyObject *arg, PyObject **result);

看见 PyIter_Send() 有关详细信息，请参阅。此插槽可以设置为 NULL 。

槽类型typedef¶

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

此函数的目的是将内存分配与内存初始化分开。它应该返回一个指向内存块的指针，该内存块有足够的长度，适当地对齐并初始化为零，但是 ob_refcnt 设置为 1 和 ob_type 设置为类型参数。如果类型的 tp_itemsize 非零，对象的 ob_size 字段应初始化为 硝酸甘油酯 分配的内存块的长度应该是 tp_basicsize + nitems*tp_itemsize ，四舍五入为 sizeof(void*) ，否则， 硝酸甘油酯 不使用，块的长度应为 tp_basicsize .

这个函数不应该进行任何其他实例初始化，甚至不应该分配额外的内存；这应该由 tp_new .

typedef void (*destructor)(PyObject*)¶

typedef void (*freefunc)(void*)¶: 见 tp_free .

typedef PyObject *(*newfunc)(PyObject*, PyObject*, PyObject*)¶: 见 tp_new .

typedef int (*initproc)(PyObject*, PyObject*, PyObject*)¶: 见 tp_init .

typedef PyObject *(*reprfunc)(PyObject*)¶: 见 tp_repr .

typedef PyObject *(*getattrfunc)(PyObject *self, char *attr)¶: 返回对象的命名属性的值。

typedef int (*setattrfunc)(PyObject *self, char *attr, PyObject *value)¶: 为对象设置命名属性的值。值参数设置为 NULL 删除属性。

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

返回对象的命名属性的值。

见 tp_getattro .

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

为对象设置命名属性的值。值参数设置为 NULL 删除属性。

见 tp_setattro .

typedef PyObject *(*descrgetfunc)(PyObject*, PyObject*, PyObject*)¶: 见 tp_descrget .

typedef int (*descrsetfunc)(PyObject*, PyObject*, PyObject*)¶: 见 tp_descrset .

typedef Py_hash_t (*hashfunc)(PyObject*)¶: 见 tp_hash .

typedef PyObject *(*richcmpfunc)(PyObject*, PyObject*, int)¶: 见 tp_richcompare .

typedef PyObject *(*getiterfunc)(PyObject*)¶: 见 tp_iter .

typedef PyObject *(*iternextfunc)(PyObject*)¶: 见 tp_iternext .

typedef Py_ssize_t (*lenfunc)(PyObject*)¶

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

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

typedef PyObject *(*unaryfunc)(PyObject*)¶

typedef PyObject *(*binaryfunc)(PyObject*, PyObject*)¶

typedef PySendResult (*sendfunc)(PyObject*, PyObject*, PyObject**)¶: 看见 am_send 。

typedef PyObject *(*ternaryfunc)(PyObject*, PyObject*, PyObject*)¶

typedef PyObject *(*ssizeargfunc)(PyObject*, Py_ssize_t)¶

typedef int (*ssizeobjargproc)(PyObject*, Py_ssize_t)¶

typedef int (*objobjproc)(PyObject*, PyObject*)¶

typedef 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 */
};

支持weakrefs、实例dicts和hash的类型：

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子类（例如，使用单独的factory func）：：

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

类型对象¶

快速引用¶

“TP插槽”¶

子槽¶

插槽类型¶

pytypeobject定义¶

PyObjor槽¶

PyvarObject插槽¶

pytypeobject插槽¶

堆类型¶

数字对象结构¶

映射对象结构¶

序列对象结构¶

缓冲区对象结构¶

异步对象结构¶

槽类型typedef¶

实例¶

Table of Contents

上一个主题

下一个主题