I'll answer the 1,2 question first, then 4th then 3rd: Show
They are the same, and yes they share a common API. When the documentation describes built in types as "objects", or class instances as "objects", or a class or whatever as an "object" ... they are talking about exactly the same language construct.
The object is a foundational language feature in Python that supports attributes and behaviors much like other OOPLs.
All Python objects also have a class much like other classed based OOPLs. The It's worth first pointing out explicitly that in Python (2.2 and above) "type" and "class"
mean the same thing (for all intents and purposes). So "int", and the rest of the so called builtin types are classes (which are represented as objects of course). For example this It's true to say there are two types of object in Python; "type" objects, or those that represent types, and
"non-type" objects - those that don't. But it's equally true to say there are two type of integers; zero, and not zero. It doesn't mean much: Everything in Python is an object including classes. Since classes form a kind object, they are all instances of a class called "type". The type object is also an instance of type. Note you can inspect the inheritance hierarchy of class by examining the _bases_ attribute of a class object. In all cases it leads back to the
Well, that's actually a good question. It should be covered in the Data Model section of the language reference, but it is sort of skimmed over. The constructor for object objects, object (that made sense) is a built in and documented with the rest of the builtins here. Also the Classes chapter of The Python Tutorial also covers this area a bit. Perhaps one of the most important structures of the Python object system is the structure that defines a new type: the Type objects are fairly large compared to most of the standard types. The reason for the size is that each type object stores a large number of values, mostly C function pointers, each of which implements a small part of the type’s functionality. The fields of the type object are examined in detail in this section. The fields will
be described in the order in which they occur in the structure. In addition to the following quick reference, the Examples section provides at-a-glance insight into the meaning and use of PyTypeObject Slot 1 Type special methods/attrs Info 2 O T D I <R> const char * __name__ X X X X X X X X X X X X ( __getattribute__, __getattr__ G ( __setattr__, __delattr__ G sub-slots % __repr__ X X X sub-slots % sub-slots % sub-slots % __hash__ X G __call__ X X __str__ X X __getattribute__, __getattr__ X X G __setattr__, __delattr__ X X G % unsigned long X X ? const char * __doc__ X X X G X G __lt__, __le__, __eq__, __ne__, __gt__, __ge__ X G X ? __iter__ X __next__ X X X X X X __base__ X __dict__ ? __get__ X __set__, __delete__ X X ? __init__ X X X X ? ? __new__ X X ? ? X X ? ? X X < __bases__ ~ < __mro__ ~ [ [ __subclasses__ [ ( [ unsigned int __del__ X A slot name in parentheses indicates it is (effectively) deprecated. Names in angle brackets should be treated as read-only. Names in square brackets are for internal use only. “<R>” (as a prefix) means the field is required (must be non- Columns: “O”: set on “T”: set on “D”: default (if slot is set to “I”: inheritance X - type slot is inherited via *PyType_Ready* if defined with a *NULL* value % - the slots of the sub-struct are inherited individually G - inherited, but only in combination with other slots; see the slot's description ? - it's complicated; see the slot's description Note that some slots are effectively inherited through the normal attribute lookup chain. sub-slots¶
slot typedefs¶
See Slot Type typedefs below for more detail. PyTypeObject Definition¶The structure definition for
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 */ struct PyMethodDef *tp_methods; struct PyMemberDef *tp_members; struct PyGetSetDef *tp_getset; // Strong reference on a heap type, borrowed reference on a static type struct _typeobject *tp_base; PyObject *tp_dict; descrgetfunc tp_descr_get; descrsetfunc tp_descr_set; Py_ssize_t tp_dictoffset; initproc tp_init; allocfunc tp_alloc; newfunc tp_new; freefunc tp_free; /* Low-level free-memory routine */ inquiry tp_is_gc; /* For PyObject_IS_GC */ PyObject *tp_bases; PyObject *tp_mro; /* method resolution order */ PyObject *tp_cache; PyObject *tp_subclasses; PyObject *tp_weaklist; destructor tp_del; /* Type attribute cache version tag. Added in version 2.6 */ unsigned int tp_version_tag; destructor tp_finalize; vectorcallfunc tp_vectorcall; } PyTypeObject; PyObject Slots¶The type object structure extends the
PyObject ob_refcnt ¶Part of the Stable ABI. This is the type object’s reference count, initialized to
Inheritance: This field is not inherited by subtypes. PyTypeObject *PyObject ob_type ¶Part of the Stable ABI. This is the type’s type, in other words its metatype. It is initialized by the argument to the Foo_Type.ob_type = &PyType_Type; This should be done before any instances of the type are created. Inheritance: This field is inherited by subtypes. PyObject *PyObject _ob_next ¶PyObject * PyObject _ob_prev ¶These fields are only present when the macro Their initialization to This could be used for various debugging purposes; currently the only uses are the Inheritance: These fields are not inherited by subtypes. PyVarObject Slots¶Py_ssize_tPyVarObject ob_size ¶Part of the Stable ABI. For statically allocated type objects, this should be initialized to zero. For dynamically allocated type objects, this field has a special internal meaning. Inheritance: This field is not inherited by subtypes. PyTypeObject Slots¶Each slot has a section describing inheritance. If PyTypeObject tp_name ¶Pointer to a NUL-terminated string containing
the name of the type. For types that are accessible as module globals, the string should be the full module name, followed by a dot, followed by the type name; for built-in types, it should be just the type name. If the module is a submodule of a package, the full package name is part of the full module name. For example, a type named For dynamically allocated type objects, this should just be the type name, and the module name explicitly stored in the type dict as the value for key For
statically allocated type objects, the tp_name field should contain a dot. Everything before the last dot is made accessible as the If no dot is present, the
entire This field must not be Inheritance: This field is not inherited by subtypes. Py_ssize_tPyTypeObject tp_basicsize ¶Py_ssize_t PyTypeObject tp_itemsize ¶These fields allow calculating the size in bytes of instances of the type. There are two kinds of types: types with fixed-length instances have a zero
For a type with variable-length instances, the instances must have an The basic size includes the fields in the instance declared by the macro A note about alignment: if the variable items
require a particular alignment, this should be taken care of by the value of For any type with variable-length instances, this field must not be Inheritance: These fields are inherited separately by subtypes. If the base type has a non-zero
PyTypeObject tp_dealloc ¶A pointer to the instance destructor function. This function must be defined unless the type guarantees that its instances will never be deallocated (as is the case for the singletons void tp_dealloc(PyObject *self); The destructor function is called by the If the type supports garbage collection (has the static void foo_dealloc(foo_object *self) { PyObject_GC_UnTrack(self); Py_CLEAR(self->ref); Py_TYPE(self)->tp_free((PyObject *)self); } Finally, if the type is heap allocated ( static void foo_dealloc(foo_object *self) { PyTypeObject *tp = Py_TYPE(self); // free references and buffers here tp->tp_free(self); Py_DECREF(tp); } Inheritance: This field is inherited by subtypes. Py_ssize_tPyTypeObject tp_vectorcall_offset ¶An optional offset to a per-instance function that implements calling the object using the
vectorcall protocol, a more efficient alternative of the simpler This field is only used if the flag The vectorcallfunc pointer may be Any class that sets Warning It is not recommended for heap types to implement the vectorcall protocol. When a user sets Changed in version
3.8: Before version 3.8, this slot was named Inheritance: This field is always inherited. However, the PyTypeObject tp_getattr ¶An optional pointer to the get-attribute-string function. This field is deprecated. When it is defined, it should point to a function that acts the same as the Inheritance: Group: This field is inherited by subtypes together with
PyTypeObject tp_setattr ¶An optional pointer to the function for setting and deleting attributes. This field is deprecated. When it is defined, it should point to a function that acts the same as the Inheritance: Group: This field is inherited by subtypes together with PyTypeObject tp_as_async ¶Pointer to an additional structure that contains fields relevant only to objects which implement awaitable and asynchronous iterator protocols at the C-level. See Async Object Structures for details. New in version 3.5: Formerly known as Inheritance: The PyTypeObject tp_repr ¶An optional pointer to a function that implements the built-in function
The signature is the same as for PyObject *tp_repr(PyObject *self); The function must return a string or a Unicode object. Ideally, this function should return a string that, when passed to
Inheritance: This field is inherited by subtypes. Default: When this field is not set, a string of
the form PyTypeObject tp_as_number ¶Pointer to an additional structure that contains fields relevant only to objects which implement the number protocol. These fields are documented in Number Object Structures. Inheritance: The PyTypeObject tp_as_sequence ¶Pointer to an additional structure that contains fields relevant only to objects which implement the sequence protocol. These fields are documented in Sequence Object Structures. Inheritance: The PyTypeObject tp_as_mapping ¶Pointer to an additional structure that contains fields relevant only to objects which implement the mapping protocol. These fields are documented in Mapping Object Structures. Inheritance: The PyTypeObject tp_hash ¶An optional pointer to a function that implements the built-in function The signature
is the same as for Py_hash_t tp_hash(PyObject *); The value When this field is not set (and This field can be set explicitly to Inheritance: Group:
This field is inherited by subtypes together with PyTypeObject tp_call ¶An optional pointer to a function that implements calling the object. This should be PyObject *tp_call(PyObject *self, PyObject *args, PyObject *kwargs); Inheritance: This field is inherited by subtypes. reprfuncPyTypeObject tp_str ¶An optional pointer to a function that implements the built-in operation The signature is the same as for PyObject *tp_str(PyObject *self); The function must return a string or a Unicode object. It should be a “friendly” string representation of the object, as this is the representation that will be used, among
other things, by the Inheritance: This field is inherited by subtypes. Default: When this field is not set, PyTypeObject tp_getattro ¶An optional pointer to the get-attribute function. The signature is the same as for
PyObject *tp_getattro(PyObject *self, PyObject *attr); It is usually convenient to set this field to Inheritance: Group: This field is
inherited by subtypes together with Default:
PyTypeObject tp_setattro ¶An optional pointer to the function for setting and deleting attributes. The signature is the same as for int tp_setattro(PyObject *self, PyObject *attr, PyObject *value); In addition, setting value to Inheritance: Group: This field is inherited by subtypes together with Default:
PyTypeObject tp_as_buffer ¶Pointer to an additional structure that contains fields relevant only to objects which implement the buffer interface. These fields are documented in Buffer Object Structures. Inheritance: The PyTypeObject tp_flags ¶This field is a bit mask of various flags. Some flags indicate variant semantics for certain situations; others are used to indicate that certain fields in the type object (or in the extension structures referenced via Inheritance: Inheritance of this field is complicated. Most flag bits are inherited individually, i.e. if the base type has a flag bit set, the subtype inherits this flag bit. The flag bits that pertain to extension structures are strictly inherited if the extension structure is inherited, i.e. the base type’s value of
the flag bit is copied into the subtype together with a pointer to the extension structure. The Default:
Bit Masks: The following bit masks are currently defined; these can be ORed together using the Py_TPFLAGS_HEAPTYPE ¶This bit is set when the type object itself is allocated on the heap, for example, types created dynamically using Inheritance: ??? Py_TPFLAGS_BASETYPE ¶This bit is set when the type can be used as the base type of another type. If this bit is clear, the type cannot be subtyped (similar to a “final” class in Java). Inheritance: ??? Py_TPFLAGS_READY ¶This bit is set when the type object has been fully initialized by
Inheritance: ??? Py_TPFLAGS_READYING ¶This bit is set while
Inheritance: ??? Py_TPFLAGS_HAVE_GC ¶This bit is set when the object supports garbage
collection. If this bit is set, instances must be created using Inheritance: Group:
The Py_TPFLAGS_DEFAULT ¶This is a bitmask
of all the bits that pertain to the existence of certain fields in the type object and its extension structures. Currently, it includes the following bits: Inheritance: ??? Py_TPFLAGS_METHOD_DESCRIPTOR ¶This bit indicates that objects behave like unbound methods. If
this flag is set for
This flag enables an optimization for typical method calls like New in version 3.8. Inheritance: This flag is never inherited by
heap types. For extension types, it is inherited whenever 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 ¶These flags are used by functions such as
Py_TPFLAGS_HAVE_FINALIZE ¶This bit is set when the
New in version 3.4. Deprecated since version 3.8: This flag isn’t necessary anymore, as the interpreter assumes the Py_TPFLAGS_HAVE_VECTORCALL ¶This bit is set when the class implements the vectorcall protocol. See
Inheritance: This bit is inherited for static subtypes if New in version 3.9. Py_TPFLAGS_IMMUTABLETYPE ¶This bit is set for type objects that are immutable: type attributes cannot be set nor deleted.
Inheritance: This flag is not inherited. New in version 3.10. Py_TPFLAGS_DISALLOW_INSTANTIATION ¶Disallow creating instances of the type: set The flag must be set before creating the
type, not after. For example, it must be set before The flag is set automatically on static types if Inheritance: This flag is not inherited. New in version 3.10. Py_TPFLAGS_MAPPING ¶
This bit indicates that instances of the class may match mapping patterns when used as the subject of a Inheritance: This flag is inherited by types that do not already set See also PEP 634 – Structural Pattern Matching: Specification New in version 3.10. Py_TPFLAGS_SEQUENCE ¶This bit indicates that instances of the class may match sequence patterns when used as the
subject of a Inheritance: This flag is inherited by types that do not already set See also PEP 634 – Structural Pattern Matching: Specification New in version 3.10. const char *PyTypeObject tp_doc ¶An optional pointer to a NUL-terminated
C string giving the docstring for this type object. This is exposed as the Inheritance: This field is not inherited by subtypes. traverseprocPyTypeObject tp_traverse ¶An optional pointer to a traversal function for the garbage collector. This is only used if the
int tp_traverse(PyObject *self, visitproc visit, void *arg); More information about Python’s garbage collection scheme can be found in section Supporting Cyclic Garbage Collection. The
static int local_traverse(localobject *self, visitproc visit, void *arg) { Py_VISIT(self->args); Py_VISIT(self->kw); Py_VISIT(self->dict); return 0; } Note that
On the other hand, even if you know a member can never be part of a cycle, as a debugging aid you may want to visit it anyway just so the
Warning When implementing Note that Instances of heap-allocated types hold a reference to their type. Their traversal function must therefore either visit Changed in version 3.9: Heap-allocated types are expected to visit Inheritance: Group:
This field is inherited by subtypes together with PyTypeObject tp_clear ¶An optional pointer to a clear function for the garbage collector. This is only used if the int tp_clear(PyObject *); The
Implementations of
static int local_clear(localobject *self) { Py_CLEAR(self->key); Py_CLEAR(self->args); Py_CLEAR(self->kw); Py_CLEAR(self->dict); return 0; } The Note that Because the goal of
More information about Python’s garbage collection scheme can be found in section Supporting Cyclic Garbage Collection. Inheritance: Group: This field is inherited by subtypes together with
PyTypeObject tp_richcompare ¶An optional pointer to the rich comparison function, whose signature is: PyObject *tp_richcompare(PyObject *self, PyObject *other, int op); The first parameter is guaranteed to be an instance of the type that
is defined by The function should return the result of the comparison (usually The following constants are defined to be used as the third argument for
The following macro is defined to ease writing rich comparison functions: Py_RETURN_RICHCOMPARE (VAL_A, VAL_B, op)¶Return The return value’s reference count is properly incremented. On error, sets an exception and returns New in version 3.7. Inheritance: Group: This field is inherited by subtypes together with Default:
PyTypeObject tp_weaklistoffset ¶If the instances of this type are weakly referenceable, this field is greater than zero and contains the offset in the instance structure of the weak reference
list head (ignoring the GC header, if present); this offset is used by Do not confuse this field with
Inheritance: This field is inherited by subtypes, but see the rules listed below. A subtype may override this offset; this means that the subtype uses a different weak reference list head than the base type. Since the list head is always found via
When a type defined by a class statement has no When a type’s When a type’s PyTypeObject tp_iter ¶An optional pointer to a function that returns an iterator for the object. Its presence normally signals that the instances of this type are iterable (although sequences may be iterable without this function). This function has the same signature as PyObject *tp_iter(PyObject *self); Inheritance: This field is inherited by subtypes. iternextfuncPyTypeObject tp_iternext ¶An optional pointer to a function that returns the next item in an iterator. The signature is: PyObject *tp_iternext(PyObject *self); When the iterator is exhausted, it must return Iterator
types should also define the This function has the same signature as Inheritance: This field is inherited by subtypes. struct PyMethodDef *PyTypeObject tp_methods ¶An optional pointer to a static For each entry in the array, an entry is added to the type’s dictionary (see Inheritance: This field is not inherited by subtypes (methods are inherited through a different mechanism). struct PyMemberDef *PyTypeObject tp_members ¶An optional pointer to a static For each entry in the array, an entry is added to the type’s dictionary (see Inheritance: This field is not inherited by subtypes (members are inherited through a different mechanism). struct PyGetSetDef *PyTypeObject tp_getset ¶An optional pointer to a
static For each entry in the array, an entry is added to the type’s dictionary (see Inheritance: This field is not inherited by subtypes (computed attributes are inherited through a different mechanism). PyTypeObject *PyTypeObject tp_base ¶An optional pointer to a base type from which type properties are inherited. At this level, only single inheritance is supported; multiple inheritance require dynamically creating a type object by calling the metatype. Note Slot initialization is subject to the rules of initializing globals. C99 requires the initializers to be “address constants”. Function designators like However, the unary ‘&’ operator applied to a non-static variable like Consequently, Inheritance: This field is not inherited by subtypes (obviously). Default: This field defaults to PyTypeObject tp_dict ¶The type’s dictionary is stored here by This field should normally be initialized to
Inheritance: This field is not inherited by subtypes (though the attributes defined in here are inherited through a different mechanism). Default: If this field is PyTypeObject tp_descr_get ¶An optional pointer to a “descriptor get” function. The function signature is: PyObject * tp_descr_get(PyObject *self, PyObject *obj, PyObject *type); Inheritance: This field is inherited by subtypes. descrsetfuncPyTypeObject tp_descr_set ¶An optional pointer to a function for setting and deleting a descriptor’s value. The function signature is: int tp_descr_set(PyObject *self, PyObject *obj, PyObject *value); The value argument is set to Inheritance: This field is inherited by subtypes. Py_ssize_tPyTypeObject tp_dictoffset ¶If the instances of this type have a dictionary
containing instance variables, this field is non-zero and contains the offset in the instances of the type of the instance variable dictionary; this offset is used by Do not confuse this field with If the value of this field is greater than zero, it specifies the offset from the start of the instance structure. If the value is less than zero, it specifies the offset from the end of the instance structure. A negative offset is more expensive to use, and should only be used when the instance structure contains a variable-length part. This is used for example to add an instance variable dictionary to subtypes of
The real dictionary offset in an instance can be computed from a negative
dictoffset = tp_basicsize + abs(ob_size)*tp_itemsize + tp_dictoffset if dictoffset is not aligned on sizeof(void*): round up to sizeof(void*) where Inheritance: This field is inherited by subtypes, but see the
rules listed below. A subtype may override this offset; this means that the subtype instances store the dictionary at a difference offset than the base type. Since the dictionary is always found via When a type defined by a class statement has no
When a type defined by a class statement has a
(Adding a slot named Default: This slot has no default. For static types, if the field is PyTypeObject tp_init ¶An optional pointer to an instance initialization function. This function corresponds to the The function signature is: int tp_init(PyObject *self, PyObject *args, PyObject *kwds); The self argument is the instance to be initialized; the args and kwds arguments represent positional and keyword arguments of the call to The Returns Inheritance: This field is inherited by subtypes. Default: For static types this field does not have a default. allocfuncPyTypeObject tp_alloc ¶An optional pointer to an instance allocation function. The function signature is: PyObject *tp_alloc(PyTypeObject *self, Py_ssize_t nitems); Inheritance: This field is inherited by static subtypes, but not by dynamic subtypes (subtypes created by a class statement). Default: For dynamic subtypes, this field is always set to For static subtypes, PyTypeObject tp_new ¶An optional pointer to an instance creation function. The function signature is: PyObject *tp_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds); The subtype argument is the type of the object being created; the args and kwds arguments represent positional and keyword arguments of the call to the type. Note that subtype doesn’t have to equal the type whose The Set the Inheritance: This field is inherited by subtypes, except it is not inherited by
static types whose Default: For static types this field has no default. This means if the slot is defined as
PyTypeObject tp_free ¶An optional pointer to an instance deallocation function. Its signature is: void tp_free(void *self); An initializer that is compatible with this signature is Inheritance: This field is inherited by static subtypes, but not by dynamic subtypes (subtypes created by a class statement) Default: In dynamic subtypes, this field is set to a
deallocator suitable to match For static subtypes, PyTypeObject tp_is_gc ¶An optional pointer to a function called by the garbage collector. The garbage collector needs to know whether a particular object is collectible or not. Normally, it is sufficient to look at the object’s
type’s int tp_is_gc(PyObject *self); (The only example of this are types themselves. The metatype, Inheritance: This field is inherited by subtypes. Default: This slot has no default. If this field is PyTypeObject tp_bases ¶Tuple of base types. This is set for types created by a class statement. It should be Inheritance: This field is not inherited. PyObject *PyTypeObject tp_mro ¶Tuple containing the expanded set of base types, starting with the type itself and ending with Inheritance: This field is not inherited; it is calculated fresh by PyTypeObject tp_cache ¶Unused. Internal use only. Inheritance: This field is not inherited. PyObject *PyTypeObject tp_subclasses ¶List of weak references to subclasses. Internal use only. Inheritance: This field is not inherited. PyObject *PyTypeObject tp_weaklist ¶Weak reference list head, for weak references to this type object. Not inherited. Internal use only. Inheritance: This field is not inherited. destructorPyTypeObject tp_del ¶This field is deprecated. Use PyTypeObject tp_version_tag ¶Used to index into the method cache. Internal use only. Inheritance: This field is not inherited. destructorPyTypeObject tp_finalize ¶An optional pointer to an instance finalization function. Its signature is: void tp_finalize(PyObject *self); If
static void local_finalize(PyObject *self) { PyObject *error_type, *error_value, *error_traceback; /* Save the current exception, if any. */ PyErr_Fetch(&error_type, &error_value, &error_traceback); /* ... */ /* Restore the saved exception. */ PyErr_Restore(error_type, error_value, error_traceback); } Also, note that, in a garbage collected Python, Inheritance: This field is inherited by subtypes. New in version 3.4. Changed in version 3.8: Before version 3.8 it was necessary to set the See also “Safe object finalization” (PEP 442) vectorcallfuncPyTypeObject tp_vectorcall ¶Vectorcall function to use for calls of this type object. In other words, it is used to implement vectorcall for Inheritance: This field is never inherited. New in version 3.9: (the field exists since 3.8 but it’s only used since 3.9) Static Types¶Traditionally, types defined in C code are static, that is, a static This results in types that are limited relative to types defined in Python:
Also, since Heap Types¶An alternative to static types is heap-allocated types, or heap types for short,
which correspond closely to classes created by Python’s This is done by filling a Number Object Structures¶typePyNumberMethods ¶This structure holds pointers to the functions which an object uses to implement the number protocol. Each function is used by the function of similar name documented in the Number Protocol section. Here is the structure definition: 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; Note Binary and ternary functions must check the type of all their operands, and implement the necessary conversions (at least one of the operands is an instance of the defined type). If the operation is not defined for the
given operands, binary and ternary functions must return Note The 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 ¶Mapping Object Structures¶typePyMappingMethods ¶This structure holds pointers to the functions which an object uses to implement the mapping protocol. It has three members: lenfuncPyMappingMethods mp_length ¶This function is used by PyMappingMethods mp_subscript ¶This function is used by PyMappingMethods mp_ass_subscript ¶This function is used by Sequence Object Structures¶typePySequenceMethods ¶This structure holds pointers to the functions which an object uses to implement the sequence protocol. lenfuncPySequenceMethods sq_length ¶This function is used by PySequenceMethods sq_concat ¶This function is used by
PySequenceMethods sq_repeat ¶This function is used by PySequenceMethods sq_item ¶This function is used by Negative indexes are handled as follows: if the PySequenceMethods sq_ass_item ¶This function is used by PySequenceMethods sq_contains ¶This function may be used by
PySequenceMethods sq_inplace_concat ¶This function is used by PySequenceMethods sq_inplace_repeat ¶This function is used by Buffer Object Structures¶typePyBufferProcs ¶This structure holds pointers to the functions required by the Buffer protocol. The protocol defines how an exporter object can expose its internal data to consumer objects. getbufferprocPyBufferProcs bf_getbuffer ¶The signature of this function is: int (PyObject *exporter, Py_buffer *view, int flags); Handle a request to exporter to fill in view as specified by flags. Except for point (3), an implementation of this function MUST take these steps:
If exporter is part of a chain or tree of buffer providers, two main schemes can be used:
The individual fields of view are described in section Buffer structure, the rules how an exporter must react to specific requests are in section Buffer request types. All memory pointed to in the
PyBufferProcs bf_releasebuffer ¶The signature of this function is: void (PyObject *exporter, Py_buffer *view); Handle a request to release the resources of the buffer. If no resources need to be released,
The exporter MUST use the
This function MUST NOT decrement
Async Object Structures¶New in version 3.5. typePyAsyncMethods ¶This structure holds pointers to the functions required to implement awaitable and asynchronous iterator objects. Here is the structure definition: typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; sendfunc am_send; } PyAsyncMethods;unaryfunc PyAsyncMethods am_await ¶The signature of this function is: PyObject *am_await(PyObject *self); The returned object must be an
iterator, i.e. This slot may be set to PyAsyncMethods am_aiter ¶The signature of this function is: PyObject *am_aiter(PyObject *self); Must return an asynchronous iterator
object. See This slot may be set to PyAsyncMethods am_anext ¶The signature of this function is: PyObject *am_anext(PyObject *self); Must return an awaitable object. See PyAsyncMethods am_send ¶The signature of this function is: PySendResult am_send(PyObject *self, PyObject *arg, PyObject **result); See
New in version 3.10. Slot Type typedefs¶typedef PyObject *(*allocfunc )(PyTypeObject *cls, Py_ssize_t
nitems)¶Part of the Stable ABI. The purpose of this function is to separate memory allocation from memory initialization. It should return a pointer to a block of memory of adequate length for the instance, suitably aligned, and initialized to
zeros, but with This function should not do any other instance initialization, not even to allocate additional memory; that should be done by destructor )(PyObject*)¶Part of the Stable ABI. typedef void (* freefunc )(void*)¶See newfunc )(PyObject*, PyObject*,
PyObject*)¶Part of the Stable ABI. See
initproc )(PyObject*, PyObject*,
PyObject*)¶Part of the Stable ABI. See
reprfunc )(PyObject*)¶Part of the Stable ABI. See
getattrfunc )(PyObject *self, char
*attr)¶Part of the Stable ABI. Return the value of the named attribute for the object. typedef int (*setattrfunc )(PyObject *self, char *attr, PyObject *value)¶Part of the Stable ABI. Set the value of the named attribute for the object. The value argument is set to getattrofunc )(PyObject *self, PyObject *attr)¶Part of the Stable ABI. Return the value of the named attribute for the object. See setattrofunc )(PyObject *self, PyObject *attr, PyObject
*value)¶Part of the Stable ABI. Set the value of the named attribute for the object. The value argument is set to See
descrgetfunc )(PyObject*,
PyObject*, PyObject*)¶Part of the Stable ABI. See descrsetfunc )(PyObject*, PyObject*, PyObject*)¶Part of the Stable ABI. See hashfunc )(PyObject*)¶Part of the Stable ABI. See richcmpfunc )(PyObject*, PyObject*, int)¶Part of the Stable ABI. See getiterfunc )(PyObject*)¶Part of the Stable ABI. See
iternextfunc )(PyObject*)¶Part of the Stable ABI. See
lenfunc )(PyObject*)¶Part of the Stable ABI. typedef int (* getbufferproc )(PyObject*, Py_buffer*, int)¶typedef void (* releasebufferproc )(PyObject*, Py_buffer*)¶typedef PyObject *(* unaryfunc )(PyObject*)¶Part of the Stable ABI. typedef PyObject *(* binaryfunc )(PyObject*,
PyObject*)¶Part of the Stable ABI. typedef PySendResult (* sendfunc )(PyObject*, PyObject*,
PyObject**)¶See ternaryfunc )(PyObject*, PyObject*,
PyObject*)¶Part of the Stable ABI. typedef PyObject *(* ssizeargfunc )(PyObject*,
Py_ssize_t)¶Part of the Stable ABI. typedef int (* ssizeobjargproc )(PyObject*, Py_ssize_t)¶Part of the Stable ABI. typedef int (* objobjproc )(PyObject*,
PyObject*)¶Part of the Stable ABI. typedef int (* objobjargproc )(PyObject*, PyObject*, PyObject*)¶Part of the Stable ABI. Examples¶The following are simple examples of Python type definitions. They include common usage you may encounter. Some demonstrate tricky corner cases. For more examples, practical info, and a tutorial, see Defining Extension Types: Tutorial and Defining Extension Types: Assorted Topics. A basic static type: 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, }; You may also find older code (especially in the CPython code base) with a more verbose initializer: 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 */ }; A type that supports weakrefs, instance dicts, and hashing: typedef struct { PyObject_HEAD const char *data; PyObject *inst_dict; PyObject *weakreflist; } MyObject; static PyTypeObject MyObject_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "mymod.MyObject", .tp_basicsize = sizeof(MyObject), .tp_doc = PyDoc_STR("My objects"), .tp_weaklistoffset = offsetof(MyObject, weakreflist), .tp_dictoffset = offsetof(MyObject, inst_dict), .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, .tp_new = myobj_new, .tp_traverse = (traverseproc)myobj_traverse, .tp_clear = (inquiry)myobj_clear, .tp_alloc = PyType_GenericNew, .tp_dealloc = (destructor)myobj_dealloc, .tp_repr = (reprfunc)myobj_repr, .tp_hash = (hashfunc)myobj_hash, .tp_richcompare = PyBaseObject_Type.tp_richcompare, }; A str subclass that cannot be subclassed and cannot be called to create instances (e.g. uses a separate factory func) using typedef struct { PyUnicodeObject raw; char *extra; } MyStr; static PyTypeObject MyStr_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "mymod.MyStr", .tp_basicsize = sizeof(MyStr), .tp_base = NULL, // set to &PyUnicode_Type in module init .tp_doc = PyDoc_STR("my custom str"), .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION, .tp_repr = (reprfunc)myobj_repr, }; The simplest static type with fixed-length instances: typedef struct { PyObject_HEAD } MyObject; static PyTypeObject MyObject_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "mymod.MyObject", }; The simplest static type with variable-length instances: 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 *), }; What is object type?An object type is a user-defined composite datatype that encapsulates a data structure along with the functions and procedures needed to manipulate the data. The variables that form the data structure are called attributes.
What is an object in Python?An Object is an instance of a Class. A class is like a blueprint while an instance is a copy of the class with actual values. Python is object-oriented programming language that stresses on objects i.e. it mainly emphasizes functions.
What is type () in Python give an example?Answer. Python type() is a built-in function that is used to return the type of data stored in the objects or variables in the program. For example, if a variable contains a value of 45.5 then the type of that variable is float.
What does type () mean in Python?Python type()
The type() function either returns the type of the object or returns a new type object based on the arguments passed.
|