Table of Contents

In Python, we often see the use of super() in class initialization.

Something like this:

class MyClass(Base):
    def __init__(self):
        super().__init__()

In order to understand super(), we first need to understand MRO (method resolution order) in Python. MRO means how to find a method for an object along the class inheritance hierarchy.

MRO in Python
#

To check a class’s MRO, we can use MyClass.__mro__. It will print out a linear list of class for method resolution.

For single class inheritance, it is simple to get the MRO list. For multiple inheritance, Python 2.3 and higher use the C3 linearization method. This post by Guido van Rossum tells more about the history and development of MRO in Python.

C3 linearization
#

There is a complex case in this post.

class PrettyType(type):
    """make the repr of the classes look nice when finally listed"""
    def __repr__(self):
        return self.__name__

# subclasses of O will also have the metaclass:
class O(metaclass=PrettyType): 'O, object'

class H(O): 'H, O, object'
# H's parent is O

class G(H): 'G, H, O, object'
# G's linearization is itself followed by its parent's linearization.

class I(G): 'I, G, H, O, object'
# I's linearization is I followed by G's

class F(H): 'F, H, O, object'

class E(H): 'E, H, O, object'

class D(F): 'D, F, H, O, object'

class C(E, F, G): 'C, E, F, G, H, O, object'
# C's linearization is C followed by a consistent linearization of
# its parents, left to right.
# First C, then E - then you might be tempted to put H after E,
# but H must come after F and G (see class F and G)
# so we try F's linearization, noting that H comes after G,
# so we try G's linearization, H then consistently comes next, then object

class B(O): 'B, O, object'

class A(B, C, D): 'A, B, C, E, D, F, G, H, O, object'

Let’s derive its MRO list step by step according to C3 linearization.

L(O) = [O]

L(H) = [H] + L(O) = [H, O]

L(B) = [B, O]

L(E) = [E] + L[H] = [E, H, O]

L(F) = [F, H, O]

L(G) = [G, H, O]

L(C) = [C] + merge(L(E), L(F), L(G), [E, F, G])
     = [C] + merge([E, H, O], [F, H, O], [G, H, O], [E, F, G])  # choose E
     = [C, E] + merge([H, O], [F, H, O], [G, H, O], [F, G])  # can not choose, choose F
     = [C, E, F] + merge([H, O], [H, O], [G, H, O], [G])  # can not choose H, choose G
     = [C, E, F, G] + merge([H, O], [H, O], [H, O])  # choose H
     = [C, E, F, G, H] + merge([O], [O], [O])
     = [C, E, F, G, H, O]

L(D) = [D] + L(F) = [D, F, H, O]

L(A) = [A] + merge(L(B), L(C), L(D), [B, C, D])
     = [A] + merge([B, O], [C, E, F, G, H, O], [D, F, H, O], [B, C, D])  # choose B
     = [A, B] + merge([O], [C, E, F, G, H, O], [D, F, H, O], [C, D])  # can not choose O, choose C
     = [A, B, C] + merge([O], [E, F, G, H, O], [D, F, H, O], [D])  # can not choose O, choose E (it is the first viable node after O)
     = [A, B, C, E] + merge([O], [F, G, H, O], [D, F, H, O], [D])  # can not choose O and F, choose D
     = [A, B, C, E, D] + merge([O], [F, G, H, O], [F, H, O])  # can not choose O, choose F
     = [A, B, C, E, D, F] + merge([O], [G, H, O], [H, O])  # can not choose O, choose G
     = [A, B, C, E, D, F, G] + merge([O], [H, O], [H, O])  # can not choose O, choose H
     = [A, B, C, E, D, F, G, H] + merge([O], [O], [O])
     = [A, B, C, E, D, F, G, H, O]

So the final MRO list would be [A, B, C, E, D, F, G, H, O]. You can verify by running print(A.mro()).

The basic idea is to work from root node to leaf node. When merging a node, always choose the first node in a certain list, from left list to right list, if this node does not appear in other positions in other lists.

use of `super()`
#

If we use super(), it will try to find the next class in the MRO list and try to call the corresponding method in that class.

class Base:
    def __init__(self):
        print("class Base init called")

class B(Base):
    def __init__(self):
        print("class B init called")
        Base.__init__(self)

class C(Base):
    def __init__(self):
        print("class C init called")
        super().__init__()


# class D(C, B):
class D(B, C):
    def __init__(self):
        print("class D init called")
        super().__init__()


def main():
    d = D()


if __name__ == "__main__":
    main()

If we run the above code, we see the following output:

class D init called
class B init called
class Base init called

The MRO list is [D, B, C, Base, object] (in python3, object is the base class for any other class). Class C is not initialized because in the __init__() method of B, we are not using super(). If we replace the line

Base.__init__(self)

with

super().__init__()

we will see the following output instead:

class D init called
class B init called
class C init called
class Base init called

If we change the inheritance of class D from D(B, C) to D(C, B), we observe the following output:

class D init called
class C init called
class B init called
class Base init called

In this case, the MRO list is [D, C, B, Base, object]. Since both D and C use super() in their init function, so we can see that C and B are initialized. Remember that super() will try to find the next class in the MRO list. We also see that Base is also initialized, because we are using Base.__init__(self) explicitly in init function for class B, nothing related to super() here.

This post provides another similar example to illustrate the idea of super(). So in order to run the initialization method the parent classes correctly and not rely on some chance, we can use super() to the rescue.