Method resolution for super(Class, obj).

[Jason]

ddtl wrote:
> Hello everybody.
>
> Consider the following code:
>
>
> class A(object):
>     def met(self):
>         print 'A.met'
> class B(A):
>     def met(self):
>         print 'B.met'
>         super(B,self).met()
> class C(A):
>     def met(self):
>         print 'C.met'
>         super(C,self).met()
> class D(B,C):
>     def met(self):
>         print 'D.met'
>         super(D,self).met()
> d = D()
> d.met()
>
>
> When executed, it prints:
>
> D.met
> B.met
> C.met
> A.met
>
> The book (Python in a nutshell, 2nd edition) explains:
>
> "The solution is to use built-in type super. super(aclass, obj),
> which returns a special superobject of object obj. When we look
> up an attribute (e.g., a method) in this superobject, the lookup
> begins after class aclass in obj's MRO."
>
> But I don't understand - MRO means that when attribute is found
> somewhere in hierarchy, the search for it stops, that is: when
> d.met() is executed, it is supposed to print 'D met', call
> super(D,self).met() which should resolve met() to be B's attribute,
> and after B's met() is executed, we should be done. Why does the
> lookup proceeds from B to C as though met() wasn't found in B?
> Indeed, lookup order (according to a new-style MRO) is B, then C
> and at last A (because of a diamond inheritance), but only when
> attribute is not found in B it is looked up in C, and only if it
> is not found neither in B nor in C it is looked up in A...
>
> What is different here?

Let's examine what the mro order is for class D:
>>> D.mro()
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>,
<class '__mai
n__.A'>, <type 'object'>]

When you call d.met(), the call dispatches to the D.met() method.
After printing out 'D.met', you use super() to get the next class in
the mro order, and call that class's met method.

As shown with the mro(), the class after D is B.  So B.met() is called.
 Normally, we would be done.  But take a look at B's method!

> class B(A):
>     def met(self):
>         print 'B.met'
>         super(B,self).met()

B.met calls super, and invokes the next met method!  So, the code does
exactly what you've asked it to do, and searches for the next class
after B in the mro list: class C.  You are then invoking met method of
that class.  So, class B is calling class C's met method.

Class C also uses super, and calls the resulting met method on the
result as well.  This finds class A as the next class in the mro list,
and invokes the met method on it as well.

When you get to A's met method, you aren't calling another met method,
so the print statements end.

If you want the dispatch to end at B's method, comment out the
'super(B,self).met()' line:
>>> class B2(A):
...     def met(self):
...         print 'B2.met'

Alternatively, you could do away with using super entirely, and
actively call the superclass method that you want:
>>> class D2(B2, C):
...     def met(self):
...         print 'D2.met'
...         B2.met(self)  # Invoke B2's method directly
...
>>> d2 = D2()
>>> d2.met()
D2.met
B2.met

You don't need super() to call a superclass method.  It can help with
complex class heirarchies, but most single-descendent class structures
don't need it.  Either way, when designing a class heirarchy, you
should either always use super() or never use super().  Mixing
non-super-using and super-using can give you problems.

(Rhetorical Q: Does this make me more or less super?)

    --Jason