Using Weakref

Python
import weakref

class Node:
    pass

obj = Node()
r = weakref.ref(obj)   # weak reference, doesn't keep obj alive
print(r())             # -> <Node object> (call it to get the referent)

del obj
print(r())              # -> None, object was garbage collected

1. Identify the memory issue: reference cycles, caches growing unbounded, or child objects keeping parents alive.
2. Choose the right weakref tool (see decision table below).
3. Use .callback for cleanup notification if you need to know when the referent dies.
4. Test garbage collection behavior explicitly (del obj; gc.collect()) to confirm no leaks.

Progress:

• Identify objects that should NOT be kept alive by references
• Pick appropriate weakref primitive (ref, proxy, WeakValueDictionary, WeakKeyDictionary, WeakSet)
• Handle the case where the referent has been collected (check for None or ReferenceError)
• Add callbacks if cleanup/logging is needed
• Verify with gc module or memory profiling

Example 1: Caching expensive objects without leaking memory

Input: Cache computed objects by key, but let them be garbage collected when nothing else references them.

Output:

Python
import weakref

class ExpensiveObject:
    def __init__(self, value):
        self.value = value

cache = weakref.WeakValueDictionary()

def get_object(key):
    obj = cache.get(key)
    if obj is None:
        obj = ExpensiveObject(key)
        cache[key] = obj
    return obj

a = get_object("x")
print(len(cache))  # 1
del a
import gc; gc.collect()
print(len(cache))  # 0, auto-removed

Example 2: Observer pattern without preventing listener cleanup

Input: A subject notifies observers, but shouldn't keep dead observers alive.

Output:

Python
import weakref

class Subject:
    def __init__(self):
        self._observers = weakref.WeakSet()

    def register(self, observer):
        self._observers.add(observer)

    def notify(self, *args):
        for obs in self._observers:
            obs.update(*args)

Example 3: Using finalize for cleanup instead of __del__

Input: Run cleanup code when an object is garbage collected, safely (no __del__ pitfalls).

Output:

Python
import weakref

class Resource:
    def __init__(self, name):
        self.name = name
        self._finalizer = weakref.finalize(self, print, f"Cleaning up {name}")

    def close(self):
        self._finalizer()

r = Resource("db-connection")
del r  # prints "Cleaning up db-connection"

Example 4: Weak reference to a bound method (avoid keeping instance alive via callback)

Input: Register a callback that is a bound method without preventing the instance from being collected.

Output:

Python
import weakref

class Handler:
    def on_event(self):
        print("event handled")

h = Handler()
weak_method = weakref.WeakMethod(h.on_event)

callback = weak_method()
if callback is not None:
    callback()

del h
print(weak_method())  # None