Question

I find the following example mildly surprising:

>>> class Foo:
        def blah(self):
            pass


>>> f = Foo()
>>> def bar(self):
        pass

>>> Foo.bar = bar
>>> f.bar
<bound method Foo.bar of <__main__.Foo object at 0x02D18FB0>>

I expected the bound method to be associated with each particular instance, and to be placed in it at construction. It seems logical that the bound method would have to be different for each instance, so that it knows which instance to pass in to the underlying function – and, indeed:

>>> g = Foo()
>>> g.blah is f.blah
False

But my understanding of the process is clearly flawed, since I would not expect assigning a function into a class attribute would put it in instances that had already been created by then.

So, my question is two fold –

1. Why does assigning a function into a class apply retroactively to instances? What are the actual lookup rules and processes that make this so?
2. Is this something guaranteed by the language, or just something that happens to happen?

Answer 1

You want to blow your mind, try this:

f.blah is f.blah

That’s right, the instance method wrapper is different each time you access it.

In fact an instance method is a descriptor. In other words, f.blah is actually:

Foo.blah.__get__(f, type(f))

Methods are not actually stored on the instance; they are stored on the class, and a method wrapper is generated on the fly to bind the method to the instance.