Объекты типов

Быстрый справочник

Определение 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(), обычно вызываемых из оператора класса). Обратите внимание, что 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

Это счётчик ссылок объекта типа, инициализированный значением 1 макрокомандой PyObject_HEAD_INIT. Обратите внимание, что для статически выделенных объектов типа, экземпляры типа (объекты, чьё поле ob_type указывает на тип) не учитываются как ссылки. Но для динамически выделенных объектов типа, экземпляры учитываются как ссылки.

Наследование:

Это поле не наследуется подтипами.

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

Указатель на строку с нулевым завершением, содержащую имя типа. Для типов, доступных как глобальные переменные модуля, строка должна содержать полное имя модуля, точку, имя типа; для встроенных типов — только имя типа. Если модуль является подмодулем пакета, полное имя пакета является частью полного имени модуля. Например, тип, названный T , определенный в модуле M в подпакете Q в пакете P , должен иметь инициализатор 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

Эти поля позволяют вычислять размер в байтах экземпляров типа.

Существует два типа типов: типы с экземплярами фиксированной длины имеют поле tp_itemsize равное нулю, типы с экземплярами переменной длины имеют поле 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 на структуре, используемой для объявления структуры экземпляра. Базовый размер не включает размер заголовка сборки мусора.

Примечание об выравнивании: если переменные элементы требуют определенного выравнивания, об этом должно позаботиться значение 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 не установлен), разрешается вызвать деаллокатот объекта напрямую вместо tp_free. Деаллокатот объекта должен быть тем, который использовался для выделения экземпляра; это обычно PyObject_Del() , если экземпляр был выделен с помощью PyObject_New() или PyObject_VarNew(), или PyObject_GC_Del() , если экземпляр был выделен с помощью PyObject_GC_New() или PyObject_GC_NewVar().

Если тип поддерживает сборку мусора (флаг Py_TPFLAGS_HAVE_GC установлен), деструктор должен вызвать PyObject_GC_UnTrack() перед очисткой любых полей членов.

static void foo_dealloc(foo_object *self) {
    PyObject_GC_UnTrack(self);
    Py_CLEAR(self->ref);
    Py_TYPE(self)->tp_free((PyObject *)self);
}

Наконец, если тип выделяется в куче (Py_TPFLAGS_HEAPTYPE), деаллокатот должен уменьшить счётчик ссылок для своего объекта типа после вызова деаллокатота типа. Для предотвращения «висячих» указателей рекомендуется:

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, более эффективной альтернативы простому tp_call.

Это поле используется только в том случае, если установлен флаг Py_TPFLAGS_HAVE_VECTORCALL. В этом случае это должно быть положительное целое число, содержащее смещение в экземпляре указателя vectorcallfunc.

Указатель vectorcallfunc может быть NULL, в этом случае экземпляр ведет себя так, как будто Py_TPFLAGS_HAVE_VECTORCALL не был установлен: вызов экземпляра переходит к tp_call.

Любой класс, который устанавливает Py_TPFLAGS_HAVE_VECTORCALL , должен также установить tp_call и убедиться, что его поведение согласуется с функцией vectorcallfunc. Это можно сделать, установив tp_call в PyVectorcall_Call().

Предупреждение

Не рекомендуется реализовывать протокол vectorcall для типов кучи. Когда пользователь устанавливает __call__ в коде Python, обновляется только tp_call, что может привести к несоответствию с функцией vectorcall.

Примечание

Семантика слота tp_vectorcall_offset является предварительной и ожидается, что она будет окончательно оформлена в Python 3.9. Если вы используете vectorcall, планируйте обновление своего кода для Python 3.9.

Изменено в версии 3.8: До версии 3.8 этот слот назывался tp_print. В Python 2.x он использовался для вывода в файл. В Python 3.0–3.7 он не использовался.

Наследование:

Это поле всегда наследуется. Однако флаг Py_TPFLAGS_HAVE_VECTORCALL не всегда наследуется. Если это не так, подкласс не будет использовать vectorcall, за исключением случаев, когда PyVectorcall_Call() вызывается явно. Это особенно относится к типам кучи (включая подклассы, определённые в Python).

getattrfunc PyTypeObject.tp_getattr

Необязательный указатель на функцию получения атрибута-строки.

Это поле устарело. При определении оно должно указывать на функцию, которая действует так же, как функция 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 и асинхронного итератора на уровне 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 не должно возвращаться в качестве нормального результата; при возникновении ошибки во время вычисления значения хэша функция должна установить исключение и вернуть -1.

Если этот элемент не установлен (и tp_richcompare также не установлен), попытка вычисления хэша объекта вызывает TypeError. Это эквивалентно его установке в PyObject_HashNotImplemented().

Этот элемент может быть явно установлен в PyObject_HashNotImplemented() для блокировки наследования метода хэширования от родительского типа. Это интерпретируется как эквивалент __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

Необязательный указатель на функцию получения атрибута.

Подпись такая же, как у 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);

Кроме того, должна поддерживаться установка 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 его экземпляров рассматривается как ссылка на тип, и объект типа INCREF'ится при создании нового экземпляра и DECREF'ится при уничтожении экземпляра (это не относится к экземплярам подтипов; только тип, на который ссылается ob_type экземпляра, INCREF'ится или DECREF'ится).

Наследование:

???

Py_TPFLAGS_BASETYPE

Этот бит устанавливается, когда тип может использоваться в качестве типа-предка другого типа. Если этот бит сброшен, тип не может быть подклассом (подобно классу «final» в 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 не равным None) должно быть эквивалентно 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. Подробности см. в tp_vectorcall_offset.

Наследование:

Этот бит наследуется для статических подтипов, если tp_call также наследуется. Типы в куче не наследуют Py_TPFLAGS_HAVE_VECTORCALL.

Добавлен в версии 3.9.

const char* PyTypeObject.tp_doc

Необязательный указатель на строку C с завершающим нулём, содержащую строку документации для данного объекта типа. Это представлено как атрибут __doc__ на типе и экземплярах типа.

Наследование:

Это поле не наследуется подтипами.

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 должны быть посещены только члены, которые владеют экземпляром (имея сильные ссылки на них). Например, если объект поддерживает слабые ссылки через слот tp_weaklist, указатель, поддерживающий связанный список (на что указывает tp_weaklist), не должен посещаться, так как экземпляр не владеет напрямую слабыми ссылками на себя (список слабых ссылок существует для поддержки механизма слабых ссылок, но экземпляр не имеет сильной ссылки на элементы внутри него, поскольку они могут быть удалены даже если экземпляр все еще жив).

Обратите внимание, что Py_VISIT() требует, чтобы параметры visit и arg в local_traverse() имели эти конкретные имена; не называйте их просто как-нибудь.

Типы, выделенные в куче (Py_TPFLAGS_HEAPTYPE, такие как те, что созданы с помощью PyType_FromSpec() и аналогичных API) хранят ссылку на свой тип. Поэтому их функция обхода должна либо посетить Py_TYPE(self), либо делегировать эту задачу, вызвав tp_traverse другого типа, выделенного в куче (например, родительского класса, выделенного в куче). В противном случае объект типа может не быть собран мусором.

Изменено в версии 3.9: Ожидается, что типы, выделенные в куче, посетят Py_TYPE(self) в tp_traverse. В более ранних версиях Python из-за ошибки 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. Например, тип кортежей не реализует функцию 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 не всегда вызывается перед удалением экземпляра. Например, когда подсчёта ссылок достаточно для определения того, что объект больше не используется, циклический сборщик мусора не участвует, и tp_dealloc вызывается непосредственно.

Поскольку целью функций 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 или числа с плавающей точкой). Третий аргумент указывает запрашиваемую операцию, как в 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, это не должно быть проблемой.

Когда тип, определённый оператором class, не имеет объявления __slots__, и ни один из его базовых типов не является слабо ссылаемым, тип делается слабо ссылаемым путём добавления в макет экземпляра заголовка списка слабых ссылок и установки значения tp_weaklistoffset для смещения этого заголовка.

Когда объявление __slots__ типа содержит слот с именем __weakref__, этот слот становится заголовком списка слабых ссылок для экземпляров типа, а смещение этого слота хранится в tp_weaklistoffset типа.

Когда объявление __slots__ типа не содержит слота с именем __weakref__, тип наследует tp_weaklistoffset от своего базового типа.

getiterfunc PyTypeObject.tp_iter

Необязательный указатель на функцию, возвращающую итератор для объекта. Его присутствие обычно указывает на то, что экземпляры этого типа итерируемы (хотя последовательности могут быть итерируемыми без этой функции).

Эта функция имеет такой же прототип, как PyObject_GetIter():

PyObject *tp_iter(PyObject *self);

Наследование:

Это поле наследуется подтипами.

iternextfunc PyTypeObject.tp_iternext

Необязательный указатель на функцию, возвращающую следующий элемент в итераторе. Прототип:

PyObject *tp_iternext(PyObject *self);

При исчерпании итератора она должна возвращать NULL; исключение StopIteration может быть или не быть установленным. При возникновении другой ошибки она тоже должна возвращать NULL. Его наличие сигнализирует, что экземпляры этого типа являются итераторами.

Типы итераторов также должны определять функцию tp_iter, которая должна возвращать сам экземпляр итератора (а не новый экземпляр итератора).

Эта функция имеет тот же прототип, что и PyIter_Next().

Наследование:

Это поле наследуется подтипами.

struct PyMethodDef* PyTypeObject.tp_methods

Необязательный указатель на статический массив, завершённый значением 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 следует установить в функции инициализации расширения модуля.

Наследование:

Это поле не наследуется подтипами (очевидно).

Значение по умолчанию:

Это поле по умолчанию равно &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

Необязательный указатель на функцию «получения дескриптора».

Подпись функции:

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

Наследование:

Это поле наследуется подтипами.

descrsetfunc PyTypeObject.tp_descr_set

Необязательный указатель на функцию для установки и удаления значения дескриптора.

Подпись функции:

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

Аргумент value устанавливается в NULL для удаления значения.

Наследование:

Это поле наследуется подтипами.

Py_ssize_t PyTypeObject.tp_dictoffset

Если экземпляры данного типа имеют словарь, содержащий переменные экземпляра, это поле не равно нулю и содержит смещение в экземплярах типа словаря переменных экземпляра; это смещение используется функцией PyObject_GenericGetAttr().

Не путайте это поле с tp_dict; это словарь атрибутов самого объекта типа.

Если значение этого поля больше нуля, оно задаёт смещение от начала структуры экземпляра. Если значение меньше нуля, оно задаёт смещение от конца структуры экземпляра. Отрицательное смещение более ресурсоёмкое и должно использоваться только тогда, когда структура экземпляра содержит переменную часть. Это используется, например, для добавления словаря переменных экземпляра к подтипам str или tuple. Обратите внимание, что поле tp_basicsize должно учитывать добавленный словарь в конце в этом случае, даже если словарь не включён в базовое расположение объекта. На системе с размером указателя 4 байта tp_dictoffset должно быть установлено в -4 для указания того, что словарь находится в самом конце структуры.

Действительное смещение словаря в экземпляре можно вычислить из отрицательного tp_dictoffset следующим образом:

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

где tp_basicsize, tp_itemsize и tp_dictoffset взяты из объекта типа, а ob_size — из экземпляра. Абсолютное значение берется, потому что целые числа используют знак ob_size для хранения знака числа. (Вам никогда не потребуется выполнять это вычисление самостоятельно; это делается за вас функцией _PyObject_GetDictPtr().)

Наследование:

Это поле наследуется подтипами, но см. перечисленные ниже правила. Подтип может переопределить это смещение; это означает, что экземпляры подтипа хранят словарь по другому смещению, чем базовый тип. Поскольку словарь всегда находится через tp_dictoffset, это не должно быть проблемой.

Когда тип, определённый оператором class, не имеет объявления __slots__ и ни один из его базовых типов не имеет словаря переменных экземпляра, слот словаря добавляется в расположение экземпляра, а tp_dictoffset устанавливается на смещение этого слота.

Когда тип, определённый оператором class, имеет объявление __slots__, тип наследует tp_dictoffset от своего базового типа.

(Добавление слота, названного __dict__, к объявлению __slots__ не имеет ожидаемого эффекта, это просто вызывает путаницу. Возможно, это должно быть добавлено как функция, подобная __weakref__ , хотя.)

Значение по умолчанию:

Этот слот не имеет значения по умолчанию. Для статических типов, если поле равно NULL , для экземпляров не создаётся __dict__.

initproc PyTypeObject.tp_init

Необязательный указатель на функцию инициализации экземпляра.

Эта функция соответствует методу __init__() классов. Как и __init__(), можно создать экземпляр без вызова __init__(), и можно повторно инициализировать экземпляр, вызвав его метод __init__() снова.

Подпись функции:

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

Аргумент self — это экземпляр, который необходимо инициализировать; аргументы args и kwds представляют позиционные и ключевые аргументы вызова __init__().

Функция tp_init, если она не NULL, вызывается при создании экземпляра обычным способом путем вызова его типа после того, как функция типа tp_new вернула экземпляр типа. Если функция tp_new возвращает экземпляр другого типа, который не является подтипом исходного типа, функция tp_init не вызывается; если tp_new возвращает экземпляр подтипа исходного типа, вызывается функция tp_init подтипа.

Возвращает 0 при успехе, -1 и устанавливает исключение при ошибке.

Наследование:

Это поле наследуется подтипами.

Значение по умолчанию:

Для статических типов это поле не имеет значения по умолчанию.

allocfunc PyTypeObject.tp_alloc

Дополнительный указатель на функцию выделения памяти для экземпляра.

Подпись функции:

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

Наследование:

Это поле наследуется статическими подтипами, но не динамическими подтипами (подтипами, созданными оператором class).

Значение по умолчанию:

Для динамических подтипов это поле всегда установлено в PyType_GenericAlloc(), чтобы принудительно использовать стандартную стратегию выделения памяти.

Для статических подтипов, PyBaseObject_Type использует PyType_GenericAlloc(). Это рекомендуемое значение для всех статически определённых типов.

newfunc PyTypeObject.tp_new

Дополнительный указатель на функцию создания экземпляра.

Подпись функции:

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

Аргумент subtype — тип создаваемого объекта; аргументы args и kwds представляют позиционные и именованные аргументы вызова типа. Обратите внимание, что subtype не обязательно должен быть равен типу, чья функция 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_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

Кортеж базовых типов.

Это устанавливается для типов, созданных оператором class. Для статически определённых типов это должно быть 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.

Также обратите внимание, что в Python со сборкой мусора tp_dealloc может быть вызвано из любого потока Python, а не только из потока, который создал объект (если объект попадает в цикл ссылок, этот цикл может быть собран сборкой мусора в любом потоке). Это не проблема для вызовов API Python, так как поток, в котором вызывается tp_dealloc, будет владеть глобальной блокировкой интерпретатора (GIL). Однако, если объект, который уничтожается, в свою очередь, уничтожает объекты из какой-либо другой библиотеки C или C++, необходимо позаботиться о том, чтобы уничтожение этих объектов в потоке, вызвавшем tp_dealloc, не нарушало никаких предположений библиотеки.

Наследование:

Это поле наследуется подтипами.

Добавлен в версии 3.4.

См. также

«Безопасное завершение работы объектов» (PEP 442)

vectorcallfunc PyTypeObject.tp_vectorcall

Функция vectorcall для использования при вызовах объекта этого типа. Другими словами, она используется для реализации vectorcall для type.__call__. Если tp_vectorcall равно NULL, используется реализация вызова по умолчанию с использованием __new__ и __init__.

Наследование:

Это поле никогда не наследуется.

Добавлен в версии 3.9: (поле существовало с 3.8, но используется только с 3.9)

Типы кучи

Традиционно, типы, определённые в коде C, являются статическими, то есть статическая структура PyTypeObject определена непосредственно в коде и инициализирована с помощью PyType_Ready().

Это приводит к типам, ограниченным по сравнению с типами, определёнными в Python:

• Статические типы ограничены одним базовым типом, т.е. они не могут использовать множественное наследование.
• Объекты статических типов (но не обязательно их экземпляры) неизменяемы. Из Python невозможно добавить или изменить атрибуты объекта типа.
• Объекты статических типов совместно используются между подинтерпретаторами, поэтому они не должны включать в себя какие-либо состояния, специфичные для подинтерпретатора.

Кроме того, так как PyTypeObject не является частью стабильной ABI, любые модули расширений, использующие статические типы, должны быть скомпилированы для конкретной младшей версии Python.

Альтернативой статическим типам являются типы, выделенные в куче, или кучевые типы, которые тесно соответствуют классам, созданным в Python с помощью class оператора.

Это делается путём заполнения структуры PyType_Spec и вызова PyType_FromSpecWithBases().