Understanding difference between parent class init() and super.init

Question

I looked at answers https://stackoverflow.com/a/33469090/11638153 and https://stackoverflow.com/a/27134600 but did not understand what is "indirection." To be specific, if I have classes like below, are there any drawbacks or advantages in hardcoding the parent class __init__(), as done in class Child1 (why do we need super() when one can explicitly write __init__() methods to invoke)?

class Base1:
    def __init__(self):
        print("Class Base1 init()")
        
class Base2:
    def __init__(self):
        print("Class Base2 init()")

class Child1(Base1, Base2):
    def __init__(self):
        print("Class Child1 init()")
        Base1.__init__(self)
        Base2.__init__(self)
        
class Child2(Base1, Base2):
    def __init__(self):
        print("Class Child2 init()")
        super().__init__()

if __name__ == "__main__":
    obj1 = Child1()
    print("---")
    obj2 = Child2()

Your specific exception is because you're not calling `super`. Use `super().__init__`, not `super.__init__`. — Blckknght, Sep 06 '22 at 23:12
Read the following: https://rhettinger.wordpress.com/2011/05/26/super-considered-super/ — juanpa.arrivillaga, Sep 06 '22 at 23:19

Raymond Hettinger · Answer 1 · 2022-09-06T23:33:24.503

2

Roughly, the difference is that ParentClass.__init__(self) always calls the specifically named class while super().__init__() makes a runtime computation to determine which class to call.

In many situations, the two ways give the same results. However, super() is much more powerful. It a multiple inheritance scenario, it can potentially call some class other than the parent of the current class. This article covers the latter scenario is detail.

For single inheritance, the reason to prefer super() is that that it read nicely and that it makes maintenance easier by computing the parent class.

For multiple inheritance, super() is the only straightforward way to access parent classes in the order of the MRO for the class of the calling instance. If those words don't mean anything to you, please look at the referenced article.

edited Sep 06 '22 at 23:33

answered Sep 06 '22 at 23:26

Raymond Hettinger

216,523
63
388
485

What do you mean by your last sentence --- `It a multiple inheritance scenario, it can potentially call some class other than the parent of the current class.`? – ewr3243 Sep 06 '22 at 23:28
2

@ewr3243 See https://www.youtube.com/watch?v=X1PQ7zzltz4 , which will thoroughly explain what Raymond meant, with examples – Alexander Sep 06 '22 at 23:39
@ewr3243 You can take literally, `super()` can call some class other than the parent of the current class. The mechanics are that super() looks at the type of the calling instance, determines its method resolution order, and starts its search after the current class. Those words are exact but most people (me included) don't fully grasp their significance at first. Hence, the reference to the article with examples or to the video link given by @Alexander. – Raymond Hettinger Sep 06 '22 at 23:39

score 1 · Answer 2 · answered Sep 07 '22 at 01:24

In your example code, Child1's design is very fragile. If its two base classes share some common base (and call their own parents' __init__ method inside of their own turn), that grandparent class might get initialized more than once, which would be bad if it's computationally costly, or has side effects. This is the "diamond pattern" of inheritance hierarchy that can be troublesome in many languages (like C++) that allow multiple inheritance.

Here's an example of the bad problem that can come up with explicit parent calls, and which super() is designed to fix:

class Grandparent:
    def __init__(self):
        print("Grandparent")

class Parent1(Grandparent):
    def __init__(self):
        print("Parent1")
        Grandparent.__init__(self)

class Parent2(Grandparent):
    def __init__(self):
        print("Parent2")
        Grandparent.__init__(self)

class Child(Parent1, Parent2):
    def __init__(self):
        print("Child")
        Parent1.__init__(self)
        Parent2.__init__(self)

c = Child() # this causes "Grandparent" to be printed twice!

Python's solution is to use super() which allows collaborative multiple inheritance. Each class must be set up to use it, including the intermediate base classes! Once you set everything up to use super, they'll call each other as necessary, and nothing will ever get called more than once.

class Grandparent:
    def __init__(self):
        print("Grandparent")

class Parent1(Grandparent):
    def __init__(self):
        print("Parent1")
        super().__init__()

class Parent2(Grandparent):
    def __init__(self):
        print("Parent2")
        super().__init__()

class Child(Parent1, Parent2):
    def __init__(self):
        print("Child")
        super().__init__()

c = Child() # no extra "Grandparent" printout this time

In fact, every instance of multiple-inheritance in Python is a diamond shape, with the Grandparent class of object (if not something else). The object class has an __init__ method that takes no arguments (other than self) and does nothing.

It's important to note that the super().__init__ calls from the ParentX classes don't always go directly to Grandparent. When initializing an instance of Parent1 or Parent2, they will, but when instantiating an instance of Child, then Parent1.__init__'s call will go to Parent2.__init__, and only from there will Parent2's super call go to Grandparent.__init__.

Where a super call resolves to depends on the MRO (Method Resolution Order) of the instance the methods are being called on. A super call generally means "find this method in the next class in the MRO" relative to where it's called from. You can see the MRO of a class by calling SomeClass.mro(). For Child in my examples, it's: [Child, Parent1, Parent2, Grandparent, object]

Understanding difference between parent class init() and super.__init__

2 Answers2

Understanding difference between parent class init() and super.init