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.
En una línea
Sección titulada «En una línea»Un objeto vive mientras alguien lo apunte; del suelta una etiqueta, no destruye el objeto.
El contador de referencias
Sección titulada «El contador de referencias»Cada objeto lleva ob_refcnt, que sube con cada nombre, cada hueco de lista, cada atributo y cada argumento de llamada.
| 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.
del no borra
Sección titulada «del no borra»a = Punto(1, 2)b = adel a # quita la etiqueta 'a'b # el objeto sigue vivodel 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.
Los ciclos, y por qué existe el recolector
Sección titulada «Los ciclos, y por qué existe el recolector»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, xdel 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.
| 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.
Los objetos que nunca mueren
Sección titulada «Los objetos que nunca mueren»Algunos objetos no se liberan jamás, y conviene saberlo antes de contar referencias:
import syssys.getrefcount(None) # 4294967295: centinela de inmortalidadsys.getrefcount(True) # otro tantoNone,True,Falseson 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.
La trampa
Sección titulada «La trampa»Cuándo NO pensar en esto
Sección titulada «Cuándo NO pensar en esto»- 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.
Ejercicio
Sección titulada «Ejercicio»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 tracemalloctracemalloc.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.
Referencias
Sección titulada «Referencias»- 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.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 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.