Conteo de referencias
*********************

Los macros de esta sección se utilizan para administrar conteos de
referencia de objetos Python.

void Py_INCREF(PyObject *o)

   Incrementar el recuento de referencia para el objeto *o*.

   Esta función se usa generalmente para convertir un *borrowed
   reference* en un *strong reference* en su lugar. La función
   "Py_NewRef()" se puede utilizar para crear un nuevo *strong
   reference*.

   El objeto no debe ser "NULL"; si no está seguro de que no sea
   "NULL", use "Py_XINCREF()".

void Py_XINCREF(PyObject *o)

   Incrementa el conteo de referencia para el objeto *o*. El objeto
   puede ser "NULL", en cuyo caso el macro no tiene efecto.

   Ver también "Py_XNewRef()".

PyObject *Py_NewRef(PyObject *o)
    * Part of the Stable ABI since version 3.10.*

   Crea un nuevo *strong reference* a un objeto: incrementa el
   recuento de referencias del objeto *o* y retorna el objeto *o*.

   Cuando el *strong reference* ya no sea necesario "Py_DECREF()" debe
   ser llamado para disminuir el recuento de referencias del objeto.

   El objeto *o* no debe ser "NULL"; use "Py_XNewRef()" si *o* puede
   ser "NULL".

   Por ejemplo:

      Py_INCREF(obj);
      self->attr = obj;

   puede ser escrito como:

      self->attr = Py_NewRef(obj);

   Ver también "Py_INCREF()".

   Nuevo en la versión 3.10.

PyObject *Py_XNewRef(PyObject *o)
    * Part of the Stable ABI since version 3.10.*

   Similar a "Py_NewRef()", pero el objeto *o* puede ser NULL.

   Si el objeto *o* es "NULL", la función solo retorna "NULL".

   Nuevo en la versión 3.10.

void Py_DECREF(PyObject *o)

   Decrementa el conteo de referencia para el objeto *o*.

   Si el recuento de referencias llega a cero, se invoca la función de
   desasignación del tipo de objeto (que no debe ser "NULL").

   Esta función se usa generalmente para eliminar un *strong
   reference* antes de salir de su alcance.

   El objeto no debe ser "NULL"; si no está seguro de que no sea
   "NULL", use "Py_XINCREF()".

   Advertencia:

     La función de desasignación puede hacer que se invoque un código
     arbitrario de Python (por ejemplo, cuando se desasigna una
     instancia de clase con un método "__del__()"). Si bien las
     excepciones en dicho código no se propagan, el código ejecutado
     tiene acceso libre a todas las variables globales de Python. Esto
     significa que cualquier objeto al que se pueda acceder desde una
     variable global debe estar en un estado coherente antes de
     invocar "Py_DECREF()". Por ejemplo, el código para eliminar un
     objeto de una lista debe copiar una referencia al objeto
     eliminado en una variable temporal, actualizar la estructura de
     datos de la lista y luego llamar a "Py_DECREF()" para la variable
     temporal.

void Py_XDECREF(PyObject *o)

   Disminuye el conteo de referencia para el objeto *o*. El objeto
   puede ser "NULL", en cuyo caso el macro no tiene efecto; de lo
   contrario, el efecto es el mismo que para "Py_DECREF()", y se
   aplica la misma advertencia.

void Py_CLEAR(PyObject *o)

   Disminuye el conteo de referencia para el objeto *o*. El objeto
   puede ser "NULL", en cuyo caso el macro no tiene efecto; de lo
   contrario, el efecto es el mismo que para "Py_DECREF()", excepto
   que el argumento también se establece en "NULL". La advertencia
   para "Py_DECREF()" no se aplica con respecto al objeto pasado
   porque el macro usa cuidadosamente una variable temporal y
   establece el argumento en "NULL" antes de disminuir su conteo de
   referencia.

   Es una buena idea usar este macro siempre que disminuya el conteo
   de referencia de un objeto que pueda atravesarse durante la
   recolección de basura.

void Py_IncRef(PyObject *o)
    * Part of the Stable ABI.*

   Increment the reference count for object *o*. A function version of
   "Py_XINCREF()". It can be used for runtime dynamic embedding of
   Python.

void Py_DecRef(PyObject *o)
    * Part of the Stable ABI.*

   Decrement the reference count for object *o*. A function version of
   "Py_XDECREF()". It can be used for runtime dynamic embedding of
   Python.

Las siguientes funciones o macros son solo para uso dentro del núcleo
del intérprete: "_Py_Dealloc()", "_Py_ForgetReference()",
"_Py_NewReference()", así como la variable global "_Py_RefTotal".
