Saltearse al contenido

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.

Una referencia débil dice «avísame si sigue vivo», no «no lo sueltes».

import weakref
class Cache:
__slots__ = ("datos", "__weakref__")
def __init__(self):
self.datos = bytearray(1024)
c = Cache()
w = weakref.ref(c) # referencia débil
w() is c # True — desreferenciar
del c # el objeto se libera: nadie lo posee
w() # None
Desreferenciar una weakref
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.

from weakref import WeakValueDictionary, WeakSet, finalize
cache = WeakValueDictionary() # las entradas desaparecen solas
cache["x"] = Objeto()
vistos = WeakSet() # no impide liberar sus miembros
finalize(obj, cerrar) # callback al liberar, sin pasar obj
  • WeakValueDictionary: 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.
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.

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 directo

El 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.

  • 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 None cuestan 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.

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 raiz
print("tras liberar la raiz:", hijo.padre)
assert hijo.padre is None, "sin referencia fuerte el padre desaparece"
  • 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.
  • 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.