# `gc` — Garbage Collector interface

Este módulo proporciona una interfaz para el recolector de basura opcional (recolector de basura cíclico generacional). Proporciona la capacidad de deshabilitar el recolector, ajustar la frecuencia de recolección y establecer opciones de depuración. También proporciona acceso a objetos inaccesibles (unreachables) que el recolector encontró pero no pudo liberar. Dado que el recolector de basura complementa el conteo de referencias, que ya se utiliza en Python, es posible desactivarlo siempre que se esté seguro de que el programa no crea referencias cíclicas. La recolección automática se puede desactivar llamando a `gc.disable()`. Para depurar un programa con fugas de memoria, se debe llamar a `gc.set_debug(gc.DEBUG_LEAK)`. Se debe tener en cuenta que la llamada anterior incluye `gc.DEBUG_SAVEALL`, lo que hace que los objetos recolectados se guarden en gc.garbage para su inspección.

El módulo `gc` proporciona las siguientes funciones:

gc.enable()

  Habilita la recolección automática de basura.

gc.disable()

  Deshabilita la recolección automática de basura.

gc.isenabled()

  Retorna `True` si la recolección automática está habilitada.

gc.collect(generation=2)

  Sin argumentos, ejecuta una recolección completa. El argumento opcional generation debe ser un número entero que especifica qué generación recolectar (de 0 a 2). Una excepción `ValueError` será lanzada si el número de generación no es válido. Se retorna el número de objetos inaccesibles encontrados.

  Las listas libres mantenidas para varios tipos incorporados son borradas cada vez que se ejecuta una recolección completa o una recolección de la generación más alta (2). No obstante, no todos los elementos de algunas listas libres pueden ser liberados, particularmente `float`, debido a su implementación particular.

  El efecto de llamar a `gc.collect()` mientras el intérprete ya está realizando una recolección es indefinido.

gc.set_debug(flags)

  Establece las flags de depuración para la recolección de basura. La información de depuración se escribirá en `sys.stderr`. A continuación se puede consultar una lista con las flags de depuración disponibles, que se pueden combinar mediante operaciones de bits para controlar la depuración.

gc.get_debug()

  Retorna las flags de depuración actualmente establecidas.

gc.get_objects(generation=None)

  Returns a list of all objects tracked by the collector, excluding the list returned. If generation is not `None`, return only the objects tracked by the collector that are in that generation.

  Distinto en la versión 3.8: Se agregó el parámetro generation.

  Raises an auditing event `gc.get_objects` with argument `generation`.

gc.get_stats()

  Retorna una lista de tres diccionarios, uno por cada generación, que contienen estadísticas de recolección desde el inicio del intérprete. El número de claves puede cambiar en el futuro, pero actualmente cada diccionario contendrá los siguientes elementos:

  - `collections` es el número de veces que se recolectó esta generación;

  - `collected` es el número total de objetos recolectados dentro de esta generación;

  - `uncollectable` es el número total de objetos que se consideraron no recolectables (y por lo tanto, se movieron a la lista `garbage`) dentro de esta generación.

  Added in version 3.4.

gc.set_threshold(threshold0[, threshold1[, threshold2]])

  Establece los umbrales de recolección (la frecuencia de recolección). Si se establece threshold0 en cero se deshabilita la recolección.

  El recolector de basura (GC por sus siglas en inglés) clasifica los objetos en tres generaciones dependiendo de cuántos barridos de colección hayan sobrevivido. Los nuevos objetos se colocan en la generación más joven (generación `0`). Si un objeto sobrevive a una colección, se traslada a la siguiente generación anterior. Dado que la generación `2` es la generación más antigua, los objetos de esa generación permanecen allí después de una colección. Para decidir cuándo ejecutar, el recopilador realiza un seguimiento del número de asignaciones y desasignaciones de objetos desde la última recopilación. Cuando el número de asignaciones menos el número de desasignaciones supera el treshold0, comienza la recopilación. Inicialmente solo se examina la generación `0`. Si la generación `0` se ha examinado más de treshold1 veces desde que se examinó la generación `1`, también se examina la generación `1`. Con la tercera generación, las cosas son un poco más complicadas, consulte Recopilación de la generación más antigua para obtener más información.

gc.get_count()

  Retorna los recuentos de la recolección actual como una tupla de la forma `(count0, count1, count2)`.

gc.get_threshold()

  Retorna los umbrales de la recolección actual como una tupla de la forma `(threshold0, threshold1, threshold2)`.

gc.get_referrers(*objs)

  Retorna la lista de objetos que referencian de forma directa a cualquiera de objs. Esta función solo localizará aquellos contenedores que admitan la recolección de basura; no se localizarán los tipos de extensión que referencian a otros objetos pero que no admiten la recolección de basura.

  Téngase en cuenta que los objetos que ya se han desreferenciado, pero que tienen referencias cíclicas y aún no han sido recolectados por el recolector de basura pueden enumerarse entre las referencias resultantes. Para obtener solo los objetos activos actualmente, llame a `collect()` antes de llamar a `get_referrers()`.

  Advertencia

  Se debe tener un especial cuidado cuando se usan objetos retornados por `get_referrers()` dado que algunos de ellos aún podrían estar en construcción y por tanto en un estado temporalmente inválido. Debe evitarse el uso de `get_referrers()` para cualquier propósito que no sea la depuración.

  Raises an auditing event `gc.get_referrers` with argument `objs`.

gc.get_referents(*objs)

  Retorna una lista de objetos a los que hace referencia directamente cualquiera de los argumentos. Las referencias retornadas son aquellos objetos visitados por los métodos `tp_traverse` a nivel de C de los argumentos (si los hay) y es posible que no todos los objetos sean directamente accesibles realmente. Los métodos `tp_traverse` solo son compatibles con los objetos que admiten recolección de basura y solo se requieren para visitar objetos que pueden estar involucrados en un ciclo de referencias. Lo que quiere decir que, por ejemplo, si se puede acceder directamente a un número entero desde uno de los argumento, ese objeto entero puede aparecer o no en la lista de resultados.

  Raises an auditing event `gc.get_referents` with argument `objs`.

gc.is_tracked(obj)

  Retorna `True` si el recolector de basura rastrea actualmente el objeto y `False` en caso contrario. Como regla general, las instancias de tipos atómicos no se rastrean y las instancias de tipos no atómicos (contenedores, objetos definidos por el usuario …) sí. Sin embargo, algunas optimizaciones específicas de tipo pueden estar presentes para suprimir el impacto del recolector de basura en instancias simples (por ejemplo, diccionarios que contienen solo claves y valores atómicos):

      >>> gc.is_tracked(0)
      False
      >>> gc.is_tracked("a")
      False
      >>> gc.is_tracked([])
      True
      >>> gc.is_tracked({})
      False
      >>> gc.is_tracked({"a": 1})
      False
      >>> gc.is_tracked({"a": []})
      True

  Added in version 3.1.

gc.is_finalized(obj)

  Retorna `True` si el objeto dado ha sido finalizado por el recolector de basura, `False` en caso contrario.

      >>> x = None
      >>> class Lazarus:
      ...     def __del__(self):
      ...         global x
      ...         x = self
      ...
      >>> lazarus = Lazarus()
      >>> gc.is_finalized(lazarus)
      False
      >>> del lazarus
      >>> gc.is_finalized(x)
      True

  Added in version 3.9.

gc.freeze()

  Congela todos los objetos rastreados por el recolector de basura; los mueve a una generación permanente y los ignora en todas las recolecciones futuras.

  Si un proceso va a llamar a `fork()` sin llamar a `exec()`, evitar la copia en escritura innecesaria en procesos secundarios maximizará el intercambio de memoria y reducirá el uso general de la memoria. Esto requiere tanto evitar la creación de «agujeros» liberados en las páginas de memoria del proceso principal y garantizar que las colecciones de GC en los procesos secundarios no tocarán el contador `gc_refs` de objetos de larga duración que se originan en el proceso principal. Para lograr ambas cosas, llame a `gc.disable()` al principio del proceso principal, a `gc.freeze()` justo antes de `fork()` y a `gc.enable()` al principio. en procesos secundarios.

  Added in version 3.7.

gc.unfreeze()

  Descongela los objetos de la generación permanente y vuelve a colocarlos en la generación más antigua.

  Added in version 3.7.

gc.get_freeze_count()

  Retorna el número de objetos de la generación permanente.

  Added in version 3.7.

Las siguientes variables se proporcionan para acceso de solo lectura (se pueden mutar los valores pero no se deben vincular de nuevo):

gc.garbage

  Una lista de objetos que el recolector consideró inaccesibles pero que no pudieron ser liberados (objetos que no se pueden recolectar). A partir de Python 3.4, esta lista debe estar vacía la mayor parte del tiempo, excepto cuando se utilizan instancias de tipos de extensión C en los que la ranura (slot) `tp_del` no sea `NULL`.

  Si se establece `DEBUG_SAVEALL`, todos los objetos inaccesibles se agregarán a esta lista en lugar de ser liberados.

  Distinto en la versión 3.2: Si la lista no está vacía en el momento del interpreter shutdown, se emite un `ResourceWarning`, que es silencioso de forma predeterminada. Si se establece `DEBUG_UNCOLLECTABLE`, además se imprimen todos los objetos no recolectables.

  Distinto en la versión 3.4: Siguiendo con PEP 442, los objetos con un método `__del__()` ya no terminan en `gc.garbage`.

gc.callbacks

  Una lista de retrollamadas que el recolector de basura invocará antes y después de la recolección. Las retrollamadas serán llamadas con dos argumentos, phase e info.

  phase puede tomar uno de estos valores:

  > «start»: la recolección de basura está a punto de comenzar.

  > «stop»: la recolección de basura ha terminado.

  info es un diccionario que proporciona información adicional para la retrollamada. Las siguientes claves están definidas actualmente:

  > «generation»: la generación más antigua que ha sido recolectada.

  > «collected»: cuando phase es «stop», el número de objetos recolectados satisfactoriamente.

  > «uncollectable»: cuando phase es «stop», el número de objetos que no pudieron ser recolectados y fueron ubicados en `garbage`.

  Las aplicaciones pueden agregar sus propias retrollamadas a esta lista. Los principales casos de uso son:

  > Recopilar estadísticas sobre la recolección de basura, como la frecuencia con la que se recolectan varias generaciones y cuánto tiempo lleva la recolección.

  > Permitir que las aplicaciones identifiquen y borren sus propios tipos no recolectables cuando aparecen en `garbage`.

  Added in version 3.3.

Las siguientes constantes son proporcionadas para ser usadas con `set_debug()`:

gc.DEBUG_STATS

  Imprime estadísticas durante la recolección. Esta información puede resultar útil para ajustar la frecuencia de recolección.

gc.DEBUG_COLLECTABLE

  Imprime información sobre los objetos recolectables encontrados.

gc.DEBUG_UNCOLLECTABLE

  Imprime información sobre los objetos no recolectables encontrados (objetos inaccesibles, pero que el recolector no puede liberar). Estos objetos se agregarán a la lista `garbage`.

  Distinto en la versión 3.2: También imprime el contenido de la lista `garbage` durante interpreter shutdown, si no está vacía.

gc.DEBUG_SAVEALL

  Cuando se establece, todos los objetos inaccesibles encontrados se agregarán a garbage en lugar de ser liberados. Esto puede resultar útil para depurar un programa con fugas de memoria.

gc.DEBUG_LEAK

  Las flags de depuración necesarias para que el recolector imprima información sobre un programa con fugas de memoria (igual a `DEBUG_COLLECTABLE | DEBUG_UNCOLLECTABLE | DEBUG_SAVEALL`).