Fugas de memoria reales
Un programa en C pierde memoria cuando olvida un free. En Python no se puede olvidar: el contador la libera sola. Lo que sí se puede es seguir apuntando a objetos que ya no sirven, y entonces el contador nunca llega a cero. Eso no es una fuga del lenguaje; es una decisión de diseño que nadie revisó.
En una línea
Sección titulada «En una línea»No hay memoria perdida: hay referencias vivas que ya no necesitas.
Las cuatro causas
Sección titulada «Las cuatro causas»1. Caché sin límite.
cache = {}def caro(x): if x not in cache: cache[x] = calcular(x) return cache[x]Crece con cada entrada distinta y mantiene vivos los resultados. En un proceso de semanas, es la fuga más común. Arreglo: lru_cache(maxsize=...) o WeakValueDictionary.
2. Registro global de objetos.
SUSCRIPTORES = []def suscribir(fn): SUSCRIPTORES.append(fn) # nunca se quitaCada suscribir añade una referencia permanente, y la lista no distingue entre suscriptores vivos y muertos. Arreglo: WeakSet, o un desuscribir explícito.
3. Clausuras que capturan de más.
def crear_manejador(config): def manejar(evento): return config["tema"] # retiene todo el dict return manejarEl manejador se queda con la configuración entera porque la usa en una línea. Arreglo: extraer el valor antes de crear la clausura (Parte III, capítulo 02).
4. Excepciones que guardan el traceback.
try: ...except Exception as e: ERRORES.append(e) # e guarda el traceback → guarda los marcos → guarda todoUna excepción almacenada mantiene vivos los objetos locales de la función donde se lanzó, porque el traceback referencia los marcos. Arreglo: guardar str(e) o e.args, no la excepción.
Cómo encontrar la tuya
Sección titulada «Cómo encontrar la tuya»tracemalloc compara dos momentos y te dice qué líneas crecieron:
import tracemalloc
tracemalloc.start()hacer_trabajo() # fase 1snap1 = tracemalloc.take_snapshot()
hacer_trabajo() # fase 2: debería ser idénticasnap2 = tracemalloc.take_snapshot()
for stat in snap2.compare_to(snap1, "lineno")[:5]: print(stat)Se ejecutan las dos fases en el mismo proceso (o se compara el snapshot de arranque con el de después de N peticiones) y se mira qué línea creció. Si la fase 2 añade memoria que la fase 1 no, esa línea es la fuga. Es la técnica más directa que existe en la biblioteca estándar.
| Modo | Crear 50 000 objetos |
|---|---|
Sin tracemalloc |
7.53 ms |
Con tracemalloc |
49.99 ms |
python mediciones/05-01-04-memoria.py
Seis veces más lento. Por eso se mide en un proceso aparte o con la instrumentación activada sólo durante la fase sospechosa: nunca en producción continua.
Contar objetos por tipo, que es más rápido
Sección titulada «Contar objetos por tipo, que es más rápido»Antes de tracemalloc hay un diagnóstico de treinta segundos: contar cuántos objetos de cada tipo hay vivos.
import gcfrom collections import Counter
conteo = Counter(type(o).__name__ for o in gc.get_objects())conteo.most_common(5)Si Sesion aparece 40 000 veces cuando debería haber 200, ya sabes dónde mirar sin abrir un snapshot. gc.get_objects() devuelve sólo los objetos que el recolector rastrea (listas, dicts, instancias), no los enteros ni las cadenas, y eso es exactamente lo que interesa.
La limitación: dice qué se acumula, no quién lo retiene. Para eso, el snapshot comparado.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- Si el proceso es corto. Un script que dura segundos no necesita gestión fina.
- Si el crecimiento está acotado. Una caché que crece hasta 10 000 entradas y se estabiliza no es una fuga: es un límite que hay que documentar.
- Sin una medición que lo demuestre. «Consume mucha memoria» no es un diagnóstico; un snapshot comparado sí.
Ejercicio
Sección titulada «Ejercicio»Un servicio web aumenta 40 MB al día y se reinicia cada semana. Describe el procedimiento para localizar la causa en una hora, sin acceso a un profiler comercial.
Solución
- Confirmar que es una fuga y no caché legítima. Comparar
tracemallocal arrancar y tras N peticiones. Si crece linealmente con las peticiones y no se estabiliza, es fuga. - Aislar el tipo de objeto.
gc.get_objects()filtrado por tipo, otracemallocagrupado porlineno, señala la línea que asigna. - Reproducir en local con el mismo tráfico simulado y dos snapshots espaciados.
- Sospechosos habituales, en orden: caché de respuestas sin límite, handlers de logging añadidos por petición, excepciones guardadas con traceback, sesiones o clientes HTTP creados por petición y no cerrados.
El presupuesto de una hora se reparte: 15 minutos confirmar, 20 reproducir, 20 leer el snapshot, 5 arreglar y verificar con otro snapshot.
La instrumentación (paso 1 y 2) es la única que requiere código; el resto es leer. Y el arreglo casi siempre es un límite (maxsize) o un WeakValueDictionary, no un del.
Comprobación del paso 1: una caché sin límite crece con las peticiones y una acotada se estabiliza.
import tracemallocfrom functools import lru_cache
sin_limite = {}
def atender_con_fuga(n): sin_limite[n] = bytearray(1000)
@lru_cache(maxsize=100)def atender_acotada(n): return bytearray(1000)
def crece(funcion, peticiones=5000): tracemalloc.start() for n in range(500): funcion(n) antes = tracemalloc.take_snapshot() for n in range(500, peticiones): funcion(n) despues = tracemalloc.take_snapshot() tracemalloc.stop() return sum(d.size_diff for d in despues.compare_to(antes, "filename")) > 1_000_000
print("sin limite crece:", crece(atender_con_fuga))print("con maxsize crece:", crece(atender_acotada))Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulo 6.
- CPython 3.13:
Modules/tracemalloc.c,Modules/gcmodule.c. - Mediciones:
mediciones/05-01-04-memoria.py.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 01 · El ciclo de vida: la regla que estas fugas rompen.
- 03 ·
weakref: la referencia que no impide liberar. - 04 · Medir: cómo se confirma un diagnóstico.