Which objects can weakref.ref() point at, and which raise TypeError?

### The rule: the type must reserve a slot Weak references are not free. For an object to be weakly referenceable, its type must reserve room for a pointer to the object's list of weak references — the slot exposed as `__weakref__`. CPython deliberately omits that slot from many small, fixed-layout built-in types, because an extra pointer per object would be a real cost on the millions of integers, strings and tuples a program creates. When the slot is absent, `weakref.ref(obj)` raises `TypeError: cannot create weak reference to 'X' object`. There is no workaround at the instance level: it is a property of the type. ### What works and what does not Weakly referenceable, and the ones worth remembering: * instances of ordinary user-defined classes — the default, and the reason weak references feel ubiquitous in application code; * functions, bound methods, classes and modules; * `set`, `frozenset`, `collections.deque`, `array.array`, generator objects, file objects; * subclasses of the built-ins below — subclassing adds the slot, so `class Key(tuple): pass` produces instances you *can* weakly reference even though `tuple` itself refuses. Not weakly referenceable: * `int`, `float`, `complex`, `bool`, `str`, `bytes`, `bytearray`, `tuple`, `list`, `dict`, `range`, `slice`; * a bare `object()` — surprisingly often the thing someone reaches for as a sentinel; * instances of `types.SimpleNamespace` and exception instances such as `ValueError('x')`; * instances of a class that declares `__slots__` without listing `'__weakref__'`. ### The `__slots__` interaction `__slots__` replaces the per-instance `__dict__` with a fixed set of descriptors, and in doing so it also drops the weak-reference slot unless you ask for it back. So a memory-optimised class silently becomes unusable as a `weakref.WeakValueDictionary` value or a `weakref.WeakKeyDictionary` key. The fix is one string: ```python class Session: __slots__ = ("room", "__weakref__") ``` This is the failure people hit months after adopting `__slots__`, when someone else tries to put the class into a weak mapping and gets a `TypeError` from a line that looks perfectly ordinary. ### Bound methods: referenceable but useless `weakref.ref(obj.method)` succeeds — a bound method object supports weak references — and then returns `None` immediately. The reason is that `obj.method` is not a stored attribute: the attribute access *creates* a new bound-method object each time, wrapping the function and the instance. As soon as the expression finishes, that temporary object has no strong reference and is collected, leaving your weak reference dead on arrival. This burns people writing callback registries that must not keep listeners alive. `weakref.WeakMethod` exists for exactly this: it holds weak references to the underlying function and instance separately and rebuilds the bound method on call, returning `None` only once the instance itself is gone. ### Why this matters beyond `weakref.ref` Every weak container inherits the constraint. A `WeakValueDictionary` refuses to store a string, a tuple or an int as a value; a `WeakKeyDictionary` requires keys that are *both* hashable and weakly referenceable — which rules out the very built-ins that are most obviously hashable, like `str` and `tuple`. A `WeakSet` requires the same of its members. Newcomers often try to build a weak memoisation table keyed by argument tuples and discover the design cannot exist; the answer is that weak keying is for *object identity lifetimes*, not for value-like data, and value-like data should go in a bounded ordinary mapping instead. ### How to check, and how to talk about it The honest interview answer is the rule plus two or three concrete examples, not a memorised list. Say: "an object is weakly referenceable if its type reserves the weak-reference slot; user-defined classes do by default, most small built-ins deliberately do not, and `__slots__` removes it unless you list `'__weakref__'`." Then demonstrate that you would confirm rather than guess — `weakref.ref(x)` in a REPL, or `weakref.getweakrefcount(x)`, tells you in one line. Interviewers ask this because the failure is a `TypeError` at an unexpected place, and because knowing *why* the slot is missing shows you understand that CPython trades a pointer per object against a feature most objects never use. One last subtlety: support for weak references says nothing about *when* the referent dies. A weakly referenceable object trapped in a reference cycle keeps its reference count above zero until the cycle collector runs, so the weak reference clears late rather than never. Type support and object lifetime are two independent questions, and mixing them up is a common way to misdiagnose a weak mapping that looks like it is holding on.