Method Resolution Order (MRO) in new-style classes?

StackOverflow

In the book Python in a Nutshell (2nd Edition) there is an example which uses
old style classes to demonstrate how methods are resolved in classic resolution order and
how is it different with the new order.

I tried the same example by rewriting the example in new style but the result is no different than what was obtained with old style classes. The python version I am using to run the example is 2.5.2. Below is the example:

class Base1(object):  
    def amethod(self): print "Base1"  

class Base2(Base1):  
    pass

class Base3(object):  
    def amethod(self): print "Base3"

class Derived(Base2,Base3):  
    pass

instance = Derived()  
instance.amethod()  
print Derived.__mro__  

The call instance.amethod() prints Base1, but as per my understanding of the MRO with new style of classes the output should have been Base3. The call Derived.__mro__ prints:

(<class "__main__.Derived">, <class "__main__.Base2">, <class "__main__.Base1">, <class "__main__.Base3">, <type "object">)

I am not sure if my understanding of MRO with new style classes is incorrect or that I am doing a silly mistake which I am not able to detect. Please help me in better understanding of MRO.

Answer rating: 191

The crucial difference between resolution order for legacy vs new-style classes comes when the same ancestor class occurs more than once in the "naive", depth-first approach -- e.g., consider a "diamond inheritance" case:

>>> class A: x = "a"
... 
>>> class B(A): pass
... 
>>> class C(A): x = "c"
... 
>>> class D(B, C): pass
... 
>>> D.x
"a"

here, legacy-style, the resolution order is D - B - A - C - A : so when looking up D.x, A is the first base in resolution order to solve it, thereby hiding the definition in C. While:

>>> class A(object): x = "a"
... 
>>> class B(A): pass
... 
>>> class C(A): x = "c"
... 
>>> class D(B, C): pass
... 
>>> D.x
"c"
>>> 

here, new-style, the order is:

>>> D.__mro__
(<class "__main__.D">, <class "__main__.B">, <class "__main__.C">, 
    <class "__main__.A">, <type "object">)

with A forced to come in resolution order only once and after all of its subclasses, so that overrides (i.e., C"s override of member x) actually work sensibly.

It"s one of the reasons that old-style classes should be avoided: multiple inheritance with "diamond-like" patterns just doesn"t work sensibly with them, while it does with new-style.





Get Solution for free from DataCamp guru