In Python, inheritance allows a class (child class) to inherit attributes and methods from another class (parent class). When a child class overrides a method of the parent class, there are situations where you might still want to call the parent’s version of the method. This is where super() comes in handy.

While it’s technically possible to call a parent class’s method directly using ParentClass.method(self, ...), super() offers advantages, especially in scenarios involving multiple inheritance [[1]].

How to Use super()

The basic syntax for using super() is:

super().method_name(arguments)

Here’s a simple example:

class Parent:
    def __init__(self, value):
        self.value = value

    def describe(self):
        print(f"Parent: value = {self.value}")

class Child(Parent):
    def __init__(self, value, extra):
        super().__init__(value)  # Call the parent's __init__
        self.extra = extra

    def describe(self):
        super().describe()  # Call the parent's describe method
        print(f"Child: extra = {self.extra}")

# example usage
child = Child(10, "additional info")
child.describe()

In this example, the Child class inherits from the Parent class. The Child‘s __init__ method uses super().__init__(value) to call the Parent‘s __init__ method, ensuring that the value attribute is initialized correctly. Similarly, the `describe` method in `Child` calls the `describe` method in `Parent` using `super().describe()` before adding its own specific output.

“super() lets you avoid referring to the base class explicitly, which can be nice.” [[3]]

super() and multiple Inheritance

The real power of super() becomes apparent when dealing with multiple inheritance. In complex inheritance hierarchies, super() ensures that methods are called in the correct order, following the method resolution order (MRO). The MRO is the order in which Python looks for a method in a class hierarchy.

Consider this example:

class A:
    def method(self):
        print("Method A")

class B:
    def method(self):
        print("Method B")

class C(A, B):
    def method(self):
        super().method()  # Calls method in A
        print("Method C")

c = C()
c.method()

In this case, class C inherits from both A and B. When c.method() is called, super().method() in C will call A‘s method as A appears before B in the inheritance list of C. The MRO can be inspected using C.mro().

When to Use Direct Class Name Instead of super()

While super() is generally recommended, there are specific cases where calling the parent class method directly using the class name might be appropriate. According to Stack Overflow, this is often sufficient for single inheritance scenarios [[1]]. Such as:

class Parent:
    def hello(self):
        print("Hello from Parent")

class Child(Parent):
    def hello(self):
        Parent.hello(self)  # Direct call to parent method
        print("Hello from Child")

c = Child()
c.hello()

However, using super() is generally preferred because it is more flexible and robust, especially when dealing with complex inheritance structures or when the inheritance hierarchy might change in the future.