weakref
Una referencia normal mantiene vivo su objeto: mientras alguien lo apunte, no se libera. A veces eso es exactamente lo que no quieres —una caché, un observador, un índice inverso— y ahí entra weakref: apunta sin ser dueño.
En una línea
Sección titulada «En una línea»Una referencia débil dice «avísame si sigue vivo», no «no lo sueltes».
Cómo funciona
Sección titulada «Cómo funciona»import weakref
class Cache: __slots__ = ("datos", "__weakref__")
def __init__(self): self.datos = bytearray(1024)
c = Cache()w = weakref.ref(c) # referencia débilw() is c # True — desreferenciardel c # el objeto se libera: nadie lo poseew() # None| Operación | Coste |
|---|---|
w() |
21 ns |
python mediciones/05-01-04-memoria.py
Veintiún nanosegundos, comparable a leer un atributo. El coste no está en la lectura, está en la comprobación: cada desreferencia puede devolver None, y el código tiene que manejarlo.
Las tres herramientas
Sección titulada «Las tres herramientas»from weakref import WeakValueDictionary, WeakSet, finalize
cache = WeakValueDictionary() # las entradas desaparecen solascache["x"] = Objeto()
vistos = WeakSet() # no impide liberar sus miembros
finalize(obj, cerrar) # callback al liberar, sin pasar objWeakValueDictionary: el diccionario no mantiene vivos los valores. Cuando el último dueño externo los suelta, la entrada desaparece. Sólo sirve como caché si otra estructura mantiene vivo el valor; para valores calculados sin dueño externo,lru_cache(maxsize=...).WeakSet: para registros de observadores que no deben prolongar la vida de nadie.finalize: la alternativa fiable a__del__, porque se ejecuta al liberar el objeto —también si lo libera el recolector de ciclos— y no puede resucitarlo.
Cuándo es la respuesta
Sección titulada «Cuándo es la respuesta»| Situación | Por qué |
|---|---|
| Caché de objetos por identidad | El objeto debe poder liberarse cuando nadie lo use |
| Lista de observadores | Un observador muerto no debe impedir liberar nada |
| Relación padre-hijo bidireccional | Rompe el ciclo: el hijo apunta al padre con weakref |
| Índice inverso (objeto → metadatos) | Los metadatos viven mientras viva el objeto |
El caso de la relación bidireccional es el más elegante: en lugar de depender del recolector de ciclos, el hijo guarda una referencia débil al padre y el ciclo no existe.
ref frente a proxy
Sección titulada «ref frente a proxy»weakref.ref devuelve un objeto que hay que llamar; weakref.proxy se usa como si fuera el original:
import weakref
w = weakref.ref(obj)w().nombre # hay que desreferenciar
p = weakref.proxy(obj)p.nombre # acceso directoEl proxy es más cómodo y más peligroso: cuando el objeto muere, cualquier acceso lanza ReferenceError, no devuelve None. Un if p is None no protege de nada, porque p nunca es None.
La regla: ref cuando el código puede comprobar el estado con naturalidad; proxy cuando quieres que el fallo sea ruidoso, como en un observador que no debería sobrevivir a su sujeto.
La trampa
Sección titulada «La trampa»Cuándo no aplica
Sección titulada «Cuándo no aplica»- Si necesitas garantizar que el objeto siga vivo. Eso es una referencia normal.
- Si el objeto es pequeño y de vida corta. La indirección y la comprobación de
Nonecuestan más que el objeto. - Para romper ciclos que podrías no crear. Si el diseño permite evitar la referencia circular, es más simple que debilitarla.
- En tipos inmutables, que no admiten referencia débil.
Ejercicio
Sección titulada «Ejercicio»Un Nodo tiene hijos y cada hijo tiene padre. Sin weakref, el árbol entero se convierte en un ciclo y depende del recolector. Reescríbelo para que no haya ciclo, y explica qué se gana y qué se pierde.
Solución
import weakref
class Nodo: __slots__ = ("valor", "hijos", "_padre_ref", "__weakref__")
def __init__(self, valor, padre=None): self.valor = valor self.hijos = [] self._padre_ref = weakref.ref(padre) if padre else lambda: None if padre: padre.hijos.append(self)
@property def padre(self): return self._padre_ref()La referencia fuerte va del padre a los hijos; el hijo sólo tiene una débil. Cuando se libera la raíz, todos los descendientes caen en cascada porque no queda ninguna referencia fuerte.
Se gana: el árbol no depende del recolector de ciclos, se libera en el momento exacto y funciona con __del__ sin sorpresas.
Se pierde: nodo.padre puede devolver None si el padre ya murió, lo que es un estado que el código debe contemplar. Y no se puede desreferenciar débilmente un Nodo sin __weakref__ en slots, que es la razón de declararlo.
Comprobación con datos de ejemplo:
raiz = Nodo("raiz")hijo = Nodo("hijo", raiz)print("padre del hijo:", hijo.padre.valor)print("hijos de la raiz:", [h.valor for h in raiz.hijos])print("padre de la raiz:", raiz.padre)del raizprint("tras liberar la raiz:", hijo.padre)assert hijo.padre is None, "sin referencia fuerte el padre desaparece"Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulo 6.
- CPython 3.13:
Objects/weakrefobject.c,Lib/weakref.py. - Mediciones:
mediciones/05-01-04-memoria.py.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 01 · El ciclo de vida: el contador que las weakrefs no incrementan.
- 02 · Fugas: la caché sin límite que esto resuelve.
- 03 · Composición (Parte IV): la relación padre-hijo sin ciclo.