Typobjektstrukturer

En av de kanske viktigaste strukturerna i Pythons objektsystem är den struktur som definierar en ny typ: PyTypeObject-strukturen. Typobjekt kan hanteras med hjälp av någon av funktionerna PyObject_* eller PyType_*, men erbjuder inte mycket som är intressant för de flesta Python-applikationer. Dessa objekt är grundläggande för hur objekt beter sig, så de är mycket viktiga för själva tolken och för alla tilläggsmoduler som implementerar nya typer.

Typobjekt är ganska stora jämfört med de flesta standardtyperna. Anledningen till storleken är att varje typobjekt lagrar ett stort antal värden, mestadels C-funktionspekare, som var och en implementerar en liten del av typens funktionalitet. Fälten i typobjektet granskas i detalj i detta avsnitt. Fälten kommer att beskrivas i den ordning de förekommer i strukturen.

Förutom följande snabbreferens ger avsnittet Exempel en snabb inblick i betydelsen och användningen av PyTypeObject.

Snabbreferens

”tp slots”

PyTypeObject Slot [1]	Typ	speciella metoder/attribut	Info [2] _ Info
			A	T	D	I
<R> tp_name	const char *	__name__	X	X
tp_basicsize	Py_ssize_t		X	X		X
tp_itemsize	Py_ssize_t			X		X
tp_dealloc	destructor		X	X		X
tp_vectorcall_offset	Py_ssize_t			X		X
(tp_getattr)	getattrfunc	__getattribute__, __getattr__				G
(tp_setattr)	setattrfunc	__setattr__, __delattr__				G
tp_as_async	PyAsyncMethods *	sub-slots				%
tp_repr	reprfunc	__repr__	X	X		X
tp_as_number	PyNumberMethods *	sub-slots				%
tp_as_sequence	PySequenceMethods *	sub-slots				%
tp_as_mapping	PyMappingMethods *	sub-slots				%
tp_hash	hashfunc	__hash__	X			G
tp_call	ternaryfunc	__call__		X		X
tp_str	reprfunc	__str__	X			X
tp_getattro	getattrofunc	__getattribute__, __getattr__	X	X		G
tp_setattro	setattrofunc	__setattr__, __delattr__	X	X		G
tp_as_buffer	PyBufferProcs *	sub-slots				%
tp_flags	unsigned long		X	X		?
tp_doc	const char *	__doc__	X	X
tp_traverse	traverseproc			X		G
tp_clear	inquiry			X		G
tp_richcompare	richcmpfunc	__lt__, __le__, __eq__, __ne__, __gt__, __ge__	X			G
(tp_weaklistoffset)	Py_ssize_t			X		?
tp_iter	getiterfunc	__iter__				X
tp_iternext	iternextfunc	__next__				X
tp_methods	PyMethodDef []		X	X
tp_members	PyMemberDef []			X
tp_getset	PyGetSetDef []		X	X
tp_base	PyTypeObject *	__base__			X
tp_dict	PyObject *	__dict__			?
tp_descr_get	descrgetfunc	__get__				X
tp_descr_set	descrsetfunc	__set__, __delete__				X
(tp_dictoffset)	Py_ssize_t			X		?
tp_init	initproc	__init__	X	X		X
tp_alloc	allocfunc		X		?	?
tp_new	newfunc	__new__	X	X	?	?
tp_free	freefunc		X	X	?	?
tp_is_gc	inquiry			X		X
<tp_bases>	PyObject *	__bases__			~
<tp_mro>	PyObject *	__mro__			~
[tp_cache]	PyObject *
[tp_subclasses]	void *	__subclasses__
[tp_weaklist]	PyObject *
(tp_del)	destructor
[tp_version_tag]	unsigned int
tp_finalize	destructor	__del__				X
tp_vectorcall	vectorcallfunc
[tp_watched]	unsigned char

[1]

(): Ett slotnamn inom parentes anger att det (i praktiken) är föråldrat.

<>: Namn inom hakparenteser bör initialt sättas till NULL och behandlas som skrivskyddade.

[]: Namn inom hakparentes är endast för internt bruk.

<R> (som prefix) betyder att fältet är obligatoriskt (måste vara icke-NULL).

[2]

Kolumner:

”O”: inställd på PyBaseObject_Type

”T”: inställd på PyType_Type

”D”: standard (om slot är inställd på NULL)

X - PyType_Ready ställer in detta värde om det är NULL
~ - PyType_Ready ställer alltid in detta värde (det ska vara NULL)
? - PyType_Ready kan ställa in detta värde beroende på andra slots

Se även kolumnen för arv ("I").

”I”: arv

X - typplatsen ärvs via *PyType_Ready* om den definieras med ett *NULL*-värde
% - understrukturens slots ärvs individuellt
G - ärvs, men endast i kombination med andra slots; se slotens beskrivning
? - det är komplicerat; se slotens beskrivning

Observera att vissa slots faktiskt ärvs genom den normala attributuppslagningskedjan.

sub-slots

Slot	Typ	särskilda metoder
am_await	unaryfunc	__await__
am_aiter	unaryfunc	__aiter__
am_anext	unaryfunc	__anext__
am_send	sendfunc
nb_add	binaryfunc	__add__ __radd__
nb_inplace_add	binaryfunc	__iadd__
nb_subtract	binaryfunc	__sub__ __rsub__
nb_inplace_subtract	binaryfunc	__isub__
nb_multiply	binaryfunc	__mul__ __rmul__
nb_inplace_multiply	binaryfunc	__imul__
nb_remainder	binaryfunc	__mod__ __rmod__
nb_inplace_remainder	binaryfunc	__imod__
nb_divmod	binaryfunc	__divmod__ __rdivmod__
nb_power	ternaryfunc	__pow__ __rpow__
nb_inplace_power	ternaryfunc	__ipow__
nb_negative	unaryfunc	__neg__
nb_positive	unaryfunc	__pos__
nb_absolute	unaryfunc	__abs__
nb_bool	inquiry	__bool
nb_invert	unaryfunc	__invert__
nb_lshift	binaryfunc	__lshift__ __rlshift__
nb_inplace_lshift	binaryfunc	__ilshift__
nb_rshift	binaryfunc	__rshift__ __rshift__ __rshift__
nb_inplace_rshift	binaryfunc	__irshift__
nb_and	binaryfunc	__and__ __rand__
nb_inplace_and	binaryfunc	__iand__
nb_xor	binaryfunc	__xor__ __rxor__
nb_inplace_xor	binaryfunc	__ixor__
nb_or	binaryfunc	__or__ __ror__
nb_inplace_or	binaryfunc	__ior__
nb_int	unaryfunc	__int__
nb_reserved	void *
nb_float	unaryfunc	__float__
nb_floor_divide	binaryfunc	__floordiv__
nb_inplace_floor_divide	binaryfunc	__ifloordiv__
nb_true_divide	binaryfunc	__truediv__
nb_inplace_true_divide	binaryfunc	__itruediv__
nb_index	unaryfunc	__index__
nb_matrix_multiply	binaryfunc	__matmul__ __rmatmul__
nb_inplace_matrix_multiply	binaryfunc	__imatmul__
mp_length	lenfunc	__len__
mp_subscript	binaryfunc	__getitem__
mp_ass_subscript	objobjargproc	__setitem__, __delitem__
sq_length	lenfunc	__len__
sq_concat	binaryfunc	__add__
sq_repeat	ssizeargfunc	__mul__
sq_item	ssizeargfunc	__getitem__
sq_ass_item	ssizeobjargproc	__setitem__ __delitem__
sq_contains	objobjproc	__contains__
sq_inplace_concat	binaryfunc	__iadd__
sq_inplace_repeat	ssizeargfunc	__imul__
bf_getbuffer	getbufferproc()	__buffer__
bf_releasebuffer	releasebufferproc()	__release_buffer__

slot typdefinitioner

typedef	Parametertyper	Typ av retur
allocfunc	PyTypeObject * Py_ssize_t	PyObject *
destructor	PyObject *	void
freefunc	void *	void
traverseproc	PyObject * visitproc void *	int
newfunc	PyTypeObject * PyObject * PyObject *	PyObject *
initproc	PyObject * PyObject * PyObject *	int
reprfunc	PyObject *	PyObject *
getattrfunc	PyObject * const char *	PyObject *
setattrfunc	PyObject * const char * PyObject *	int
getattrofunc	PyObject * PyObject *	PyObject *
setattrofunc	PyObject * PyObject * PyObject *	int
descrgetfunc	PyObject * PyObject * PyObject *	PyObject *
descrsetfunc	PyObject * PyObject * PyObject *	int
hashfunc	PyObject *	Py_hash_t
richcmpfunc	PyObject * PyObject * int	PyObject *
getiterfunc	PyObject *	PyObject *
iternextfunc	PyObject *	PyObject *
lenfunc	PyObject *	Py_ssize_t
getbufferproc	PyObject * Py_buffer * int	int
releasebufferproc	PyObject * Py_buffer *	void
inquiry	PyObject *	int
unaryfunc	PyObject *	PyObject *
binaryfunc	PyObject * PyObject *	PyObject *
ternaryfunc	PyObject * PyObject * PyObject *	PyObject *
ssizeargfunc	PyObject * Py_ssize_t	PyObject *
ssizeobjargproc	PyObject * Py_ssize_t PyObject *	int
objobjproc	PyObject * PyObject *	int
objobjargproc	PyObject * PyObject * PyObject *	int

Se Slotstyp typedef nedan för mer information.

PyTypeObject Definition

Strukturdefinitionen för PyTypeObject finns i Include/cpython/object.h. För att underlätta referensen upprepar detta den definition som finns där:

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

    /* Methods to implement standard operations */

    destructor tp_dealloc;
    Py_ssize_t tp_vectorcall_offset;
    getattrfunc tp_getattr;
    setattrfunc tp_setattr;
    PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2)
                                    or tp_reserved (Python 3) */
    reprfunc tp_repr;

    /* Method suites for standard classes */

    PyNumberMethods *tp_as_number;
    PySequenceMethods *tp_as_sequence;
    PyMappingMethods *tp_as_mapping;

    /* More standard operations (here for binary compatibility) */

    hashfunc tp_hash;
    ternaryfunc tp_call;
    reprfunc tp_str;
    getattrofunc tp_getattro;
    setattrofunc tp_setattro;

    /* Functions to access object as input/output buffer */
    PyBufferProcs *tp_as_buffer;

    /* Flags to define presence of optional/expanded features */
    unsigned long tp_flags;

    const char *tp_doc; /* Documentation string */

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

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

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

    /* weak reference enabler */
    Py_ssize_t tp_weaklistoffset;

    /* Iterators */
    getiterfunc tp_iter;
    iternextfunc tp_iternext;

    /* Attribute descriptor and subclassing stuff */
    PyMethodDef *tp_methods;
    PyMemberDef *tp_members;
    PyGetSetDef *tp_getset;
    // Strong reference on a heap type, borrowed reference on a static type
    PyTypeObject *tp_base;
    PyObject *tp_dict;
    descrgetfunc tp_descr_get;
    descrsetfunc tp_descr_set;
    Py_ssize_t tp_dictoffset;
    initproc tp_init;
    allocfunc tp_alloc;
    newfunc tp_new;
    freefunc tp_free; /* Low-level free-memory routine */
    inquiry tp_is_gc; /* For PyObject_IS_GC */
    PyObject *tp_bases;
    PyObject *tp_mro; /* method resolution order */
    PyObject *tp_cache; /* no longer used */
    void *tp_subclasses;  /* for static builtin types this is an index */
    PyObject *tp_weaklist; /* not used for static builtin types */
    destructor tp_del;

    /* Type attribute cache version tag. Added in version 2.6.
     * If zero, the cache is invalid and must be initialized.
     */
    unsigned int tp_version_tag;

    destructor tp_finalize;
    vectorcallfunc tp_vectorcall;

    /* bitset of which type-watchers care about this type */
    unsigned char tp_watched;

    /* Number of tp_version_tag values used.
     * Set to _Py_ATTR_CACHE_UNUSED if the attribute cache is
     * disabled for this type (e.g. due to custom MRO entries).
     * Otherwise, limited to MAX_VERSIONS_PER_CLASS (defined elsewhere).
     */
    uint16_t tp_versions_used;
} PyTypeObject;

PyObject Slots

Typobjektstrukturen utökar PyVarObject-strukturen. Fältet ob_size används för dynamiska typer (skapade av type_new(), som vanligtvis anropas från en class statement). Observera att PyType_Type (metatypen) initialiserar tp_itemsize, vilket innebär att dess instanser (dvs. typobjekt) måste ha fältet ob_size.

PyObject.ob_refcnt

Typobjektets referensantal initialiseras till 1 av makrot PyObject_HEAD_INIT. Observera att för statiskt allokerade typobjekt räknas typens instanser (objekt vars ob_type pekar tillbaka på typen) inte som referenser. Men för dynamiskt allokerade typobjekt räknas förekomsterna som referenser.

Arv:

Detta fält ärvs inte av subtyper.

PyObject.ob_type

Detta är typens typ, med andra ord dess metatyp. Den initialiseras av argumentet till makrot PyObject_HEAD_INIT, och dess värde bör normalt vara &PyType_Type. Men för dynamiskt laddningsbara tilläggsmoduler som måste kunna användas på Windows (åtminstone), klagar kompilatorn på att detta inte är en giltig initierare. Därför är konventionen att skicka NULL till makrot PyObject_HEAD_INIT och att initiera detta fält explicit i början av modulens initialiseringsfunktion, innan något annat görs. Detta görs typiskt så här:

Foo_Type.ob_type = &PyType_Type;

Detta bör göras innan några instanser av typen skapas. PyType_Ready() kontrollerar om ob_type är NULL, och initialiserar det i så fall till fältet ob_type i basklassen. PyType_Ready() ändrar inte detta fält om det är icke-noll.

Arv:

Detta fält ärvs av subtyperna.

PyVarObject platser

PyVarObject.ob_size

För statiskt allokerade objekttyper bör detta initialiseras till noll. För dynamiskt allokerade objekttyper har detta fält en speciell intern betydelse.

Detta fält bör nås med hjälp av makrot Py_SIZE().

Arv:

Detta fält ärvs inte av subtyper.

PyTypeObject platser

Varje slot har ett avsnitt som beskriver nedärvning. Om PyType_Ready() kan sätta ett värde när fältet är satt till NULL så kommer det också att finnas en ”Default” sektion. (Observera att många fält som anges i PyBaseObject_Type och PyType_Type fungerar som standardvärden)

const char *PyTypeObject.tp_name

Pekare till en NUL-avslutad sträng som innehåller typens namn. För typer som är tillgängliga som modulglobaler ska strängen vara det fullständiga modulnamnet, följt av en punkt, följt av typnamnet; för inbyggda typer ska det bara vara typnamnet. Om modulen är en undermodul till ett paket ingår det fullständiga paketnamnet i det fullständiga modulnamnet. Till exempel, en typ med namnet T definierad i modul M i underpaket Q i paket P bör ha tp_name initialiseraren "P.Q.M.T".

För dynamiskt allokerade objekttyper bör detta bara vara typnamnet och modulnamnet explicit lagrat i typdiktningen som värdet för nyckeln '__module__'.

För statiskt allokerade objekttyper ska fältet tp_name innehålla en punkt. Allt före den sista punkten görs tillgängligt som attributet __module__ och allt efter den sista punkten görs tillgängligt som attributet __name__.

Om ingen punkt finns, görs hela fältet tp_name tillgängligt som attributet __name__, och attributet __module__ är odefinierat (om det inte uttryckligen har angetts i ordlistan, enligt vad som förklaras ovan). Detta innebär att din typ inte kommer att kunna plockas. Dessutom kommer den inte att listas i moduldokumentationer som skapats med pydoc.

Detta fält får inte vara NULL. Det är det enda obligatoriska fältet i PyTypeObject() (förutom eventuellt tp_itemsize).

Arv:

Detta fält ärvs inte av subtyper.

Py_ssize_t PyTypeObject.tp_basicsize

Py_ssize_t PyTypeObject.tp_itemsize

Dessa fält gör det möjligt att beräkna storleken i bytes för instanser av typen.

Det finns två typer av typer: typer med instanser med fast längd har fältet tp_itemsize som är noll, medan typer med instanser med variabel längd har fältet tp_itemsize som inte är noll. För en typ med instanser med fast längd har alla instanser samma storlek, angiven i tp_basicsize. (Undantag från denna regel kan göras med hjälp av PyUnstable_Object_GC_NewWithExtraData())

För en typ med instanser med variabel längd måste instanserna ha ett fält ob_size, och instansstorleken är tp_basicsize plus N gånger tp_itemsize, där N är objektets ”längd”.

Funktioner som PyObject_NewVar() tar värdet av N som ett argument och lagrar det i instansens ob_size-fält. Observera att fältet ob_size senare kan användas för andra ändamål. Exempelvis använder instanser av int bitarna i ob_size på ett implementationsdefinierat sätt; den underliggande lagringen och dess storlek bör nås med hjälp av PyLong_Export().

Anteckning

Fältet ob_size bör nås med hjälp av makrona Py_SIZE() och Py_SET_SIZE().

Att det finns ett fält ob_size i instanslayouten betyder inte heller att instansstrukturen har variabel längd. Till exempel har typen list instanser med fast längd, men dessa instanser har ändå ett fält ob_size. (Precis som med int bör du undvika att läsa listors ob_size direkt. Anropa PyList_Size() istället)

I tp_basicsize ingår den storlek som behövs för data i typens tp_base, plus eventuella extra data som behövs för varje instans.

Det korrekta sättet att ange tp_basicsize är att använda operatorn sizeof på den struct som används för att deklarera instanslayouten. Denna struct måste inkludera den struct som används för att deklarera bastypen. Med andra ord måste tp_basicsize vara större än eller lika med basens tp_basicsize.

Eftersom varje typ är en subtyp av object måste denna struktur innehålla PyObject eller PyVarObject (beroende på om ob_size ska ingå). Dessa definieras vanligtvis av makrot PyObject_HEAD respektive PyObject_VAR_HEAD.

Grundstorleken inkluderar inte storleken på GC-huvudet, eftersom det huvudet inte ingår i PyObject_HEAD.

För fall där struct som används för att deklarera bastypen är okänd, se PyType_Spec.basicsize och PyType_FromMetaclass().

Anmärkningar om anpassning:

• tp_basicsize måste vara en multipel av _Alignof(PyObject). När du använder sizeof på en struct som innehåller PyObject_HEAD, som rekommenderat, säkerställer kompilatorn detta. Om du inte använder en C-struktur, eller om du använder kompilatortillägg som __attribute__((packed)), är det upp till dig.

• Om de variabla objekten kräver en viss inriktning måste tp_basicsize och tp_itemsize var och en vara en multipel av den inriktningen. Om t.ex. en variabeldel av en typ lagrar en double, är det ditt ansvar att båda fälten är en multipel av _Alignof(double).

Arv:

Dessa fält ärvs separat av subtyperna. (Det vill säga, om fältet är satt till noll kommer PyType_Ready() att kopiera värdet från bastypen, vilket indikerar att instanserna inte behöver ytterligare lagring)

Om bastypen har ett icke-nollvärde för tp_itemsize är det i allmänhet inte säkert att ange tp_itemsize till ett annat icke-nollvärde i en subtyp (detta beror dock på implementeringen av bastypen).

destructor PyTypeObject.tp_dealloc

En pekare till instansens destruktorfunktion. Funktionens signatur är:

void tp_dealloc(PyObject *self);

Destruktorfunktionen ska ta bort alla referenser som instansen äger (t.ex. anropa Py_CLEAR()), frigöra alla minnesbuffertar som instansen äger och anropa typens tp_free-funktion för att frigöra själva objektet.

Om du kan anropa funktioner som kan ställa in felindikatorn måste du använda PyErr_GetRaisedException() och PyErr_SetRaisedException() för att säkerställa att du inte slår ut en redan existerande felindikator (deallokeringen kan ha inträffat under behandlingen av ett annat fel):

static void
foo_dealloc(foo_object *self)
{
    PyObject *et, *ev, *etb;
    PyObject *exc = PyErr_GetRaisedException();
    ...
    PyErr_SetRaisedException(exc);
}

Själva dealloc-hanteraren får inte ge upphov till ett undantag; om den stöter på ett felfall bör den anropa PyErr_FormatUnraisable() för att logga (och rensa) ett undantag som inte går att radera.

Det finns inga garantier för när ett objekt förstörs, förutom:

• Python kommer att förstöra ett objekt omedelbart eller en tid efter att den sista referensen till objektet har tagits bort, såvida inte dess finalizer (tp_finalize) därefter återupplivar objektet.

• Ett objekt kommer inte att förstöras medan det automatiskt slutförs (tp_finalize) eller automatiskt rensas (tp_clear).

CPython förstör för närvarande ett objekt omedelbart från Py_DECREF() när det nya referensantalet är noll, men detta kan ändras i en framtida version.

Det rekommenderas att anropa PyObject_CallFinalizerFromDealloc() i början av tp_dealloc för att garantera att objektet alltid är finalized innan det förstörs.

Om typen stödjer garbage collection (flaggan Py_TPFLAGS_HAVE_GC är satt) ska destruktorn anropa PyObject_GC_UnTrack() innan den rensar några medlemsfält.

Det är tillåtet att anropa tp_clear från tp_dealloc för att minska koddubblering och för att garantera att objektet alltid rensas innan det förstörs. Tänk på att tp_clear redan kan ha anropats.

Om typen är heap-allokerad (Py_TPFLAGS_HEAPTYPE), bör deallokatorn släppa den ägda referensen till sitt typobjekt (via Py_DECREF()) efter anropet till typdeallokatorn. Se exempelkoden nedan.:

statiskt void
foo_dealloc(PyObject *op)
{
   foo_object *self = (foo_object *) op;
   PyObject_GC_UnTrack(self);
   Py_CLEAR(själv>ref);
   Py_TYPE(self)->tp_free(self);
}

tp_dealloc måste lämna undantagsstatusen oförändrad. Om den behöver anropa något som kan ge upphov till ett undantag, måste undantagstillståndet först säkerhetskopieras och återställas senare (efter loggning av eventuella undantag med PyErr_WriteUnraisable()).

Exempel:

static void
foo_dealloc(PyObject *self)
{
    PyObject *exc = PyErr_GetRaisedException();

    if (PyObject_CallFinalizerFromDealloc(self) < 0) {
        // self was resurrected.
        goto done;
    }

    PyTypeObject *tp = Py_TYPE(self);

    if (tp->tp_flags & Py_TPFLAGS_HAVE_GC) {
        PyObject_GC_UnTrack(self);
    }

    // Optional, but convenient to avoid code duplication.
    if (tp->tp_clear && tp->tp_clear(self) < 0) {
        PyErr_WriteUnraisable(self);
    }

    // Any additional destruction goes here.

    tp->tp_free(self);
    self = NULL;  // In case PyErr_WriteUnraisable() is called below.

    if (tp->tp_flags & Py_TPFLAGS_HEAPTYPE) {
        Py_CLEAR(tp);
    }

done:
    // Optional, if something was called that might have raised an
    // exception.
    if (PyErr_Occurred()) {
        PyErr_WriteUnraisable(self);
    }
    PyErr_SetRaisedException(exc);
}

tp_dealloc kan anropas från vilken Python-tråd som helst, inte bara den tråd som skapade objektet (om objektet blir en del av en refcount-cykel kan den cykeln samlas in av en garbage collection på vilken tråd som helst). Detta är inte ett problem för Python API-anrop, eftersom den tråd som tp_dealloc anropas från har en attached thread state. Men om objektet som förstörs i sin tur förstör objekt från något annat C-bibliotek, bör man se till att förstörelsen av dessa objekt i den tråd som anropade tp_dealloc inte bryter mot några antaganden i biblioteket.

Arv:

Detta fält ärvs av subtyperna.

Se även

Objektets livscykel för detaljer om hur denna slot förhåller sig till andra slots.

Py_ssize_t PyTypeObject.tp_vectorcall_offset

En valfri offset till en funktion per instans som implementerar anrop av objektet med hjälp av vectorcall-protokollet, ett effektivare alternativ till den enklare tp_call.

Detta fält används endast om flaggan Py_TPFLAGS_HAVE_VECTORCALL är satt. Om så är fallet måste detta vara ett positivt heltal som innehåller offset i instansen för en pekare av typen vectorcallfunc.

Poängaren vectorcallfunc kan vara NULL, i vilket fall instansen beter sig som om Py_TPFLAGS_HAVE_VECTORCALL inte var inställd: anrop av instansen faller tillbaka till tp_call.

Alla klasser som ställer in Py_TPFLAGS_HAVE_VECTORCALL måste också ställa in tp_call och se till att dess beteende är förenligt med funktionen vectorcallfunc. Detta kan göras genom att ställa in tp_call till PyVectorcall_Call().

Ändrad i version 3.8: Före version 3.8 hette denna slot tp_print. I Python 2.x användes den för utskrift till en fil. I Python 3.0 till 3.7 var den oanvänd.

Ändrad i version 3.12: Före version 3.12 var det inte rekommenderat för mutable heap types att implementera vectorcall-protokollet. När en användare ställer in __call__ i Python-kod, uppdateras endast tp_call, vilket sannolikt gör den inkonsekvent med vectorcall-funktionen. Sedan 3.12 kommer inställningen __call__ att inaktivera vectorcall-optimering genom att rensa flaggan Py_TPFLAGS_HAVE_VECTORCALL.

Arv:

Detta fält är alltid ärftligt. Dock är Py_TPFLAGS_HAVE_VECTORCALL flaggan inte alltid ärvd. Om den inte är satt, kommer subklassen inte att använda vectorcall, förutom när PyVectorcall_Call() explicit anropas.

getattrfunc PyTypeObject.tp_getattr

En valfri pekare till funktionen get-attribute-string.

Detta fält är föråldrat. När det definieras bör det peka på en funktion som fungerar på samma sätt som tp_getattro-funktionen, men som tar en C-sträng istället för ett Python-strängobjekt för att ge attributnamnet.

Arv:

Grupp: tp_getattr, tp_getattro

Detta fält ärvs av subtyper tillsammans med tp_getattro: en subtyp ärver både tp_getattr och tp_getattro från sin bastyp när subtypens tp_getattr och tp_getattro båda är NULL.

setattrfunc PyTypeObject.tp_setattr

En valfri pekare till funktionen för att ställa in och ta bort attribut.

Detta fält är föråldrat. När det definieras bör det peka på en funktion som fungerar på samma sätt som tp_setattro-funktionen, men som tar en C-sträng istället för ett Python-strängobjekt för att ge attributnamnet.

Arv:

Grupp: tp_setattr, tp_setattro

Detta fält ärvs av subtyper tillsammans med tp_setattro: en subtyp ärver både tp_setattr och tp_setattro från sin bastyp när subtypens tp_setattr och tp_setattro båda är NULL.

PyAsyncMethods *PyTypeObject.tp_as_async

Pekare till en ytterligare struktur som innehåller fält som endast är relevanta för objekt som implementerar protokollen awaitable och asynchronous iterator på C-nivå. Se Strukturer för asynkrona objekt för detaljer.

Tillagd i version 3.5: Tidigare känd som tp_compare och tp_reserved.

Arv:

Fältet tp_as_async ärvs inte, men de ingående fälten ärvs individuellt.

reprfunc PyTypeObject.tp_repr

En valfri pekare till en funktion som implementerar den inbyggda funktionen repr().

Signaturen är densamma som för PyObject_Repr():

PyObject *tp_repr(PyObject *self);

Funktionen måste returnera en sträng eller ett Unicode-objekt. Helst ska denna funktion returnera en sträng som, när den skickas till eval(), i en lämplig miljö, returnerar ett objekt med samma värde. Om detta inte är möjligt, bör den returnera en sträng som börjar med '<' och slutar med '>' från vilken både typen och värdet på objektet kan härledas.

Arv:

Detta fält ärvs av subtyperna.

Standard:

Om detta fält inte är inställt returneras en sträng av formen <%s object at %p>, där %s ersätts av typnamnet och %p av objektets minnesadress.

PyNumberMethods *PyTypeObject.tp_as_number

Pekare till en ytterligare struktur som innehåller fält som endast är relevanta för objekt som implementerar nummerprotokollet. Dessa fält är dokumenterade i Strukturer för nummerobjekt.

Arv:

Fältet tp_as_number ärvs inte, men de ingående fälten ärvs individuellt.

PySequenceMethods *PyTypeObject.tp_as_sequence

Pekare till en ytterligare struktur som innehåller fält som endast är relevanta för objekt som implementerar sekvensprotokollet. Dessa fält är dokumenterade i Strukturer för sekvensobjekt.

Arv:

Fältet tp_as_sequence ärvs inte, men de ingående fälten ärvs individuellt.

PyMappingMethods *PyTypeObject.tp_as_mapping

Pekare till en ytterligare struktur som innehåller fält som endast är relevanta för objekt som implementerar mappningsprotokollet. Dessa fält är dokumenterade i Mappning av objektstrukturer.

Arv:

Fältet tp_as_mapping ärvs inte, men de ingående fälten ärvs individuellt.

hashfunc PyTypeObject.tp_hash

En valfri pekare till en funktion som implementerar den inbyggda funktionen hash().

Signaturen är densamma som för PyObject_Hash():

Py_hash_t tp_hash(PyObject *);

Värdet -1 ska inte returneras som ett normalt returvärde; när ett fel inträffar under beräkningen av hashvärdet ska funktionen sätta ett undantag och returnera -1.

När detta fält inte är inställt (och tp_richcompare inte är inställt), kommer ett försök att ta objektets hash att ge upphov till TypeError. Detta är samma sak som att sätta den till PyObject_HashNotImplemented().

Detta fält kan explicit sättas till PyObject_HashNotImplemented() för att blockera arv av hash-metoden från en överordnad typ. Detta tolkas som motsvarigheten till __hash__ = None på Python-nivå, vilket gör att isinstance(o, collections.Hashable) korrekt returnerar False. Observera att det omvända också är sant - att sätta __hash__ = None på en klass på Python-nivå kommer att resultera i att tp_hash slot sätts till PyObject_HashNotImplemented().

Arv:

Grupp: tp_hash, tp_richcompare

Detta fält ärvs av subtyper tillsammans med tp_richcompare: en subtyp ärver både tp_richcompare och tp_hash, när subtypens tp_richcompare och tp_hash båda är NULL.

Standard:

PyBaseObject_Type använder PyObject_GenericHash().

ternaryfunc PyTypeObject.tp_call

En valfri pekare till en funktion som implementerar anrop av objektet. Denna bör vara NULL om objektet inte är anropsbart. Signaturen är densamma som för PyObject_Call():

PyObject *tp_call(PyObject *self, PyObject *args, PyObject *kwargs);

Arv:

Detta fält ärvs av subtyperna.

reprfunc PyTypeObject.tp_str

En valfri pekare till en funktion som implementerar den inbyggda operationen str(). (Observera att str nu är en typ och att str() anropar konstruktören för den typen. Denna konstruktör anropar PyObject_Str() för att göra det faktiska arbetet, och PyObject_Str() kommer att anropa denna hanterare)

Signaturen är densamma som för PyObject_Str():

PyObject *tp_str(PyObject *self);

Funktionen måste returnera en sträng eller ett Unicode-objekt. Det bör vara en ”vänlig” strängrepresentation av objektet, eftersom det är den representation som kommer att användas, bland annat, av funktionen print().

Arv:

Detta fält ärvs av subtyperna.

Standard:

När detta fält inte är inställt anropas PyObject_Repr() för att returnera en strängrepresentation.

getattrofunc PyTypeObject.tp_getattro

En valfri pekare till funktionen get-attribute.

Signaturen är densamma som för PyObject_GetAttr():

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

Det är oftast lämpligt att ställa in detta fält till PyObject_GenericGetAttr(), som implementerar det normala sättet att leta efter objektattribut.

Arv:

Grupp: tp_getattr, tp_getattro

Detta fält ärvs av subtyper tillsammans med tp_getattr: en subtyp ärver både tp_getattr och tp_getattro från sin bastyp när subtypens tp_getattr och tp_getattro båda är NULL.

Standard:

PyBaseObject_Type använder PyObject_GenericGetAttr().

setattrofunc PyTypeObject.tp_setattro

En valfri pekare till funktionen för att ställa in och ta bort attribut.

Signaturen är densamma som för PyObject_SetAttr():

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

Dessutom måste det finnas stöd för att sätta value till NULL för att ta bort ett attribut. Det är vanligtvis bekvämt att ställa in detta fält till PyObject_GenericSetAttr(), som implementerar det normala sättet att ställa in objektattribut.

Arv:

Grupp: tp_setattr, tp_setattro

Detta fält ärvs av subtyper tillsammans med tp_setattr: en subtyp ärver både tp_setattr och tp_setattro från sin bastyp när subtypens tp_setattr och tp_setattro båda är NULL.

Standard:

PyBaseObject_Type använder PyObject_GenericSetAttr().

PyBufferProcs *PyTypeObject.tp_as_buffer

Pekare till en ytterligare struktur som innehåller fält som endast är relevanta för objekt som implementerar buffertgränssnittet. Dessa fält är dokumenterade i Strukturer för buffertobjekt.

Arv:

Fältet tp_as_buffer ärvs inte, men de ingående fälten ärvs individuellt.

unsigned long PyTypeObject.tp_flags

Detta fält är en bitmask med olika flaggor. Vissa flaggor anger varierande semantik för vissa situationer; andra används för att ange att vissa fält i typobjektet (eller i de tilläggsstrukturer som refereras via tp_as_number, tp_as_sequence, tp_as_mapping, och tp_as_buffer) som historiskt sett inte alltid funnits är giltiga; om en sådan flaggbit är klar får de typfält som den skyddar inte nås och måste anses ha värdet noll eller NULL istället.

Arv:

Nedärvningen av detta fält är komplicerad. De flesta flaggbitar ärvs individuellt, dvs. om bastypen har en flaggbit inställd ärver subtypen denna flaggbit. De flaggbitar som hör till tilläggsstrukturer ärvs strikt om tilläggsstrukturen ärvs, d.v.s. bastypens värde på flaggbiten kopieras till subtypen tillsammans med en pekare till tilläggsstrukturen. Flaggbiten Py_TPFLAGS_HAVE_GC ärvs tillsammans med fälten tp_traverse och tp_clear, dvs. om flaggbiten Py_TPFLAGS_HAVE_GC är klar i subtypen och fälten tp_traverse och tp_clear i subtypen finns och har värdena NULL.

Standard:

PyBaseObject_Type använder Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE.

Bitmasker:

Följande bitmasker är för närvarande definierade; dessa kan kombineras med operatorn | för att bilda värdet i fältet tp_flags. Makrot PyType_HasFeature() tar en typ och ett flaggvärde, tp och f, och kontrollerar om tp->tp_flags & f är icke-noll.

Py_TPFLAGS_HEAPTYPE

Denna bit är inställd när själva typobjektet allokeras på heapen, t.ex. typer som skapas dynamiskt med PyType_FromSpec(). I detta fall betraktas fältet ob_type i dess instanser som en referens till typen, och typobjektet INCREF’ed när en ny instans skapas, och DECREF’ed när en instans förstörs (detta gäller inte instanser av subtyper; endast den typ som instansens ob_type refererar till INCREF’ed eller DECREF’ed). Heap-typer bör också stödja garbage collection eftersom de kan bilda en referenscykel med sitt eget modulobjekt.

Arv:

???

Py_TPFLAGS_BASETYPE

Denna bit är satt när typen kan användas som bastyp för en annan typ. Om denna bit är klar kan typen inte subtypas (på samma sätt som en ”final”-klass i Java).

Arv:

???

Py_TPFLAGS_READY

Denna bit är inställd när typobjektet har initialiserats fullständigt av PyType_Ready().

Arv:

???

Py_TPFLAGS_READYING

Denna bit är inställd när PyType_Ready() håller på att initiera typobjektet.

Arv:

???

Py_TPFLAGS_HAVE_GC

Denna bit är inställd när objektet stöder garbage collection. Om denna bit är inställd måste minne för nya instanser (se tp_alloc) allokeras med PyObject_GC_New eller PyType_GenericAlloc() och avallokeras (se tp_free) med PyObject_GC_Del(). Mer information finns i avsnitt Stöd för cyklisk skräpinsamling.

Arv:

Grupp: Py_TPFLAGS_HAVE_GC, tp_traverse, tp_clear

Flaggbiten Py_TPFLAGS_HAVE_GC ärvs tillsammans med fälten tp_traverse och tp_clear, dvs. om flaggbiten Py_TPFLAGS_HAVE_GC är klar i subtypen och fälten tp_traverse och tp_clear i subtypen finns och har värdena NULL.

Py_TPFLAGS_DEFAULT

Detta är en bitmask med alla de bitar som rör förekomsten av vissa fält i typobjektet och dess tilläggsstrukturer. För närvarande innehåller den följande bitar: Py_TPFLAGS_HAVE_STACKLESS_EXTENSION.

Arv:

???

Py_TPFLAGS_METHOD_DESCRIPTOR

Denna bit indikerar att objekt beter sig som obundna metoder.

Om denna flagga är inställd för type(meth), då:

• meth.__get__(obj, cls)(*args, **kwds) (med obj inte None) måste vara likvärdig med meth(obj, *args, **kwds).

• meth.__get__(None, cls)(*args, **kwds) måste vara likvärdig med meth(*args, **kwds).

Denna flagga möjliggör en optimering för typiska metodanrop som obj.meth(): den undviker att skapa ett tillfälligt ”bound method”-objekt för obj.meth.

Tillagd i version 3.8.

Arv:

Denna flagga ärvs aldrig av typer som inte har flaggan Py_TPFLAGS_IMMUTABLETYPE inställd. För tilläggstyper ärvs den närhelst tp_descr_get ärvs.

Py_TPFLAGS_MANAGED_DICT

Denna bit anger att instanser av klassen har attributet __dict__ och att utrymmet för ordlistan hanteras av den virtuella datorn.

Om denna flagga är satt, bör Py_TPFLAGS_HAVE_GC också vara satt.

Typövergångsfunktionen måste anropa PyObject_VisitManagedDict() och dess rensningsfunktion måste anropa PyObject_ClearManagedDict().

Tillagd i version 3.12.

Arv:

Denna flagga ärvs om inte fältet tp_dictoffset är inställt i en superklass.

Py_TPFLAGS_MANAGED_WEAKREF

Denna bit anger att instanser av klassen ska vara svagt refererbara.

Tillagd i version 3.12.

Arv:

Denna flagga ärvs om inte fältet tp_weaklistoffset är inställt i en superklass.

Py_TPFLAGS_ITEMS_AT_END

Används endast med typer med variabel storlek, dvs. sådana som har tp_itemsize som inte är noll.

Indikerar att den variabelstora delen av en instans av denna typ är i slutet av instansens minnesområde, vid en offset av Py_TYPE(obj)->tp_basicsize (som kan vara annorlunda i varje underklass).

När du ställer in denna flagga måste du se till att alla superklasser antingen använder denna minneslayout eller inte har variabel storlek. Python kontrollerar inte detta.

Tillagd i version 3.12.

Arv:

Denna flagga ärvs.

Py_TPFLAGS_LONG_SUBCLASS

Py_TPFLAGS_LIST_SUBCLASS

Py_TPFLAGS_TUPLE_SUBCLASS

Py_TPFLAGS_BYTES_SUBCLASS

Py_TPFLAGS_UNICODE_SUBCLASS

Py_TPFLAGS_DICT_SUBCLASS

Py_TPFLAGS_BASE_EXC_SUBCLASS

Py_TPFLAGS_TYPE_SUBCLASS

Dessa flaggor används av funktioner som PyLong_Check() för att snabbt avgöra om en typ är en underklass av en inbyggd typ; sådana specifika kontroller är snabbare än en generisk kontroll, som PyObject_IsInstance(). Anpassade typer som ärver från inbyggda typer bör ha sina tp_flags inställda på lämpligt sätt, annars kommer koden som interagerar med sådana typer att bete sig annorlunda beroende på vilken typ av kontroll som används.

Py_TPFLAGS_HAVE_FINALIZE

Denna bit är inställd när tp_finalize finns i typstrukturen.

Tillagd i version 3.4.

Föråldrad sedan version 3.8: Denna flagga är inte längre nödvändig, eftersom tolken antar att tp_finalize alltid finns i typstrukturen.

Py_TPFLAGS_HAVE_VECTORCALL

Denna bit är inställd när klassen implementerar vectorcall-protokollet. Se tp_vectorcall_offset för detaljer.

Arv:

Denna bit ärvs om tp_call också ärvs.

Tillagd i version 3.9.

Ändrad i version 3.12: Denna flagga tas nu bort från en klass när klassens __call__()-metod tilldelas på nytt.

Denna flagga kan nu ärvas av mutabla klasser.

Py_TPFLAGS_IMMUTABLETYPE

Denna bit är inställd för typobjekt som är oföränderliga: typattribut kan inte ställas in eller tas bort.

PyType_Ready() tillämpar automatiskt denna flagga på static types.

Arv:

Denna flagga är inte ärftlig.

Tillagd i version 3.10.

Py_TPFLAGS_DISALLOW_INSTANTIATION

Tillåt inte att skapa instanser av typen: sätt tp_new till NULL och skapa inte nyckeln __new__ i typordboken.

Flaggan måste anges innan typen skapas, inte efteråt. Den måste till exempel ställas in innan PyType_Ready() anropas på typen.

Flaggan sätts automatiskt på static types om tp_base är NULL eller &PyBaseObject_Type och tp_new är NULL.

Arv:

Denna flagga ärvs inte. Underklasser kommer dock inte att kunna instansieras om de inte tillhandahåller en icke-NULL tp_new (vilket endast är möjligt via C API).

Anteckning

Använd inte denna flagga för att inte tillåta instansiering av en klass direkt men tillåta instansiering av dess underklasser (t.ex. för en abstrakt basklass). Gör istället så att tp_new bara lyckas för underklasser.

Tillagd i version 3.10.

Py_TPFLAGS_MAPPING

Denna bit indikerar att instanser av klassen kan matcha mappningsmönster när de används som ämne för ett match-block. Den sätts automatiskt vid registrering eller underklassning av collections.abc.Mapping, och avmarkeras vid registrering av collections.abc.Sequence.

Anteckning

Py_TPFLAGS_MAPPING och Py_TPFLAGS_SEQUENCE är ömsesidigt uteslutande; det är ett fel att aktivera båda flaggorna samtidigt.

Arv:

Denna flagga ärvs av typer som inte redan har satt Py_TPFLAGS_SEQUENCE.

Se även

PEP 634 – Matchning av strukturella mönster: Specifikation

Tillagd i version 3.10.

Py_TPFLAGS_SEQUENCE

Denna bit indikerar att instanser av klassen kan matcha sekvensmönster när de används som subjekt i ett match-block. Den sätts automatiskt vid registrering eller underklassning av collections.abc.Sequence, och avmarkeras vid registrering av collections.abc.Mapping.

Anteckning

Py_TPFLAGS_MAPPING och Py_TPFLAGS_SEQUENCE är ömsesidigt uteslutande; det är ett fel att aktivera båda flaggorna samtidigt.

Arv:

Denna flagga ärvs av typer som inte redan har satt Py_TPFLAGS_MAPPING.

Se även

PEP 634 – Matchning av strukturella mönster: Specifikation

Tillagd i version 3.10.

Py_TPFLAGS_VALID_VERSION_TAG

Internt. Denna flagga ska inte ställas in eller tas bort. För att indikera att en klass har ändrats anropa PyType_Modified()

Varning

Denna flagga finns i header-filer, men används inte. Den kommer att tas bort i en framtida version av CPython

const char *PyTypeObject.tp_doc

En valfri pekare till en NUL-avslutad C-sträng som anger dokumentsträngen för detta typobjekt. Detta exponeras som attributet __doc__ på typen och instanser av typen.

Arv:

Detta fält ärvs inte av subtyper.

traverseproc PyTypeObject.tp_traverse

En valfri pekare till en traversalfunktion för skräpsamlaren. Denna används endast om flaggbiten Py_TPFLAGS_HAVE_GC är satt. Signaturen är:

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

Mer information om Pythons skräpplockningssystem finns i avsnitt Stöd för cyklisk skräpinsamling.

Pekaren tp_traverse används av garbage collector för att upptäcka referenscykler. En typisk implementering av en tp_traverse-funktion anropar helt enkelt Py_VISIT() på var och en av instansens medlemmar som är Python-objekt som instansen äger. Detta är till exempel funktionen local_traverse() från tilläggsmodulen _thread:

static int
local_traverse(PyObject *op, visitproc visit, void *arg)
{
    localobject *self = (localobject *) op;
    Py_VISIT(self->args);
    Py_VISIT(self->kw);
    Py_VISIT(self->dict);
    return 0;
}

Observera att Py_VISIT() endast anropas på de medlemmar som kan delta i referenscykler. Även om det också finns en medlem self->key, kan den endast vara NULL eller en Python-sträng och kan därför inte ingå i en referenscykel.

Å andra sidan, även om du vet att en medlem aldrig kan ingå i en cykel, kan du som felsökningshjälp vilja besöka den ändå, bara för att gc-modulens get_referents()-funktion ska inkludera den.

Heap-typer (Py_TPFLAGS_HEAPTYPE) måste besöka sin typ med:

Py_VISIT(Py_TYPE(self));

Den behövs bara sedan Python 3.9. För att stödja Python 3.8 och äldre måste denna rad vara villkorlig:

#if PY_VERSION_HEX >= 0x03090000
    Py_VISIT(Py_TYPE(self));
#endif

Om bit Py_TPFLAGS_MANAGED_DICT är inställd i fältet tp_flags måste traversefunktionen anropa PyObject_VisitManagedDict() så här:

PyObject_VisitManagedDict((PyObject*)self, visit, arg);

Varning

Vid implementering av tp_traverse, måste endast de medlemmar som instansen äger (genom att ha strong references till dem) besökas. Om ett objekt t.ex. stöder svaga referenser via tp_weaklist slot, får pekaren som stöder den länkade listan (som tp_weaklist pekar på) inte besökas eftersom instansen inte direkt äger de svaga referenserna till sig själv (weakreference-listan finns där för att stödja maskineriet för svaga referenser, men instansen har ingen stark referens till elementen inuti den, eftersom de får tas bort även om instansen fortfarande lever).

Observera att Py_VISIT() kräver att parametrarna visit och arg till local_traverse() har dessa specifika namn; ge dem inte vilka namn som helst.

Instanser av heap-allocated types innehåller en referens till sin typ. Deras traverseringsfunktion måste därför antingen besöka Py_TYPE(self) eller delegera detta ansvar genom att anropa tp_traverse för en annan heap-allokerad typ (t.ex. en heap-allokerad superklass). Om de inte gör detta kan typobjektet inte samlas in av skräpsamling.

Anteckning

Funktionen tp_traverse kan anropas från vilken tråd som helst.

Ändrad i version 3.9: Heap-allokerade typer förväntas besöka Py_TYPE(self) i tp_traverse. I tidigare versioner av Python, på grund av bug 40217, kan detta leda till krascher i underklasser.

Arv:

Grupp: Py_TPFLAGS_HAVE_GC, tp_traverse, tp_clear

Detta fält ärvs av subtyper tillsammans med tp_clear och flaggbiten Py_TPFLAGS_HAVE_GC: flaggbiten, tp_traverse och tp_clear ärvs alla från bastypen om de alla är noll i subtypen.

inquiry PyTypeObject.tp_clear

En valfri pekare till en tydlig funktion. Signaturen är:

int tp_clear(PyObject *);

Syftet med denna funktion är att bryta referenscykler som orsakar en cyclic isolate så att objekten kan förstöras på ett säkert sätt. Ett rensat objekt är ett delvis förstört objekt; objektet är inte skyldigt att uppfylla designinvarianter som hålls under normal användning.

tp_clear behöver inte radera referenser till objekt som inte kan delta i referenscykler, t.ex. Python-strängar eller Python-integraler. Det kan dock vara bekvämt att rensa alla referenser och skriva typens tp_dealloc-funktion för att anropa tp_clear för att undvika koddubblering. (Tänk på att tp_clear kanske redan har anropats. Föredra att anropa idempotenta funktioner som Py_CLEAR())

All icke-trivial upprensning bör utföras i tp_finalize istället för tp_clear.

Anteckning

Om tp_clear misslyckas med att bryta en referenscykel kan objekten i cyclic isolate förbli obegränsat oinsamlingsbara (”läcka”). Se gc.garbage.

Anteckning

Referenser (direkta och indirekta) kan redan ha rensats; det är inte garanterat att de är i ett konsekvent tillstånd.

Anteckning

Funktionen tp_clear kan anropas från vilken tråd som helst.

Anteckning

Det är inte garanterat att ett objekt automatiskt rensas innan dess destruktor (tp_dealloc) anropas.

Denna funktion skiljer sig från destruktorn (tp_dealloc) på följande sätt:

• Syftet med att cleara ett objekt är att ta bort referenser till andra objekt som kan delta i en referenscykel. Destruktorns syfte är å andra sidan ett överordnat: den måste frigöra alla resurser som den äger, inklusive referenser till objekt som inte kan delta i en referenscykel (t.ex. heltal) samt objektets eget minne (genom att anropa tp_free).

• När tp_clear anropas kan andra objekt fortfarande ha referenser till det objekt som rensas. På grund av detta får tp_clear inte deallokera objektets eget minne (tp_free). Destruktorn, å andra sidan, anropas endast när inga (starka) referenser finns, och måste därför på ett säkert sätt förstöra själva objektet genom att avallokera det.

• tp_clear kanske aldrig anropas automatiskt. Ett objekts destruktor kommer däremot att anropas automatiskt en tid efter det att objektet blir oåtkomligt (dvs. antingen finns det inga referenser till objektet eller så är objektet medlem i en cyclic isolate).

Inga garantier görs om när, om eller hur ofta Python automatiskt rensar ett objekt, förutom:

• Python rensar inte automatiskt ett objekt om det är nåbart, dvs. om det finns en referens till det och det inte är en medlem av en cyclic isolate.

• Python kommer inte automatiskt att rensa ett objekt om det inte har blivit automatiskt finaliserat (se tp_finalize). (Om finaliseraren återupplivade objektet kan det hända att objektet automatiskt finaliseras igen innan det rensas)

• Om ett objekt är medlem i ett cyclic isolate, kommer Python inte automatiskt att rensa det om någon medlem i det cykliska isolatet ännu inte har slutförts automatiskt (tp_finalize).

• Python kommer inte att förstöra ett objekt förrän efter att alla automatiska anrop till dess tp_clear-funktion har returnerats. Detta säkerställer att handlingen att bryta en referenscykel inte ogiltigförklarar self-pekaren medan tp_clear fortfarande körs.

• Python kommer inte automatiskt att anropa tp_clear flera gånger samtidigt.

CPython rensar för närvarande bara automatiskt objekt när det behövs för att bryta referenscykler i en cyclic isolate, men framtida versioner kan rensa objekt regelbundet innan de förstörs.

Sammantaget måste alla tp_clear-funktioner i systemet kombineras för att bryta alla referenscykler. Detta är subtilt, och om du är osäker kan du använda en tp_clear-funktion. Till exempel implementerar inte tupeltypen en tp_clear-funktion, eftersom det är möjligt att bevisa att ingen referenscykel kan bestå helt av tuplar. Därför är tp_clear-funktioner av andra typer ansvariga för att bryta alla cykler som innehåller en tupel. Detta är inte omedelbart uppenbart, och det finns sällan en bra anledning att undvika att implementera tp_clear.

Implementeringar av tp_clear bör ta bort instansens referenser till de av dess medlemmar som kan vara Python-objekt, och sätta dess pekare till dessa medlemmar till NULL, som i följande exempel:

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

Makrot Py_CLEAR() bör användas eftersom det är känsligt att rensa referenser: referensen till det ingående objektet får inte släppas (via Py_DECREF()) förrän efter att pekaren till det ingående objektet har satts till NULL. Detta beror på att frigörandet av referensen kan leda till att det inneslutna objektet blir skräp, vilket utlöser en kedja av återvinningsaktiviteter som kan inkludera anrop av godtycklig Python-kod (på grund av finalizers eller weakref callbacks som är associerade med det inneslutna objektet). Om det är möjligt för sådan kod att referera till self igen, är det viktigt att pekaren till det inneslutna objektet är NULL vid den tidpunkten, så att self vet att det inneslutna objektet inte längre kan användas. Makrot Py_CLEAR() utför dessa operationer i en säker ordning.

Om bitarna Py_TPFLAGS_MANAGED_DICT är inställda i fältet tp_flags, måste traversefunktionen anropa PyObject_ClearManagedDict() så här:

PyObject_ClearManagedDict((PyObject*)self);

Mer information om Pythons skräpplockningssystem finns i avsnitt Stöd för cyklisk skräpinsamling.

Arv:

Grupp: Py_TPFLAGS_HAVE_GC, tp_traverse, tp_clear

Detta fält ärvs av subtyper tillsammans med tp_traverse och flaggbiten Py_TPFLAGS_HAVE_GC: flaggbiten, tp_traverse och tp_clear ärvs alla från bastypen om de alla är noll i subtypen.

Se även

Objektets livscykel för detaljer om hur denna slot förhåller sig till andra slots.

richcmpfunc PyTypeObject.tp_richcompare

En valfri pekare till den rika jämförelsefunktionen, vars signatur är:

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

Den första parametern är garanterat en instans av den typ som definieras av PyTypeObject.

Funktionen ska returnera resultatet av jämförelsen (vanligtvis Py_True eller Py_False). Om jämförelsen är odefinierad måste den returnera Py_NotImplemented, om ett annat fel inträffade måste den returnera NULL och sätta ett undantagsvillkor.

Följande konstanter är definierade för att användas som det tredje argumentet för tp_richcompare och för PyObject_RichCompare():

Konstant	Jämförelse
Py_LT	<
Py_LE	<=
Py_EQ	==
Py_NE	!=
Py_GT	>
Py_GE	>=

Följande makro är definierat för att underlätta skrivandet av rika jämförelsefunktioner:

Py_RETURN_RICHCOMPARE(VAL_A, VAL_B, op)

Returnerar Py_True eller Py_False från funktionen, beroende på resultatet av en jämförelse. VAL_A och VAL_B måste kunna ordnas av C:s jämförelseoperatorer (de kan t.ex. vara C:s ints eller floats). Det tredje argumentet specificerar den begärda operationen, som för PyObject_RichCompare().

Det returnerade värdet är en ny strong reference.

Vid fel, anger ett undantag och returnerar NULL från funktionen.

Tillagd i version 3.7.

Arv:

Grupp: tp_hash, tp_richcompare

Detta fält ärvs av subtyper tillsammans med tp_hash: en subtyp ärver tp_richcompare och tp_hash när subtypens tp_richcompare och tp_hash båda är NULL.

Standard:

PyBaseObject_Type tillhandahåller en tp_richcompare-implementation, som kan ärvas. Men om endast tp_hash definieras, används inte ens den ärvda funktionen och instanser av typen kommer inte att kunna delta i några jämförelser.

Py_ssize_t PyTypeObject.tp_weaklistoffset

Även om detta fält fortfarande stöds bör Py_TPFLAGS_MANAGED_WEAKREF användas i stället, om det är möjligt.

Om instanserna av denna typ är svagt refererbara, är detta fält större än noll och innehåller offset i instansstrukturen för huvudet på listan över svaga referenser (ignorerar GC-headern, om sådan finns); denna offset används av funktionerna PyObject_ClearWeakRefs() och PyWeakref_*. Instansstrukturen måste innehålla ett fält av typen PyObject* som initialiseras till NULL.

Förväxla inte detta fält med tp_weaklist; det är listhuvudet för svaga referenser till typobjektet självt.

Det är ett fel att ange både Py_TPFLAGS_MANAGED_WEAKREF bit och tp_weaklistoffset.

Arv:

Detta fält ärvs av subtyper, men se de regler som anges nedan. En subtyp kan åsidosätta denna offset; detta innebär att subtypen använder ett annat listhuvud för svaga referenser än bastypen. Eftersom listhuvudet alltid hittas via tp_weaklistoffset, bör detta inte vara något problem.

Standard:

Om bitarna Py_TPFLAGS_MANAGED_WEAKREF är inställda i fältet tp_flags, kommer tp_weaklistoffset att sättas till ett negativt värde, för att indikera att det är osäkert att använda detta fält.

getiterfunc PyTypeObject.tp_iter

En valfri pekare till en funktion som returnerar en iterator för objektet. Dess närvaro signalerar normalt att instanser av denna typ är iterable (även om sekvenser kan vara iterabla utan denna funktion).

Denna funktion har samma signatur som PyObject_GetIter():

PyObject *tp_iter(PyObject *self);

Arv:

Detta fält ärvs av subtyperna.

iternextfunc PyTypeObject.tp_iternext

En valfri pekare till en funktion som returnerar nästa objekt i en iterator. Signaturen är:

PyObject *tp_iternext(PyObject *self);

När iteratorn är uttömd måste den returnera NULL; ett StopIteration undantag kan eller kan inte ställas in. När ett annat fel inträffar måste den också returnera NULL. Dess närvaro signalerar att förekomsterna av denna typ är iteratorer.

Iteratortyper bör också definiera funktionen tp_iter, och den funktionen bör returnera själva iteratorinstansen (inte en ny iteratorinstans).

Denna funktion har samma signatur som PyIter_Next().

Arv:

Detta fält ärvs av subtyperna.

struct PyMethodDef *PyTypeObject.tp_methods

En valfri pekare till en statisk NULL-terminerad array av PyMethodDef-strukturer, som deklarerar vanliga metoder av denna typ.

För varje post i matrisen läggs en post till i typens dictionary (se tp_dict nedan) som innehåller en metoddeskriptor.

Arv:

Detta fält ärvs inte av subtyper (metoder ärvs genom en annan mekanism).

struct PyMemberDef *PyTypeObject.tp_members

En valfri pekare till en statisk NULL-terminerad array av PyMemberDef-strukturer, som deklarerar vanliga datamedlemmar (fält eller slots) för instanser av denna typ.

För varje post i matrisen läggs en post till i typens dictionary (se tp_dict nedan) som innehåller en medlemsdeskriptor.

Arv:

Detta fält ärvs inte av subtyper (medlemmar ärvs genom en annan mekanism).

struct PyGetSetDef *PyTypeObject.tp_getset

En valfri pekare till en statisk NULL-terminerad array av PyGetSetDef-strukturer, som deklarerar beräknade attribut för instanser av denna typ.

För varje post i matrisen läggs en post till i typens dictionary (se tp_dict nedan) som innehåller en getset-descriptor.

Arv:

Detta fält ärvs inte av subtyper (beräknade attribut ärvs genom en annan mekanism).

PyTypeObject *PyTypeObject.tp_base

En valfri pekare till en bastyp från vilken typegenskaper ärvs. På denna nivå stöds endast enkel nedärvning; multipel nedärvning kräver att ett typobjekt skapas dynamiskt genom att anropa metatypen.

Anteckning

Slotinitialisering är föremål för reglerna för initialisering av globaler. C99 kräver att initialisatorerna är ”adresskonstanter”. Funktionsbeteckningar som PyType_GenericNew(), med implicit konvertering till en pekare, är giltiga C99-adresskonstanter.

Den unära operatorn ’&’ som används på en icke-statisk variabel som PyBaseObject_Type är dock inte nödvändig för att producera en adresskonstant. Kompilatorer kan stödja detta (gcc gör det), MSVC gör det inte. Båda kompilatorerna är strikt standardkonforma i detta speciella beteende.

Följaktligen bör tp_base anges i tilläggsmodulens init-funktion.

Arv:

Detta fält ärvs inte av subtyper (naturligtvis).

Standard:

Detta fält är som standard &PyBaseObject_Type (som för Python-programmerare är känt som typen object).

PyObject *PyTypeObject.tp_dict

Typens ordbok lagras här av PyType_Ready().

Detta fält bör normalt initialiseras till NULL innan PyType_Ready anropas; det kan också initialiseras till en dictionary som innehåller initiala attribut för typen. När PyType_Ready() har initialiserat typen kan extra attribut för typen läggas till i denna ordbok endast om de inte motsvarar överbelastade operationer (som __add__()). När initialiseringen av typen har avslutats bör detta fält behandlas som skrivskyddat.

Vissa typer kanske inte lagrar sin ordbok i denna slot. Använd PyType_GetDict() för att hämta ordlistan för en godtycklig typ.

Ändrad i version 3.12: Intern detalj: För statiska inbyggda typer är detta alltid NULL. Istället lagras dict för sådana typer på PyInterpreterState. Använd PyType_GetDict() för att få fram dict för en godtycklig typ.

Arv:

Detta fält ärvs inte av subtyper (även om de attribut som definieras här ärvs genom en annan mekanism).

Standard:

Om detta fält är NULL kommer PyType_Ready() att tilldela det en ny ordbok.

Varning

Det är inte säkert att använda PyDict_SetItem() på eller på annat sätt modifiera tp_dict med dictionary C-API.

descrgetfunc PyTypeObject.tp_descr_get

En valfri pekare till en ”descriptor get”-funktion.

Funktionens signatur är:

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

Arv:

Detta fält ärvs av subtyperna.

descrsetfunc PyTypeObject.tp_descr_set

En valfri pekare till en funktion för att ställa in och ta bort en descriptors värde.

Funktionens signatur är:

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

Argumentet värde sätts till NULL för att ta bort värdet.

Arv:

Detta fält ärvs av subtyperna.

Py_ssize_t PyTypeObject.tp_dictoffset

Även om detta fält fortfarande stöds, bör Py_TPFLAGS_MANAGED_DICT användas istället, om det är möjligt.

Om instanserna av denna typ har en ordbok som innehåller instansvariabler, är detta fält icke-noll och innehåller offset i instanserna av typen av instansvariabelordboken; denna offset används av PyObject_GenericGetAttr().

Förväxla inte detta fält med tp_dict; det är ordlistan för attribut för själva typobjektet.

Värdet anger ordbokens förskjutning från början av instansstrukturen.

tp_dictoffset bör betraktas som skrivskyddad. För att få pekaren till ordlistan anropa PyObject_GenericGetDict(). Anrop av PyObject_GenericGetDict() kan behöva allokera minne för ordlistan, så det kan vara mer effektivt att anropa PyObject_GetAttr() när man vill komma åt ett attribut på objektet.

Det är ett fel att ange både Py_TPFLAGS_MANAGED_DICT bit och tp_dictoffset.

Arv:

Detta fält ärvs av subtyper. En subtyp bör inte åsidosätta denna offset; det kan vara osäkert om C-kod försöker komma åt ordboken vid den tidigare offset. För att korrekt stödja arv, använd Py_TPFLAGS_MANAGED_DICT.

Standard:

Denna slot har inget standardvärde. För statiska typer, om fältet är NULL skapas ingen __dict__ för instanser.

Om bitarna Py_TPFLAGS_MANAGED_DICT är inställda i fältet tp_flags, så kommer tp_dictoffset att sättas till -1, för att indikera att det är osäkert att använda detta fält.

initproc PyTypeObject.tp_init

En valfri pekare till en instansinitialiseringsfunktion.

Denna funktion motsvarar metoden __init__() för klasser. Precis som __init__() är det möjligt att skapa en instans utan att anropa __init__(), och det är möjligt att återinitialisera en instans genom att anropa dess __init__()-metod igen.

Funktionens signatur är:

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

Argumentet self är den instans som ska initialiseras; argumenten args och kwds representerar positions- och nyckelordsargument för anropet till __init__().

Funktionen tp_init, om den inte är NULL, anropas när en instans skapas normalt genom att anropa dess typ, efter att typens funktion tp_new har returnerat en instans av typen. Om funktionen tp_new returnerar en instans av någon annan typ som inte är en subtyp av den ursprungliga typen anropas ingen funktion tp_init; om tp_new returnerar en instans av en subtyp av den ursprungliga typen anropas subtypens funktion tp_init.

Returnerar 0 vid framgång, -1 och anger ett undantag vid fel.

Arv:

Detta fält ärvs av subtyperna.

Standard:

För static types har detta fält ingen standard.

allocfunc PyTypeObject.tp_alloc

En valfri pekare till en funktion för instansallokering.

Funktionens signatur är:

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

Arv:

Statiska subtyper ärver denna slot, som kommer att vara PyType_GenericAlloc() om den ärvs från object.

Heap subtyper ärver inte denna slot.

Standard:

För subtyper av heap är detta fält alltid inställt på PyType_GenericAlloc().

För statiska subtyper ärvs denna plats (se ovan).

newfunc PyTypeObject.tp_new

En valfri pekare till en funktion för att skapa en instans.

Funktionens signatur är:

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

Argumentet subtype är typen av det objekt som skapas; argumenten args och kwds representerar positions- och nyckelordsargument i anropet till typen. Observera att subtype inte behöver vara lika med den typ vars tp_new-funktion anropas; det kan vara en subtyp av den typen (men inte en orelaterad typ).

Funktionen tp_new bör anropa subtype->tp_alloc(subtype, nitems) för att allokera utrymme för objektet, och sedan bara göra så mycket ytterligare initialisering som är absolut nödvändigt. Initialisering som säkert kan ignoreras eller upprepas bör placeras i handlaren tp_init. En bra tumregel är att för oföränderliga typer bör all initialisering ske i tp_new, medan för föränderliga typer bör de flesta initialiseringar skjutas upp till tp_init.

Ange flaggan Py_TPFLAGS_DISALLOW_INSTANTIATION för att inte tillåta att instanser av typen skapas i Python.

Arv:

Detta fält ärvs av subtyper, förutom att det inte ärvs av static types vars tp_base är NULL eller &PyBaseObject_Type.

Standard:

För static types har detta fält ingen standard. Detta innebär att om slot definieras som NULL kan typen inte anropas för att skapa nya instanser; förmodligen finns det något annat sätt att skapa instanser, som en fabriksfunktion.

freefunc PyTypeObject.tp_free

En valfri pekare till en funktion för avallokering av instanser. Dess signatur är:

void tp_free(void *self);

Denna funktion måste frigöra det minne som allokerats av tp_alloc.

Arv:

Statiska subtyper ärver denna slot, som kommer att vara PyObject_Free() om den ärvs från object. Undantag för detta: Om typen stöder garbage collection (dvs. flaggan Py_TPFLAGS_HAVE_GC är inställd i tp_flags) och den skulle ärva PyObject_Free(), ärvs inte denna slot utan är istället standardvärdet för PyObject_GC_Del().

Heap subtyper ärver inte denna slot.

Standard:

För heap subtypes, är standardvärdet för denna plats en deallokator som är lämplig för att matcha PyType_GenericAlloc() och värdet på flaggan Py_TPFLAGS_HAVE_GC.

För statiska subtyper ärvs denna plats (se ovan).

inquiry PyTypeObject.tp_is_gc

En valfri pekare till en funktion som anropas av skräpsamlaren.

Skräpsamlaren behöver veta om ett visst objekt är insamlingsbart eller inte. Normalt räcker det att titta på objekttypens fält tp_flags och kontrollera flaggbiten Py_TPFLAGS_HAVE_GC. Men vissa typer har en blandning av statiskt och dynamiskt allokerade instanser, och de statiskt allokerade instanserna är inte insamlingsbara. Sådana typer bör definiera denna funktion; den bör returnera 1 för en samlingsbar instans och 0 för en icke-samlingsbar instans. Signaturen är:

int tp_is_gc(PyObject *self);

(Det enda exemplet på detta är typerna själva. Metatypen, PyType_Type, definierar den här funktionen för att skilja mellan statiskt och dynamiskt allokerade typer.)

Arv:

Detta fält ärvs av subtyperna.

Standard:

Denna slot har ingen standard. Om detta fält är NULL, används Py_TPFLAGS_HAVE_GC som funktionell motsvarighet.

PyObject *PyTypeObject.tp_bases

Tupel av bastyper.

Detta fält bör sättas till NULL och behandlas som skrivskyddat. Python kommer att fylla i det när typen är initialiserad.

För dynamiskt skapade klasser kan Py_tp_bases slot användas istället för bases-argumentet i PyType_FromSpecWithBases(). Argumentformen är att föredra.

Varning

Multipel nedärvning fungerar inte bra för statiskt definierade typer. Om du ställer in tp_bases till en tupel kommer Python inte att ge upphov till ett fel, men vissa slots kommer endast att ärvas från den första basen.

Arv:

Detta fält är inte ärftligt.

PyObject *PyTypeObject.tp_mro

Tupel som innehåller den utökade uppsättningen bastyper, som börjar med typen själv och slutar med object, i Method Resolution Order.

Detta fält bör sättas till NULL och behandlas som skrivskyddat. Python kommer att fylla i det när typen är initialiserad.

Arv:

Detta fält är inte ärftligt, utan beräknas av PyType_Ready().

PyObject *PyTypeObject.tp_cache

Oanvänd. Endast för internt bruk.

Arv:

Detta fält är inte ärftligt.

void *PyTypeObject.tp_subclasses

En samling av underklasser. Endast för internt bruk. Kan vara en ogiltig pekare.

För att få en lista över underklasser anropar du Python-metoden __subclasses__().

Ändrad i version 3.12: För vissa typer innehåller detta fält inte ett giltigt PyObject*. Typen ändrades till void* för att ange detta.

Arv:

Detta fält är inte ärftligt.

PyObject *PyTypeObject.tp_weaklist

Svag referenslistans huvud, för svaga referenser till detta typobjekt. Ärvs inte. Endast för internt bruk.

Ändrad i version 3.12: Intern detalj: För de statiska inbyggda typerna är detta alltid NULL, även om weakrefs läggs till. Istället lagras weakrefs för var och en på PyInterpreterState. Använd det publika C-API:et eller det interna makrot _PyObject_GET_WEAKREFS_LISTPTR() för att undvika skillnaden.

Arv:

Detta fält är inte ärftligt.

destructor PyTypeObject.tp_del

Detta fält är föråldrat. Använd tp_finalize istället.

unsigned int PyTypeObject.tp_version_tag

Används för att indexera till metodcachen. Endast för internt bruk.

Arv:

Detta fält är inte ärftligt.

destructor PyTypeObject.tp_finalize

En valfri pekare till en funktion för att avsluta en instans. Detta är C-implementeringen av specialmetoden __del__(). Dess signatur är:

void tp_finalize(PyObject *self);

Det primära syftet med finalization är att utföra alla icke-triviala rensningar som måste utföras innan objektet förstörs, medan objektet och alla andra objekt som det direkt eller indirekt refererar till fortfarande är i ett konsekvent tillstånd. Finalizern tillåts exekvera godtycklig Python-kod.

Innan Python automatiskt finaliserar ett objekt kan några av objektets direkta eller indirekta referenter själva ha finaliserats automatiskt. Ingen av referenterna kommer dock att ha blivit automatiskt rensade (tp_clear) ännu.

Andra icke-finaliserade objekt kan fortfarande använda ett finaliserat objekt, så finaliseraren måste lämna objektet i ett sunt tillstånd (t.ex. invarianter är fortfarande uppfyllda).

Anteckning

Efter att Python automatiskt har slutfört ett objekt kan Python automatiskt börja rensa (tp_clear) objektet och dess referenter (direkta och indirekta). Rensade objekt garanteras inte att vara i ett konsekvent tillstånd; ett färdigställt objekt måste kunna tolerera rensade referenter.

Anteckning

Det är inte garanterat att ett objekt automatiskt finaliseras innan dess destruktor (tp_dealloc) anropas. Det rekommenderas att anropa PyObject_CallFinalizerFromDealloc() i början av tp_dealloc för att garantera att objektet alltid slutförs innan det förstörs.

Anteckning

Funktionen tp_finalize kan anropas från valfri tråd, även om GIL kommer att hållas kvar.

Anteckning

Funktionen tp_finalize kan anropas under nedstängning, efter att vissa globala variabler har tagits bort. Se dokumentationen för metoden __del__() för detaljer.

När Python finaliserar ett objekt beter det sig som följande algoritm:

1. Python kan markera objektet som finalized. För närvarande markerar Python alltid objekt vars typ stöder garbage collection (dvs. flaggan Py_TPFLAGS_HAVE_GC är inställd i tp_flags) och markerar aldrig andra typer av objekt; detta kan ändras i en framtida version.

2. Om objektet inte är markerat som finalized och dess tp_finalize finalizer-funktion är icke-NULL, anropas finalizer-funktionen.

3. Om finalizer-funktionen anropades och finalizer gjorde objektet nåbart (dvs. det finns en referens till objektet och det är inte medlem i ett cyclic isolate), sägs finalizer ha återuppväckt objektet. Det är ospecificerat om finalizern också kan återuppliva objektet genom att lägga till en ny referens till objektet som inte gör det nåbart, dvs. objektet är (fortfarande) medlem i ett cykliskt isolat.

4. Om finalizer återuppväckte objektet avbryts objektets väntande förstörelse och objektets finalized-märke kan tas bort om det finns. För närvarande tar Python aldrig bort finalized-markeringen; detta kan ändras i en framtida version.

Automatisk finalisering avser all finalisering som utförs av Python utom via anrop till PyObject_CallFinalizer() eller PyObject_CallFinalizerFromDealloc(). Inga garantier ges för när, om eller hur ofta ett objekt automatiskt slutförs, förutom:

• Python kommer inte automatiskt att avsluta ett objekt om det är nåbart, dvs. det finns en referens till det och det är inte en medlem av en cyclic isolate.

• Python kommer inte automatiskt att slutföra ett objekt om det inte skulle markera objektet som slutfört. För närvarande gäller detta för objekt vars typ inte stöder garbage collection, dvs. flaggan Py_TPFLAGS_HAVE_GC är inte inställd. Sådana objekt kan fortfarande slutföras manuellt genom att anropa PyObject_CallFinalizer() eller PyObject_CallFinalizerFromDealloc().

• Python kommer inte automatiskt att slutföra två medlemmar av en cyclic isolate samtidigt.

• Python kommer inte automatiskt att slutföra ett objekt efter att det automatiskt har rensat (tp_clear) objektet.

• Om ett objekt är medlem i ett cyclic isolate, kommer Python inte automatiskt att slutföra det efter att automatiskt ha rensat (se tp_clear) någon annan medlem.

• Python kommer automatiskt att slutföra varje medlem i en cyclic isolate innan den automatiskt rensar (se tp_clear) någon av dem.

• Om Python automatiskt ska rensa ett objekt (tp_clear), kommer det automatiskt att slutföra objektet först.

Python slutför för närvarande endast automatiskt objekt som är medlemmar i en cyclic isolate, men framtida versioner kan komma att slutföra objekt regelbundet innan de förstörs.

Om du vill slutföra ett objekt manuellt ska du inte anropa den här funktionen direkt, utan anropa istället PyObject_CallFinalizer() eller PyObject_CallFinalizerFromDealloc().

tp_finalize bör lämna den aktuella undantagsstatusen oförändrad. Det rekommenderade sättet att skriva en icke-trivial finalizer är att säkerhetskopiera undantaget i början genom att anropa PyErr_GetRaisedException() och återställa undantaget i slutet genom att anropa PyErr_SetRaisedException(). Om ett undantag påträffas i mitten av finalizer, logga och rensa det med PyErr_WriteUnraisable() eller PyErr_FormatUnraisable(). Till exempel:

static void
foo_finalize(PyObject *self)
{
    // Save the current exception, if any.
    PyObject *exc = PyErr_GetRaisedException();

    // ...

    if (do_something_that_might_raise() != success_indicator) {
        PyErr_WriteUnraisable(self);
        goto done;
    }

done:
    // Restore the saved exception.  This silently discards any exception
    // raised above, so be sure to call PyErr_WriteUnraisable first if
    // necessary.
    PyErr_SetRaisedException(exc);
}

Arv:

Detta fält ärvs av subtyperna.

Tillagd i version 3.4.

Ändrad i version 3.8: Före version 3.8 var det nödvändigt att sätta flaggbiten Py_TPFLAGS_HAVE_FINALIZE för att detta fält skulle kunna användas. Detta är inte längre nödvändigt.

Se även

• PEP 442: ”Säkert objekt färdigställs”

• Objektets livscykel för detaljer om hur denna slot förhåller sig till andra slots.

• PyObject_CallFinalizer()

• PyObject_CallFinalizerFromDealloc()

vectorcallfunc PyTypeObject.tp_vectorcall

En vectorcall-funktion att använda för anrop av detta typobjekt (snarare än instanser). Med andra ord kan tp_vectorcall användas för att optimera type.__call__, som vanligtvis returnerar en ny instans av type.

Som med alla vectorcall-funktioner, om tp_vectorcall är NULL, används tp_call-protokollet (Py_TYPE(type)->tp_call) istället.

Anteckning

vectorcall-protokoll kräver att vectorcall-funktionen har samma beteende som motsvarande tp_call. Detta innebär att type->tp_vectorcall måste matcha beteendet hos Py_TYPE(type)->tp_call.

Specifikt, om type använder standardmetaklassen, måste type->tp_vectorcall bete sig på samma sätt som PyType_Type->tp_call, vilket:

• anropar type->tp_new,

• om resultatet är en subklass av type, anropar type->tp_init på resultatet av tp_new, och

• returnerar resultatet av tp_new.

Vanligtvis är tp_vectorcall åsidosatt för att optimera denna process för specifika tp_new och tp_init. När du gör detta för användarsubklassbara typer, notera att båda kan åsidosättas (med __new__() respektive __init__()).

Arv:

Detta fält är aldrig ärftligt.

Tillagd i version 3.9: (fältet har funnits sedan 3.8 men det används bara sedan 3.9)

unsigned char PyTypeObject.tp_watched

Internt. Får inte användas.

Tillagd i version 3.12.

Statiska typer

Traditionellt är typer som definieras i C-kod statiska, det vill säga en statisk PyTypeObject-struktur definieras direkt i koden och initieras med PyType_Ready().

Detta resulterar i typer som är begränsade i förhållande till de typer som definieras i Python:

• Statiska typer är begränsade till en bas, dvs. de kan inte använda multipel nedärvning.

• Statiska typobjekt (men inte nödvändigtvis deras instanser) är oföränderliga. Det är inte möjligt att lägga till eller ändra typobjektets attribut från Python.

• Statiska typobjekt delas mellan undertolkare, så de bör inte innehålla något undertolkarspecifikt tillstånd.

Eftersom PyTypeObject endast är en del av Limited API som en opak struktur, måste alla tilläggsmoduler som använder statiska typer kompileras för en specifik mindre Python-version.

Typer av högar

Ett alternativ till statiska typer är heap-allokerade typer, eller heap-typer förkortat, som motsvarar klasser skapade med Pythons class-sats. Heap-typer har flaggan Py_TPFLAGS_HEAPTYPE inställd.

Detta görs genom att fylla en PyType_Spec-struktur och anropa PyType_FromSpec(), PyType_FromSpecWithBases(), PyType_FromModuleAndSpec(), eller PyType_FromMetaclass().

Strukturer för nummerobjekt

type PyNumberMethods

Denna struktur innehåller pekare till de funktioner som ett objekt använder för att implementera nummerprotokollet. Varje funktion används av funktionen med liknande namn som dokumenteras i avsnittet Nummerprotokoll.

Här är strukturdefinitionen:

typedef struct {
     binaryfunc nb_add;
     binaryfunc nb_subtract;
     binaryfunc nb_multiply;
     binaryfunc nb_remainder;
     binaryfunc nb_divmod;
     ternaryfunc nb_power;
     unaryfunc nb_negative;
     unaryfunc nb_positive;
     unaryfunc nb_absolute;
     inquiry nb_bool;
     unaryfunc nb_invert;
     binaryfunc nb_lshift;
     binaryfunc nb_rshift;
     binaryfunc nb_and;
     binaryfunc nb_xor;
     binaryfunc nb_or;
     unaryfunc nb_int;
     void *nb_reserved;
     unaryfunc nb_float;

     binaryfunc nb_inplace_add;
     binaryfunc nb_inplace_subtract;
     binaryfunc nb_inplace_multiply;
     binaryfunc nb_inplace_remainder;
     ternaryfunc nb_inplace_power;
     binaryfunc nb_inplace_lshift;
     binaryfunc nb_inplace_rshift;
     binaryfunc nb_inplace_and;
     binaryfunc nb_inplace_xor;
     binaryfunc nb_inplace_or;

     binaryfunc nb_floor_divide;
     binaryfunc nb_true_divide;
     binaryfunc nb_inplace_floor_divide;
     binaryfunc nb_inplace_true_divide;

     unaryfunc nb_index;

     binaryfunc nb_matrix_multiply;
     binaryfunc nb_inplace_matrix_multiply;
} PyNumberMethods;

Anteckning

Binära och ternära funktioner måste kontrollera typen av alla sina operander och implementera nödvändiga konverteringar (minst en av operanderna är en instans av den definierade typen). Om operationen inte är definierad för de givna operanderna måste binära och ternära funktioner returnera Py_NotImplemented, om ett annat fel inträffade måste de returnera NULL och ange ett undantag.

Anteckning

Fältet nb_reserved bör alltid vara NULL. Det kallades tidigare nb_long, och döptes om i Python 3.0.1.

binaryfunc PyNumberMethods.nb_add

binaryfunc PyNumberMethods.nb_subtract

binaryfunc PyNumberMethods.nb_multiply

binaryfunc PyNumberMethods.nb_remainder

binaryfunc PyNumberMethods.nb_divmod

ternaryfunc PyNumberMethods.nb_power

unaryfunc PyNumberMethods.nb_negative

unaryfunc PyNumberMethods.nb_positive

unaryfunc PyNumberMethods.nb_absolute

inquiry PyNumberMethods.nb_bool

unaryfunc PyNumberMethods.nb_invert

binaryfunc PyNumberMethods.nb_lshift

binaryfunc PyNumberMethods.nb_rshift

binaryfunc PyNumberMethods.nb_and

binaryfunc PyNumberMethods.nb_xor

binaryfunc PyNumberMethods.nb_or

unaryfunc PyNumberMethods.nb_int

void *PyNumberMethods.nb_reserved

unaryfunc PyNumberMethods.nb_float

binaryfunc PyNumberMethods.nb_inplace_add

binaryfunc PyNumberMethods.nb_inplace_subtract

binaryfunc PyNumberMethods.nb_inplace_multiply

binaryfunc PyNumberMethods.nb_inplace_remainder

ternaryfunc PyNumberMethods.nb_inplace_power

binaryfunc PyNumberMethods.nb_inplace_lshift

binaryfunc PyNumberMethods.nb_inplace_rshift

binaryfunc PyNumberMethods.nb_inplace_and

binaryfunc PyNumberMethods.nb_inplace_xor

binaryfunc PyNumberMethods.nb_inplace_or

binaryfunc PyNumberMethods.nb_floor_divide

binaryfunc PyNumberMethods.nb_true_divide

binaryfunc PyNumberMethods.nb_inplace_floor_divide

binaryfunc PyNumberMethods.nb_inplace_true_divide

unaryfunc PyNumberMethods.nb_index

binaryfunc PyNumberMethods.nb_matrix_multiply

binaryfunc PyNumberMethods.nb_inplace_matrix_multiply

Mappning av objektstrukturer

type PyMappingMethods

Denna struktur innehåller pekare till de funktioner som ett objekt använder för att implementera mappningsprotokollet. Den har tre medlemmar:

lenfunc PyMappingMethods.mp_length

Denna funktion används av PyMapping_Size() och PyObject_Size(), och har samma signatur. Denna slot kan sättas till NULL om objektet inte har någon definierad längd.

binaryfunc PyMappingMethods.mp_subscript

Denna funktion används av PyObject_GetItem() och PySequence_GetSlice(), och har samma signatur som PyObject_GetItem(). Denna slot måste vara fylld för att funktionen PyMapping_Check() ska returnera 1, annars kan den vara NULL.

objobjargproc PyMappingMethods.mp_ass_subscript

Denna funktion används av PyObject_SetItem(), PyObject_DelItem(), PySequence_SetSlice() och PySequence_DelSlice(). Den har samma signatur som PyObject_SetItem(), men v kan också sättas till NULL för att radera ett objekt. Om denna slot är NULL har objektet inte stöd för tilldelning och borttagning av objekt.

Strukturer för sekvensobjekt

type PySequenceMethods

Denna struktur innehåller pekare till de funktioner som ett objekt använder för att implementera sekvensprotokollet.

lenfunc PySequenceMethods.sq_length

Denna funktion används av PySequence_Size() och PyObject_Size(), och har samma signatur. Den används också för att hantera negativa index via sq_item och sq_ass_item.

binaryfunc PySequenceMethods.sq_concat

Denna funktion används av PySequence_Concat() och har samma signatur. Den används också av operatorn +, efter att ha försökt numerisk addition via nb_add slot.

ssizeargfunc PySequenceMethods.sq_repeat

Denna funktion används av PySequence_Repeat() och har samma signatur. Den används också av operatorn *, efter att ha försökt numerisk multiplikation via nb_multiply slot.

ssizeargfunc PySequenceMethods.sq_item

Denna funktion används av PySequence_GetItem() och har samma signatur. Den används också av PyObject_GetItem(), efter att ha provat prenumerationen via mp_subscript slot. Denna slot måste vara fylld för att funktionen PySequence_Check() skall returnera 1, annars kan den vara NULL.

Negativa index hanteras på följande sätt: om sq_length är fylld, anropas den och sekvenslängden används för att beräkna ett positivt index som skickas till sq_item. Om sq_length är NULL, skickas indexet som det är till funktionen.

ssizeobjargproc PySequenceMethods.sq_ass_item

Denna funktion används av PySequence_SetItem() och har samma signatur. Den används också av PyObject_SetItem() och PyObject_DelItem(), efter att ha försökt tilldelning och borttagning av objekt via mp_ass_subscript slot. Denna slot kan lämnas till NULL om objektet inte stöder tilldelning och borttagning av objekt.

objobjproc PySequenceMethods.sq_contains

Denna funktion kan användas av PySequence_Contains() och har samma signatur. Denna plats kan lämnas till NULL, i detta fall kommer PySequence_Contains() helt enkelt att korsa sekvensen tills den hittar en matchning.

binaryfunc PySequenceMethods.sq_inplace_concat

Denna funktion används av PySequence_InPlaceConcat() och har samma signatur. Den bör modifiera sin första operand och returnera den. Denna plats kan lämnas till NULL, i detta fall kommer PySequence_InPlaceConcat() att falla tillbaka till PySequence_Concat(). Den används också av den utökade tilldelningen +=, efter att ha försökt numerisk in-place addition via nb_inplace_add slot.

ssizeargfunc PySequenceMethods.sq_inplace_repeat

Denna funktion används av PySequence_InPlaceRepeat() och har samma signatur. Den bör modifiera sin första operand och returnera den. Denna plats kan lämnas till NULL, i detta fall kommer PySequence_InPlaceRepeat() att falla tillbaka till PySequence_Repeat(). Den används också av den utökade tilldelningen *=, efter att ha försökt numerisk multiplikation på plats via nb_inplace_multiply slot.

Strukturer för buffertobjekt

type PyBufferProcs

Denna struktur innehåller pekare till de funktioner som krävs enligt Buffer protocol. Protokollet definierar hur ett exportobjekt kan exponera sina interna data till konsumentobjekt.

getbufferproc PyBufferProcs.bf_getbuffer

Signaturen för denna funktion är:

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

Hantera en begäran till exporter om att fylla i view enligt specifikationen i flags. Med undantag för punkt (3) MÅSTE en implementering av denna funktion vidta följande steg:

1. Kontrollera om begäran kan uppfyllas. Om inte, skapa BufferError, sätt view->obj till NULL och returnera -1.

2. Fyll i de begärda fälten.

3. Öka en intern räknare för antalet exporter.

4. Sätt view->obj till exporter och inkrementera view->obj.

5. Returnera 0.

Om exporter är en del av en kedja eller ett träd av buffertleverantörer kan två huvudsakliga system användas:

• Återexportera: Varje medlem i trädet fungerar som det exporterande objektet och sätter view->obj till en ny referens till sig själv.

• Redirect: Buffertbegäran omdirigeras till trädets rotobjekt. Här kommer view->obj att vara en ny referens till rotobjektet.

De enskilda fälten i view beskrivs i avsnitt Buffertstruktur, reglerna för hur en exportör måste reagera på specifika förfrågningar finns i avsnitt Buffertförfrågningstyper.

Allt minne som pekas ut i Py_buffer-strukturen tillhör exportören och måste förbli giltigt tills det inte finns några konsumenter kvar. format, shape, strides, suboffsets och internal är skrivskyddade för konsumenten.

PyBuffer_FillInfo() ger ett enkelt sätt att exponera en enkel bytesbuffert samtidigt som alla typer av förfrågningar hanteras korrekt.

PyObject_GetBuffer() är gränssnittet för den konsument som omsluter denna funktion.

releasebufferproc PyBufferProcs.bf_releasebuffer

Signaturen för denna funktion är:

void (PyObject *exporter, Py_buffer *view);

Hanterar en begäran om att frigöra buffertens resurser. Om inga resurser behöver frigöras kan PyBufferProcs.bf_releasebuffer vara NULL. Annars kommer en standardimplementering av denna funktion att vidta dessa valfria steg:

1. Minskar en intern räknare för antalet exporter.

2. Om räknaren är 0, frigör allt minne som är associerat med view.

Exportören MÅSTE använda fältet internal för att hålla reda på buffertspecifika resurser. Detta fält är garanterat konstant, medan en konsument KAN skicka en kopia av den ursprungliga bufferten som view-argument.

Denna funktion FÅR INTE decimera view->obj, eftersom det görs automatiskt i PyBuffer_Release() (detta system är användbart för att bryta referenscykler).

PyBuffer_Release() är gränssnittet för den konsument som omsluter denna funktion.

Strukturer för asynkrona objekt

Tillagd i version 3.5.

type PyAsyncMethods

Denna struktur innehåller pekare till de funktioner som krävs för att implementera objekten awaitable och asynchronous iterator.

Här är strukturdefinitionen:

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

unaryfunc PyAsyncMethods.am_await

Signaturen för denna funktion är:

PyObject *am_await(PyObject *self);

Det returnerade objektet måste vara en iterator, d.v.s. PyIter_Check() måste returnera 1 för det.

Denna slot kan sättas till NULL om ett objekt inte är en awaitable.

unaryfunc PyAsyncMethods.am_aiter

Signaturen för denna funktion är:

PyObject *am_aiter(PyObject *self);

Måste returnera ett asynkron iterator-objekt. Se __anext__() för detaljer.

Denna slot kan sättas till NULL om ett objekt inte implementerar asynkront iterationsprotokoll.

unaryfunc PyAsyncMethods.am_anext

Signaturen för denna funktion är:

PyObject *am_anext(PyObject *self);

Måste returnera ett awaitable-objekt. Se __anext__() för detaljer. Denna slot kan sättas till NULL.

sendfunc PyAsyncMethods.am_send

Signaturen för denna funktion är:

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

Se PyIter_Send() för detaljer. Denna slot kan sättas till NULL.

Tillagd i version 3.10.

Slotstyp typedef

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

En del av Stabil ABI.

Syftet med denna funktion är att separera minnesallokering från minnesinitialisering. Den ska returnera en pekare till ett minnesblock som är tillräckligt långt för instansen, lämpligt inriktat och initialiserat till nollor, men med ob_refcnt satt till 1 och ob_type satt till typargumentet. Om typens tp_itemsize inte är noll, ska objektets ob_size initialiseras till nitems och längden på det allokerade minnesblocket blir tp_basicsize + nitems*tp_itemsize, avrundat uppåt till en multipel av sizeof(void*); annars används inte nitems och längden på blocket blir tp_basicsize.

Denna funktion bör inte göra någon annan instansinitialisering, inte ens för att allokera ytterligare minne; det bör göras av tp_new.

typedef void (*destructor)(PyObject*)

En del av Stabil ABI.

typedef void (*freefunc)(void*)

Se tp_free.

typedef PyObject *(*newfunc)(PyTypeObject*, PyObject*, PyObject*)

En del av Stabil ABI.

Se tp_new.

typedef int (*initproc)(PyObject*, PyObject*, PyObject*)

En del av Stabil ABI.

Se tp_init.

typedef PyObject *(*reprfunc)(PyObject*)

En del av Stabil ABI.

Se tp_repr.

typedef PyObject *(*getattrfunc)(PyObject *self, char *attr)

En del av Stabil ABI.

Returnerar värdet på det namngivna attributet för objektet.

typedef int (*setattrfunc)(PyObject *self, char *attr, PyObject *value)

En del av Stabil ABI.

Ställ in värdet på det namngivna attributet för objektet. Argumentet value sätts till NULL för att ta bort attributet.

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

En del av Stabil ABI.

Returnerar värdet på det namngivna attributet för objektet.

Se tp_getattro.

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

En del av Stabil ABI.

Ställ in värdet på det namngivna attributet för objektet. Argumentet value sätts till NULL för att ta bort attributet.

Se tp_setattro.

typedef PyObject *(*descrgetfunc)(PyObject*, PyObject*, PyObject*)

En del av Stabil ABI.

Se tp_descr_get.

typedef int (*descrsetfunc)(PyObject*, PyObject*, PyObject*)

En del av Stabil ABI.

Se tp_descr_set.

typedef Py_hash_t (*hashfunc)(PyObject*)

En del av Stabil ABI.

Se tp_hash.

typedef PyObject *(*richcmpfunc)(PyObject*, PyObject*, int)

En del av Stabil ABI.

Se tp_richcompare.

typedef PyObject *(*getiterfunc)(PyObject*)

En del av Stabil ABI.

Se tp_iter.

typedef PyObject *(*iternextfunc)(PyObject*)

En del av Stabil ABI.

Se tp_iternext.

typedef Py_ssize_t (*lenfunc)(PyObject*)

En del av Stabil ABI.

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

En del av Stabil ABI sedan version 3.12.

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

En del av Stabil ABI sedan version 3.12.

typedef PyObject *(*unaryfunc)(PyObject*)

En del av Stabil ABI.

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

En del av Stabil ABI.

typedef PySendResult (*sendfunc)(PyObject*, PyObject*, PyObject**)

Se am_send.

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

En del av Stabil ABI.

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

En del av Stabil ABI.

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

En del av Stabil ABI.

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

En del av Stabil ABI.

typedef int (*objobjargproc)(PyObject*, PyObject*, PyObject*)

En del av Stabil ABI.

Exempel

Följande är enkla exempel på Python-typdefinitioner. De inkluderar vanlig användning som du kan stöta på. Några demonstrerar knepiga hörnfall. För fler exempel, praktisk information och en handledning, se Definiera typer av tillägg: Handledning och Definiera utökningstyper: Blandade ämnen.

En grundläggande statisk typ:

typedef struct {
    PyObject_HEAD
    const char *data;
} MyObject;

static PyTypeObject MyObject_Type = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "mymod.MyObject",
    .tp_basicsize = sizeof(MyObject),
    .tp_doc = PyDoc_STR("My objects"),
    .tp_new = myobj_new,
    .tp_dealloc = (destructor)myobj_dealloc,
    .tp_repr = (reprfunc)myobj_repr,
};

Du kan också hitta äldre kod (särskilt i CPython-kodbasen) med en mer utförlig initialiserare:

static PyTypeObject MyObject_Type = {
    PyVarObject_HEAD_INIT(NULL, 0)
    "mymod.MyObject",               /* tp_name */
    sizeof(MyObject),               /* tp_basicsize */
    0,                              /* tp_itemsize */
    (destructor)myobj_dealloc,      /* tp_dealloc */
    0,                              /* tp_vectorcall_offset */
    0,                              /* tp_getattr */
    0,                              /* tp_setattr */
    0,                              /* tp_as_async */
    (reprfunc)myobj_repr,           /* tp_repr */
    0,                              /* tp_as_number */
    0,                              /* tp_as_sequence */
    0,                              /* tp_as_mapping */
    0,                              /* tp_hash */
    0,                              /* tp_call */
    0,                              /* tp_str */
    0,                              /* tp_getattro */
    0,                              /* tp_setattro */
    0,                              /* tp_as_buffer */
    0,                              /* tp_flags */
    PyDoc_STR("My objects"),        /* tp_doc */
    0,                              /* tp_traverse */
    0,                              /* tp_clear */
    0,                              /* tp_richcompare */
    0,                              /* tp_weaklistoffset */
    0,                              /* tp_iter */
    0,                              /* tp_iternext */
    0,                              /* tp_methods */
    0,                              /* tp_members */
    0,                              /* tp_getset */
    0,                              /* tp_base */
    0,                              /* tp_dict */
    0,                              /* tp_descr_get */
    0,                              /* tp_descr_set */
    0,                              /* tp_dictoffset */
    0,                              /* tp_init */
    0,                              /* tp_alloc */
    myobj_new,                      /* tp_new */
};

En typ som stöder weakrefs, instance dicts och hashing:

typedef struct {
    PyObject_HEAD
    const char *data;
} MyObject;

static PyTypeObject MyObject_Type = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "mymod.MyObject",
    .tp_basicsize = sizeof(MyObject),
    .tp_doc = PyDoc_STR("My objects"),
    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
         Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_MANAGED_DICT |
         Py_TPFLAGS_MANAGED_WEAKREF,
    .tp_new = myobj_new,
    .tp_traverse = (traverseproc)myobj_traverse,
    .tp_clear = (inquiry)myobj_clear,
    .tp_alloc = PyType_GenericNew,
    .tp_dealloc = (destructor)myobj_dealloc,
    .tp_repr = (reprfunc)myobj_repr,
    .tp_hash = (hashfunc)myobj_hash,
    .tp_richcompare = PyBaseObject_Type.tp_richcompare,
};

En str-underklass som inte kan underklassas och inte kan anropas för att skapa instanser (t.ex. använder en separat fabriksfunktion) med Py_TPFLAGS_DISALLOW_INSTANTIATION flagga:

typedef struct {
    PyUnicodeObject raw;
    char *extra;
} MyStr;

static PyTypeObject MyStr_Type = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "mymod.MyStr",
    .tp_basicsize = sizeof(MyStr),
    .tp_base = NULL,  // ställ in till &PyUnicode_Type i modulen init
    .tp_doc = PyDoc_STR("my custom str"),
    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION,
    .tp_repr = (reprfunc)myobj_repr,
};

Den enklaste statiska typen med instanser av fast längd:

typedef struct {
    PyObject_HEAD
} MyObject;

static PyTypeObject MyObject_Type = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "mymod.MyObject",
};

Den enklaste statiska typen med instanser av variabel längd:

typedef struct {
    PyObject_VAR_HEAD
    const char *data[1];
} MyObject;

static PyTypeObject MyObject_Type = {
    PyVarObject_HEAD_INIT(NULL, 0)
    .tp_name = "mymod.MyObject",
    .tp_basicsize = sizeof(MyObject) - sizeof(char *),
    .tp_itemsize = sizeof(char *),
};