In multiple inheritance in Python, init of parent class A and B is done at the same time?

Question

I have a question about the instantiation process of a child class with multiple inheritance from parent class A without arg and parent class B with kwargs respectively.

In the code below, I don't know why ParentB's set_kwargs()method is executed while ParentA is inited when a Child instance is created.

(Expecially, why does the results show Child receive {}? How can I avoid this results?)

Any help would be really appreciated.

Thanks!

class GrandParent:
    def __init__(self):
        print(f"{self.__class__.__name__} initialized")

class ParentA(GrandParent):
    def __init__(self):
        super().__init__()

class ParentB(GrandParent):
    def __init__(self, **kwargs):
        super().__init__()
        self.set_kwargs(**kwargs)
        
    def set_kwargs(self, **kwargs):
        print(f"{self.__class__.__name__} receive {kwargs}")
        self.content = kwargs.get('content')

class Child(ParentA, ParentB):
    def __init__(self, **kwargs):
        ParentA.__init__(self)
        ParentB.__init__(self, **kwargs)

c = Child(content = 3)

results:

Child initialized
Child receive {}
Child initialized
Child receive {'content': 3}

Answer 1

For most cases of multiple inheritance, you will want the superclass methods to be called in sequence by the Python runtime itself.

To do that, just place a call to the target method in the return of super().

In your case, the most derived class' init should read like this:

class Child(ParentA, ParentB):
    def __init__(self, **kwargs):
        super().__init__(self, **kwargs)

And all three superclasses __init__ methods will be correctly run. Note that for that to take place, they have to be built to be able to work cooperatively in a class hierarchy like this - for which two things are needed: one is that each method in any of the superclasses place itself a class to super().method()- and this is ok in your code. The other is that if parameters are to be passed to these methods, which not all classes will know, the method in each superclass should extract only the parameters it does know about, and pass the remaining parameters in its own super() call.

So the correct form is actually:

class GrandParent:
    def __init__(self):
        print(f"{self.__class__.__name__} initialized")

class ParentA(GrandParent):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

class ParentB(GrandParent):
    def __init__(self, **kwargs):
        content = kwargs.pop('content')
        super().__init__(**kwargs)
        self.set_kwargs(content)
        
    def set_kwargs(self, content):
        print(f"{self.__class__.__name__} receive {content}")
        self.content = content

class Child(ParentA, ParentB):
    def __init__(self, **kwargs):
        super.__init__(**kwargs)

c = Child(content = 3)

The class which will be called next when you place a super() call is calculated by Python when you create a class with multiple parents - so, even though both "ParentA" and "ParentB" inherit directly from grandparent, when the super() call chain bubbles up from "Child", Python will "know" that from within "ParentA" the next superclass is "ClassB" and call its __init__ instead.

The algorithm for finding the "method resolution order" is quite complicated, and it just "works as it should" for most, if not all, usecases. It's exact description can be found here: https://www.python.org/download/releases/2.3/mro/ (really - you don't have to understand it all - there are so many corner cases it handles - just get the "feeling" of it.)