类型对象

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

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

类型定义：一元函数、二元函数、三元函数、查询、强制、intargfunc、intintargfunc、intobjargproc、intintobjargproc、objobjargproc、析构函数、freefunc、printfunc、getattrfunc、getattrofunc、setattrfunc、setattrofunc、cmpfunc、reprfunc、hashfunc

PyTypeObject 的结构定义可以在 Include/object.h 中找到。为了方便参考，这里重复了在那里找到的定义：

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

    /* Methods to implement standard operations */

    destructor tp_dealloc;
    printfunc tp_print;
    getattrfunc tp_getattr;
    setattrfunc tp_setattr;
    cmpfunc tp_compare;
    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 */
    long tp_flags;

    char *tp_doc; /* Documentation string */

    /* Assigned meaning in release 2.0 */
    /* call function for all accessible objects */
    traverseproc tp_traverse;

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

    /* Assigned meaning in release 2.1 */
    /* rich comparisons */
    richcmpfunc tp_richcompare;

    /* weak reference enabler */
    long tp_weaklistoffset;

    /* Added in release 2.2 */
    /* 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;
    long 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;

} PyTypeObject;

类型对象结构扩展了 PyVarObject 结构。 ob_size 字段用于动态类型（由 type_new() 创建，通常从类语句调用）。注意 PyType_Type（元类型）初始化 tp_itemsize，这意味着它的实例（即类型对象）必须有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

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

该字段不被子类型继承。

2.5 版本变更：该字段曾经是 int 类型。这可能需要更改您的代码才能正确支持 64 位系统。

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，如果是，则对其进行初始化：在 Python 2.2 中，它被设置为 &PyType_Type；在 Python 2.2.1 及更高版本中，它被初始化为基类的 ob_type 字段。 PyType_Ready() 如果该字段不为零，则不会更改该字段。

在 Python 2.2 中，这个字段不被子类型继承。在 2.2.1 和 2.3 及更高版本中，它由子类型继承。

Py_ssize_t PyVarObject.ob_size

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

该字段不被子类型继承。

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 创建的模块文档中。

该字段不被子类型继承。

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 字段中。也有例外：例如，long int 使用负数 ob_size 表示负数，而 N 则是 abs(ob_size)。此外，实例布局中存在 ob_size 字段并不意味着实例结构是可变长度的（例如，列表类型的结构具有固定长度的实例，但这些实例具有有意义的 ob_size 字段）。

基本大小包括由宏 PyObject_HEAD 或 PyObject_VAR_HEAD（以用于声明实例结构体）声明的实例中的字段，而这又包括 _ob_prev和 _ob_next 字段（如果存在）。这意味着获取 tp_basicsize 初始化程序的唯一正确方法是在用于声明实例布局的结构上使用 sizeof 运算符。基本大小不包括 GC 头大小（这是 Python 2.2 中的新内容；在 2.1 和 2.0 中，GC 头大小包含在 tp_basicsize 中）。

这些字段由子类型单独继承。如果基类型具有非零 tp_itemsize，则将 tp_itemsize 设置为子类型中不同的非零值通常是不安全的（尽管这取决于基本类型）。

关于对齐的注意事项：如果变量项需要特定对齐，则应通过 tp_basicsize 的值来处理。示例：假设一个类型实现了一个 double 数组。 tp_itemsize 是 sizeof(double)。 tp_basicsize 是 sizeof(double) 的倍数是程序员的责任（假设这是 double 的对齐要求）。

destructor PyTypeObject.tp_dealloc

指向实例析构函数的指针。这个函数必须被定义，除非类型保证它的实例永远不会被释放（就像单例 None 和 Ellipsis 的情况）。

当新的引用计数为零时，析构函数由 Py_DECREF() 和 Py_XDECREF() 宏调用。此时，实例仍然存在，但没有对它的引用。析构函数应该释放实例拥有的所有引用，释放实例拥有的所有内存缓冲区（使用与用于分配缓冲区的分配函数对应的释放函数），最后（作为它的最后一个动作）调用类型的 [X270X ]tp_free 函数。如果类型不是子类型化的（没有设置 Py_TPFLAGS_BASETYPE 标志位），则允许直接调用对象释放器而不是通过 tp_free。对象释放器应该是用来分配实例的；这通常是 PyObject_Del() 如果实例是使用 PyObject_New() 或 PyObject_VarNew() 分配的，或者 PyObject_GC_Del() 如果实例已分配使用 PyObject_GC_New() 或 PyObject_GC_NewVar()。

该字段由子类型继承。

printfunc PyTypeObject.tp_print

指向实例打印函数的可选指针。

打印函数仅在实例打印到 real 文件时调用；当它被打印到一个伪文件（如 StringIO 实例）时，实例的 tp_repr 或 tp_str 函数被调用以将其转换为字符串。当类型的 tp_print 字段为 NULL 时，也会调用这些。类型永远不应该以产生与 tp_repr 或 tp_str 不同的输出的方式实现 tp_print。

使用与 PyObject_Print(): int tp_print(PyObject *self, FILE *file, int flags) 相同的签名调用打印函数。 self 参数是要打印的实例。 file 参数是要打印到的 stdio 文件。 flags 参数由标志位组成。当前定义的唯一标志位是 Py_PRINT_RAW。当设置 Py_PRINT_RAW 标志位时，实例的打印方式应与 tp_str 的格式化方式相同；当 Py_PRINT_RAW 标志位被清除时，该实例的打印方式应与 tp_repr 将其格式化相同。它应该返回 -1 并在比较过程中发生错误时设置异常条件。

tp_print 字段可能会被弃用。无论如何，建议不要定义tp_print，而是依靠tp_repr和tp_str进行打印。

该字段由子类型继承。

getattrfunc PyTypeObject.tp_getattr

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

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

PyObject * tp_getattr(PyObject *o, char *attr_name);

该字段与 tp_getattro 一起被子类型继承：当子类型的 tp_gettr] 和 tp_gettr tp_getattro 都是 NULL。

setattrfunc PyTypeObject.tp_setattr

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

此字段已弃用。定义时，它应该指向一个与 tp_setattro 函数作用相同的函数，但采用 C 字符串而不是 Python 字符串对象来给出属性名称。签名是

PyObject * tp_setattr(PyObject *o, char *attr_name, PyObject *v);

v 参数设置为 NULL 以删除属性。该字段由子类型与 tp_setattro 一起继承：当子类型的 tp193X] 和 tp_setattr tp_setattro 都是 NULL。

cmpfunc PyTypeObject.tp_compare

指向三路比较函数的可选指针。

签名与 PyObject_Compare() 相同。如果 self 大于 other，则函数应该返回 1，如果 self 等于 other[，则返回 0 X131X] 和 -1 如果 self 小于 other。它应该返回 -1 并在比较过程中发生错误时设置异常条件。

该字段与 tp_richcompare 和 tp_hash 一起被子类型继承：子类型继承 tp_compare、tp_richcompare、、 tp_hash 当子类型的 tp_compare、tp_richcompare 和 tp_hash 都是 NULL.

reprfunc PyTypeObject.tp_repr

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

签名与 PyObject_Repr() 相同；它必须返回一个字符串或一个 Unicode 对象。理想情况下，这个函数应该返回一个字符串，当传递给 eval() 时，给定合适的环境，返回一个具有相同值的对象。如果这不可行，它应该返回一个以 '<' 开头并以 '>' 结尾的字符串，从中可以推导出对象的类型和值。

如果未设置此字段，则返回 <%s object at %p> 形式的字符串，其中 %s 替换为类型名称，%p 替换为对象的内存地址。

该字段由子类型继承。

PyNumberMethods *tp_as_number

指向包含仅与实现数字协议的对象相关的字段的附加结构的指针。这些字段记录在数字对象结构中。

tp_as_number 字段不是继承的，但是包含的字段是单独继承的。

PySequenceMethods *tp_as_sequence

指向包含仅与实现序列协议的对象相关的字段的附加结构的指针。这些字段记录在序列对象结构中。

tp_as_sequence 字段不是继承的，但是包含的字段是单独继承的。

PyMappingMethods *tp_as_mapping

指向包含仅与实现映射协议的对象相关的字段的附加结构的指针。这些字段记录在映射对象结构中。

tp_as_mapping 字段不是继承的，但是包含的字段是单独继承的。

hashfunc PyTypeObject.tp_hash

指向实现内置函数 hash() 的函数的可选指针。

签名与 PyObject_Hash() 相同；它必须返回一个 C long。值 -1 不应作为正常返回值返回；当哈希值计算过程中发生错误时，函数应设置异常并返回-1。

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

当不设置该字段时，有两种可能：如果tp_compare和tp_richcompare字段都是NULL，则返回一个基于对象地址的默认哈希值; 否则，会引发 TypeError。

该字段由子类型与 tp_richcompare 和 tp_compare 一起继承：子类型继承 tp_compare、tp_richcompare、、 tp_hash，当子类型的tp_compare、tp_richcompare和tp_hash都是NULL时

ternaryfunc PyTypeObject.tp_call

指向实现调用对象的函数的可选指针。如果对象不可调用，这应该是 NULL。签名与 PyObject_Call() 相同。

该字段由子类型继承。

reprfunc PyTypeObject.tp_str

指向实现内置操作 str() 的函数的可选指针。（注意 str 现在是一个类型，而 str() 调用该类型的构造函数。此构造函数调用 PyObject_Str() 来完成实际工作，而 PyObject_Str() 将调用此处理程序。）

签名与 PyObject_Str() 相同；它必须返回一个字符串或一个 Unicode 对象。此函数应返回对象的“友好”字符串表示，因为这是打印语句将使用的表示。

如果未设置此字段，则调用 PyObject_Repr() 以返回字符串表示形式。

该字段由子类型继承。

getattrofunc PyTypeObject.tp_getattro

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

签名与 PyObject_GetAttr() 相同。通常将此字段设置为 PyObject_GenericGetAttr() 很方便，它实现了查找对象属性的正常方式。

该字段由子类型与 tp_getattr 一起继承：当子类型的 tp_getattr] 和 tp_gettr tp_getattro 都是 NULL。

setattrofunc PyTypeObject.tp_setattro

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

签名与 PyObject_SetAttr() 相同，但必须支持将 v 设置为 NULL 以删除属性。通常将此字段设置为 PyObject_GenericSetAttr() 会很方便，它实现了设置对象属性的正常方式。

该字段与 tp_setattr 一起被子类型继承：当子类型的 tp192X] 和 tp_setattr 从其基本类型继承 tp_setattr tp_setattro 都是 NULL。

PyBufferProcs *PyTypeObject.tp_as_buffer

指向包含仅与实现缓冲区接口的对象相关的字段的附加结构的指针。这些字段记录在缓冲区对象结构中。

tp_as_buffer 字段不是继承的，但是包含的字段是单独继承的。

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 字段存在（如 Py_TPFLAGS1标志位）并具有 NULL 值。

当前定义了以下位掩码；这些可以使用 | 运算符进行或运算以形成 tp_flags 字段的值。宏 PyType_HasFeature() 接受类型和标志值 tp 和 f，并检查 tp->tp_flags & f 是否非零。

Py_TPFLAGS_HAVE_GETCHARBUFFER: 如果设置了该位，则 tp_as_buffer 引用的 PyBufferProcs 结构具有 bf_getcharbuffer 字段。

Py_TPFLAGS_HAVE_SEQUENCE_IN: 如果设置了该位，则 tp_as_sequence 引用的 PySequenceMethods 结构具有 sq_contains 字段。

Py_TPFLAGS_GC: 这一点已经过时了。它用来命名的位不再使用。该符号现在定义为零。

Py_TPFLAGS_HAVE_INPLACEOPS: 如果设置了该位，则 tp_as_sequence 引用的 PySequenceMethods 结构和 tp_as_number 引用的 PyNumberMethods 结构包含就地运算符的字段。特别是，这意味着 PyNumberMethods 结构具有字段 nb_inplace_add、nb_inplace_subtract、nb_inplace_multiply、nb_inplace_divide、[ X133X]、nb_inplace_power、nb_inplace_lshift、nb_inplace_rshift、nb_inplace_and、nb_inplace_xor和nb_inplace_or；并且 PySequenceMethods 结构具有字段 sq_inplace_concat 和 sq_inplace_repeat。

Py_TPFLAGS_CHECKTYPES: 如果设置了此位，则 tp_as_number 引用的 PyNumberMethods 结构中的二元和三元运算接受任意对象类型的参数，并在需要时进行自己的类型转换。如果此位清除，则这些操作要求所有参数都将当前类型作为其类型，并且调用者应该首先执行强制操作。这适用于 nb_add、nb_subtract、nb_multiply、nb_divide、nb_remainder、nb_divmod、nb_power ]、nb_lshift、nb_rshift、nb_and、nb_xor 和 nb_or。

Py_TPFLAGS_HAVE_RICHCOMPARE: 如果设置了该位，则类型对象具有 tp_richcompare 字段，以及 tp_traverse 和 tp_clear 字段。

Py_TPFLAGS_HAVE_WEAKREFS: 如果设置了该位，则定义 tp_weaklistoffset 字段。如果类型的 tp_weaklistoffset 字段的值大于零，则该类型的实例是弱可引用的。

Py_TPFLAGS_HAVE_ITER: 如果设置了该位，则类型对象具有 tp_iter 和 tp_iternext 字段。

Py_TPFLAGS_HAVE_CLASS: 如果设置了这个位，类型对象有几个从 Python 2.2 开始定义的新字段： tp_methods, tp_members, tp_getset, tp_base[X16] , tp_dict, tp_descr_get, tp_descr_set, tp_dictoffset, ,tp_inittp_init X296X]tp_new、tp_free、tp_is_gc、tp_bases、tp_mro[X3839X]、[X3839X]xp_mro[X3839X] tp_subclasses 和 tp_weaklist。

Py_TPFLAGS_HEAPTYPE: 当类型对象本身在堆上分配时，该位被设置。在这种情况下，其实例的 ob_type 字段被认为是对该类型的引用，并且在创建新实例时对类型对象进行 INCREF 处理，在实例销毁时进行 DECREF 处理（这不会不适用于子类型的实例；只有实例的 ob_type 引用的类型被 INCREF'ed 或 DECREF'ed）。

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 清除但设置 Py_TPFLAGS_HAVE_RICHCOMPARE 时，这些字段也存在。

Py_TPFLAGS_DEFAULT: 这是与类型对象及其扩展结构中某些字段的存在有关的所有位的位掩码。目前，它包括下列位： Py_TPFLAGS_HAVE_GETCHARBUFFER ， Py_TPFLAGS_HAVE_SEQUENCE_IN ， Py_TPFLAGS_HAVE_INPLACEOPS ， Py_TPFLAGS_HAVE_RICHCOMPARE ， Py_TPFLAGS_HAVE_WEAKREFS ，[X231X ]Py_TPFLAGS_HAVE_ITER 和 Py_TPFLAGS_HAVE_CLASS。

char *PyTypeObject.tp_doc

一个指向以 NUL 结尾的 C 字符串的可选指针，给出此类型对象的文档字符串。这作为类型和类型实例的 __doc__ 属性公开。

该字段是 不是由子类型继承的 。

以下三个字段仅在设置了 Py_TPFLAGS_HAVE_RICHCOMPARE 标志位时才存在。

traverseproc PyTypeObject.tp_traverse

指向垃圾收集器遍历函数的可选指针。这仅在设置了 Py_TPFLAGS_HAVE_GC 标志位时使用。有关 Python 垃圾收集方案的更多信息，请参见支持循环垃圾收集部分。

垃圾收集器使用 tp_traverse 指针来检测引用周期。 tp_traverse 函数的典型实现简单地调用 Py_VISIT() 对每个实例的成员是 Python 对象。例如，这是来自 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 或 Python 字符串，因此不能成为引用循环的一部分。

另一方面，即使您知道成员永远不会成为循环的一部分，作为调试帮助，您可能仍然希望访问它，就像 gc 模块的 get_referents()函数将包括它。

请注意， Py_VISIT() 需要 visit 和 arg 参数到 local_traverse() 以具有这些特定名称；不要随便命名它们。

该字段与tp_clear和Py_TPFLAGS_HAVE_GC标志位一起被子类型继承：标志位，tp_traverse和tp_clear]都是继承的从基本类型开始，如果它们在子类型和中都为零，则子类型设置了 Py_TPFLAGS_HAVE_RICHCOMPARE 标志位。

inquiry PyTypeObject.tp_clear

指向垃圾收集器清除函数的可选指针。这仅在设置了 Py_TPFLAGS_HAVE_GC 标志位时使用。

tp_clear成员函数用于在垃圾收集器检测到的循环垃圾中中断引用循环。综上所述，系统中的所有 tp_clear 函数必须结合起来才能打破所有参考循环。这是微妙的，如果有任何疑问，请提供 tp_clear 函数。例如，元组类型没有实现 tp_clear 函数，因为可以证明没有引用循环可以完全由元组组成。因此，其他类型的 tp_clear 函数必须足以中断任何包含元组的循环。这不是很明显，而且很少有充分的理由避免实现 tp_clear。

tp_clear 的实现应该删除实例对其可能是 Python 对象的成员的引用，并将其指向这些成员的指针设置为 NULL，如下例所示：

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

应该使用 Py_CLEAR() 宏，因为清除引用是微妙的：在指向所包含对象的指针设置为 NULL 之前，不得减少对所包含对象的引用。这是因为减少引用计数可能会导致包含的对象变成垃圾，触发一系列回收活动，其中可能包括调用任意 Python 代码（由于与包含的对象关联的终结器或弱引用回调）。如果这样的代码有可能再次引用 self，那么此时指向所包含对象的指针是 NULL 很重要，这样 self 就知道所包含的对象不能再使用对象。 Py_CLEAR() 宏以安全的顺序执行操作。

因为 tp_clear 函数的目标是打破引用循环，所以没有必要清除包含的对象，如 Python 字符串或 Python 整数，它们不能参与引用循环。另一方面，清除所有包含的 Python 对象可能会很方便，并编写类型的 tp_dealloc 函数来调用 tp_clear。

有关 Python 垃圾收集方案的更多信息，请参见支持循环垃圾收集部分。

该字段与tp_traverse和Py_TPFLAGS_HAVE_GC标志位一起被子类型继承：标志位，tp_traverse和tp_clear][X16]都是继承的从基本类型开始，如果它们在子类型和中都为零，则子类型设置了 Py_TPFLAGS_HAVE_RICHCOMPARE 标志位。

richcmpfunc PyTypeObject.tp_richcompare

指向富比较函数的可选指针，其签名为 PyObject *tp_richcompare(PyObject *a, PyObject *b, int op)。

该函数应返回比较的结果（通常为 Py_True 或 Py_False）。如果比较未定义，则必须返回 Py_NotImplemented，如果发生另一个错误，则必须返回 NULL 并设置异常条件。

笔记

如果你想实现一个只有有限的一组比较有意义的类型（例如 ==和!=，但不是<和朋友），在丰富的对比功能中直接提升TypeError。

该字段与 tp_compare 和 tp_hash 一起被子类型继承：子类型继承了 tp_compare、tp_richcompare 和的所有三个tp_hash，当子类型的tp_compare、tp_richcompare、tp_hash都是NULL时

以下常量被定义为用作 tp_richcompare 和 PyObject_RichCompare() 的第三个参数：

持续的	比较
`Py_LT`	`<`
`Py_LE`	`<=`
`Py_EQ`	`==`
`Py_NE`	`!=`
`Py_GT`	`>`
`Py_GE`	`>=`

下一个字段仅在设置了 Py_TPFLAGS_HAVE_WEAKREFS 标志位时才存在。

long PyTypeObject.tp_weaklistoffset

如果该类型的实例是弱引用的，则该字段大于零并包含弱引用列表头的实例结构中的偏移量（忽略 GC 头，如果存在）；该偏移量由 PyObject_ClearWeakRefs() 和 PyWeakref_*() 函数使用。实例结构需要包含一个类型为 PyObject* 的字段，该字段被初始化为 NULL。

不要将此字段与 tp_weaklist 混淆；这是对类型对象本身的弱引用的列表头。

此字段由子类型继承，但请参阅下面列出的规则。一个子类型可以覆盖这个偏移量；这意味着子类型使用与基类型不同的弱引用列表头。由于总是通过 tp_weaklistoffset 找到列表头，所以这应该不是问题。

当 class 语句定义的类型没有 __slots__ 声明，并且其基类型都不是弱引用时，通过向实例布局添加弱引用列表头槽并设置 [ X243X]tp_weaklistoffset 该插槽的偏移量。

当类型的 __slots__ 声明包含一个名为 __weakref__ 的插槽时，该插槽成为该类型实例的弱引用列表头，并且该插槽的偏移量存储在该类型的 tp_weaklistoffset[ X219X]。

当类型的 __slots__ 声明不包含名为 __weakref__ 的槽时，该类型从其基类型继承其 tp_weaklistoffset。

仅当设置了 Py_TPFLAGS_HAVE_ITER 标志位时，才会存在接下来的两个字段。

getiterfunc PyTypeObject.tp_iter

指向返回对象迭代器的函数的可选指针。它的存在通常表明这种类型的实例是可迭代的（尽管序列可能在没有这个函数的情况下是可迭代的，经典实例总是有这个函数，即使它们没有定义 __iter__() 方法）。

此函数与 PyObject_GetIter() 具有相同的签名。

该字段由子类型继承。

iternextfunc PyTypeObject.tp_iternext

指向返回迭代器中下一项的函数的可选指针。当迭代器耗尽时，必须返回NULL； StopIteration 异常可能会也可能不会被设置。当另一个错误发生时，它也必须返回 NULL。它的存在通常表明该类型的实例是迭代器（尽管经典实例始终具有此功能，即使它们没有定义 next() 方法）。

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

此函数与 PyIter_Next() 具有相同的签名。

该字段由子类型继承。

下一个字段，直到并包括 tp_weaklist，仅在设置了 Py_TPFLAGS_HAVE_CLASS 标志位时才存在。

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 结构数组的可选指针，声明此类型实例的计算属性。

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

该字段不由子类型继承（计算的属性通过不同的机制继承）。

PyTypeObject *PyTypeObject.tp_base

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

该字段不由子类型继承（显然），但它默认为 &PyBaseObject_Type（Python 程序员将其称为类型 object）。

PyObject *PyTypeObject.tp_dict

类型的字典由 PyType_Ready() 存储在这里。

在调用 PyType_Ready 之前，该字段通常应初始化为 NULL；它也可以被初始化为一个包含该类型初始属性的字典。一旦 PyType_Ready() 初始化了类型，只有当它们不对应于重载操作（如 __add__()）时，类型的额外属性才可以添加到此字典中。

这个字段不被子类型继承（尽管这里定义的属性是通过不同的机制继承的）。

descrgetfunc PyTypeObject.tp_descr_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 以删除该值。该字段由子类型继承。

long 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 取自实例。取绝对值是因为 long ints 使用 ob_size 的符号来存储数字的符号。（从来不需要你自己做这个计算；它是由 _PyObject_GetDictPtr() 为你完成的。）

此字段由子类型继承，但请参阅下面列出的规则。一个子类型可以覆盖这个偏移量；这意味着子类型实例将字典存储在与基类型不同的偏移量处。由于字典总是通过 tp_dictoffset 找到，所以这应该不是问题。

当 class 语句定义的类型没有 __slots__ 声明，并且其基本类型都没有实例变量字典时，会在实例布局中添加一个字典槽并设置 tp_dictoffset到该插槽的偏移量。

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

（在 __slots__ 声明中添加一个名为 __dict__ 的插槽没有预期的效果，只会引起混淆。也许这应该像 __weakref__ 一样作为功能添加。）

initproc PyTypeObject.tp_init

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

这个函数对应类的__init__()方法。和 __init__() 一样，可以不调用 __init__() 来创建实例，并且可以通过再次调用其 __init__() 方法来重新初始化实例。

函数签名是

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

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

tp_init 函数，如果不是 NULL，则在通过调用其类型正常创建实例时，在类型的 tp_new 函数返回了类型。如果 tp_new 函数返回某个其他类型的实例，该实例不是原始类型的子类型，则不会调用 tp_init 函数；如果 tp_new 返回原始类型的子类型的实例，则调用子类型的 tp_init。（版本说明：此处描述的是 Python 2.2.1 及更高版本中实现的内容。在 Python 2.2 中，tp_new 返回的对象类型的 tp_init 总是被调用，如果不是 NULL。）

该字段由子类型继承。

allocfunc PyTypeObject.tp_alloc

指向实例分配函数的可选指针。

函数签名是

PyObject *tp_alloc(PyTypeObject *self, Py_ssize_t nitems)

该函数的目的是将内存分配与内存初始化分开。它应该返回一个指向实例足够长度的内存块的指针，适当对齐并初始化为零，但 ob_refcnt 设置为 1 和 ob_type 设置为类型参数。如果类型的 tp_itemsize 非零，则对象的 ob_size 字段应初始化为 nitems，分配的内存块长度应为 tp_basicsize + nitems*tp_itemsize ]，向上取整为 sizeof(void*) 的倍数；否则，不使用 nitems，块的长度应为 tp_basicsize。

不要使用这个函数来做任何其他的实例初始化，甚至不要分配额外的内存；这应该由 tp_new 完成。

该字段由静态子类型继承，但不由动态子类型（由类语句创建的子类型）继承；在后者中，此字段始终设置为 PyType_GenericAlloc()，以强制执行标准堆分配策略。这也是静态定义类型的推荐值。

newfunc PyTypeObject.tp_new

指向实例创建函数的可选指针。

如果该函数为 NULL 特定类型，则不能调用该类型来创建新实例；大概还有其他一些方法来创建实例，比如工厂函数。

函数签名是

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 的静态类型继承。后一个例外是一种预防措施，因此旧的扩展类型不会通过与 Python 2.2 链接而变得可调用。

destructor PyTypeObject.tp_free

指向实例释放函数的可选指针。

此函数的签名略有变化：在 Python 2.2 和 2.2.1 中，其签名为 destructor：

void tp_free(PyObject *)

在 Python 2.3 及更高版本中，它的签名是 freefunc：

void tp_free(void *)

唯一与这两个版本兼容的初始化程序是 _PyObject_Del，其定义已在 Python 2.3 中进行了适当调整。

该字段由静态子类型继承，但不由动态子类型（由类语句创建的子类型）继承；在后者中，该字段设置为适合匹配 PyType_GenericAlloc() 和 Py_TPFLAGS_HAVE_GC 标志位的值的解除分配器。

inquiry PyTypeObject.tp_is_gc

指向垃圾收集器调用的函数的可选指针。

垃圾收集器需要知道特定对象是否可收集。通常，查看对象类型的 tp_flags 字段，并检查 Py_TPFLAGS_HAVE_GC 标志位就足够了。但是有些类型混合了静态和动态分配的实例，并且静态分配的实例是不可收集的。这些类型应该定义这个函数；它应该为可收集实例返回 1，对于不可收集实例返回 0。签名是

int tp_is_gc(PyObject *self)

（唯一的例子是类型本身。元类型 PyType_Type 定义了这个函数来区分静态和动态分配的类型。）

该字段由子类型继承。（版本说明：在 Python 2.2 中，它没有被继承。它在 2.2.1 及更高版本中被继承。）

PyObject *PyTypeObject.tp_bases

基本类型的元组。

这是为 class 语句创建的类型设置的。对于静态定义的类型，它应该是 NULL。

该字段不是继承的。

PyObject *PyTypeObject.tp_mro

包含扩展的基类型集的元组，从类型本身开始，以 object 结束，按方法解析顺序。

该字段不是继承的；它是由 PyType_Ready() 新鲜计算的。

PyObject *PyTypeObject.tp_cache

没用过。不继承。仅供内部使用。

PyObject *PyTypeObject.tp_subclasses

对子类的弱引用列表。不继承。仅供内部使用。

PyObject *PyTypeObject.tp_weaklist

弱引用列表头，用于对该类型对象的弱引用。不继承。仅供内部使用。

其余字段仅在定义了功能测试宏 COUNT_ALLOCS 时才定义，并且仅供内部使用。为了完整起见，它们被记录在此处。这些字段都不是由子类型继承的。请参阅 PYTHONSHOWALLOCCOUNT 环境变量。

Py_ssize_t PyTypeObject.tp_allocs

分配数量。

Py_ssize_t PyTypeObject.tp_frees

免费次数。

Py_ssize_t PyTypeObject.tp_maxalloc

最大同时分配的对象。

PyTypeObject *PyTypeObject.tp_next

指向具有非零 tp_allocs 字段的下一个类型对象的指针。

另外，请注意，在垃圾回收的 Python 中，可以从任何 Python 线程调用 tp_dealloc，而不仅仅是创建对象的线程（如果对象成为 refcount 循环的一部分，则该循环可能会被任何线）。这对于 Python API 调用来说不是问题，因为调用 tp_dealloc 的线程将拥有全局解释器锁 (GIL)。但是，如果被销毁的对象又从其他 C 或 C++ 库中销毁对象，则应注意确保在调用 tp_dealloc 的线程上销毁这些对象不会违反库的任何假设。

数字对象结构

type PyNumberMethods

该结构包含指向对象用来实现数字协议的函数的指针。几乎下面的每个函数都被 Number Protocol 部分中记录的类似名称的函数使用。

这是结构定义：

typedef struct {
     binaryfunc nb_add;
     binaryfunc nb_subtract;
     binaryfunc nb_multiply;
     binaryfunc nb_divide;
     binaryfunc nb_remainder;
     binaryfunc nb_divmod;
     ternaryfunc nb_power;
     unaryfunc nb_negative;
     unaryfunc nb_positive;
     unaryfunc nb_absolute;
     inquiry nb_nonzero;       /* Used by PyObject_IsTrue */
     unaryfunc nb_invert;
     binaryfunc nb_lshift;
     binaryfunc nb_rshift;
     binaryfunc nb_and;
     binaryfunc nb_xor;
     binaryfunc nb_or;
     coercion nb_coerce;       /* Used by the coerce() function */
     unaryfunc nb_int;
     unaryfunc nb_long;
     unaryfunc nb_float;
     unaryfunc nb_oct;
     unaryfunc nb_hex;

     /* Added in release 2.0 */
     binaryfunc nb_inplace_add;
     binaryfunc nb_inplace_subtract;
     binaryfunc nb_inplace_multiply;
     binaryfunc nb_inplace_divide;
     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;

     /* Added in release 2.2 */
     binaryfunc nb_floor_divide;
     binaryfunc nb_true_divide;
     binaryfunc nb_inplace_floor_divide;
     binaryfunc nb_inplace_true_divide;

     /* Added in release 2.5 */
     unaryfunc nb_index;
} PyNumberMethods;

二元和三元函数可能会接收不同类型的参数，具体取决于标志位 Py_TPFLAGS_CHECKTYPES：

如果 Py_TPFLAGS_CHECKTYPES 未设置，则保证函数参数为对象类型；调用者负责调用 nb_coerce 成员指定的强制方法来转换参数：
coercion PyNumberMethods.nb_coerce

该函数由 PyNumber_CoerceEx() 使用并且具有相同的签名。第一个参数始终是指向定义类型对象的指针。如果可以转换为常见的“更大”类型，则该函数将指针替换为对转换对象的新引用，并返回 0。如果无法转换，则函数返回 1。如果设置了错误条件，则返回 -1。
如果设置了 Py_TPFLAGS_CHECKTYPES 标志，则二元和三元函数必须检查其所有操作数的类型，并实现必要的转换（至少一个操作数是定义类型的实例）。这是推荐的方式；使用 Python 3 强制将完全消失。

如果没有为给定的操作数定义操作，二元和三元函数必须返回 Py_NotImplemented，如果发生另一个错误，它们必须返回 NULL 并设置异常。

映射对象结构

type PyMappingMethods

该结构包含指向对象用来实现映射协议的函数的指针。它有三个成员：

lenfunc PyMappingMethods.mp_length

该函数由 PyMapping_Length() 和 PyObject_Size() 使用，并且具有相同的签名。如果对象没有定义的长度，这个槽可以设置为 NULL。

binaryfunc PyMappingMethods.mp_subscript

该函数由 PyObject_GetItem() 使用并且具有相同的签名。 PyMapping_Check()函数返回1时必须填入这个槽，否则可以是NULL。

objobjargproc PyMappingMethods.mp_ass_subscript

该函数由 PyObject_SetItem() 和 PyObject_DelItem() 使用。它与 PyObject_SetItem() 具有相同的签名，但 v 也可以设置为 NULL 以删除项目。如果此槽为NULL，则对象不支持项的赋值和删除。

序列对象结构

type PySequenceMethods

该结构包含指向对象用来实现序列协议的函数的指针。

lenfunc PySequenceMethods.sq_length

该函数由 PySequence_Size() 和 PyObject_Size() 使用，并且具有相同的签名。

binaryfunc PySequenceMethods.sq_concat

该函数由 PySequence_Concat() 使用并且具有相同的签名。在通过 nb_add 插槽尝试数字加法后，它也被 + 操作员使用。

ssizeargfunc PySequenceMethods.sq_repeat

该函数由 PySequence_Repeat() 使用并且具有相同的签名。在通过 nb_multiply 插槽尝试数字乘法之后，它也被 * 运算符使用。

ssizeargfunc PySequenceMethods.sq_item

该函数由 PySequence_GetItem() 使用并且具有相同的签名。 PySequence_Check()函数返回1时必须填入这个槽，否则可以是NULL。

负索引处理如下：如果 sq_length 槽被填满，则调用它并使用序列长度计算传递给 sq_item 的正索引。如果 sq_length 是 NULL，则索引按原样传递给函数。

ssizeobjargproc PySequenceMethods.sq_ass_item

该函数由 PySequence_SetItem() 使用并且具有相同的签名。如果对象不支持项目分配和删除，则此插槽可能会保留为 NULL。

objobjproc PySequenceMethods.sq_contains

此函数可由 PySequence_Contains() 使用并具有相同的签名。这个槽可以留给 NULL，在这种情况下 PySequence_Contains() 简单地遍历序列直到找到匹配。

binaryfunc PySequenceMethods.sq_inplace_concat

该函数由 PySequence_InPlaceConcat() 使用并且具有相同的签名。它应该修改它的第一个操作数，并返回它。

ssizeargfunc PySequenceMethods.sq_inplace_repeat

该函数由 PySequence_InPlaceRepeat() 使用并且具有相同的签名。它应该修改它的第一个操作数，并返回它。

缓冲区对象结构

缓冲区接口导出一个模型，其中对象可以将其内部数据公开为一组数据块，其中每个块被指定为一个指针/长度对。这些块被称为段并且假定在内存中是不连续的。

如果一个对象不导出缓冲区接口，那么它在 PyTypeObject 结构中的 tp_as_buffer 成员应该是 NULL。否则，tp_as_buffer 将指向一个 PyBufferProcs 结构。

笔记

非常重要的是，您的 PyTypeObject 结构使用 Py_TPFLAGS_DEFAULT 作为 tp_flags 成员的值，而不是 0。这告诉 Python 运行时您的 PyBufferProcs 结构包含 bf_getcharbuffer 槽。旧版本的 Python 没有这个成员，所以使用旧扩展的新 Python 解释器需要能够在使用之前测试它的存在。

type PyBufferProcs

用于保存定义缓冲区协议实现的函数指针的结构。

第一个插槽是 bf_getreadbuffer，类型为 readbufferproc。如果此槽为NULL，则该对象不支持从内部数据读取。这是没有意义的，因此实现者应该填写它，但调用者应该测试该插槽是否包含非 NULL 值。

下一个插槽是 bf_getwritebuffer，类型为 writebufferproc。如果对象不允许写入其返回的缓冲区，则此插槽可能为 NULL。

第三个插槽是 bf_getsegcount，类型为 segcountproc。这个槽不能是NULL，用于通知调用者对象包含多少段。简单的对象，如 PyString_Type 和 PyBuffer_Type 对象包含单个段。

最后一个插槽是 bf_getcharbuffer，类型为 charbufferproc。仅当对象的 PyTypeObject 的 tp_flags 字段中存在 Py_TPFLAGS_HAVE_GETCHARBUFFER 标志时，才会出现此插槽。在使用这个槽之前，调用者应该使用 PyType_HasFeature() 函数测试它是否存在。如果该标志存在，则bf_getcharbuffer可能是NULL，表示对象的内容不能用作8位字符。如果对象的内容不能解释为 8 位字符，则槽函数也可能引发错误。例如，如果对象是一个配置为保存浮点值的数组，如果调用者尝试使用 bf_getcharbuffer 来获取 8 位字符序列，则可能会引发异常。这种将内部缓冲区导出为“文本”的概念用于区分本质上是二进制的对象和具有基于字符内容的对象。

笔记

当前政策似乎声明这些字符可能是多字节字符。这意味着 N 的缓冲区大小并不意味着存在 N 个字符。

Py_TPFLAGS_HAVE_GETCHARBUFFER: 在类型结构中设置的标志位指示 bf_getcharbuffer 插槽是已知的。此设置并不表示对象支持缓冲区接口或 bf_getcharbuffer 插槽是非 NULL。

typedef Py_ssize_t (*readbufferproc)(PyObject *self, Py_ssize_t segment, void **ptrptr)

返回指向 *ptrptr 中缓冲区可读段的指针。此函数允许引发异常，在这种情况下，它必须返回 -1。指定的 segment 必须为零或正数，并且严格小于 bf_getsegcount 槽函数返回的段数。成功时，它返回段的长度，并将 *ptrptr 设置为指向该内存的指针。

typedef Py_ssize_t (*writebufferproc)(PyObject *self, Py_ssize_t segment, void **ptrptr)

返回一个指向 *ptrptr 中可写内存缓冲区的指针，并将该段的长度作为函数返回值。内存缓冲区必须对应缓冲区段段。必须返回 -1 并设置错误异常。 TypeError 如果对象仅支持只读缓冲区，则应引发，当 segment 指定不存在的段时，应引发 SystemError。

typedef Py_ssize_t (*segcountproc)(PyObject *self, Py_ssize_t *lenp)

返回构成缓冲区的内存段数。如果 lenp 不是 NULL，则实现必须报告 *lenp 中所有段的大小总和（以字节为单位）。该功能不能失败。

typedef Py_ssize_t (*charbufferproc)(PyObject *self, Py_ssize_t segment, char **ptrptr)

返回设置为 ptrptr 的段 segment 的大小。 *ptrptr 设置为内存缓冲区。出错时返回 -1。

类型对象 — Python 文档

目录

类型对象

数字对象结构

映射对象结构

序列对象结构

缓冲区对象结构