*Py_GetConstant(unsignedintconstant_id)
Part of the
since version 3.13.Get a
to a constant.
Set an exception and return NULL if constant_id is invalid.
constant_id must be one of these constant identifiers:
Constant Identifier
Value
Returned object
Py_CONSTANT_NONE
0
Py_CONSTANT_FALSE
1
Py_CONSTANT_TRUE
2
Py_CONSTANT_ELLIPSIS
3
Py_CONSTANT_NOT_IMPLEMENTED
4
Py_CONSTANT_ZERO
5
0
Py_CONSTANT_ONE
6
1
Py_CONSTANT_EMPTY_STR
7
''
Py_CONSTANT_EMPTY_BYTES
8
b''
Py_CONSTANT_EMPTY_TUPLE
9
()
Numeric values are only given for projects which cannot use the constant identifiers.
Added in version 3.13.
CPython implementation detail: In CPython, all of these constants are
.
*Py_GetConstantBorrowed(unsignedintconstant_id)
Part of the
since version 3.13.Similar to
, but return a
.
This function is primarily intended for backwards compatibility: using
is recommended for new code.
The reference is borrowed from the interpreter, and is valid until the interpreter finalization.
Added in version 3.13.
*Py_NotImplemented
The NotImplemented singleton, used to signal that an operation is not implemented for the given type combination.
Py_RETURN_NOTIMPLEMENTED
Properly handle returning
from within a C function (that is, create a new
to
and return it).
Py_PRINT_RAW
Flag to be used with multiple functions that print the object (like
and
). If passed, these functions use the
of the object instead of the
.
intPyObject_Print(
*o, FILE*fp, intflags)
Print an object o, on file fp. Returns -1 on error. The flags argument is used to enable certain printing options. The only option currently supported is
; if given, the
of the object is written instead of the
.
intPyObject_HasAttrWithError(
*o,
*attr_name)
Part of the
since version 3.13.Returns 1 if o has the attribute attr_name, and 0 otherwise. This is equivalent to the Python expression hasattr(o,attr_name). On failure, return -1.
Added in version 3.13.
intPyObject_HasAttrStringWithError(
*o, constchar*attr_name)
Part of the
since version 3.13.This is the same as
, but attr_name is specified as a constchar* UTF-8 encoded bytes string, rather than a
*.
Added in version 3.13.
intPyObject_HasAttr(
*o,
*attr_name)
Part of the
.Returns 1 if o has the attribute attr_name, and 0 otherwise. This function always succeeds.
intPyObject_HasAttrString(
*o, constchar*attr_name)
Part of the
.This is the same as
, but attr_name is specified as a constchar* UTF-8 encoded bytes string, rather than a
*.
*PyObject_GetAttr(
*o,
*attr_name)
Return value: New reference. Part of the
.Retrieve an attribute named attr_name from object o. Returns the attribute value on success, or NULL on failure. This is the equivalent of the Python expression o.attr_name.
If the missing attribute should not be treated as a failure, you can use
instead.
*PyObject_GetAttrString(
*o, constchar*attr_name)
Return value: New reference. Part of the
.This is the same as
, but attr_name is specified as a constchar* UTF-8 encoded bytes string, rather than a
*.
If the missing attribute should not be treated as a failure, you can use
PyObject_GetOptionalAttrString()
instead.
intPyObject_GetOptionalAttr(
*obj,
*attr_name,
**result);
Part of the
since version 3.13.Variant of
which doesn’t raise
if the attribute is not found.
If the attribute is found, return 1 and set *result to a new
to the attribute. If the attribute is not found, return 0 and set *result to NULL; the
is silenced. If an error other than AttributeError is raised, return -1 and set *result to NULL.
Added in version 3.13.
intPyObject_GetOptionalAttrString(
*obj, constchar*attr_name,
**result);
Part of the
since version 3.13.This is the same as
, but attr_name is specified as a constchar* UTF-8 encoded bytes string, rather than a
*.
Added in version 3.13.
*PyObject_GenericGetAttr(
*o,
*name)
Return value: New reference. Part of the
.Generic attribute getter function that is meant to be put into a type object’s tp_getattro slot. It looks for a descriptor in the dictionary of classes in the object’s MRO as well as an attribute in the object’s
(if present). As outlined in
, data descriptors take preference over instance attributes, while non-data descriptors don’t. Otherwise, an
is raised.
intPyObject_SetAttr(
*o,
*attr_name,
*v)
Part of the
.Set the value of the attribute named attr_name, for object o, to the value v. Raise an exception and return -1 on failure; return 0 on success. This is the equivalent of the Python statement o.attr_name=v.
If v is NULL, the attribute is deleted. This behaviour is deprecated in favour of using
, but there are currently no plans to remove it.
intPyObject_SetAttrString(
*o, constchar*attr_name,
*v)
Part of the
.This is the same as
, but attr_name is specified as a constchar* UTF-8 encoded bytes string, rather than a
*.
If v is NULL, the attribute is deleted, but this feature is deprecated in favour of using
.
The number of different attribute names passed to this function should be kept small, usually by using a statically allocated string as attr_name. For attribute names that aren’t known at compile time, prefer calling
and
directly. For more details, see
, which may be used internally to create a key object.
intPyObject_GenericSetAttr(
*o,
*name,
*value)
Part of the
.Generic attribute setter and deleter function that is meant to be put into a type object’s
slot. It looks for a data descriptor in the dictionary of classes in the object’s MRO, and if found it takes preference over setting or deleting the attribute in the instance dictionary. Otherwise, the attribute is set or deleted in the object’s
(if present). On success, 0 is returned, otherwise an
is raised and -1 is returned.
intPyObject_DelAttr(
*o,
*attr_name)
Part of the
since version 3.13.Delete attribute named attr_name, for object o. Returns -1 on failure. This is the equivalent of the Python statement delo.attr_name.
intPyObject_DelAttrString(
*o, constchar*attr_name)
Part of the
since version 3.13.This is the same as
, but attr_name is specified as a constchar* UTF-8 encoded bytes string, rather than a
*.
The number of different attribute names passed to this function should be kept small, usually by using a statically allocated string as attr_name. For attribute names that aren’t known at compile time, prefer calling
and
directly. For more details, see
, which may be used internally to create a key object for lookup.
*PyObject_GenericGetDict(
*o, void*context)
Return value: New reference. Part of the
since version 3.10.A generic implementation for the getter of a __dict__ descriptor. It creates the dictionary if necessary.
This function may also be called to get the
of the object o. Pass NULL for context when calling it. Since this function may need to allocate memory for the dictionary, it may be more efficient to call
when accessing an attribute on the object.
On failure, returns NULL with an exception set.
Added in version 3.3.
intPyObject_GenericSetDict(
*o,
*value, void*context)
Part of the
since version 3.7.A generic implementation for the setter of a __dict__ descriptor. This implementation does not allow the dictionary to be deleted.
Added in version 3.3.
**_PyObject_GetDictPtr(
*obj)
Return a pointer to
of the object obj. If there is no __dict__, return NULL without setting an exception.
This function may need to allocate memory for the dictionary, so it may be more efficient to call
when accessing an attribute on the object.
*PyObject_RichCompare(
*o1,
*o2, intopid)
Return value: New reference. Part of the
.Compare the values of o1 and o2 using the operation specified by opid, which must be one of
,
,
,
,
, or
, corresponding to <, <=, ==, !=, >, or >= respectively. This is the equivalent of the Python expression o1opo2, where op is the operator corresponding to opid. Returns the value of the comparison on success, or NULL on failure.
intPyObject_RichCompareBool(
*o1,
*o2, intopid)
Part of the
.Compare the values of o1 and o2 using the operation specified by opid, like
, but returns -1 on error, 0 if the result is false, 1 otherwise.
Note
If o1 and o2 are the same object,
will always return 1 for
and 0 for
.
*PyObject_Format(
*obj,
*format_spec)
Part of the
.Format obj using format_spec. This is equivalent to the Python expression format(obj,format_spec).
format_spec may be NULL. In this case the call is equivalent to format(obj). Returns the formatted string on success, NULL on failure.
*PyObject_Repr(
*o)
Return value: New reference. Part of the
.Compute a string representation of object o. Returns the string representation on success, NULL on failure. This is the equivalent of the Python expression repr(o). Called by the
built-in function.
If argument is NULL, return the string '<NULL>'.
Changed in version 3.4: This function now includes a debug assertion to help ensure that it does not silently discard an active exception.
*PyObject_ASCII(
*o)
Return value: New reference. Part of the
.As
, compute a string representation of object o, but escape the non-ASCII characters in the string returned by PyObject_Repr() with \x, \u or \U escapes. This generates a string similar to that returned by PyObject_Repr() in Python 2. Called by the
built-in function.
If argument is NULL, return the string '<NULL>'.
*PyObject_Str(
*o)
Return value: New reference. Part of the
.Compute a string representation of object o. Returns the string representation on success, NULL on failure. This is the equivalent of the Python expression str(o). Called by the
built-in function and, therefore, by the
function.
If argument is NULL, return the string '<NULL>'.
Changed in version 3.4: This function now includes a debug assertion to help ensure that it does not silently discard an active exception.
*PyObject_Bytes(
*o)
Return value: New reference. Part of the
.Compute a bytes representation of object o. NULL is returned on failure and a bytes object on success. This is equivalent to the Python expression bytes(o), when o is not an integer. Unlike bytes(o), a TypeError is raised when o is an integer instead of a zero-initialized bytes object.
If argument is NULL, return the
object b'<NULL>'.
intPyObject_IsSubclass(
*derived,
*cls)
Part of the
.Return 1 if the class derived is identical to or derived from the class cls, otherwise return 0. In case of an error, return -1.
If cls is a tuple, the check will be done against every entry in cls. The result will be 1 when at least one of the checks returns 1, otherwise it will be 0.
If cls has a
method, it will be called to determine the subclass status as described in
. Otherwise, derived is a subclass of cls if it is a direct or indirect subclass, i.e. contained in
.
Normally only class objects, i.e. instances of
or a derived class, are considered classes. However, objects can override this by having a
attribute (which must be a tuple of base classes).
intPyObject_IsInstance(
*inst,
*cls)
Part of the
.Return 1 if inst is an instance of the class cls or a subclass of cls, or 0 if not. On error, returns -1 and sets an exception.
If cls is a tuple, the check will be done against every entry in cls. The result will be 1 when at least one of the checks returns 1, otherwise it will be 0.
If cls has a
method, it will be called to determine the subclass status as described in
. Otherwise, inst is an instance of cls if its class is a subclass of cls.
An instance inst can override what is considered its class by having a
attribute.
An object cls can override if it is considered a class, and what its base classes are, by having a
attribute (which must be a tuple of base classes).
PyObject_Hash(
*o)
Part of the
.Compute and return the hash value of an object o. On failure, return -1. This is the equivalent of the Python expression hash(o).
Changed in version 3.2: The return type is now Py_hash_t. This is a signed integer the same size as
.
PyObject_HashNotImplemented(
*o)
Part of the
.Set a
indicating that type(o) is not
and return -1. This function receives special treatment when stored in a tp_hash slot, allowing a type to explicitly indicate to the interpreter that it is not hashable.
intPyObject_IsTrue(
*o)
Part of the
.Returns 1 if the object o is considered to be true, and 0 otherwise. This is equivalent to the Python expression notnoto. On failure, return -1.
intPyObject_Not(
*o)
Part of the
.Returns 0 if the object o is considered to be true, and 1 otherwise. This is equivalent to the Python expression noto. On failure, return -1.
*PyObject_Type(
*o)
Return value: New reference. Part of the
.When o is non-NULL, returns a type object corresponding to the object type of object o. On failure, raises
and returns NULL. This is equivalent to the Python expression type(o). This function creates a new
to the return value. There’s really no reason to use this function instead of the
function, which returns a pointer of type
*, except when a new strong reference is needed.
intPyObject_TypeCheck(
*o,
*type)
Return non-zero if the object o is of type type or a subtype of type, and 0 otherwise. Both parameters must be non-NULL.
PyObject_Size(
*o)
PyObject_Length(
*o)
Part of the
.Return the length of object o. If the object o provides either the sequence and mapping protocols, the sequence length is returned. On error, -1 is returned. This is the equivalent to the Python expression len(o).
PyObject_LengthHint(
*o,
defaultvalue)
Return an estimated length for the object o. First try to return its actual length, then an estimate using
, and finally return the default value. On error return -1. This is the equivalent to the Python expression operator.length_hint(o,defaultvalue).
Added in version 3.4.
*PyObject_GetItem(
*o,
*key)
Return value: New reference. Part of the
.Return element of o corresponding to the object key or NULL on failure. This is the equivalent of the Python expression o[key].
intPyObject_SetItem(
*o,
*key,
*v)
Part of the
.Map the object key to the value v. Raise an exception and return -1 on failure; return 0 on success. This is the equivalent of the Python statement o[key]=v. This function does not steal a reference to v.
intPyObject_DelItem(
*o,
*key)
Part of the
.Remove the mapping for the object key from the object o. Return -1 on failure. This is equivalent to the Python statement delo[key].
intPyObject_DelItemString(
*o, constchar*key)
Part of the
.This is the same as
, but key is specified as a constchar* UTF-8 encoded bytes string, rather than a
*.
*PyObject_Dir(
*o)
Return value: New reference. Part of the
.This is equivalent to the Python expression dir(o), returning a (possibly empty) list of strings appropriate for the object argument, or NULL if there was an error. If the argument is NULL, this is like the Python dir(), returning the names of the current locals; in this case, if no execution frame is active then NULL is returned but
will return false.
*PyObject_GetIter(
*o)
Return value: New reference. Part of the
.This is equivalent to the Python expression iter(o). It returns a new iterator for the object argument, or the object itself if the object is already an iterator. Raises
and returns NULL if the object cannot be iterated.
*PyObject_SelfIter(
*obj)
Return value: New reference. Part of the
.This is equivalent to the Python __iter__(self):returnself method. It is intended for
types, to be used in the
slot.
*PyObject_GetAIter(
*o)
Return value: New reference. Part of the
since version 3.10.This is the equivalent to the Python expression aiter(o). Takes an AsyncIterable object and returns an AsyncIterator for it. This is typically a new iterator but if the argument is an AsyncIterator, this returns itself. Raises
and returns NULL if the object cannot be iterated.
Added in version 3.10.
void*PyObject_GetTypeData(
*o,
*cls)
Part of the
since version 3.12.Get a pointer to subclass-specific data reserved for cls.
The object o must be an instance of cls, and cls must have been created using negative
. Python does not check this.
On error, set an exception and return NULL.
Added in version 3.12.
PyType_GetTypeDataSize(
*cls)
Part of the
since version 3.12.Return the size of the instance memory space reserved for cls, i.e. the size of the memory
returns.
This may be larger than requested using
; it is safe to use this larger size (e.g. with memset()).
The type clsmust have been created using negative
. Python does not check this.
On error, set an exception and return a negative value.
Added in version 3.12.
void*PyObject_GetItemData(
*o)
Get a pointer to per-item data for a class with
.
On error, set an exception and return NULL.
is raised if o does not have
set.
Added in version 3.12.
intPyObject_VisitManagedDict(
*obj,
visit, void*arg)
Visit the managed dictionary of obj.
This function must only be called in a traverse function of the type which has the
flag set.
Added in version 3.13.
voidPyObject_ClearManagedDict(
*obj)
Clear the managed dictionary of obj.
This function must only be called in a clear function of the type which has the
flag set.
Added in version 3.13.
intPyUnstable_Object_EnableDeferredRefcount(
*obj)
This is
. It may change without warning in minor releases.
Enable
on obj, if supported by the runtime. In the
build, this allows the interpreter to avoid reference count adjustments to obj, which may improve multi-threaded performance. The tradeoff is that obj will only be deallocated by the tracing garbage collector, and not when the interpreter no longer has any references to it.
This function returns 1 if deferred reference counting is enabled on obj, and 0 if deferred reference counting is not supported or if the hint was ignored by the interpreter, such as when deferred reference counting is already enabled on obj. This function is thread-safe, and cannot fail.
This function does nothing on builds with the
enabled, which do not support deferred reference counting. This also does nothing if obj is not an object tracked by the garbage collector (see
and
).
This function is intended to be used soon after obj is created, by the code that creates it, such as in the object’s
slot.
Added in version 3.14.
intPyUnstable_Object_IsUniqueReferencedTemporary(
*obj)
This is
. It may change without warning in minor releases.
Check if obj is a unique temporary object. Returns 1 if obj is known to be a unique temporary object, and 0 otherwise. This function cannot fail, but the check is conservative, and may return 0 in some cases even if obj is a unique temporary object.
If an object is a unique temporary, it is guaranteed that the current code has the only reference to the object. For arguments to C functions, this should be used instead of checking if the reference count is 1. Starting with Python 3.14, the interpreter internally avoids some reference count modifications when loading objects onto the operands stack by
references when possible, which means that a reference count of 1 by itself does not guarantee that a function argument uniquely referenced.
In the example below, my_func is called with a unique temporary object as its argument:
my_func([1,2,3])In the example below, my_func is not called with a unique temporary object as its argument, even if its refcount is 1:
my_list=[1,2,3]my_func(my_list)See also the function
.
Added in version 3.14.
intPyUnstable_IsImmortal(
*obj)
This is
. It may change without warning in minor releases.
This function returns non-zero if obj is
, and zero otherwise. This function cannot fail.
Note
Objects that are immortal in one CPython version are not guaranteed to be immortal in another.
Added in version 3.14.
intPyUnstable_TryIncRef(
*obj)
This is
. It may change without warning in minor releases.
Increments the reference count of obj if it is not zero. Returns 1 if the object’s reference count was successfully incremented. Otherwise, this function returns 0.
must have been called earlier on obj or this function may spuriously return 0 in the
.
This function is logically equivalent to the following C code, except that it behaves atomically in the
:
if(Py_REFCNT(op)>0){Py_INCREF(op);return1;}return0;This is intended as a building block for managing weak references without the overhead of a Python
.
Typically, correct use of this function requires support from obj’s deallocator (
). For example, the following sketch could be adapted to implement a “weakmap” that works like a
for a specific type:
PyMutexmutex;PyObject*add_entry(weakmap_key_type*key,PyObject*value){PyUnstable_EnableTryIncRef(value);weakmap_typeweakmap=...;PyMutex_Lock(&mutex);weakmap_add_entry(weakmap,key,value);PyMutex_Unlock(&mutex);Py_RETURN_NONE;}PyObject*get_value(weakmap_key_type*key){weakmap_typeweakmap=...;PyMutex_Lock(&mutex);PyObject*result=weakmap_find(weakmap,key);if(PyUnstable_TryIncRef(result)){// `result` is safe to usePyMutex_Unlock(&mutex);returnresult;}// if we get here, `result` is starting to be garbage-collected,// but has not been removed from the weakmap yetPyMutex_Unlock(&mutex);returnNULL;}// tp_dealloc function for weakmap valuesvoidvalue_dealloc(PyObject*value){weakmap_typeweakmap=...;PyMutex_Lock(&mutex);weakmap_remove_value(weakmap,value);...PyMutex_Unlock(&mutex);}Added in version 3.14.
voidPyUnstable_EnableTryIncRef(
*obj)
This is
. It may change without warning in minor releases.
Enables subsequent uses of
on obj. The caller must hold a
to obj when calling this.
Added in version 3.14.
intPyUnstable_Object_IsUniquelyReferenced(
*op)
This is
. It may change without warning in minor releases.
Determine if op only has one reference.
On GIL-enabled builds, this function is equivalent to
(
)==1.
On a
, this checks if op’s
is equal to one and additionally checks if op is only used by this thread.
(
)==1 is not thread-safe on free-threaded builds; prefer this function.
The caller must hold an
, despite the fact that this function doesn’t call into the Python interpreter. This function cannot fail.
Added in version 3.14.