How does Pythons super() work with multiple inheritance?

How does Pythons super() work with multiple inheritance?

This is detailed with a reasonable amount of detail by Guido himself in his blog post Method Resolution Order (including two earlier attempts).

In your example, Third() will call First.__init__. Python looks for each attribute in the classs parents as they are listed left to right. In this case, we are looking for __init__. So, if you define

class Third(First, Second):
    ...

Python will start by looking at First, and, if First doesnt have the attribute, then it will look at Second.

This situation becomes more complex when inheritance starts crossing paths (for example if First inherited from Second). Read the link above for more details, but, in a nutshell, Python will try to maintain the order in which each class appears on the inheritance list, starting with the child class itself.

So, for instance, if you had:

class First(object):
    def __init__(self):
        print first

class Second(First):
    def __init__(self):
        print second

class Third(First):
    def __init__(self):
        print third

class Fourth(Second, Third):
    def __init__(self):
        super(Fourth, self).__init__()
        print thats it

the MRO would be [Fourth, Second, Third, First].

By the way: if Python cannot find a coherent method resolution order, itll raise an exception, instead of falling back to behavior which might surprise the user.

Example of an ambiguous MRO:

class First(object):
    def __init__(self):
        print first
        
class Second(First):
    def __init__(self):
        print second

class Third(First, Second):
    def __init__(self):
        print third

Should Thirds MRO be [First, Second] or [Second, First]? Theres no obvious expectation, and Python will raise an error:

TypeError: Error when calling the metaclass bases
    Cannot create a consistent method resolution order (MRO) for bases Second, First

Why do the examples above lack super() calls? The point of the examples is to show how the MRO is constructed. They are not intended to print firstnsecondthird or whatever. You can – and should, of course, play around with the example, add super() calls, see what happens, and gain a deeper understanding of Pythons inheritance model. But my goal here is to keep it simple and show how the MRO is built. And it is built as I explained:

>>> Fourth.__mro__
(<class __main__.Fourth>,
 <class __main__.Second>, <class __main__.Third>,
 <class __main__.First>,
 <type object>)

Your code, and the other answers, are all buggy. They are missing the super() calls in the first two classes that are required for co-operative subclassing to work.

Here is a fixed version of the code:

class First(object):
    def __init__(self):
        super(First, self).__init__()
        print(first)

class Second(object):
    def __init__(self):
        super(Second, self).__init__()
        print(second)

class Third(First, Second):
    def __init__(self):
        super(Third, self).__init__()
        print(third)

The super() call finds the next method in the MRO at each step, which is why First and Second have to have it too, otherwise execution stops at the end of Second.__init__().

This is what I get:

>>> Third()
second
first
third

How does Pythons super() work with multiple inheritance?

I wanted to elaborate the answer by lifeless a bit because when I started reading about how to use super() in a multiple inheritance hierarchy in Python, I didt get it immediately.

What you need to understand is that super(MyClass, self).__init__() provides the next __init__ method according to the used Method Resolution Ordering (MRO) algorithm in the context of the complete inheritance hierarchy.

This last part is crucial to understand. Lets consider the example again:

#!/usr/bin/env python2

class First(object):
  def __init__(self):
    print First(): entering
    super(First, self).__init__()
    print First(): exiting

class Second(object):
  def __init__(self):
    print Second(): entering
    super(Second, self).__init__()
    print Second(): exiting

class Third(First, Second):
  def __init__(self):
    print Third(): entering
    super(Third, self).__init__()
    print Third(): exiting

According to this article about Method Resolution Order by Guido van Rossum, the order to resolve __init__ is calculated (before Python 2.3) using a depth-first left-to-right traversal :

Third --> First --> object --> Second --> object

After removing all duplicates, except for the last one, we get :

Third --> First --> Second --> object

So, lets follow what happens when we instantiate an instance of the Third class, e.g. x = Third().

1. According to MRO Third.__init__ executes.
   • prints Third(): entering
   • then super(Third, self).__init__() executes and MRO returns First.__init__ which is called.
2. First.__init__ executes.
   • prints First(): entering
   • then super(First, self).__init__() executes and MRO returns Second.__init__ which is called.
3. Second.__init__ executes.
   • prints Second(): entering
   • then super(Second, self).__init__() executes and MRO returns object.__init__ which is called.
4. object.__init__ executes (no print statements in the code there)
5. execution goes back to Second.__init__ which then prints Second(): exiting
6. execution goes back to First.__init__ which then prints First(): exiting
7. execution goes back to Third.__init__ which then prints Third(): exiting

This details out why instantiating Third() results in to :

Third(): entering
First(): entering
Second(): entering
Second(): exiting
First(): exiting
Third(): exiting

The MRO algorithm has been improved from Python 2.3 onwards to work well in complex cases, but I guess that using the depth-first left-to-right traversal + removing duplicates expect for the last still works in most cases (please comment if this is not the case). Be sure to read the blog post by Guido!