Re: Method resolution for super(Class, obj).


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

.

Relevant Pages

  • Re: Why does super() require the class as the first argument?
    ... > to super classes using their names: ... > def go: ... class A: # mro: A, ...
    (comp.lang.python)
  • Re: invoking a method from two superclasses
    ... def prints: print# or pass if you prefer ... must include a definition of the method, along with super() calls to move the method ... Also note that the inheritances above can be "eventually inherits from" ... Think of the mro order as a solution to the partial order constraints ...
    (comp.lang.python)
  • Re: invoking a method from two superclasses
    ... I've discovered the surprising fact described in the documentation of super ... The mro is guaranteed to have the ... def prints: ...
    (comp.lang.python)
  • Re: trouble understanding super()
    ... def met: ... But why does the second version (with super) not also do this? ... so why isn't A.met called twice still? ... In this case the object's mro will be (D, B, C, A, ...
    (comp.lang.python)
  • Re: Method resolution for super(Class, obj).
    ... the mro order, and call that class's met method. ... As shown with the mro(), the class after D is B. So B.metis called. ... super() is context dependant - if super.metis invoked as ... It's all rather better explained in the Nutshell Guide than it is in the Python documentation. ...
    (comp.lang.python)