Understanding Python super() with __init__() methods [duplicate]

I’m trying to understand super()

The reason we use super is so that child classes that may be using cooperative multiple inheritance will call the correct next parent class function in the Method Resolution Order (MRO).

In Python 3, we can call it like this:

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

In Python 2, we were required to call super like this with the defining class’s name and self, but we’ll avoid this from now on because it’s redundant, slower (due to the name lookups), and more verbose (so update your Python if you haven’t already!):

        super(ChildB, self).__init__()

Without super, you are limited in your ability to use multiple inheritance because you hard-wire the next parent’s call:

        Base.__init__(self) # Avoid this.

I further explain below.

“What difference is there actually in this code?:”

class ChildA(Base):
    def __init__(self):
        Base.__init__(self)

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

The primary difference in this code is that in ChildB you get a layer of indirection in the __init__ with super, which uses the class in which it is defined to determine the next class’s __init__ to look up in the MRO.

I illustrate this difference in an answer at the canonical question, How to use ‘super’ in Python?, which demonstrates dependency injection and cooperative multiple inheritance.

If Python didn’t have super

Here’s code that’s actually closely equivalent to super (how it’s implemented in C, minus some checking and fallback behavior, and translated to Python):

class ChildB(Base):
    def __init__(self):
        mro = type(self).mro()
        check_next = mro.index(ChildB) + 1 # next after *this* class.
        while check_next < len(mro):
            next_class = mro[check_next]
            if '__init__' in next_class.__dict__:
                next_class.__init__(self)
                break
            check_next += 1

Written a little more like native Python:

class ChildB(Base):
    def __init__(self):
        mro = type(self).mro()
        for next_class in mro[mro.index(ChildB) + 1:]: # slice to end
            if hasattr(next_class, '__init__'):
                next_class.__init__(self)
                break

If we didn’t have the super object, we’d have to write this manual code everywhere (or recreate it!) to ensure that we call the proper next method in the Method Resolution Order!

How does super do this in Python 3 without being told explicitly which class and instance from the method it was called from?

It gets the calling stack frame, and finds the class (implicitly stored as a local free variable, __class__, making the calling function a closure over the class) and the first argument to that function, which should be the instance or class that informs it which Method Resolution Order (MRO) to use.

Since it requires that first argument for the MRO, using super with static methods is impossible as they do not have access to the MRO of the class from which they are called.

Criticisms of other answers:

super() lets you avoid referring to the base class explicitly, which can be nice. . But the main advantage comes with multiple inheritance, where all sorts of fun stuff can happen. See the standard docs on super if you haven’t already.

It’s rather hand-wavey and doesn’t tell us much, but the point of super is not to avoid writing the parent class. The point is to ensure that the next method in line in the method resolution order (MRO) is called. This becomes important in multiple inheritance.

I’ll explain here.

class Base(object):
    def __init__(self):
        print("Base init'ed")

class ChildA(Base):
    def __init__(self):
        print("ChildA init'ed")
        Base.__init__(self)

class ChildB(Base):
    def __init__(self):
        print("ChildB init'ed")
        super().__init__()

And let’s create a dependency that we want to be called after the Child:

class UserDependency(Base):
    def __init__(self):
        print("UserDependency init'ed")
        super().__init__()

Now remember, ChildB uses super, ChildA does not:

class UserA(ChildA, UserDependency):
    def __init__(self):
        print("UserA init'ed")
        super().__init__()

class UserB(ChildB, UserDependency):
    def __init__(self):
        print("UserB init'ed")
        super().__init__()

And UserA does not call the UserDependency method:

>>> UserA()
UserA init'ed
ChildA init'ed
Base init'ed
<__main__.UserA object at 0x0000000003403BA8>

But UserB does in-fact call UserDependency because ChildB invokes super:

>>> UserB()
UserB init'ed
ChildB init'ed
UserDependency init'ed
Base init'ed
<__main__.UserB object at 0x0000000003403438>

Criticism for another answer

In no circumstance should you do the following, which another answer suggests, as you’ll definitely get errors when you subclass ChildB:

super(self.__class__, self).__init__()  # DON'T DO THIS! EVER.

(That answer is not clever or particularly interesting, but in spite of direct criticism in the comments and over 17 downvotes, the answerer persisted in suggesting it until a kind editor fixed his problem.)

Explanation: Using self.__class__ as a substitute for the class name in super() will lead to recursion. super lets us look up the next parent in the MRO (see the first section of this answer) for child classes. If you tell super we’re in the child instance’s method, it will then lookup the next method in line (probably this one) resulting in recursion, probably causing a logical failure (in the answerer’s example, it does) or a RuntimeError when the recursion depth is exceeded.

>>> class Polygon(object):
...     def __init__(self, id):
...         self.id = id
...
>>> class Rectangle(Polygon):
...     def __init__(self, id, width, height):
...         super(self.__class__, self).__init__(id)
...         self.shape = (width, height)
...
>>> class Square(Rectangle):
...     pass
...
>>> Square('a', 10, 10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in __init__
TypeError: __init__() missing 2 required positional arguments: 'width' and 'height'

Python 3’s new super() calling method with no arguments fortunately allows us to sidestep this issue.

Related Contents:

  1. What does ‘super’ do in Python? – difference between super().__init__() and explicit superclass __init__()
  2. Why do Python classes inherit object?
  3. How do I call a parent class’s method from a child class in Python?
  4. Calling parent class __init__ with multiple inheritance, what’s the right way?
  5. List all base classes in a hierarchy of given class?
  6. Superclass inherits from a subclass. Coursera. Are they crazy? [closed]
  7. What is the purpose of the word ‘self’?
  8. Static class variables and methods in Python
  9. What is the difference between old style and new style classes in Python?
  10. What are the differences between type() and isinstance()?
  11. Python function overloading
  12. How to invoke the super constructor in Python?
  13. difference between variables inside and outside of __init__()
  14. Explaining the ‘self’ variable to a beginner [duplicate]
  15. What is the difference between __init__ and __call__?
  16. Is it possible to make abstract classes in Python?
  17. How can I dynamically create derived classes from a base class
  18. Chain-calling parent initialisers in python [duplicate]
  19. Attaching a decorator to all functions within a class
  20. Private members in Python
  21. Python super() raises TypeError
  22. Why do attribute references act like this with Python inheritance? [duplicate]
  23. How do I access Class member variables in Python?
  24. Which classes cannot be subclassed?
  25. What is the `self` parameter in class methods?
  26. super() fails with error: TypeError “argument 1 must be type, not classobj” when parent does not inherit from object
  27. What is the purpose of python’s inner classes?
  28. difference between variables inside and outside of __init__() (class and instance attributes)
  29. How to avoid infinite recursion with super()?
  30. Does Python have class prototypes (or forward declarations)?
  31. What is the purpose of the `self` parameter? Why is it needed?
  32. Prevent creating new attributes outside __init__
  33. Is it possible to make abstract classes?
  34. How do I set and access attributes of a class? [duplicate]
  35. Python super method and calling alternatives
  36. Python: how to “kill” a class instance/object?
  37. What is the difference between super() with arguments and without arguments?
  38. How to implement a binary search tree in Python?
  39. Which of the 4 ways to call super() in Python 3 to use?
  40. How can I call a function within a class?
  41. Spawning multiple instances of the same object concurrently in python
  42. super() raises “TypeError: must be type, not classobj” for new-style class
  43. How do I implement __getattribute__ without an infinite recursion error?
  44. TypeError: module.__init__() takes at most 2 arguments (3 given)
  45. python multiple inheritance passing arguments to constructors using super
  46. Making a python user-defined class sortable, hashable
  47. Using Properties in Python classes cause “maximum recursion depth exceeded” [duplicate]
  48. List as a member of a python class, why is its contents being shared across all instances of the class?
  49. Understanding the difference between __getattr__ and __getattribute__
  50. member variable string gets treated as Tuple in Python

Leave a Comment