The super() Function in Python OOP

The super() Function in Python OOP

In the realm of Python object-oriented programming, understanding the super() function is paramount. Mastering this functionality unlocks the full potential of class hierarchies and inheritance. In this article, we'll embark on a journey to explore the nuances of Python's super() function, delving into its implementation and significance across various scenarios.

Understanding Python's Super Class

At its core, the super() function in Python facilitates the invocation of methods from a parent class within a child class. This functionality fosters a hierarchical structure among classes, promoting code organization and reusability. In Python 3, super() is particularly instrumental in initializing abstract classes, ensuring consistent behavior across subclasses.

Leveraging super() in Python Classes

Let's dive into a practical example to grasp the essence of super() in action:

class Parent:
    def do_something(self):
        print("Parent class doing something.")

class Child(Parent):
    def do_something(self):
        print("Child class doing something.")

child = Child()

In this demonstration, Child class inherits from Parent class, and the do_something() method of the parent class is invoked within the child class using super().

Python Abstract Class Initialization with super()

Abstract classes, which cannot be instantiated directly, often utilize super() for initialization. Let's examine an example:

from abc import ABC, abstractmethod

class MyAbstractClass(ABC):
    def __init__(self):
        print("Initializing MyAbstractClass")

    def my_method(self):

class MySubclass(MyAbstractClass):
    def __init__(self):
        print("Initializing MySubclass")

    def my_method(self):
        print("Calling my_method in MySubclass")

my_obj = MySubclass()

Here, MySubclass inherits from the abstract class MyAbstractClass, and super() is employed to initialize the abstract class during instantiation.

The Dynamics of Multiple Inheritance with super()

Python supports multiple inheritance, where a class can inherit from multiple parent classes. In such scenarios, super() aids in managing the method resolution order (MRO) effectively. Let's explore:

class A:
    def some_method(self):
        print("Method from class A")

class B:
    def some_method(self):
        print("Method from class B")

class C(A, B):
    def some_method(self):
        print("Method from class C")

obj = C()

In this illustration, C inherits from both A and B, and super() ensures the correct order of method calls based on the MRO.


In conclusion, the super() function in Python serves as a cornerstone in class hierarchies, enabling seamless interaction between parent and child classes. Mastery of super() empowers developers to craft elegant and maintainable code structures, fostering a robust foundation for Python development.


Andrew Thompson

I'm a Python developer based in Seattle and the author of this website.

Updated: 15 March 2024

About author