Why does reaching a plain function through an instance produce a bound method in Python?

### There is no method type at definition time A `def` in a class body executes like any other `def`: it builds a function object and binds it to a name in the class namespace. Nothing marks it as a method. What makes it *behave* like one is that the built-in function type implements `__get__`, so a function is a non-data descriptor by construction. ```python class Collector: def sample(self): return "reading" type(Collector.__dict__["sample"]) # <class 'function'> type(Collector().sample) # <class 'method'> ``` The class dictionary holds a function. Only the *access* produces a method. ### What binding actually produces `instance.sample` runs `object.__getattribute__`, which finds the function on the type and calls `function.__get__(instance, Collector)`. That returns a **bound method object** with two attributes: * `__func__` — the original function object, shared by every binding; * `__self__` — the instance the method was fetched from. Calling the bound method inserts `__self__` as the first positional argument and delegates to `__func__`. So `c.sample()` is `type(c).sample(c)` with a small wrapper in between, and the parameter conventionally named `self` is not magic at all — it is the ordinary first parameter, filled in by the binding step. The binding is also *fresh each time*. Two accesses to `c.sample` produce two distinct bound method objects, equal to each other (bound methods compare by `__func__` and `__self__`) but not identical. This is why using a bound method as a dictionary key or storing it in a callback registry keeps the instance alive: the bound method holds a strong reference to `__self__`, which is a real source of retention in long-lived collector or observer registries. `weakref.WeakMethod` exists exactly for that case. ### Class access, and the variants When the same attribute is reached through the class, `obj` is `None`, and a function's `__get__` returns `self` — the plain function. That is why `Collector.sample` is a function you must call with an explicit instance, and why `Collector.sample(c)` and `c.sample()` do the same thing. Python 2's "unbound method" wrapper for this case was removed in Python 3; the class attribute is simply the function. The two familiar decorators are ordinary descriptors written in C over the same protocol: * `staticmethod` wraps a function and its `__get__` returns that function **unbound**, so no instance or class is prepended. Since 3.10 the wrapper is itself directly callable, so calling one out of the class dictionary also works. * `classmethod`'s `__get__` binds to the owning class rather than the instance, so `__self__` on the result is the class object. Reaching it through an instance still binds the class, and through a subclass binds the subclass — which is what makes alternative-constructor patterns inherit correctly. ### The failure this explains Because functions are **non-data** descriptors, they lose to the instance dictionary. Assigning a callable to an instance attribute therefore stores it raw: ```python c.sample = lambda: "stubbed" c.sample() # works, but no instance was passed ``` The stored lambda is returned straight out of `obj.__dict__` with no `__get__` call, so it receives no `self`. Anyone hand-rolling a per-object stub for a sensor-telemetry collector hits this immediately: the replacement must either take no `self` parameter, or be bound explicitly with `func.__get__(instance, type(instance))`, or be installed on the class instead. The mirror-image mistake is patching on the class and forgetting that every instance now sees it. ### Performance, and what changed Materialising a bound method object on every call would be wasteful, and CPython avoids it. Since 3.11 the specializing adaptive interpreter recognises the fetch-then-call pattern at a call site and, when the shape is stable, calls the underlying function with the instance pushed as the first argument without allocating the intermediate bound method at all. The semantics are unchanged — you still get a real method object the moment you store the attribute in a variable or pass it somewhere — but the common `c.sample()` path is much cheaper than the description above suggests. One 3.14 refinement worth knowing: `functools.partial` now implements the descriptor protocol too, so a partial object placed in a class body binds like a function does. On earlier versions it did not, and a partial used as a method silently failed to receive the instance.