Saltearse al contenido

El ciclo de vida de un objeto

En C liberas la memoria que reservas. En Python la liberas dejando de apuntar: cuando el último nombre suelta un objeto, el objeto desaparece. Esa regla tan simple tiene una excepción —los ciclos— y una consecuencia que sorprende: del no borra objetos, borra nombres.

Un objeto vive mientras alguien lo apunte; del suelta una etiqueta, no destruye el objeto.

Cada objeto lleva ob_refcnt, que sube con cada nombre, cada hueco de lista, cada atributo y cada argumento de llamada.

Contador de un objeto según quién lo apunta
Acción Referencias
a = Punto(1, 2) 1
b = a 2
lista = [a] 3
del lista 2

python mediciones/05-01-04-memoria.py

Cuando llega a cero, CPython libera el objeto inmediatamente, en esa misma línea. No hay pausa ni recolección diferida: la memoria se devuelve al asignador.

a = Punto(1, 2)
b = a
del a # quita la etiqueta 'a'
b # el objeto sigue vivo

del a decrementa el contador y elimina el nombre del ámbito. El objeto sólo muere si era el último. Por eso del no sirve para «liberar memoria» en el sentido de C: sirve para dejar de referenciar.

Un objeto que se apunta a sí mismo, o dos que se apuntan entre sí, tienen contador mayor que cero aunque nadie externo los use. Ahí el contador no basta:

class Nodo:
def __init__(self):
self.otro = None
x, y = Nodo(), Nodo()
x.otro, y.otro = y, x
del x, y # nadie los apunta, pero se apuntan entre sí

El recolector de ciclos (gc) los detecta recorriendo los objetos contenedores y libera los que no son alcanzables desde fuera. Trabaja por generaciones: la 0 se revisa a menudo, las siguientes mucho menos.

Coste del recolector
Modo Crear 200 000 objetos
gc activado 34.08 ms
gc desactivado 32.83 ms

python mediciones/05-01-04-memoria.py

Un 4 % en este patrón. El coste del recolector no es constante: crece con el número de contenedores creados entre recolecciones, y en procesos que crean millones de listas y diccionarios puede llegar al 10–20 %. Desactivarlo (gc.disable()) sólo es razonable en procesos cortos que no crean ciclos, y hay que volver a activarlo.

Algunos objetos no se liberan jamás, y conviene saberlo antes de contar referencias:

import sys
sys.getrefcount(None) # 4294967295: centinela de inmortalidad
sys.getrefcount(True) # otro tanto
  • None, True, False son singletons del intérprete.
  • Los enteros de −5 a 256 están cacheados y se reutilizan.
  • Las cadenas literales del código se internan: la misma constante es un solo objeto.

Eso significa que del x sobre uno de ellos no libera nada, y que sys.getrefcount(x) devuelve números que no controlas. Para saber si tu objeto se libera, no cuentes referencias globales: usa una weakref y comprueba si sigue viva.

  • En scripts cortos, el sistema operativo recupera todo al terminar.
  • Si el proceso no crece en memoria en un perfil de horas, no hay fuga que buscar.
  • Antes de medir. gc.disable() como optimización sin un perfil que lo justifique es superstición.

Este código «libera» una lista de un millón de elementos, pero el proceso no baja de memoria. Explica por qué:

cache = {}
cache["datos"] = list(range(1_000_000))
cache.clear()
Solución

cache.clear() elimina las referencias, así que los objetos sí se liberan y el asignador los marca como disponibles. Pero CPython no devuelve esa memoria al sistema operativo en todos los casos: la guarda en sus propios pools para reutilizarla. El proceso mantiene el RSS alto aunque el montón esté libre.

Para ver la diferencia hay que mirar el objeto, no el proceso:

import tracemalloc
tracemalloc.start()
# ... crear y limpiar ...
print(tracemalloc.get_traced_memory())

Si el valor baja, la memoria está libre aunque el proceso no se vea más pequeño. gc.collect() y malloc_trim (en Linux) pueden devolver parte, pero no es algo que el código deba gestionar.

La lección: «el proceso no baja» y «hay una fuga» no son lo mismo. El capítulo siguiente trata las fugas reales.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 6: reciclaje de objetos.
  • CPython 3.13: Objects/object.c (Py_DECREF), Modules/gcmodule.c.
  • Mediciones: mediciones/05-01-04-memoria.py.
  • 03 · Nombres, no variables (Parte I): de dónde sale el contador.
  • 02 · Fugas de memoria reales: cuando el contador nunca llega a cero.
  • 03 · weakref: referencias que no cuentan.