typeobj.md

1> **Источник:** https://python-all.ru/3.8/c-api/typeobj.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# Объекты типов89Пожалуй, одна из самых важных структур объектной системы Python – это структура, определяющая новый тип: структура [`PyTypeObject`](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject). Объекты типа можно обрабатывать с помощью любой из функций `PyObject_*()` или `PyType_*()`, но для большинства приложений Python они не представляют большого интереса. Эти объекты являются основой поведения объектов, поэтому они очень важны как для самого интерпретатора, так и для любых модулей расширения, реализующих новые типы.1011Объекты типа довольно велики по сравнению с большинством стандартных типов. Причина такого размера в том, что каждый объект типа хранит большое количество значений, в основном указателей на функции C, каждый из которых реализует небольшую часть функциональности типа. Поля объекта типа подробно рассматриваются в этом разделе. Поля будут описаны в порядке их появления в структуре.1213В дополнение к следующему краткому справочнику раздел [Примеры](https://python-all.ru/3.8/c-api/typeobj.html#typedef-examples) даёт представление о значении и использовании [`PyTypeObject`](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject).1415## Краткий справочник1617### “tp slots”1819| Слот PyTypeObject [1](https://python-all.ru/3.8/c-api/typeobj.html#slots) | [Тип](https://python-all.ru/3.8/c-api/typeobj.html#slot-typedefs-table) | специальные методы/атрибуты | Информация [2](https://python-all.ru/3.8/c-api/typeobj.html#cols) |  |  |  |20| --- | --- | --- | --- | --- | --- | --- |21| O | T | D | I |  |  |  |22| \<R\> [`tp_name`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_name) | const char \* | name | X | X |  |  |23| [`tp_basicsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_basicsize) | Py\_ssize\_t |  | X | X |  | X |24| [`tp_itemsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_itemsize) | Py\_ssize\_t |  |  | X |  | X |25| [`tp_dealloc`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dealloc) | [`destructor`](https://python-all.ru/3.8/c-api/typeobj.html#c.destructor) |  | X | X |  | X |26| [`tp_vectorcall_offset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_vectorcall_offset) | Py\_ssize\_t |  |  |  |  | ? |27| ([`tp_getattr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattr)) | [`getattrfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.getattrfunc) | getattribute\_\_, \_\_getattr |  |  |  | G |28| ([`tp_setattr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattr)) | [`setattrfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.setattrfunc) | setattr\_\_, \_\_delattr |  |  |  | G |29| [`tp_as_async`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_async) | [`PyAsyncMethods`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyAsyncMethods) \* | [подслоты](https://python-all.ru/3.8/c-api/typeobj.html#sub-slots) |  |  |  | % |30| [`tp_repr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_repr) | [`reprfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.reprfunc) | repr | X | X |  | X |31| [`tp_as_number`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_number) | [`PyNumberMethods`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods) \* | [подслоты](https://python-all.ru/3.8/c-api/typeobj.html#sub-slots) |  |  |  | % |32| [`tp_as_sequence`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_sequence) | [`PySequenceMethods`](https://python-all.ru/3.8/c-api/typeobj.html#c.PySequenceMethods) \* | [подслоты](https://python-all.ru/3.8/c-api/typeobj.html#sub-slots) |  |  |  | % |33| [`tp_as_mapping`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_mapping) | [`PyMappingMethods`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyMappingMethods) \* | [подслоты](https://python-all.ru/3.8/c-api/typeobj.html#sub-slots) |  |  |  | % |34| [`tp_hash`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_hash) | [`hashfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.hashfunc) | hash | X |  |  | G |35| [`tp_call`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_call) | [`ternaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.ternaryfunc) | call |  | X |  | X |36| [`tp_str`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_str) | [`reprfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.reprfunc) | str | X |  |  | X |37| [`tp_getattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattro) | [`getattrofunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.getattrofunc) | getattribute\_\_, \_\_getattr | X | X |  | G |38| [`tp_setattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattro) | [`setattrofunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.setattrofunc) | setattr\_\_, \_\_delattr | X | X |  | G |39| [`tp_as_buffer`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_buffer) | [`PyBufferProcs`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyBufferProcs) \* |  |  |  |  | % |40| [`tp_flags`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_flags) | unsigned long |  | X | X |  | ? |41| [`tp_doc`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_doc) | const char \* | doc | X | X |  |  |42| [`tp_traverse`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_traverse) | [`traverseproc`](https://python-all.ru/3.8/c-api/gcsupport.html#c.traverseproc) |  |  | X |  | G |43| [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear) | [`inquiry`](https://python-all.ru/3.8/c-api/gcsupport.html#c.inquiry) |  |  | X |  | G |44| [`tp_richcompare`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_richcompare) | [`richcmpfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.richcmpfunc) | lt\_\_, \_\_le\_\_, \_\_eq\_\_, \_\_ne\_\_, \_\_gt\_\_, \_\_ge | X |  |  | G |45| [`tp_weaklistoffset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_weaklistoffset) | Py\_ssize\_t |  |  | X |  | ? |46| [`tp_iter`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_iter) | [`getiterfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.getiterfunc) | iter |  |  |  | X |47| [`tp_iternext`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_iternext) | [`iternextfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.iternextfunc) | next |  |  |  | X |48| [`tp_methods`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_methods) | [`PyMethodDef`](https://python-all.ru/3.8/c-api/structures.html#c.PyMethodDef) \[\] |  | X | X |  |  |49| [`tp_members`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_members) | [`PyMemberDef`](https://python-all.ru/3.8/c-api/structures.html#c.PyMemberDef) \[\] |  |  | X |  |  |50| [`tp_getset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getset) | [`PyGetSetDef`](https://python-all.ru/3.8/c-api/structures.html#c.PyGetSetDef) \[\] |  | X | X |  |  |51| [`tp_base`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_base) | [`PyTypeObject`](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject) \* | base |  |  | X |  |52| [`tp_dict`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dict) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | dict |  |  | ? |  |53| [`tp_descr_get`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_descr_get) | [`descrgetfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.descrgetfunc) | get |  |  |  | X |54| [`tp_descr_set`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_descr_set) | [`descrsetfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.descrsetfunc) | set\_\_, \_\_delete |  |  |  | X |55| [`tp_dictoffset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dictoffset) | Py\_ssize\_t |  |  | X |  | ? |56| [`tp_init`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_init) | [`initproc`](https://python-all.ru/3.8/c-api/typeobj.html#c.initproc) | init | X | X |  | X |57| [`tp_alloc`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_alloc) | [`allocfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.allocfunc) |  | X |  | ? | ? |58| [`tp_new`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_new) | [`newfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.newfunc) | new | X | X | ? | ? |59| [`tp_free`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_free) | [`freefunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.freefunc) |  | X | X | ? | ? |60| [`tp_is_gc`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_is_gc) | [`inquiry`](https://python-all.ru/3.8/c-api/gcsupport.html#c.inquiry) |  |  | X |  | X |61| \<[`tp_bases`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_bases)\> | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | bases |  |  | ~ |  |62| \<[`tp_mro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_mro)\> | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | mro |  |  | ~ |  |63| \[[`tp_cache`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_cache)\] | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |  |  |  |  |  |64| \[[`tp_subclasses`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_subclasses)\] | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | subclasses |  |  |  |  |65| \[[`tp_weaklist`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_weaklist)\] | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |  |  |  |  |  |66| ([`tp_del`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_del)) | [`destructor`](https://python-all.ru/3.8/c-api/typeobj.html#c.destructor) |  |  |  |  |  |67| \[[`tp_version_tag`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_version_tag)\] | unsigned int |  |  |  |  |  |68| [`tp_finalize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_finalize) | [`destructor`](https://python-all.ru/3.8/c-api/typeobj.html#c.destructor) | del |  |  |  | X |6970Если `COUNT_ALLOCS` определено, то существуют также (только для внутреннего использования) следующие поля:7172- [`tp_allocs`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_allocs)73- [`tp_frees`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_frees)74- [`tp_maxalloc`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_maxalloc)75- [`tp_prev`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_prev)76- [`tp_next`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_next)7778**[1](https://python-all.ru/3.8/c-api/typeobj.html#id1)**7980Имя слота в скобках означает, что он (фактически) устарел. Имена в угловых скобках следует считать доступными только для чтения. Имена в квадратных скобках предназначены только для внутреннего использования. «\<R\>» (в качестве префикса) означает, что поле обязательно (должно быть не `NULL`).8182**[2](https://python-all.ru/3.8/c-api/typeobj.html#id2)**8384Столбцы:8586**“O”**: устанавливается на `PyBaseObject_Type`8788**“T”**: устанавливается на [`PyType_Type`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Type)8990**“D”**: значение по умолчанию (если слот установлен в `NULL`)9192```text93X - PyType_Ready sets this value if it is NULL94~ - PyType_Ready always sets this value (it should be NULL)95? - PyType_Ready may set this value depending on other slots9697Also see the inheritance column ("I").98```99100**“I”**: наследование101102```text103X - type slot is inherited via PyType_Ready if defined with a NULL value104% - the slots of the sub-struct are inherited individually105G - inherited, but only in combination with other slots; see the slot's description106? - it's complicated; see the slot's description107```108109Обратите внимание, что некоторые слоты фактически наследуются через обычную цепочку поиска атрибутов.110111### подслоты112113| Слот | [Тип](https://python-all.ru/3.8/c-api/typeobj.html#slot-typedefs-table) | специальные методы |114| --- | --- | --- |115| [`am_await`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyAsyncMethods.am_await) | [`unaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) | await |116| [`am_aiter`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyAsyncMethods.am_aiter) | [`unaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) | aiter |117| [`am_anext`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyAsyncMethods.am_anext) | [`unaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) | anext |118|  |  |  |119| [`nb_add`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_add) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | add\_\_ \_\_radd |120| [`nb_inplace_add`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_add) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | iadd |121| [`nb_subtract`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_subtract) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | sub\_\_ \_\_rsub |122| [`nb_inplace_subtract`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_subtract) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | sub |123| [`nb_multiply`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_multiply) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | mul\_\_ \_\_rmul |124| [`nb_inplace_multiply`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_multiply) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | mul |125| [`nb_remainder`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_remainder) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | mod\_\_ \_\_rmod |126| [`nb_inplace_remainder`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_remainder) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | mod |127| [`nb_divmod`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_divmod) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | divmod\_\_ \_\_rdivmod |128| [`nb_power`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_power) | [`ternaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.ternaryfunc) | pow\_\_ \_\_rpow |129| [`nb_inplace_power`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_power) | [`ternaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.ternaryfunc) | pow |130| [`nb_negative`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_negative) | [`unaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) | neg |131| [`nb_positive`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_positive) | [`unaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) | pos |132| [`nb_absolute`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_absolute) | [`unaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) | abs |133| [`nb_bool`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_bool) | [`inquiry`](https://python-all.ru/3.8/c-api/gcsupport.html#c.inquiry) | bool |134| [`nb_invert`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_invert) | [`unaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) | invert |135| [`nb_lshift`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_lshift) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | lshift\_\_ \_\_rlshift |136| [`nb_inplace_lshift`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_lshift) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | lshift |137| [`nb_rshift`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_rshift) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | rshift\_\_ \_\_rrshift |138| [`nb_inplace_rshift`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_rshift) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | rshift |139| [`nb_and`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_and) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | and\_\_ \_\_rand |140| [`nb_inplace_and`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_and) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | and |141| [`nb_xor`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_xor) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | xor\_\_ \_\_rxor |142| [`nb_inplace_xor`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_xor) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | xor |143| [`nb_or`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_or) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | or\_\_ \_\_ror |144| [`nb_inplace_or`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_or) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | or |145| [`nb_int`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_int) | [`unaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) | int |146| [`nb_reserved`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_reserved) | void \* |  |147| [`nb_float`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_float) | [`unaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) | float |148| [`nb_floor_divide`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_floor_divide) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | floordiv |149| [`nb_inplace_floor_divide`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_floor_divide) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | floordiv |150| [`nb_true_divide`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_true_divide) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | truediv |151| [`nb_inplace_true_divide`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_true_divide) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | truediv |152| [`nb_index`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_index) | [`unaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) | index |153| [`nb_matrix_multiply`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_matrix_multiply) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | matmul\_\_ \_\_rmatmul |154| [`nb_inplace_matrix_multiply`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_matrix_multiply) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | matmul |155|  |  |  |156| [`mp_length`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyMappingMethods.mp_length) | [`lenfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.lenfunc) | len |157| [`mp_subscript`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyMappingMethods.mp_subscript) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | getitem |158| [`mp_ass_subscript`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyMappingMethods.mp_ass_subscript) | [`objobjargproc`](https://python-all.ru/3.8/c-api/typeobj.html#c.objobjargproc) | setitem\_\_, \_\_delitem |159|  |  |  |160| [`sq_length`](https://python-all.ru/3.8/c-api/typeobj.html#c.PySequenceMethods.sq_length) | [`lenfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.lenfunc) | len |161| [`sq_concat`](https://python-all.ru/3.8/c-api/typeobj.html#c.PySequenceMethods.sq_concat) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | add |162| [`sq_repeat`](https://python-all.ru/3.8/c-api/typeobj.html#c.PySequenceMethods.sq_repeat) | [`ssizeargfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.ssizeargfunc) | mul |163| [`sq_item`](https://python-all.ru/3.8/c-api/typeobj.html#c.PySequenceMethods.sq_item) | [`ssizeargfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.ssizeargfunc) | getitem |164| [`sq_ass_item`](https://python-all.ru/3.8/c-api/typeobj.html#c.PySequenceMethods.sq_ass_item) | [`ssizeobjargproc`](https://python-all.ru/3.8/c-api/typeobj.html#c.ssizeobjargproc) | setitem\_\_ \_\_delitem |165| [`sq_contains`](https://python-all.ru/3.8/c-api/typeobj.html#c.PySequenceMethods.sq_contains) | [`objobjproc`](https://python-all.ru/3.8/c-api/typeobj.html#c.objobjproc) | contains |166| [`sq_inplace_concat`](https://python-all.ru/3.8/c-api/typeobj.html#c.PySequenceMethods.sq_inplace_concat) | [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | iadd |167| [`sq_inplace_repeat`](https://python-all.ru/3.8/c-api/typeobj.html#c.PySequenceMethods.sq_inplace_repeat) | [`ssizeargfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.ssizeargfunc) | imul |168|  |  |  |169| [`bf_getbuffer`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyBufferProcs.bf_getbuffer) | [`getbufferproc()`](https://python-all.ru/3.8/c-api/typeobj.html#c.getbufferproc) |  |170| [`bf_releasebuffer`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyBufferProcs.bf_releasebuffer) | [`releasebufferproc()`](https://python-all.ru/3.8/c-api/typeobj.html#c.releasebufferproc) |  |171172### Синонимы типов слотов173174| typedef | Типы параметров | Тип возвращаемого значения |175| --- | --- | --- |176| [`allocfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.allocfunc) | [`PyTypeObject`](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject) \* Py\_ssize\_t | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |177| [`destructor`](https://python-all.ru/3.8/c-api/typeobj.html#c.destructor) | void \* | void |178| [`freefunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.freefunc) | void \* | void |179| [`traverseproc`](https://python-all.ru/3.8/c-api/gcsupport.html#c.traverseproc) | void \* [`visitproc`](https://python-all.ru/3.8/c-api/gcsupport.html#c.visitproc) void \* | int |180| [`newfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.newfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |181| [`initproc`](https://python-all.ru/3.8/c-api/typeobj.html#c.initproc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | int |182| [`reprfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.reprfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |183| [`getattrfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.getattrfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* const char \* | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |184| [`setattrfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.setattrfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* const char \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | int |185| [`getattrofunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.getattrofunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |186| [`setattrofunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.setattrofunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | int |187| [`descrgetfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.descrgetfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |188| [`descrsetfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.descrsetfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | int |189| [`hashfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.hashfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | Py\_hash\_t |190| [`richcmpfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.richcmpfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* int | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |191| [`getiterfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.getiterfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |192| [`iternextfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.iternextfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |193| [`lenfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.lenfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | Py\_ssize\_t |194| [`getbufferproc`](https://python-all.ru/3.8/c-api/typeobj.html#c.getbufferproc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`Py_buffer`](https://python-all.ru/3.8/c-api/buffer.html#c.Py_buffer) \* int | int |195| [`releasebufferproc`](https://python-all.ru/3.8/c-api/typeobj.html#c.releasebufferproc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`Py_buffer`](https://python-all.ru/3.8/c-api/buffer.html#c.Py_buffer) \* | void |196| [`inquiry`](https://python-all.ru/3.8/c-api/gcsupport.html#c.inquiry) | void \* | int |197| [`unaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |198| [`binaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |199| [`ternaryfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.ternaryfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |200| [`ssizeargfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.ssizeargfunc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* Py\_ssize\_t | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* |201| [`ssizeobjargproc`](https://python-all.ru/3.8/c-api/typeobj.html#c.ssizeobjargproc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* Py\_ssize\_t | int |202| [`objobjproc`](https://python-all.ru/3.8/c-api/typeobj.html#c.objobjproc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | int |203| [`objobjargproc`](https://python-all.ru/3.8/c-api/typeobj.html#c.objobjargproc) | [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* [`PyObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \* | int |204205Подробнее см. [определения типов слотов](https://python-all.ru/3.8/c-api/typeobj.html#id5) ниже.206207## Определение PyTypeObject208209Определение структуры для [`PyTypeObject`](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject) можно найти в `Include/object.h`. Для удобства здесь повторяется определение, приведённое там:210211```c212typedef struct _typeobject {213    PyObject_VAR_HEAD214    const char *tp_name; /* Для вывода в формате "<module>.<name>" */215    Py_ssize_t tp_basicsize, tp_itemsize; /* Для выделения памяти */216217    /* Методы для реализации стандартных операций */218219    destructor tp_dealloc;220    Py_ssize_t tp_vectorcall_offset;221    getattrfunc tp_getattr;222    setattrfunc tp_setattr;223    PyAsyncMethods *tp_as_async; /* ранее известный как tp_compare (Python 2)224                                    или tp_reserved (Python 3) */225    reprfunc tp_repr;226227    /* Наборы методов для стандартных классов */228229    PyNumberMethods *tp_as_number;230    PySequenceMethods *tp_as_sequence;231    PyMappingMethods *tp_as_mapping;232233    /* Дополнительные стандартные операции (здесь для двоичной совместимости) */234235    hashfunc tp_hash;236    ternaryfunc tp_call;237    reprfunc tp_str;238    getattrofunc tp_getattro;239    setattrofunc tp_setattro;240241    /* Функции для доступа к объекту как к буферу ввода/вывода */242    PyBufferProcs *tp_as_buffer;243244    /* Флаги для определения наличия опциональных/расширенных возможностей */245    unsigned long tp_flags;246247    const char *tp_doc; /* Строка документации */248249    /* вызов функции для всех доступных объектов */250    traverseproc tp_traverse;251252    /* удаление ссылок на содержащиеся объекты */253    inquiry tp_clear;254255    /* расширенные сравнения */256    richcmpfunc tp_richcompare;257258    /* включение слабых ссылок */259    Py_ssize_t tp_weaklistoffset;260261    /* Итераторы */262    getiterfunc tp_iter;263    iternextfunc tp_iternext;264265    /* Дескриптор атрибутов и механизмы подклассов */266    struct PyMethodDef *tp_methods;267    struct PyMemberDef *tp_members;268    struct PyGetSetDef *tp_getset;269    struct _typeobject *tp_base;270    PyObject *tp_dict;271    descrgetfunc tp_descr_get;272    descrsetfunc tp_descr_set;273    Py_ssize_t tp_dictoffset;274    initproc tp_init;275    allocfunc tp_alloc;276    newfunc tp_new;277    freefunc tp_free; /* Низкоуровневая процедура освобождения памяти */278    inquiry tp_is_gc; /* Для PyObject_IS_GC */279    PyObject *tp_bases;280    PyObject *tp_mro; /* порядок разрешения методов */281    PyObject *tp_cache;282    PyObject *tp_subclasses;283    PyObject *tp_weaklist;284    destructor tp_del;285286    /* Метка версии кэша атрибутов типа. Добавлено в версии 2.6. */287    unsigned int tp_version_tag;288289    destructor tp_finalize;290291} PyTypeObject;292```293294## Слоты PyObject295296Структура объекта-типа расширяет структуру [`PyVarObject`](https://python-all.ru/3.8/c-api/structures.html#c.PyVarObject). Поле `ob_size` используется для динамических типов (создаваемых с помощью `type_new()`, обычно вызываемого из объявления класса). Обратите внимание, что [`PyType_Type`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Type) (метатип) инициализирует [`tp_itemsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_itemsize), что означает, что его экземпляры (т.е. объекты-типы) *должны* иметь поле `ob_size`.297298**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject)\* `PyObject._ob_next`**299300**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject)\* `PyObject._ob_prev`**301302Эти поля присутствуют только тогда, когда определён макрос `Py_TRACE_REFS`. Их инициализация значением `NULL` выполняется макросом `PyObject_HEAD_INIT`. Для статически выделенных объектов эти поля всегда остаются `NULL`. Для динамически выделенных объектов эти два поля используются для включения объекта в двусвязный список *всех* живых объектов в куче. Это может использоваться для различных целей отладки; в настоящее время единственное применение – вывод объектов, которые остаются живыми в конце выполнения, когда установлена переменная окружения [`PYTHONDUMPREFS`](https://python-all.ru/3.8/using/cmdline.html#envvar-PYTHONDUMPREFS).303304**Наследование:**305306Эти поля не наследуются подтипами.307308**Py\_ssize\_t `PyObject.ob_refcnt`**309310Это счётчик ссылок объекта-типа, инициализируемый значением `1` макросом `PyObject_HEAD_INIT`. Обратите внимание: для статически выделенных объектов-типов экземпляры типа (объекты, у которых `ob_type` указывает обратно на тип) *не* считаются ссылками. Но для динамически выделенных объектов-типов экземпляры *считаются* ссылками.311312**Наследование:**313314Это поле не наследуется подтипами.315316**[PyTypeObject](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject)\* `PyObject.ob_type`**317318Это тип типа, иными словами, его метатип. Он инициализируется аргументом макроса `PyObject_HEAD_INIT`, и его значением обычно должно быть `&PyType_Type`. Однако для динамически загружаемых модулей расширения, которые должны работать на Windows (по крайней мере), компилятор сообщает, что это недопустимый инициализатор. Поэтому принято передавать `NULL` макросу `PyObject_HEAD_INIT` и явно инициализировать это поле в начале функции инициализации модуля, перед любыми другими действиями. Обычно это делается так:319320```c321Foo_Type.ob_type = &PyType_Type;322```323324Это должно быть сделано до создания любых экземпляров типа. [`PyType_Ready()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Ready) проверяет, равен ли `ob_type` значению `NULL`, и если да, инициализирует его значением поля `ob_type` базового класса. [`PyType_Ready()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Ready) не будет изменять это поле, если оно ненулевое.325326**Наследование:**327328Это поле наследуется подтипами.329330## Слоты PyVarObject331332**Py\_ssize\_t `PyVarObject.ob_size`**333334Для статически выделенных объектов-типов это поле должно быть инициализировано нулём. Для динамически выделенных объектов-типов это поле имеет особый внутренний смысл.335336**Наследование:**337338Это поле не наследуется подтипами.339340## Слоты PyTypeObject341342Каждый слот имеет раздел, описывающий наследование. Если [`PyType_Ready()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Ready) может устанавливать значение, когда поле установлено в `NULL`, то также будет раздел «Default» (значение по умолчанию). (Обратите внимание, что многие поля, заданные в `PyBaseObject_Type` и [`PyType_Type`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Type), фактически действуют как значения по умолчанию.)343344**const char\* `PyTypeObject.tp_name`**345346Указатель на строку, завершающуюся NUL, содержащую имя типа. Для типов, доступных как глобальные переменные модуля, строка должна содержать полное имя модуля, за которым следует точка, а затем имя типа; для встроенных типов это должно быть просто имя типа. Если модуль является подмодулем пакета, полное имя пакета является частью полного имени модуля. Например, тип с именем `T`, определённый в модуле `M` в подпакете `Q` пакета `P`, должен иметь инициализатор [`tp_name`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_name) со значением `"P.Q.M.T"`.347348Для динамически выделенных объектов-типов это должно быть просто имя типа, а имя модуля явно хранится в словаре типа как значение для ключа `'__module__'`.349350Для статически выделенных объектов-типов поле tp\_name должно содержать точку. Всё до последней точки становится доступным как атрибут `__module__`, а всё после последней точки – как атрибут [`__name__`](https://python-all.ru/3.8/library/stdtypes.html#definition.__name__).351352Если точка отсутствует, всё поле [`tp_name`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_name) становится доступным как атрибут [`__name__`](https://python-all.ru/3.8/library/stdtypes.html#definition.__name__), а атрибут `__module__` не определён (если только не задан явно в словаре, как описано выше). Это означает, что ваш тип невозможно будет сериализовать с помощью pickle. Кроме того, он не будет отображаться в документации модуля, создаваемой pydoc.353354Это поле не должно быть `NULL`. Это единственное обязательное поле в [`PyTypeObject()`](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject) (кроме потенциально [`tp_itemsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_itemsize)).355356**Наследование:**357358Это поле не наследуется подтипами.359360**Py\_ssize\_t `PyTypeObject.tp_basicsize`**361362**Py\_ssize\_t `PyTypeObject.tp_itemsize`**363364Эти поля позволяют вычислить размер экземпляров типа в байтах.365366Существует два вида типов: типы с экземплярами фиксированной длины имеют нулевое [`tp_itemsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_itemsize) поле, типы с экземплярами переменной длины имеют ненулевое [`tp_itemsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_itemsize) поле. Для типа с экземплярами фиксированной длины все экземпляры имеют одинаковый размер, указанный в [`tp_basicsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_basicsize).367368Для типа с экземплярами переменной длины экземпляры должны иметь `ob_size` поле, а размер экземпляра равен [`tp_basicsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_basicsize) плюс N умножить на [`tp_itemsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_itemsize), где N – «длина» объекта. Значение N обычно хранится в поле `ob_size` экземпляра. Есть исключения: например, int использует отрицательное `ob_size` для обозначения отрицательного числа, и N равно `abs(ob_size)`. Кроме того, наличие поля `ob_size` в структуре экземпляра не означает, что структура экземпляра имеет переменную длину (например, структура для типа списка имеет экземпляры фиксированной длины, но при этом у этих экземпляров есть значимое поле `ob_size`).369370Базовый размер включает поля того экземпляра, которые объявлены макросом [`PyObject_HEAD`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject_HEAD) или [`PyObject_VAR_HEAD`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject_VAR_HEAD) (в зависимости от того, какой из них используется для объявления структуры экземпляра), и он, в свою очередь, включает поля `_ob_prev` и `_ob_next`, если они присутствуют. Это означает, что единственный правильный способ получить инициализатор для [`tp_basicsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_basicsize) – это использовать оператор `sizeof` для структуры, используемой для объявления макета экземпляра. Базовый размер не включает размер заголовка GC.371372Замечание о выравнивании: если переменные элементы требуют определённого выравнивания, это должно быть обеспечено значением [`tp_basicsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_basicsize). Пример: предположим, тип реализует массив `double`. [`tp_itemsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_itemsize) равно `sizeof(double)`. Программист должен гарантировать, что [`tp_basicsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_basicsize) кратно `sizeof(double)` (при условии, что это и есть требование выравнивания для `double`).373374Для любого типа с экземплярами переменной длины это поле не должно быть `NULL`.375376**Наследование:**377378Эти поля наследуются подтипами независимо друг от друга. Если базовый тип имеет ненулевое [`tp_itemsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_itemsize), обычно небезопасно устанавливать [`tp_itemsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_itemsize) в другое ненулевое значение в подтипе (хотя это зависит от реализации базового типа).379380**[destructor](https://python-all.ru/3.8/c-api/typeobj.html#c.destructor) `PyTypeObject.tp_dealloc`**381382Указатель на функцию-деструктор экземпляра. Эта функция должна быть определена, если только тип не гарантирует, что его экземпляры никогда не будут освобождены (как в случае с синглетонами `None` и `Ellipsis`). Сигнатура функции:383384```c385void tp_dealloc(PyObject *self);386```387388Функция-деструктор вызывается макросами [`Py_DECREF()`](https://python-all.ru/3.8/c-api/refcounting.html#c.Py_DECREF) и [`Py_XDECREF()`](https://python-all.ru/3.8/c-api/refcounting.html#c.Py_XDECREF), когда новое значение счётчика ссылок становится нулевым. В этот момент экземпляр всё ещё существует, но на него нет ссылок. Функция-деструктор должна освободить все ссылки, которыми владеет экземпляр, освободить все буферы памяти, принадлежащие экземпляру (с использованием функции освобождения, соответствующей функции выделения, использованной для выделения буфера), и вызвать функцию [`tp_free`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_free) типа. Если тип не является субтипируемым (не имеет установленного флага [`Py_TPFLAGS_BASETYPE`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_BASETYPE)), допускается вызывать деаллокатор объекта напрямую, а не через [`tp_free`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_free). Деаллокатор объекта должен быть тем же, что использовался для выделения экземпляра; обычно это [`PyObject_Del()`](https://python-all.ru/3.8/c-api/allocation.html#c.PyObject_Del), если экземпляр был выделен с помощью [`PyObject_New()`](https://python-all.ru/3.8/c-api/allocation.html#c.PyObject_New) или `PyObject_VarNew()`, или [`PyObject_GC_Del()`](https://python-all.ru/3.8/c-api/gcsupport.html#c.PyObject_GC_Del), если экземпляр был выделен с помощью [`PyObject_GC_New()`](https://python-all.ru/3.8/c-api/gcsupport.html#c.PyObject_GC_New) или [`PyObject_GC_NewVar()`](https://python-all.ru/3.8/c-api/gcsupport.html#c.PyObject_GC_NewVar).389390Наконец, если тип выделен в куче ([`Py_TPFLAGS_HEAPTYPE`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HEAPTYPE)), то деаллокатор должен уменьшить счётчик ссылок для своего объекта-типа после вызова деаллокатора типа. Чтобы избежать висячих указателей, рекомендуемый способ сделать это:391392```c393static void foo_dealloc(foo_object *self) {394    PyTypeObject *tp = Py_TYPE(self);395    // Освободить ссылки и буферы здесь.396    tp->tp_free(self);397    Py_DECREF(tp);398}399```400401**Наследование:**402403Это поле наследуется подтипами.404405**Py\_ssize\_t `PyTypeObject.tp_vectorcall_offset`**406407Необязательное смещение к функции для каждого экземпляра, которая реализует вызов объекта с использованием протокола *vectorcall*, более эффективной альтернативы более простому [`tp_call`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_call).408409Это поле используется только если установлен флаг [`_Py_TPFLAGS_HAVE_VECTORCALL`](https://python-all.ru/3.8/c-api/typeobj.html#_Py_TPFLAGS_HAVE_VECTORCALL). В этом случае оно должно быть положительным целым числом, содержащим смещение в экземпляре указателя [`vectorcallfunc`](https://python-all.ru/3.8/c-api/typeobj.html#c.vectorcallfunc). Сигнатура такая же, как для [`_PyObject_Vectorcall()`](https://python-all.ru/3.8/c-api/object.html#c._PyObject_Vectorcall):410411```c412PyObject *vectorcallfunc(PyObject *callable, PyObject *const *args, size_t nargsf, PyObject *kwnames)413```414415Указатель *vectorcallfunc* может быть нулевым; в этом случае экземпляр ведёт себя так, как если бы [`_Py_TPFLAGS_HAVE_VECTORCALL`](https://python-all.ru/3.8/c-api/typeobj.html#_Py_TPFLAGS_HAVE_VECTORCALL) не был установлен: вызов экземпляра сводится к [`tp_call`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_call).416417Любой класс, устанавливающий `_Py_TPFLAGS_HAVE_VECTORCALL`, должен также установить [`tp_call`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_call) и убедиться, что его поведение согласовано с функцией *vectorcallfunc*. Этого можно добиться, установив *tp\_call* в `PyVectorcall_Call`:418419#### `PyObject *PyVectorcall_Call(PyObject *callable, PyObject *tuple, PyObject *dict)`420421Вызвать *vectorcallfunc* объекта *callable* с позиционными и именованными аргументами, заданными в кортеже и словаре соответственно.422423Эта функция предназначена для использования в слоте `tp_call`. Она не обращается к `tp_call` и в настоящее время не проверяет флаг `_Py_TPFLAGS_HAVE_VECTORCALL`. Для вызова объекта используйте одну из функций [`PyObject_Call`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_Call).424425> **Примечание**426>427> [heap types](https://python-all.ru/3.8/c-api/typeobj.html#heap-types) не рекомендуется реализовывать протокол vectorcall. Когда пользователь устанавливает `__call__` в коде Python, обновляется только `tp_call`, что может привести к несоответствию с функцией vectorcall.428429> **Примечание**430>431> Семантика слота `tp_vectorcall_offset` является предварительной и ожидается, что будет окончательно определена в Python 3.9. Если вы используете vectorcall, планируйте обновление своего кода для Python 3.9.432433Изменено в версии 3.8: Этот слот использовался для форматирования вывода в Python 2.x. В Python 3.0–3.7 он был зарезервирован и назывался `tp_print`.434435**Наследование:**436437Это поле наследуется подтипами вместе с [`tp_call`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_call): подтип наследует [`tp_vectorcall_offset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_vectorcall_offset) от своего базового типа, когда [`tp_call`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_call) подтипа равно `NULL`.438439Обратите внимание, что [heap types](https://python-all.ru/3.8/c-api/typeobj.html#id4) (включая подклассы, определённые в Python) не наследуют флаг [`_Py_TPFLAGS_HAVE_VECTORCALL`](https://python-all.ru/3.8/c-api/typeobj.html#_Py_TPFLAGS_HAVE_VECTORCALL).440441**[getattrfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.getattrfunc) `PyTypeObject.tp_getattr`**442443Необязательный указатель на функцию получения строки атрибута.444445Это поле устарело. Если оно определено, оно должно указывать на функцию, которая действует так же, как функция [`tp_getattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattro), но принимает C-строку вместо строкового объекта Python для указания имени атрибута.446447**Наследование:**448449Группа: `tp_getattr`, `tp_getattro`450451Это поле наследуется подтипами вместе с [`tp_getattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattro): подтип наследует и [`tp_getattr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattr), и [`tp_getattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattro) от своего базового типа, когда [`tp_getattr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattr) и [`tp_getattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattro) подтипа оба равны `NULL`.452453**[setattrfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.setattrfunc) `PyTypeObject.tp_setattr`**454455Необязательный указатель на функцию для установки и удаления атрибутов.456457Это поле устарело. Если оно определено, оно должно указывать на функцию, которая действует так же, как функция [`tp_setattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattro), но принимает C-строку вместо строкового объекта Python для указания имени атрибута.458459**Наследование:**460461Группа: `tp_setattr`, `tp_setattro`462463Это поле наследуется подтипами вместе с [`tp_setattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattro): подтип наследует и [`tp_setattr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattr), и [`tp_setattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattro) от своего базового типа, когда [`tp_setattr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattr) и [`tp_setattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattro) подтипа оба равны `NULL`.464465**[PyAsyncMethods](https://python-all.ru/3.8/c-api/typeobj.html#c.PyAsyncMethods)\* `PyTypeObject.tp_as_async`**466467Указатель на дополнительную структуру, содержащую поля, значимые только для объектов, реализующих протоколы [ожидаемого объекта](https://python-all.ru/3.8/glossary.html#term-awaitable) и [асинхронного итератора](https://python-all.ru/3.8/glossary.html#term-asynchronous-iterator) на уровне C. Подробнее см. в [Структуры асинхронных объектов](https://python-all.ru/3.8/c-api/typeobj.html#async-structs).468469Новое в версии 3.5: Ранее было известно как `tp_compare` и `tp_reserved`.470471**Наследование:**472473Поле [`tp_as_async`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_async) не наследуется, но содержащиеся в нем поля наследуются по отдельности.474475**[reprfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.reprfunc) `PyTypeObject.tp_repr`**476477Необязательный указатель на функцию, реализующую встроенную функцию [`repr()`](https://python-all.ru/3.8/library/functions.html#repr).478479Сигнатура такая же, как для [`PyObject_Repr()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_Repr):480481```c482PyObject *tp_repr(PyObject *self);483```484485Функция должна возвращать строку или объект Unicode. В идеале она должна возвращать строку, которая при передаче в [`eval()`](https://python-all.ru/3.8/library/functions.html#eval) в подходящем окружении возвращает объект с тем же значением. Если это невозможно, она должна возвращать строку, начинающуюся с `'<'` и заканчивающуюся `'>'`, из которой можно вывести как тип, так и значение объекта.486487**Наследование:**488489Это поле наследуется подтипами.490491**По умолчанию:**492493Если это поле не задано, возвращается строка вида `<%s object at %p>`, где `%s` заменяется именем типа, а `%p` – адресом памяти объекта.494495**[PyNumberMethods](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods)\* `PyTypeObject.tp_as_number`**496497Указатель на дополнительную структуру, содержащую поля, значимые только для объектов, реализующих числовой протокол. Эти поля описаны в [Структуры числовых объектов](https://python-all.ru/3.8/c-api/typeobj.html#number-structs).498499**Наследование:**500501Поле [`tp_as_number`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_number) не наследуется, но содержащиеся в нём поля наследуются по отдельности.502503**[PySequenceMethods](https://python-all.ru/3.8/c-api/typeobj.html#c.PySequenceMethods)\* `PyTypeObject.tp_as_sequence`**504505Указатель на дополнительную структуру, содержащую поля, значимые только для объектов, реализующих протокол последовательности. Эти поля описаны в [Структуры объектов-последовательностей](https://python-all.ru/3.8/c-api/typeobj.html#sequence-structs).506507**Наследование:**508509Поле [`tp_as_sequence`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_sequence) не наследуется, но содержащиеся в нём поля наследуются по отдельности.510511**[PyMappingMethods](https://python-all.ru/3.8/c-api/typeobj.html#c.PyMappingMethods)\* `PyTypeObject.tp_as_mapping`**512513Указатель на дополнительную структуру, содержащую поля, значимые только для объектов, реализующих протокол отображения. Эти поля описаны в [Структуры объектов-отображений](https://python-all.ru/3.8/c-api/typeobj.html#mapping-structs).514515**Наследование:**516517Поле [`tp_as_mapping`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_mapping) не наследуется, но содержащиеся в нём поля наследуются по отдельности.518519**[hashfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.hashfunc) `PyTypeObject.tp_hash`**520521Необязательный указатель на функцию, реализующую встроенную функцию [`hash()`](https://python-all.ru/3.8/library/functions.html#hash).522523Сигнатура такая же, как для [`PyObject_Hash()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_Hash):524525```c526Py_hash_t tp_hash(PyObject *);527```528529Значение `-1` не должно возвращаться как обычное возвращаемое значение; при возникновении ошибки во время вычисления хеш-значения функция должна установить исключение и вернуть `-1`.530531Если это поле не задано (*и* `tp_richcompare` не задано), то попытка получить хеш объекта вызывает [`TypeError`](https://python-all.ru/3.8/library/exceptions.html#TypeError). Это то же самое, что установить его в [`PyObject_HashNotImplemented()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_HashNotImplemented).532533Это поле можно явно установить в [`PyObject_HashNotImplemented()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_HashNotImplemented), чтобы заблокировать наследование хеш-метода от родительского типа. Это интерпретируется как эквивалент `__hash__ = None` на уровне Python, в результате чего `isinstance(o, collections.Hashable)` корректно возвращает `False`. Обратите внимание, что верно и обратное: установка `__hash__ = None` в классе на уровне Python приведет к тому, что слот `tp_hash` будет установлен в [`PyObject_HashNotImplemented()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_HashNotImplemented).534535**Наследование:**536537Группа: `tp_hash`, `tp_richcompare`538539Это поле наследуется подтипами вместе с [`tp_richcompare`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_richcompare): подтип наследует как [`tp_richcompare`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_richcompare), так и [`tp_hash`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_hash), если [`tp_richcompare`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_richcompare) и [`tp_hash`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_hash) подтипа равны `NULL`.540541**[ternaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.ternaryfunc) `PyTypeObject.tp_call`**542543Необязательный указатель на функцию, реализующую вызов объекта. Это значение должно быть `NULL`, если объект не является вызываемым. Сигнатура такая же, как у [`PyObject_Call()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_Call):544545```c546PyObject *tp_call(PyObject *self, PyObject *args, PyObject *kwargs);547```548549**Наследование:**550551Это поле наследуется подтипами.552553**[reprfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.reprfunc) `PyTypeObject.tp_str`**554555Необязательный указатель на функцию, реализующую встроенную операцию [`str()`](https://python-all.ru/3.8/library/stdtypes.html#str). (Обратите внимание, что [`str`](https://python-all.ru/3.8/library/stdtypes.html#str) теперь является типом, а [`str()`](https://python-all.ru/3.8/library/stdtypes.html#str) вызывает конструктор этого типа. Этот конструктор вызывает [`PyObject_Str()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_Str) для выполнения фактической работы, и [`PyObject_Str()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_Str) будет вызывать этот обработчик.)556557Сигнатура такая же, как для [`PyObject_Str()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_Str):558559```c560PyObject *tp_str(PyObject *self);561```562563Функция должна возвращать строку или объект Unicode. Это должно быть «дружественное» строковое представление объекта, так как это представление будет использоваться, в частности, функцией [`print()`](https://python-all.ru/3.8/library/functions.html#print).564565**Наследование:**566567Это поле наследуется подтипами.568569**По умолчанию:**570571Если это поле не задано, вызывается [`PyObject_Repr()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_Repr) для возврата строкового представления.572573**[getattrofunc](https://python-all.ru/3.8/c-api/typeobj.html#c.getattrofunc) `PyTypeObject.tp_getattro`**574575Необязательный указатель на функцию получения атрибута.576577Сигнатура такая же, как для [`PyObject_GetAttr()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_GetAttr):578579```c580PyObject *tp_getattro(PyObject *self, PyObject *attr);581```582583Обычно удобно установить это поле в [`PyObject_GenericGetAttr()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_GenericGetAttr), которое реализует обычный способ поиска атрибутов объекта.584585**Наследование:**586587Группа: `tp_getattr`, `tp_getattro`588589Это поле наследуется подтипами вместе с [`tp_getattr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattr): подтип наследует и [`tp_getattr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattr), и [`tp_getattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattro) от своего базового типа, когда [`tp_getattr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattr) и [`tp_getattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattro) подтипа оба равны `NULL`.590591**По умолчанию:**592593`PyBaseObject_Type` использует [`PyObject_GenericGetAttr()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_GenericGetAttr).594595**[setattrofunc](https://python-all.ru/3.8/c-api/typeobj.html#c.setattrofunc) `PyTypeObject.tp_setattro`**596597Необязательный указатель на функцию для установки и удаления атрибутов.598599Сигнатура такая же, как для [`PyObject_SetAttr()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_SetAttr):600601```c602PyObject *tp_setattro(PyObject *self, PyObject *attr, PyObject *value);603```604605Кроме того, установка *value* в `NULL` для удаления атрибута должна поддерживаться. Обычно удобно устанавливать это поле в [`PyObject_GenericSetAttr()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_GenericSetAttr), которое реализует обычный способ установки атрибутов объекта.606607**Наследование:**608609Группа: `tp_setattr`, `tp_setattro`610611Это поле наследуется подтипами вместе с [`tp_setattr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattr): подтип наследует и [`tp_setattr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattr), и [`tp_setattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattro) от своего базового типа, когда [`tp_setattr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattr) и [`tp_setattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattro) подтипа оба равны `NULL`.612613**По умолчанию:**614615`PyBaseObject_Type` использует [`PyObject_GenericSetAttr()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_GenericSetAttr).616617**[PyBufferProcs](https://python-all.ru/3.8/c-api/typeobj.html#c.PyBufferProcs)\* `PyTypeObject.tp_as_buffer`**618619Указатель на дополнительную структуру, содержащую поля, значимые только для объектов, реализующих буферный интерфейс. Эти поля описаны в [Buffer Object Structures](https://python-all.ru/3.8/c-api/typeobj.html#buffer-structs).620621**Наследование:**622623Поле [`tp_as_buffer`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_buffer) не наследуется, но содержащиеся в нем поля наследуются по отдельности.624625**unsigned long `PyTypeObject.tp_flags`**626627Это поле представляет собой битовую маску различных флагов. Некоторые флаги указывают на изменённую семантику для определённых ситуаций; другие используются для указания того, что определённые поля в объекте типа (или в расширяющих структурах, на которые ссылаются через [`tp_as_number`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_number), [`tp_as_sequence`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_sequence), [`tp_as_mapping`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_mapping) и [`tp_as_buffer`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_as_buffer)), которые исторически не всегда присутствовали, теперь действительны; если такой бит флага сброшен, то поля типа, которые он защищает, не должны использоваться и должны считаться имеющими значение ноль или `NULL`.628629**Наследование:**630631Наследование этого поля сложное. Большинство битов флагов наследуются индивидуально, т.е. если у базового типа установлен бит флага, подтип наследует этот бит флага. Биты флагов, относящиеся к расширяющим структурам, строго наследуются, если наследуется расширяющая структура, т.е. значение бита флага базового типа копируется в подтип вместе с указателем на расширяющую структуру. Бит флага [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC) наследуется вместе с полями [`tp_traverse`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_traverse) и [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear), т.е. если бит флага [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC) сброшен в подтипе, а поля [`tp_traverse`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_traverse) и [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear) в подтипе существуют и имеют значения `NULL`.632633**По умолчанию:**634635`PyBaseObject_Type` использует `Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE`.636637**Битовые маски:**638639В настоящее время определены следующие битовые маски; их можно объединять с помощью оператора `|` для получения значения поля [`tp_flags`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_flags). Макрос [`PyType_HasFeature()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_HasFeature) принимает тип и значение флагов, *tp* и *f*, и проверяет, является ли `tp->tp_flags & f` ненулевым.640641#### `Py_TPFLAGS_HEAPTYPE`642643Этот бит устанавливается, когда сам объект типа выделен в куче, например, для типов, созданных динамически с помощью [`PyType_FromSpec()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_FromSpec). В этом случае поле `ob_type` его экземпляров считается ссылкой на тип, и при создании нового экземпляра для объекта типа вызывается INCREF, а при уничтожении экземпляра – DECREF (это не относится к экземплярам подтипов; только тип, на который ссылается ob\_type экземпляра, подвергается INCREF или DECREF).644645**Наследование:**646647???648649#### `Py_TPFLAGS_BASETYPE`650651Этот бит устанавливается, когда тип может использоваться как базовый тип другого типа. Если этот бит сброшен, тип не может быть унаследован (аналогично «финальному» классу в Java).652653**Наследование:**654655???656657#### `Py_TPFLAGS_READY`658659Этот бит устанавливается, когда объект типа был полностью инициализирован функцией [`PyType_Ready()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Ready).660661**Наследование:**662663???664665#### `Py_TPFLAGS_READYING`666667Этот бит устанавливается, пока [`PyType_Ready()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Ready) находится в процессе инициализации объекта типа.668669**Наследование:**670671???672673#### `Py_TPFLAGS_HAVE_GC`674675Этот бит устанавливается, когда объект поддерживает сборку мусора. Если бит установлен, экземпляры должны создаваться с помощью [`PyObject_GC_New()`](https://python-all.ru/3.8/c-api/gcsupport.html#c.PyObject_GC_New) и уничтожаться с помощью [`PyObject_GC_Del()`](https://python-all.ru/3.8/c-api/gcsupport.html#c.PyObject_GC_Del). Дополнительная информация – в разделе [Поддержка циклической сборки мусора](https://python-all.ru/3.8/c-api/gcsupport.html#supporting-cycle-detection). Этот бит также означает, что связанные со сборкой мусора поля [`tp_traverse`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_traverse) и [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear) присутствуют в объекте типа.676677**Наследование:**678679Группа: [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC), `tp_traverse`, `tp_clear`680681Бит флага [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC) наследуется вместе с полями `tp_traverse` и `tp_clear`, то есть если бит флага [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC) сброшен в подтипе, а поля `tp_traverse` и `tp_clear` в подтипе существуют и имеют значения `NULL`.682683#### `Py_TPFLAGS_DEFAULT`684685Это битовая маска всех битов, относящихся к наличию определённых полей в объекте типа и его структурах расширения. В настоящее время она включает следующие биты: `Py_TPFLAGS_HAVE_STACKLESS_EXTENSION`, `Py_TPFLAGS_HAVE_VERSION_TAG`.686687**Наследование:**688689???690691#### `Py_TPFLAGS_METHOD_DESCRIPTOR`692693Этот бит указывает, что объекты ведут себя как несвязанные методы.694695Если этот флаг установлен для `type(meth)`, то:696697- `meth.__get__(obj, cls)(*args, **kwds)` (при `obj` не None) должен быть эквивалентен `meth(obj, *args, **kwds)`.698- `meth.__get__(None, cls)(*args, **kwds)` должен быть эквивалентен `meth(*args, **kwds)`.699700Этот флаг включает оптимизацию для типичных вызовов методов, таких как `obj.meth()`: он позволяет избежать создания временного объекта «связанный метод» для `obj.meth`.701702Новое в версии 3.8.703704**Наследование:**705706Этот флаг никогда не наследуется динамическими типами (heap types). Для типов расширений он наследуется всякий раз, когда наследуется [`tp_descr_get`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_descr_get).707708#### `Py_TPFLAGS_LONG_SUBCLASS`709710#### `Py_TPFLAGS_LIST_SUBCLASS`711712#### `Py_TPFLAGS_TUPLE_SUBCLASS`713714#### `Py_TPFLAGS_BYTES_SUBCLASS`715716#### `Py_TPFLAGS_UNICODE_SUBCLASS`717718#### `Py_TPFLAGS_DICT_SUBCLASS`719720#### `Py_TPFLAGS_BASE_EXC_SUBCLASS`721722#### `Py_TPFLAGS_TYPE_SUBCLASS`723724Эти флаги используются такими функциями, как [`PyLong_Check()`](https://python-all.ru/3.8/c-api/long.html#c.PyLong_Check), для быстрого определения, является ли тип подклассом встроенного типа; такие конкретные проверки выполняются быстрее, чем общая проверка, например [`PyObject_IsInstance()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_IsInstance). Пользовательские типы, наследующие от встроенных, должны иметь соответствующий [`tp_flags`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_flags) установленным, иначе код, взаимодействующий с такими типами, будет вести себя по-разному в зависимости от того, какая проверка используется.725726#### `Py_TPFLAGS_HAVE_FINALIZE`727728Этот бит устанавливается, когда слот [`tp_finalize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_finalize) присутствует в структуре типа.729730Новое в версии 3.4.731732Устарело с версии 3.8: Этот флаг больше не нужен, так как интерпретатор предполагает, что слот [`tp_finalize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_finalize) всегда присутствует в структуре типа.733734#### `_Py_TPFLAGS_HAVE_VECTORCALL`735736Этот бит устанавливается, когда класс реализует протокол vectorcall. Подробнее см. [`tp_vectorcall_offset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_vectorcall_offset).737738**Наследование:**739740Этот бит устанавливается на *статических* подтипах, если `tp_flags` не переопределён: подтип наследует `_Py_TPFLAGS_HAVE_VECTORCALL` от своего базового типа, когда [`tp_call`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_call) подтипа равно `NULL` и `Py_TPFLAGS_HEAPTYPE` подтипа не установлен.741742[Heap types](https://python-all.ru/3.8/c-api/typeobj.html#id4) не наследуют `_Py_TPFLAGS_HAVE_VECTORCALL`.743744> **Примечание**745>746> Этот флаг является предварительным и, как ожидается, станет общедоступным в Python 3.9 с другим именем и, возможно, изменённой семантикой. Если вы используете vectorcall, планируйте обновление своего кода для Python 3.9.747748Новое в версии 3.8.749750**const char\* `PyTypeObject.tp_doc`**751752Необязательный указатель на C-строку, завершающуюся нулевым символом, содержащую строку документации для этого объекта типа. Это отображается как атрибут `__doc__` у типа и его экземпляров.753754**Наследование:**755756Это поле *не* наследуется подтипами.757758**[traverseproc](https://python-all.ru/3.8/c-api/gcsupport.html#c.traverseproc) `PyTypeObject.tp_traverse`**759760Необязательный указатель на функцию обхода для сборщика мусора. Используется только если установлен бит флага [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC). Сигнатура:761762```c763int tp_traverse(PyObject *self, visitproc visit, void *arg);764```765766Дополнительная информация о схеме сборки мусора в Python доступна в разделе [Поддержка циклической сборки мусора](https://python-all.ru/3.8/c-api/gcsupport.html#supporting-cycle-detection).767768Указатель [`tp_traverse`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_traverse) используется сборщиком мусора для обнаружения циклических ссылок. Типичная реализация функции [`tp_traverse`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_traverse) просто вызывает [`Py_VISIT()`](https://python-all.ru/3.8/c-api/gcsupport.html#c.Py_VISIT) для каждого элемента экземпляра, являющегося объектом Python, которым владеет экземпляр. Например, это функция `local_traverse()` из модуля расширения [`_thread`](https://python-all.ru/3.8/library/_thread.html#module-_thread):769770```c771static int772local_traverse(localobject *self, visitproc visit, void *arg)773{774    Py_VISIT(self->args);775    Py_VISIT(self->kw);776    Py_VISIT(self->dict);777    return 0;778}779```780781Обратите внимание, что [`Py_VISIT()`](https://python-all.ru/3.8/c-api/gcsupport.html#c.Py_VISIT) вызывается только для тех членов, которые могут участвовать в циклических ссылках. Хотя есть также член `self->key`, он может быть только `NULL` или строкой Python и поэтому не может быть частью циклической ссылки.782783С другой стороны, даже если известно, что член никогда не может быть частью цикла, в качестве средства отладки его всё равно можно обойти, чтобы функция [`get_referents()`](https://python-all.ru/3.8/library/gc.html#gc.get_referents) модуля [`gc`](https://python-all.ru/3.8/library/gc.html#module-gc) включила его.784785> **Предупреждение**786>787> При реализации [`tp_traverse`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_traverse) должны обходиться только те члены, которыми экземпляр *владеет* (имея на них сильные ссылки). Например, если объект поддерживает слабые ссылки через слот [`tp_weaklist`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_weaklist), указатель, поддерживающий связный список (на который указывает *tp\_weaklist*), **не** должен обходиться, так как экземпляр не владеет напрямую слабыми ссылками на себя (список слабых ссылок существует для поддержки механизма слабых ссылок, но у экземпляра нет сильной ссылки на элементы внутри него, поскольку им разрешено удаляться, даже если экземпляр всё ещё жив).788789Обратите внимание, что [`Py_VISIT()`](https://python-all.ru/3.8/c-api/gcsupport.html#c.Py_VISIT) требует, чтобы параметры *visit* и *arg* для `local_traverse()` имели именно такие имена; не следует называть их как попало.790791**Наследование:**792793Группа: [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC), `tp_traverse`, `tp_clear`794795Это поле наследуется подтипами вместе с [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear) и флагом [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC): флаг, [`tp_traverse`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_traverse) и [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear) наследуются от базового типа, если они равны нулю в подтипе.796797**[inquiry](https://python-all.ru/3.8/c-api/gcsupport.html#c.inquiry) `PyTypeObject.tp_clear`**798799Необязательный указатель на функцию очистки для сборщика мусора. Используется только если установлен флаг [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC). Сигнатура:800801```c802int tp_clear(PyObject *);803```804805Функция-член [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear) используется для разрыва циклических ссылок в циклическом мусоре, обнаруженном сборщиком мусора. В совокупности все функции [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear) в системе должны совместно разрывать все циклические ссылки. Это тонкий момент, и при любых сомнениях следует предоставить функцию [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear). Например, тип tuple не реализует функцию [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear), поскольку можно доказать, что ни одна циклическая ссылка не может состоять исключительно из кортежей. Поэтому функции [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear) других типов должны быть достаточны для разрыва любой циклической ссылки, содержащей кортеж. Это не очевидно, и редко есть веская причина избегать реализации [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear).806807Реализации [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear) должны удалять ссылки экземпляра на те его члены, которые могут являться объектами Python, и устанавливать указатели на эти члены в `NULL`, как показано в следующем примере:808809```c810static int811local_clear(localobject *self)812{813    Py_CLEAR(self->key);814    Py_CLEAR(self->args);815    Py_CLEAR(self->kw);816    Py_CLEAR(self->dict);817    return 0;818}819```820821Следует использовать макрос [`Py_CLEAR()`](https://python-all.ru/3.8/c-api/refcounting.html#c.Py_CLEAR), потому что очистка ссылок – это деликатная операция: счётчик ссылок на содержащийся объект не должен уменьшаться до тех пор, пока указатель на содержащийся объект не будет установлен в `NULL`. Это связано с тем, что уменьшение счётчика ссылок может привести к тому, что содержащийся объект станет мусором, вызвав цепочку действий по его освобождению, которая может включать вызов произвольного кода Python (из-за финализаторов или колбэков слабых ссылок, связанных с содержащимся объектом). Если такой код может снова сослаться на *self*, важно, чтобы указатель на содержащийся объект был `NULL` в этот момент, чтобы *self* знал, что содержащийся объект больше не может использоваться. Макрос [`Py_CLEAR()`](https://python-all.ru/3.8/c-api/refcounting.html#c.Py_CLEAR) выполняет операции в безопасном порядке.822823Поскольку цель функций [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear) – разрывать циклические ссылки, нет необходимости очищать содержащиеся объекты, такие как строки Python или целые числа Python, которые не могут участвовать в циклических ссылках. С другой стороны, может быть удобно очистить все содержащиеся объекты Python и написать функцию [`tp_dealloc`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dealloc) типа так, чтобы она вызывала [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear).824825Дополнительную информацию о схеме сборки мусора Python можно найти в разделе [Поддержка циклической сборки мусора](https://python-all.ru/3.8/c-api/gcsupport.html#supporting-cycle-detection).826827**Наследование:**828829Группа: [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC), `tp_traverse`, `tp_clear`830831Это поле наследуется подтипами вместе с [`tp_traverse`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_traverse) и флагом [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC): флаг, [`tp_traverse`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_traverse) и [`tp_clear`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_clear) наследуются от базового типа, если они равны нулю в подтипе.832833**[richcmpfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.richcmpfunc) `PyTypeObject.tp_richcompare`**834835Необязательный указатель на функцию расширенного сравнения, сигнатура которой:836837```c838PyObject *tp_richcompare(PyObject *self, PyObject *other, int op);839```840841Первый параметр гарантированно является экземпляром типа, определяемого через [`PyTypeObject`](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject).842843Функция должна возвращать результат сравнения (обычно `Py_True` или `Py_False`). Если сравнение не определено, она должна вернуть `Py_NotImplemented`; если произошла другая ошибка, она должна вернуть `NULL` и установить условие исключения.844845Следующие константы определены для использования в качестве третьего аргумента для [`tp_richcompare`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_richcompare) и для [`PyObject_RichCompare()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_RichCompare):846847| Константа | Сравнение |848| --- | --- |849| `Py_LT` | `<` |850| `Py_LE` | `<=` |851| `Py_EQ` | `==` |852| `Py_NE` | `!=` |853| `Py_GT` | `>` |854| `Py_GE` | `>=` |855856Для упрощения написания функций расширенного сравнения определён следующий макрос:857858**`Py_RETURN_RICHCOMPARE`(VAL\_A, VAL\_B, op)**859860Возвращает `Py_True` или `Py_False` из функции в зависимости от результата сравнения. VAL\_A и VAL\_B должны быть упорядочиваемыми с помощью операторов сравнения языка C (например, это могут быть значения типа int или float). Третий аргумент задаёт требуемую операцию, как и для [`PyObject_RichCompare()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_RichCompare).861862Счётчик ссылок возвращаемого значения корректно увеличивается.863864В случае ошибки устанавливает исключение и возвращает `NULL` из функции.865866Добавлено в версии 3.7.867868**Наследование:**869870Группа: `tp_hash`, `tp_richcompare`871872Это поле наследуется подтипами вместе с [`tp_hash`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_hash): подтип наследует [`tp_richcompare`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_richcompare) и [`tp_hash`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_hash), когда [`tp_richcompare`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_richcompare) и [`tp_hash`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_hash) подтипа оба `NULL`.873874**По умолчанию:**875876`PyBaseObject_Type` предоставляет реализацию `tp_richcompare`, которая может быть унаследована. Однако, если определено только `tp_hash`, унаследованная функция не используется, и экземпляры типа не смогут участвовать в сравнениях.877878**Py\_ssize\_t `PyTypeObject.tp_weaklistoffset`**879880Если экземпляры этого типа поддерживают слабые ссылки, это поле больше нуля и содержит смещение в структуре экземпляра до головы списка слабых ссылок (игнорируя заголовок GC, если он присутствует); это смещение используется функциями `PyObject_ClearWeakRefs()` и `PyWeakref_*()`. Структура экземпляра должна включать поле типа [`PyObject*`](https://python-all.ru/3.8/c-api/structures.html#c.PyObject), которое инициализируется значением `NULL`.881882Не путайте это поле с [`tp_weaklist`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_weaklist); это голова списка для слабых ссылок на сам объект типа.883884**Наследование:**885886Это поле наследуется подтипами, но см. правила ниже. Подтип может переопределить это смещение; это означает, что подтип использует другую голову списка слабых ссылок, нежели базовый тип. Поскольку голова списка всегда находится через [`tp_weaklistoffset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_weaklistoffset), это не должно быть проблемой.887888Если тип, определённый с помощью оператора class, не содержит объявления [`__slots__`](https://python-all.ru/3.8/reference/datamodel.html#object.__slots__), и ни один из его базовых типов не поддерживает слабые ссылки, тип делается доступным для слабых ссылок: в компоновку экземпляра добавляется слот заголовка списка слабых ссылок, и [`tp_weaklistoffset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_weaklistoffset) устанавливается на смещение этого слота.889890Если объявление [`__slots__`](https://python-all.ru/3.8/reference/datamodel.html#object.__slots__) типа содержит слот с именем `__weakref__`, этот слот становится заголовком списка слабых ссылок для экземпляров типа, а его смещение сохраняется в поле [`tp_weaklistoffset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_weaklistoffset) типа.891892Если объявление [`__slots__`](https://python-all.ru/3.8/reference/datamodel.html#object.__slots__) типа не содержит слота с именем `__weakref__`, тип наследует значение [`tp_weaklistoffset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_weaklistoffset) от своего базового типа.893894**[getiterfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.getiterfunc) `PyTypeObject.tp_iter`**895896Необязательный указатель на функцию, возвращающую итератор для объекта. Его наличие обычно указывает на то, что экземпляры этого типа являются итерируемыми (хотя последовательности могут быть итерируемыми и без этой функции).897898Эта функция имеет ту же сигнатуру, что и [`PyObject_GetIter()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_GetIter):899900```c901PyObject *tp_iter(PyObject *self);902```903904**Наследование:**905906Это поле наследуется подтипами.907908**[iternextfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.iternextfunc) `PyTypeObject.tp_iternext`**909910Необязательный указатель на функцию, возвращающую следующий элемент итератора. Сигнатура:911912```c913PyObject *tp_iternext(PyObject *self);914```915916Когда итератор исчерпан, он должен возвращать `NULL`; исключение [`StopIteration`](https://python-all.ru/3.8/library/exceptions.html#StopIteration) может быть установлено или нет. При другой ошибке он также должен возвращать `NULL`. Его наличие означает, что экземпляры этого типа являются итераторами.917918Типы-итераторы также должны определять функцию [`tp_iter`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_iter), и эта функция должна возвращать сам экземпляр итератора (не новый экземпляр итератора).919920Эта функция имеет ту же сигнатуру, что и [`PyIter_Next()`](https://python-all.ru/3.8/c-api/iter.html#c.PyIter_Next).921922**Наследование:**923924Это поле наследуется подтипами.925926**struct [PyMethodDef](https://python-all.ru/3.8/c-api/structures.html#c.PyMethodDef)\* `PyTypeObject.tp_methods`**927928Необязательный указатель на статический массив структур [`PyMethodDef`](https://python-all.ru/3.8/c-api/structures.html#c.PyMethodDef), завершающийся `NULL`, объявляющий обычные методы этого типа.929930Для каждой записи в массиве в словарь типа добавляется запись (см. [`tp_dict`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dict) ниже), содержащая дескриптор метода.931932**Наследование:**933934Это поле не наследуется подтипами (методы наследуются через другой механизм).935936**struct [PyMemberDef](https://python-all.ru/3.8/c-api/structures.html#c.PyMemberDef)\* `PyTypeObject.tp_members`**937938Необязательный указатель на статический массив [`PyMemberDef`](https://python-all.ru/3.8/c-api/structures.html#c.PyMemberDef) структур, завершающийся `NULL`, объявляющий обычные элементы данных (поля или слоты) экземпляров этого типа.939940Для каждой записи в массиве в словарь типа добавляется запись, содержащая дескриптор члена (см. [`tp_dict`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dict) ниже).941942**Наследование:**943944Это поле не наследуется подтипами (члены наследуются через другой механизм).945946**struct [PyGetSetDef](https://python-all.ru/3.8/c-api/structures.html#c.PyGetSetDef)\* `PyTypeObject.tp_getset`**947948Необязательный указатель на статический массив [`PyGetSetDef`](https://python-all.ru/3.8/c-api/structures.html#c.PyGetSetDef) структур, завершающийся `NULL`, объявляющий вычисляемые атрибуты экземпляров этого типа.949950Для каждой записи в массиве в словарь типа добавляется запись, содержащая дескриптор getset (см. [`tp_dict`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dict) ниже).951952**Наследование:**953954Это поле не наследуется подтипами (вычисляемые атрибуты наследуются через другой механизм).955956**[PyTypeObject](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject)\* `PyTypeObject.tp_base`**957958Необязательный указатель на базовый тип, от которого наследуются свойства типа. На этом уровне поддерживается только одиночное наследование; множественное наследование требует динамического создания объекта типа вызовом метатипа.959960> **Примечание**961>962> Инициализация слотов подчиняется правилам инициализации глобальных переменных. C99 требует, чтобы инициализаторы были «адресными константами». Обозначения функций, такие как [`PyType_GenericNew()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_GenericNew), с неявным преобразованием в указатель, являются допустимыми адресными константами C99.963>964> Однако унарный оператор '&', применённый к нестатической переменной, такой как `PyBaseObject_Type()`, не обязан давать адресную константу. Компиляторы могут это поддерживать (gcc поддерживает), MSVC – нет. Оба компилятора в этом конкретном поведении строго соответствуют стандарту.965>966> Следовательно, [`tp_base`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_base) должно устанавливаться в функции инициализации модуля расширения.967968**Наследование:**969970Это поле не наследуется подтипами (очевидно).971972**По умолчанию:**973974По умолчанию это поле равно `&PyBaseObject_Type` (которое программистам Python известно как тип [`object`](https://python-all.ru/3.8/library/functions.html#object)).975976**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject)\* `PyTypeObject.tp_dict`**977978Словарь типа сохраняется здесь с помощью [`PyType_Ready()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Ready).979980Это поле обычно должно быть инициализировано значением `NULL` до вызова PyType\_Ready; его также можно инициализировать словарём с начальными атрибутами типа. После того, как [`PyType_Ready()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Ready) инициализирует тип, дополнительные атрибуты можно добавлять в этот словарь только если они не соответствуют перегруженным операциям (например, [`__add__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__add__)).981982**Наследование:**983984Это поле не наследуется подтипами (хотя определённые здесь атрибуты наследуются через другой механизм).985986**По умолчанию:**987988Если это поле равно `NULL`, [`PyType_Ready()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Ready) назначит ему новый словарь.989990> **Предупреждение**991>992> Небезопасно использовать [`PyDict_SetItem()`](https://python-all.ru/3.8/c-api/dict.html#c.PyDict_SetItem) на или иным образом изменять [`tp_dict`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dict) с помощью C-API словаря.993994**[descrgetfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.descrgetfunc) `PyTypeObject.tp_descr_get`**995996Необязательный указатель на функцию «descriptor get».997998Сигнатура функции:9991000```c1001PyObject * tp_descr_get(PyObject *self, PyObject *obj, PyObject *type);1002```10031004**Наследование:**10051006Это поле наследуется подтипами.10071008**[descrsetfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.descrsetfunc) `PyTypeObject.tp_descr_set`**10091010Необязательный указатель на функцию для установки и удаления значения дескриптора.10111012Сигнатура функции:10131014```c1015int tp_descr_set(PyObject *self, PyObject *obj, PyObject *value);1016```10171018Аргумент *value* устанавливается в `NULL` для удаления значения.10191020**Наследование:**10211022Это поле наследуется подтипами.10231024**Py\_ssize\_t `PyTypeObject.tp_dictoffset`**10251026Если экземпляры этого типа имеют словарь, содержащий переменные экземпляра, это поле не равно нулю и содержит смещение в структуре экземпляра для словаря переменных экземпляра; это смещение используется [`PyObject_GenericGetAttr()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_GenericGetAttr).10271028Не путайте это поле с [`tp_dict`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dict); это словарь для атрибутов самого объекта типа.10291030Если значение этого поля больше нуля, оно задаёт смещение от начала структуры экземпляра. Если значение меньше нуля, оно задаёт смещение от *конца* структуры экземпляра. Использование отрицательного смещения обходится дороже, и его следует применять только в тех случаях, когда структура экземпляра содержит часть переменной длины. Это используется, например, для добавления словаря переменных экземпляра в подтипы [`str`](https://python-all.ru/3.8/library/stdtypes.html#str) или [`tuple`](https://python-all.ru/3.8/library/stdtypes.html#tuple). Обратите внимание, что поле [`tp_basicsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_basicsize) должно учитывать словарь, добавленный в конец в этом случае, даже если словарь не входит в базовую компоновку объекта. В системе с размером указателя 4 байта [`tp_dictoffset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dictoffset) должно быть установлено в `-4`, чтобы указать, что словарь находится в самом конце структуры.10311032Реальное смещение словаря в экземпляре можно вычислить из отрицательного [`tp_dictoffset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dictoffset) следующим образом:10331034```c1035dictoffset = tp_basicsize + abs(ob_size)*tp_itemsize + tp_dictoffset1036if dictoffset is not aligned on sizeof(void*):1037    round up to sizeof(void*)1038```10391040где [`tp_basicsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_basicsize), [`tp_itemsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_itemsize) и [`tp_dictoffset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dictoffset) берутся из объекта типа, а `ob_size` берётся из экземпляра. Абсолютное значение берётся, потому что целые числа используют знак `ob_size` для хранения знака числа. (Никогда не требуется выполнять это вычисление самостоятельно; оно делается за вас функцией `_PyObject_GetDictPtr()`.)10411042**Наследование:**10431044Это поле наследуется подтипами, но см. правила ниже. Подтип может переопределить это смещение; это означает, что экземпляры подтипа хранят словарь по другому смещению, нежели базовый тип. Поскольку словарь всегда находится через [`tp_dictoffset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dictoffset), это не должно вызывать проблем.10451046Если тип, определённый с помощью оператора class, не содержит объявления [`__slots__`](https://python-all.ru/3.8/reference/datamodel.html#object.__slots__), и ни один из его базовых типов не имеет словаря переменных экземпляра, в компоновку экземпляра добавляется слот словаря, а [`tp_dictoffset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dictoffset) устанавливается на смещение этого слота.10471048Если тип, определённый с помощью оператора class, содержит объявление [`__slots__`](https://python-all.ru/3.8/reference/datamodel.html#object.__slots__), тот тип наследует значение [`tp_dictoffset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dictoffset) от своего базового типа.10491050(Добавление слота с именем [`__dict__`](https://python-all.ru/3.8/library/stdtypes.html#object.__dict__) в объявление [`__slots__`](https://python-all.ru/3.8/reference/datamodel.html#object.__slots__) не даёт ожидаемого эффекта, а только вызывает путаницу. Возможно, эту возможность стоит добавить как отдельную функцию, подобно `__weakref__`.)10511052**По умолчанию:**10531054Этот слот не имеет значения по умолчанию. Для статических типов, если поле равно `NULL`, то для экземпляров не создаётся [`__dict__`](https://python-all.ru/3.8/library/stdtypes.html#object.__dict__).10551056**[initproc](https://python-all.ru/3.8/c-api/typeobj.html#c.initproc) `PyTypeObject.tp_init`**10571058Необязательный указатель на функцию инициализации экземпляра.10591060Эта функция соответствует методу [`__init__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__init__) классов. Как и [`__init__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__init__), можно создать экземпляр без вызова [`__init__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__init__), и можно переинициализировать экземпляр, вызвав его метод [`__init__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__init__) ещё раз.10611062Сигнатура функции:10631064```c1065int tp_init(PyObject *self, PyObject *args, PyObject *kwds);1066```10671068Аргумент self – это инициализируемый экземпляр; аргументы *args* и *kwds* представляют позиционные и именованные аргументы вызова [`__init__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__init__).10691070Функция [`tp_init`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_init), если она не `NULL`, вызывается при обычном создании экземпляра через вызов его типа, после того как функция [`tp_new`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_new) типа вернула экземпляр этого типа. Если функция [`tp_new`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_new) возвращает экземпляр другого типа, не являющегося подтипом исходного, функция [`tp_init`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_init) не вызывается; если [`tp_new`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_new) возвращает экземпляр подтипа исходного типа, вызывается [`tp_init`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_init) подтипа.10711072Возвращает `0` при успехе, `-1` и устанавливает исключение при ошибке.10731074**Наследование:**10751076Это поле наследуется подтипами.10771078**По умолчанию:**10791080Для статических типов это поле не имеет значения по умолчанию.10811082**[allocfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.allocfunc) `PyTypeObject.tp_alloc`**10831084Необязательный указатель на функцию выделения экземпляра.10851086Сигнатура функции:10871088```c1089PyObject *tp_alloc(PyTypeObject *self, Py_ssize_t nitems);1090```10911092**Наследование:**10931094Это поле наследуется статическими подтипами, но не динамическими подтипами (подтипами, созданными с помощью инструкции class).10951096**По умолчанию:**10971098Для динамических подтипов это поле всегда устанавливается в [`PyType_GenericAlloc()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_GenericAlloc), чтобы принудительно применять стандартную стратегию выделения памяти из кучи.10991100Для статических подтипов `PyBaseObject_Type` использует [`PyType_GenericAlloc()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_GenericAlloc). Это рекомендуемое значение для всех статически определённых типов.11011102**[newfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.newfunc) `PyTypeObject.tp_new`**11031104Необязательный указатель на функцию создания экземпляра.11051106Сигнатура функции:11071108```c1109PyObject *tp_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds);1110```11111112Аргумент subtype – это тип создаваемого объекта; аргументы *args* и *kwds* представляют позиционные и именованные аргументы вызова типа. Обратите внимание, что subtype не обязан совпадать с типом, для которого вызывается функция [`tp_new`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_new); это может быть подтип этого типа (но не произвольный тип).11131114Функция [`tp_new`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_new) должна вызывать `subtype->tp_alloc(subtype, nitems)` для выделения памяти под объект, а затем выполнять лишь минимально необходимую инициализацию. Инициализацию, которую можно безопасно пропустить или повторить, следует помещать в обработчик [`tp_init`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_init). Хорошее эмпирическое правило: для неизменяемых типов вся инициализация должна выполняться в [`tp_new`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_new), а для изменяемых типов большую часть инициализации лучше отложить до [`tp_init`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_init).11151116**Наследование:**11171118Это поле наследуется подтипами, за исключением статических типов, у которых [`tp_base`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_base) равно `NULL` или `&PyBaseObject_Type`.11191120**По умолчанию:**11211122Для статических типов это поле не имеет значения по умолчанию. Это означает, что если слот определён как `NULL`, тип нельзя вызвать для создания новых экземпляров; вероятно, существует другой способ создания экземпляров, например, фабричная функция.11231124**[freefunc](https://python-all.ru/3.8/c-api/typeobj.html#c.freefunc) `PyTypeObject.tp_free`**11251126Необязательный указатель на функцию освобождения экземпляра. Её сигнатура:11271128```c1129void tp_free(void *self);1130```11311132Инициализатор, совместимый с этой сигнатурой: [`PyObject_Free()`](https://python-all.ru/3.8/c-api/memory.html#c.PyObject_Free).11331134**Наследование:**11351136Это поле наследуется статическими подтипами, но не динамическими подтипами (подтипами, созданными через объявление класса).11371138**По умолчанию:**11391140В динамических подтипах это поле устанавливается в деаллокатор, подходящий для соответствия [`PyType_GenericAlloc()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_GenericAlloc) и значению флага [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC).11411142Для статических подтипов `PyBaseObject_Type` использует PyObject\_Del.11431144**[inquiry](https://python-all.ru/3.8/c-api/gcsupport.html#c.inquiry) `PyTypeObject.tp_is_gc`**11451146Необязательный указатель на функцию, вызываемую сборщиком мусора.11471148Сборщику мусора необходимо знать, можно ли собрать конкретный объект или нет. Обычно достаточно посмотреть на поле [`tp_flags`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_flags) типа объекта и проверить бит флага [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC). Но некоторые типы содержат как статически, так и динамически выделенные экземпляры, и статически выделенные экземпляры не подлежат сборке. Такие типы должны определять эту функцию; она должна возвращать `1` для собираемого экземпляра и `0` для несобираемого. Сигнатура:11491150```c1151int tp_is_gc(PyObject *self);1152```11531154(Единственный пример этого – сами типы. Метатип, [`PyType_Type`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Type), определяет эту функцию, чтобы различать статически и динамически выделенные типы.)11551156**Наследование:**11571158Это поле наследуется подтипами.11591160**По умолчанию:**11611162У этого слота нет значения по умолчанию. Если это поле равно `NULL`, то в качестве функционального эквивалента используется [`Py_TPFLAGS_HAVE_GC`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_GC).11631164**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject)\* `PyTypeObject.tp_bases`**11651166Кортеж базовых типов.11671168Это устанавливается для типов, созданных с помощью оператора class. Для статически определённых типов это должно быть `NULL`.11691170**Наследование:**11711172Это поле не наследуется.11731174**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject)\* `PyTypeObject.tp_mro`**11751176Кортеж, содержащий расширенный набор базовых типов, начиная с самого типа и заканчивая [`object`](https://python-all.ru/3.8/library/functions.html#object), в порядке разрешения методов (MRO).11771178**Наследование:**11791180Это поле не наследуется; оно вычисляется заново с помощью [`PyType_Ready()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Ready).11811182**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject)\* `PyTypeObject.tp_cache`**11831184Не используется. Только для внутреннего использования.11851186**Наследование:**11871188Это поле не наследуется.11891190**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject)\* `PyTypeObject.tp_subclasses`**11911192Список слабых ссылок на подклассы. Только для внутреннего использования.11931194**Наследование:**11951196Это поле не наследуется.11971198**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject)\* `PyTypeObject.tp_weaklist`**11991200Голова списка слабых ссылок для слабых ссылок на этот объект типа. Не наследуется. Только для внутреннего использования.12011202**Наследование:**12031204Это поле не наследуется.12051206**[destructor](https://python-all.ru/3.8/c-api/typeobj.html#c.destructor) `PyTypeObject.tp_del`**12071208Это поле устарело. Используйте [`tp_finalize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_finalize) вместо него.12091210**unsigned int `PyTypeObject.tp_version_tag`**12111212Используется для индексации кэша методов. Только для внутреннего использования.12131214**Наследование:**12151216Это поле не наследуется.12171218**[destructor](https://python-all.ru/3.8/c-api/typeobj.html#c.destructor) `PyTypeObject.tp_finalize`**12191220Необязательный указатель на функцию финализации экземпляра. Её сигнатура:12211222```c1223void tp_finalize(PyObject *self);1224```12251226Если [`tp_finalize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_finalize) установлен, интерпретатор вызывает его один раз при финализации экземпляра. Он вызывается либо сборщиком мусора (если экземпляр является частью изолированного цикла ссылок), либо непосредственно перед освобождением объекта. В любом случае гарантируется, что он будет вызван до попытки разорвать циклы ссылок, что обеспечивает нахождение объекта в корректном состоянии.12271228[`tp_finalize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_finalize) не должен изменять текущий статус исключения; поэтому рекомендуемый способ написания нетривиального финализатора:12291230```c1231static void1232local_finalize(PyObject *self)1233{1234    PyObject *error_type, *error_value, *error_traceback;12351236    /* Сохранить текущее исключение, если оно есть. */1237    PyErr_Fetch(&error_type, &error_value, &error_traceback);12381239    /* ... */12401241    /* Восстановить сохранённое исключение. */1242    PyErr_Restore(error_type, error_value, error_traceback);1243}1244```12451246Чтобы это поле учитывалось (даже при наследовании), необходимо также установить бит флагов [`Py_TPFLAGS_HAVE_FINALIZE`](https://python-all.ru/3.8/c-api/typeobj.html#Py_TPFLAGS_HAVE_FINALIZE).12471248**Наследование:**12491250Это поле наследуется подтипами.12511252Новое в версии 3.4.12531254> **См. также**1255>1256> «Безопасная финализация объектов» ([**PEP 442**](https://python-all.ru/3.8/c-api/typeobj.html))12571258Остальные поля определены только в том случае, если определён макрос проверки функциональности `COUNT_ALLOCS`, и предназначены исключительно для внутреннего использования. Они описаны здесь для полноты. Ни одно из этих полей не наследуется подтипами.12591260**Py\_ssize\_t `PyTypeObject.tp_allocs`**12611262Количество выделений памяти.12631264**Py\_ssize\_t `PyTypeObject.tp_frees`**12651266Количество освобождений.12671268**Py\_ssize\_t `PyTypeObject.tp_maxalloc`**12691270Максимальное количество одновременно выделенных объектов.12711272**[PyTypeObject](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject)\* `PyTypeObject.tp_prev`**12731274Указатель на предыдущий объект типа с ненулевым полем [`tp_allocs`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_allocs).12751276**[PyTypeObject](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject)\* `PyTypeObject.tp_next`**12771278Указатель на следующий объект типа с ненулевым полем [`tp_allocs`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_allocs).12791280Также учтите, что в Python со сборкой мусора [`tp_dealloc`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_dealloc) может быть вызвана из любого потока Python, а не только из того, который создал объект (если объект становится частью цикла подсчёта ссылок, этот цикл может быть собран сборщиком мусора в любом потоке). Это не проблема для вызовов API Python, так как поток, из которого вызывается tp\_dealloc, будет владеть глобальной блокировкой интерпретатора (GIL). Однако, если уничтожаемый объект в свою очередь уничтожает объекты из какой-либо другой библиотеки C или C++, следует соблюдать осторожность, чтобы уничтожение этих объектов в потоке, вызвавшем tp\_dealloc, не нарушало никаких предположений этой библиотеки.12811282## Кучные типы12831284Традиционно типы, определяемые в коде C, являются *статическими*, то есть статическая структура [`PyTypeObject`](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject) определяется непосредственно в коде и инициализируется с помощью [`PyType_Ready()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Ready).12851286В результате получаются типы, которые ограничены по сравнению с типами, определёнными в Python.12871288- Статические типы ограничены одним базовым классом, то есть не могут использовать множественное наследование.1289- Объекты статических типов (но не обязательно их экземпляры) неизменяемы. Из Python невозможно добавить или изменить атрибуты объекта типа.1290- Объекты статических типов разделяются между [под-интерпретаторами](https://python-all.ru/3.8/c-api/init.html#sub-interpreter-support), поэтому они не должны содержать состояние, специфичное для под-интерпретатора.12911292Кроме того, поскольку [`PyTypeObject`](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject) не является частью [стабильного ABI](https://python-all.ru/3.8/c-api/stable.html#stable), любые модули расширения, использующие статические типы, должны компилироваться для конкретной минорной версии Python.12931294Альтернативой статическим типам являются *типы, выделяемые в куче*, или сокращённо *кучные типы*, которые тесно соответствуют классам, создаваемым с помощью оператора Python `class`.12951296Это делается путём заполнения структуры [`PyType_Spec`](https://python-all.ru/3.8/c-api/type.html#c.PyType_Spec) и вызова [`PyType_FromSpecWithBases()`](https://python-all.ru/3.8/c-api/type.html#c.PyType_FromSpecWithBases).12971298# Структуры числовых объектов12991300**`PyNumberMethods`**13011302Эта структура содержит указатели на функции, которые объект использует для реализации числового протокола. Каждая функция используется одноимённой функцией, описанной в разделе [Числовой протокол](https://python-all.ru/3.8/c-api/number.html#number).13031304Вот определение структуры:13051306```c1307typedef struct {1308     binaryfunc nb_add;1309     binaryfunc nb_subtract;1310     binaryfunc nb_multiply;1311     binaryfunc nb_remainder;1312     binaryfunc nb_divmod;1313     ternaryfunc nb_power;1314     unaryfunc nb_negative;1315     unaryfunc nb_positive;1316     unaryfunc nb_absolute;1317     inquiry nb_bool;1318     unaryfunc nb_invert;1319     binaryfunc nb_lshift;1320     binaryfunc nb_rshift;1321     binaryfunc nb_and;1322     binaryfunc nb_xor;1323     binaryfunc nb_or;1324     unaryfunc nb_int;1325     void *nb_reserved;1326     unaryfunc nb_float;13271328     binaryfunc nb_inplace_add;1329     binaryfunc nb_inplace_subtract;1330     binaryfunc nb_inplace_multiply;1331     binaryfunc nb_inplace_remainder;1332     ternaryfunc nb_inplace_power;1333     binaryfunc nb_inplace_lshift;1334     binaryfunc nb_inplace_rshift;1335     binaryfunc nb_inplace_and;1336     binaryfunc nb_inplace_xor;1337     binaryfunc nb_inplace_or;13381339     binaryfunc nb_floor_divide;1340     binaryfunc nb_true_divide;1341     binaryfunc nb_inplace_floor_divide;1342     binaryfunc nb_inplace_true_divide;13431344     unaryfunc nb_index;13451346     binaryfunc nb_matrix_multiply;1347     binaryfunc nb_inplace_matrix_multiply;1348} PyNumberMethods;1349```13501351> **Примечание**1352>1353> Бинарные и тернарные функции должны проверять тип всех своих операндов и выполнять необходимые преобразования (хотя бы один из операндов должен быть экземпляром определяемого типа). Если операция не определена для данных операндов, бинарные и тернарные функции должны вернуть `Py_NotImplemented`; если произошла другая ошибка, они должны вернуть `NULL` и установить исключение.13541355> **Примечание**1356>1357> Поле `nb_reserved` всегда должно быть `NULL`. Ранее оно называлось `nb_long` и было переименовано в Python 3.0.1.13581359**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_add`**13601361**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_subtract`**13621363**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_multiply`**13641365**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_remainder`**13661367**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_divmod`**13681369**[ternaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.ternaryfunc) `PyNumberMethods.nb_power`**13701371**[unaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) `PyNumberMethods.nb_negative`**13721373**[unaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) `PyNumberMethods.nb_positive`**13741375**[unaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) `PyNumberMethods.nb_absolute`**13761377**[inquiry](https://python-all.ru/3.8/c-api/gcsupport.html#c.inquiry) `PyNumberMethods.nb_bool`**13781379**[unaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) `PyNumberMethods.nb_invert`**13801381**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_lshift`**13821383**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_rshift`**13841385**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_and`**13861387**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_xor`**13881389**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_or`**13901391**[unaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) `PyNumberMethods.nb_int`**13921393**void \*`PyNumberMethods.nb_reserved`**13941395**[unaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) `PyNumberMethods.nb_float`**13961397**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_inplace_add`**13981399**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_inplace_subtract`**14001401**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_inplace_multiply`**14021403**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_inplace_remainder`**14041405**[ternaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.ternaryfunc) `PyNumberMethods.nb_inplace_power`**14061407**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_inplace_lshift`**14081409**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_inplace_rshift`**14101411**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_inplace_and`**14121413**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_inplace_xor`**14141415**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_inplace_or`**14161417**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_floor_divide`**14181419**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_true_divide`**14201421**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_inplace_floor_divide`**14221423**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_inplace_true_divide`**14241425**[unaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) `PyNumberMethods.nb_index`**14261427**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_matrix_multiply`**14281429**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyNumberMethods.nb_inplace_matrix_multiply`**14301431# Структуры объектов отображения14321433**`PyMappingMethods`**14341435Эта структура хранит указатели на функции, которые объект использует для реализации протокола отображения. Она содержит три члена:14361437**[lenfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.lenfunc) `PyMappingMethods.mp_length`**14381439Эта функция используется [`PyMapping_Size()`](https://python-all.ru/3.8/c-api/mapping.html#c.PyMapping_Size) и [`PyObject_Size()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_Size) и имеет ту же сигнатуру. Этот слот может быть установлен в `NULL`, если у объекта нет определённой длины.14401441**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PyMappingMethods.mp_subscript`**14421443Эта функция используется [`PyObject_GetItem()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_GetItem) и [`PySequence_GetSlice()`](https://python-all.ru/3.8/c-api/sequence.html#c.PySequence_GetSlice) и имеет ту же сигнатуру, что и `PyObject_GetItem()`. Этот слот должен быть заполнен, чтобы функция [`PyMapping_Check()`](https://python-all.ru/3.8/c-api/mapping.html#c.PyMapping_Check) возвращала `1`; в противном случае он может быть `NULL` .14441445**[objobjargproc](https://python-all.ru/3.8/c-api/typeobj.html#c.objobjargproc) `PyMappingMethods.mp_ass_subscript`**14461447Эта функция используется [`PyObject_SetItem()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_SetItem), [`PyObject_DelItem()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_DelItem), `PyObject_SetSlice()` и `PyObject_DelSlice()`. У неё та же сигнатура, что и у `PyObject_SetItem()`, но *v* также может быть установлен в `NULL` для удаления элемента. Если этот слот равен `NULL`, объект не поддерживает присваивание и удаление элементов.14481449# Структуры объектов последовательностей14501451**`PySequenceMethods`**14521453Эта структура содержит указатели на функции, которые объект использует для реализации протокола последовательности.14541455**[lenfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.lenfunc) `PySequenceMethods.sq_length`**14561457Эта функция используется [`PySequence_Size()`](https://python-all.ru/3.8/c-api/sequence.html#c.PySequence_Size) и [`PyObject_Size()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_Size) и имеет ту же сигнатуру. Она также используется для обработки отрицательных индексов через слоты [`sq_item`](https://python-all.ru/3.8/c-api/typeobj.html#c.PySequenceMethods.sq_item) и [`sq_ass_item`](https://python-all.ru/3.8/c-api/typeobj.html#c.PySequenceMethods.sq_ass_item).14581459**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PySequenceMethods.sq_concat`**14601461Эта функция используется [`PySequence_Concat()`](https://python-all.ru/3.8/c-api/sequence.html#c.PySequence_Concat) и имеет ту же сигнатуру. Она также используется оператором `+` после попытки численного сложения через слот [`nb_add`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_add).14621463**[ssizeargfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.ssizeargfunc) `PySequenceMethods.sq_repeat`**14641465Эта функция используется [`PySequence_Repeat()`](https://python-all.ru/3.8/c-api/sequence.html#c.PySequence_Repeat) и имеет ту же сигнатуру. Она также используется оператором `*` после попытки численного умножения через слот [`nb_multiply`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_multiply).14661467**[ssizeargfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.ssizeargfunc) `PySequenceMethods.sq_item`**14681469Эта функция используется [`PySequence_GetItem()`](https://python-all.ru/3.8/c-api/sequence.html#c.PySequence_GetItem) и имеет ту же сигнатуру. Она также используется [`PyObject_GetItem()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_GetItem) после попытки индексирования через слот [`mp_subscript`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyMappingMethods.mp_subscript). Этот слот должен быть заполнен, чтобы функция [`PySequence_Check()`](https://python-all.ru/3.8/c-api/sequence.html#c.PySequence_Check) возвращала `1`; в противном случае он может быть `NULL`.14701471Отрицательные индексы обрабатываются следующим образом: если слот `sq_length`\\nзаполнен, он вызывается, и длина последовательности используется для вычисления положительного\\nиндекса, который передаётся в `sq_item`. Если `sq_length` равно `NULL`,\\nиндекс передаётся функции как есть.14721473**[ssizeobjargproc](https://python-all.ru/3.8/c-api/typeobj.html#c.ssizeobjargproc) `PySequenceMethods.sq_ass_item`**14741475Эта функция используется [`PySequence_SetItem()`](https://python-all.ru/3.8/c-api/sequence.html#c.PySequence_SetItem) и имеет ту же сигнатуру. Она также используется [`PyObject_SetItem()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_SetItem) и [`PyObject_DelItem()`](https://python-all.ru/3.8/c-api/object.html#c.PyObject_DelItem) после попытки присваивания и удаления элемента через слот [`mp_ass_subscript`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyMappingMethods.mp_ass_subscript). Этот слот может быть оставлен равным `NULL`, если объект не поддерживает присваивание и удаление элементов.14761477**[objobjproc](https://python-all.ru/3.8/c-api/typeobj.html#c.objobjproc) `PySequenceMethods.sq_contains`**14781479Эта функция может использоваться [`PySequence_Contains()`](https://python-all.ru/3.8/c-api/sequence.html#c.PySequence_Contains) и имеет ту же сигнатуру. Этот слот может быть оставлен равным `NULL`; в этом случае `PySequence_Contains()` просто проходит по последовательности, пока не найдёт совпадение.14801481**[binaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.binaryfunc) `PySequenceMethods.sq_inplace_concat`**14821483Эта функция используется [`PySequence_InPlaceConcat()`](https://python-all.ru/3.8/c-api/sequence.html#c.PySequence_InPlaceConcat) и имеет ту же сигнатуру. Она должна изменить свой первый операнд и вернуть его. Этот слот может быть оставлен равным `NULL`; в этом случае `PySequence_InPlaceConcat()` будет использовать [`PySequence_Concat()`](https://python-all.ru/3.8/c-api/sequence.html#c.PySequence_Concat) как запасной вариант. Она также используется расширенным присваиванием `+=` после попытки численного сложения на месте через слот [`nb_inplace_add`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_add).14841485**[ssizeargfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.ssizeargfunc) `PySequenceMethods.sq_inplace_repeat`**14861487Эта функция используется [`PySequence_InPlaceRepeat()`](https://python-all.ru/3.8/c-api/sequence.html#c.PySequence_InPlaceRepeat) и имеет ту же сигнатуру. Она должна изменить свой первый операнд и вернуть его. Этот слот может быть оставлен равным `NULL`; в этом случае `PySequence_InPlaceRepeat()` будет использовать [`PySequence_Repeat()`](https://python-all.ru/3.8/c-api/sequence.html#c.PySequence_Repeat) как запасной вариант. Она также используется расширенным присваиванием `*=` после попытки численного умножения на месте через слот [`nb_inplace_multiply`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyNumberMethods.nb_inplace_multiply).14881489# Структуры объектов буфера14901491**`PyBufferProcs`**14921493Эта структура содержит указатели на функции, необходимые для [протокола буфера](https://python-all.ru/3.8/c-api/buffer.html#bufferobjects). Протокол определяет, как объект-экспортёр может предоставлять свои внутренние данные объектам-потребителям.14941495**[getbufferproc](https://python-all.ru/3.8/c-api/typeobj.html#c.getbufferproc) `PyBufferProcs.bf_getbuffer`**14961497Сигнатура этой функции:14981499```c1500int (PyObject *exporter, Py_buffer *view, int flags);1501```15021503Обрабатывает запрос к *экспортёру* на заполнение *представления* в соответствии с *флагами*. За исключением пункта (3), реализация этой функции ОБЯЗАНА выполнить следующие шаги:150415051. Проверить, можно ли удовлетворить запрос. Если нет, возбудить `PyExc_BufferError`, установить `view->obj` в `NULL` и вернуть `-1`.15062. Заполнить запрошенные поля.15073. Увеличить внутренний счётчик числа экспортов.15084. Установить `view->obj` в *экспортёр* и увеличить `view->obj`.15095. Вернуть `0`.15101511Если *экспортёр* является частью цепочки или дерева поставщиков буферов, можно использовать две основные схемы:15121513- Повторный экспорт: каждый элемент дерева выступает в роли экспортирующего объекта и устанавливает `view->obj` в новую ссылку на себя.1514- Перенаправление: запрос буфера перенаправляется корневому объекту дерева. Здесь `view->obj` будет новой ссылкой на корневой объект.15151516Отдельные поля *представления* описаны в разделе [Структура буфера](https://python-all.ru/3.8/c-api/buffer.html#buffer-structure), правила, как экспортёр должен реагировать на конкретные запросы – в разделе [Типы запросов буфера](https://python-all.ru/3.8/c-api/buffer.html#buffer-request-types).15171518Вся память, на которую указывает структура [`Py_buffer`](https://python-all.ru/3.8/c-api/buffer.html#c.Py_buffer), принадлежит экспортёру и должна оставаться действительной, пока есть хотя бы один потребитель. [`format`](https://python-all.ru/3.8/c-api/buffer.html#c.Py_buffer.format), [`shape`](https://python-all.ru/3.8/c-api/buffer.html#c.Py_buffer.shape), [`strides`](https://python-all.ru/3.8/c-api/buffer.html#c.Py_buffer.strides), [`suboffsets`](https://python-all.ru/3.8/c-api/buffer.html#c.Py_buffer.suboffsets) и [`internal`](https://python-all.ru/3.8/c-api/buffer.html#c.Py_buffer.internal) доступны потребителю только для чтения.15191520[`PyBuffer_FillInfo()`](https://python-all.ru/3.8/c-api/buffer.html#c.PyBuffer_FillInfo) предоставляет простой способ предоставления простого байтового буфера, корректно обрабатывая все типы запросов.15211522[`PyObject_GetBuffer()`](https://python-all.ru/3.8/c-api/buffer.html#c.PyObject_GetBuffer) – это интерфейс для потребителя, который оборачивает эту функцию.15231524**[releasebufferproc](https://python-all.ru/3.8/c-api/typeobj.html#c.releasebufferproc) `PyBufferProcs.bf_releasebuffer`**15251526Сигнатура этой функции:15271528```c1529void (PyObject *exporter, Py_buffer *view);1530```15311532Обрабатывает запрос на освобождение ресурсов буфера. Если никакие ресурсы освобождать не нужно, [`PyBufferProcs.bf_releasebuffer`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyBufferProcs.bf_releasebuffer) может быть `NULL`. В противном случае стандартная реализация этой функции выполнит следующие необязательные шаги:153315341. Уменьшить внутренний счётчик числа экспортов.15352. Если счётчик равен `0`, освободить всю память, связанную с *представлением*.15361537Экспортёр ОБЯЗАН использовать поле [`internal`](https://python-all.ru/3.8/c-api/buffer.html#c.Py_buffer.internal) для отслеживания ресурсов, специфичных для буфера. Гарантируется, что это поле остаётся постоянным, в то время как потребитель МОЖЕТ передавать копию исходного буфера в качестве аргумента *view*.15381539Эта функция НЕ ДОЛЖНА уменьшать `view->obj`, так как это делается автоматически в [`PyBuffer_Release()`](https://python-all.ru/3.8/c-api/buffer.html#c.PyBuffer_Release) (такая схема полезна для разрыва циклических ссылок).15401541[`PyBuffer_Release()`](https://python-all.ru/3.8/c-api/buffer.html#c.PyBuffer_Release) – это интерфейс для потребителя, который оборачивает эту функцию.15421543# Асинхронные структуры объектов15441545Новое в версии 3.5.15461547**`PyAsyncMethods`**15481549Эта структура содержит указатели на функции, необходимые для реализации объектов [ожидаемый объект](https://python-all.ru/3.8/glossary.html#term-awaitable) и [асинхронный итератор](https://python-all.ru/3.8/glossary.html#term-asynchronous-iterator).15501551Вот определение структуры:15521553```c1554typedef struct {1555    unaryfunc am_await;1556    unaryfunc am_aiter;1557    unaryfunc am_anext;1558} PyAsyncMethods;1559```15601561**[unaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) `PyAsyncMethods.am_await`**15621563Сигнатура этой функции:15641565```c1566PyObject *am_await(PyObject *self);1567```15681569Возвращаемый объект должен быть итератором, то есть [`PyIter_Check()`](https://python-all.ru/3.8/c-api/iter.html#c.PyIter_Check) должен возвращать `1` для него.15701571Этот слот может быть установлен в `NULL`, если объект не является [ожидаемым объектом](https://python-all.ru/3.8/glossary.html#term-awaitable).15721573**[unaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) `PyAsyncMethods.am_aiter`**15741575Сигнатура этой функции:15761577```c1578PyObject *am_aiter(PyObject *self);1579```15801581Должен возвращать [ожидаемый](https://python-all.ru/3.8/glossary.html#term-awaitable) объект. Подробнее см. [`__anext__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__anext__).15821583Этот слот может быть установлен в `NULL`, если объект не реализует протокол асинхронной итерации.15841585**[unaryfunc](https://python-all.ru/3.8/c-api/typeobj.html#c.unaryfunc) `PyAsyncMethods.am_anext`**15861587Сигнатура этой функции:15881589```c1590PyObject *am_anext(PyObject *self);1591```15921593Должен возвращать объект [ожидаемый объект](https://python-all.ru/3.8/glossary.html#term-awaitable). Подробности см. в [`__anext__()`](https://python-all.ru/3.8/reference/datamodel.html#object.__anext__). Этот слот может быть установлен в `NULL`.15941595# Определения типов слотов15961597**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*allocfunc)`([PyTypeObject](https://python-all.ru/3.8/c-api/type.html#c.PyTypeObject) *\*cls*, Py\_ssize\_t *nitems*)**15981599Назначение этой функции – разделить выделение памяти и её инициализацию. Она должна возвращать указатель на блок памяти достаточной длины для экземпляра, с подходящим выравниванием и обнулённый, но с `ob_refcnt`, установленным в `1`, и `ob_type`, установленным в аргумент типа. Если [`tp_itemsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_itemsize) типа не равно нулю, поле `ob_size` объекта должно быть инициализировано значением *nitems*, а длина выделенного блока памяти должна быть `tp_basicsize + nitems*tp_itemsize`, округлённой до кратного `sizeof(void*)`; в противном случае *nitems* не используется, и длина блока должна быть [`tp_basicsize`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_basicsize).16001601Эта функция не должна выполнять никакой другой инициализации экземпляра, включая выделение дополнительной памяти; это должно выполнять [`tp_new`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_new).16021603**void `(*destructor)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16041605**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*vectorcallfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\*callable*, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*const *\*args*, size\_t *nargsf*, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\*kwnames*)**16061607См. [`tp_vectorcall_offset`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_vectorcall_offset).16081609Аргументы для `vectorcallfunc` такие же, как для [`_PyObject_Vectorcall()`](https://python-all.ru/3.8/c-api/object.html#c._PyObject_Vectorcall).16101611Новое в версии 3.8.16121613**void `(*freefunc)`(void *\**)**16141615См. [`tp_free`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_free).16161617**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*newfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16181619См. [`tp_new`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_new).16201621**int `(*initproc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16221623См. [`tp_init`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_init).16241625**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*reprfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16261627См. [`tp_repr`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_repr).16281629**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*getattrfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\*self*, char *\*attr*)**16301631Возвращает значение именованного атрибута для объекта.16321633**int `(*setattrfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\*self*, char *\*attr*, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\*value*)**16341635Устанавливает значение именованного атрибута для объекта. Аргумент value устанавливается в `NULL` для удаления атрибута.16361637**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*getattrofunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\*self*, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\*attr*)**16381639Возвращает значение именованного атрибута для объекта.16401641См. [`tp_getattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_getattro).16421643**int `(*setattrofunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\*self*, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\*attr*, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\*value*)**16441645Устанавливает значение именованного атрибута для объекта. Аргумент value устанавливается в `NULL` для удаления атрибута.16461647См. [`tp_setattro`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_setattro).16481649**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*descrgetfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16501651См. `tp_descrget`.16521653**int `(*descrsetfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16541655См. `tp_descrset`.16561657**Py\_hash\_t `(*hashfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16581659См. [`tp_hash`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_hash).16601661**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*richcmpfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, int)**16621663См. [`tp_richcompare`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_richcompare).16641665**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*getiterfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16661667См. [`tp_iter`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_iter).16681669**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*iternextfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16701671См. [`tp_iternext`](https://python-all.ru/3.8/c-api/typeobj.html#c.PyTypeObject.tp_iternext).16721673**Py\_ssize\_t `(*lenfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16741675**int `(*getbufferproc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [Py\_buffer](https://python-all.ru/3.8/c-api/buffer.html#c.Py_buffer) *\**, int)**16761677**void `(*releasebufferproc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [Py\_buffer](https://python-all.ru/3.8/c-api/buffer.html#c.Py_buffer) *\**)**16781679**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*unaryfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16801681**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*binaryfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16821683**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*ternaryfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16841685**[PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) \*`(*ssizeargfunc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, Py\_ssize\_t)**16861687**int `(*ssizeobjargproc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, Py\_ssize\_t)**16881689**int `(*objobjproc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16901691**int `(*objobjargproc)`([PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**, [PyObject](https://python-all.ru/3.8/c-api/structures.html#c.PyObject) *\**)**16921693# Примеры16941695Ниже приведены простые примеры определений типов Python. Они включают распространённые варианты использования, с которыми можно столкнуться. Некоторые демонстрируют сложные граничные случаи. За дополнительными примерами, практической информацией и учебным пособием обращайтесь к [Defining Extension Types: Tutorial](https://python-all.ru/3.8/extending/newtypes_tutorial.html#defining-new-types) и [Defining Extension Types: Assorted Topics](https://python-all.ru/3.8/extending/newtypes.html#new-types-topics).16961697Простой статический тип:16981699```c1700typedef struct {1701    PyObject_HEAD1702    const char *data;1703} MyObject;17041705static PyTypeObject MyObject_Type = {1706    PyVarObject_HEAD_INIT(NULL, 0)1707    .tp_name = "mymod.MyObject",1708    .tp_basicsize = sizeof(MyObject),1709    .tp_doc = "My objects",1710    .tp_new = myobj_new,1711    .tp_dealloc = (destructor)myobj_dealloc,1712    .tp_repr = (reprfunc)myobj_repr,1713};1714```17151716Также можно встретить старый код (особенно в кодовой базе CPython) с более многословным инициализатором:17171718```c1719static PyTypeObject MyObject_Type = {1720    PyVarObject_HEAD_INIT(NULL, 0)1721    "mymod.MyObject",               /* tp_name */1722    sizeof(MyObject),               /* tp_basicsize */1723    0,                              /* tp_itemsize */1724    (destructor)myobj_dealloc,      /* tp_dealloc */1725    0,                              /* tp_vectorcall_offset */1726    0,                              /* tp_getattr */1727    0,                              /* tp_setattr */1728    0,                              /* tp_as_async */1729    (reprfunc)myobj_repr,           /* tp_repr */1730    0,                              /* tp_as_number */1731    0,                              /* tp_as_sequence */1732    0,                              /* tp_as_mapping */1733    0,                              /* tp_hash */1734    0,                              /* tp_call */1735    0,                              /* tp_str */1736    0,                              /* tp_getattro */1737    0,                              /* tp_setattro */1738    0,                              /* tp_as_buffer */1739    0,                              /* tp_flags */1740    "My objects",                   /* tp_doc */1741    0,                              /* tp_traverse */1742    0,                              /* tp_clear */1743    0,                              /* tp_richcompare */1744    0,                              /* tp_weaklistoffset */1745    0,                              /* tp_iter */1746    0,                              /* tp_iternext */1747    0,                              /* tp_methods */1748    0,                              /* tp_members */1749    0,                              /* tp_getset */1750    0,                              /* tp_base */1751    0,                              /* tp_dict */1752    0,                              /* tp_descr_get */1753    0,                              /* tp_descr_set */1754    0,                              /* tp_dictoffset */1755    0,                              /* tp_init */1756    0,                              /* tp_alloc */1757    myobj_new,                      /* tp_new */1758};1759```17601761Тип, поддерживающий слабые ссылки, словари экземпляров и хеширование:17621763```c1764typedef struct {1765    PyObject_HEAD1766    const char *data;1767    PyObject *inst_dict;1768    PyObject *weakreflist;1769} MyObject;17701771static PyTypeObject MyObject_Type = {1772    PyVarObject_HEAD_INIT(NULL, 0)1773    .tp_name = "mymod.MyObject",1774    .tp_basicsize = sizeof(MyObject),1775    .tp_doc = "My objects",1776    .tp_weaklistoffset = offsetof(MyObject, weakreflist),1777    .tp_dictoffset = offsetof(MyObject, inst_dict),1778    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,1779    .tp_new = myobj_new,1780    .tp_traverse = (traverseproc)myobj_traverse,1781    .tp_clear = (inquiry)myobj_clear,1782    .tp_alloc = PyType_GenericNew,1783    .tp_dealloc = (destructor)myobj_dealloc,1784    .tp_repr = (reprfunc)myobj_repr,1785    .tp_hash = (hashfunc)myobj_hash,1786    .tp_richcompare = PyBaseObject_Type.tp_richcompare,1787};1788```17891790Подкласс str, который не может быть наследован и не может быть вызван для создания экземпляров (например, использует отдельную фабричную функцию):17911792```c1793typedef struct {1794    PyUnicodeObject raw;1795    char *extra;1796} MyStr;17971798static PyTypeObject MyStr_Type = {1799    PyVarObject_HEAD_INIT(NULL, 0)1800    .tp_name = "mymod.MyStr",1801    .tp_basicsize = sizeof(MyStr),1802    .tp_base = NULL,  // устанавливается в &PyUnicode_Type при инициализации модуля1803    .tp_doc = "my custom str",1804    .tp_flags = Py_TPFLAGS_DEFAULT,1805    .tp_new = NULL,1806    .tp_repr = (reprfunc)myobj_repr,1807};1808```18091810Простейший статический тип (с экземплярами фиксированной длины):18111812```c1813typedef struct {1814    PyObject_HEAD1815} MyObject;18161817static PyTypeObject MyObject_Type = {1818    PyVarObject_HEAD_INIT(NULL, 0)1819    .tp_name = "mymod.MyObject",1820};1821```18221823Простейший статический тип (с экземплярами переменной длины):18241825```c1826typedef struct {1827    PyObject_VAR_HEAD1828    const char *data[1];1829} MyObject;18301831static PyTypeObject MyObject_Type = {1832    PyVarObject_HEAD_INIT(NULL, 0)1833    .tp_name = "mymod.MyObject",1834    .tp_basicsize = sizeof(MyObject) - sizeof(char *),1835    .tp_itemsize = sizeof(char *),1836};1837```1838