Python super().__init__(): Comprehensive Guide

The super() function in Python is commonly used with the __init__ method to initialize a parent class’s attributes within a child class. This enables you to extend and customize the behavior of parent classes while still retaining access to their attributes and methods.

Using super() effectively allows you to write more flexible and maintainable code by promoting reuse and avoiding code duplication.

By the end of this guide, you’ll understand how to use super().__init__() effectively in Python, with a focus on object-oriented programming.

What is super() in Python?

The super() function in Python returns a temporary object of the superclass, allowing you to call its methods, including the __init__ method. This function is especially useful in inheritance hierarchies where you want to extend or override parent class methods in a child class.

Syntax of super():

super().method_name(args)

In the context of __init__, super() enables a child class to call the parent class’s __init__ method, allowing the child to inherit and initialize attributes from the parent class.

Using super() with __init__ for Single Inheritance

In single inheritance, super() is straightforward to use. A child class can inherit the attributes and methods of a single parent class, and super().__init__() allows it to initialize these inherited attributes.

Example: Using super() with __init__

class Animal:
    def __init__(self, name):
        self.name = name
        print(f"{self.name} is an animal.")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # Initialize the parent class (Animal)
        self.breed = breed
        print(f"{self.name} is a {self.breed}.")

# Create an instance of Dog
dog = Dog("Buddy", "Golden Retriever")

Output:

Buddy is an animal.
Buddy is a Golden Retriever.

In this example, Dog inherits from Animal. By calling super().__init__(name), the __init__ method of Animal is executed, which sets the name attribute and prints a message.

Using super() with __init__ in Multiple Inheritance

When working with multiple inheritance, super() helps manage the Method Resolution Order (MRO). Python’s MRO determines the order in which base classes are initialized. Using super() ensures that each class in the inheritance chain is initialized only once, in the correct order.

Example: Using super() with __init__ in Multiple Inheritance

class A:
    def __init__(self):
        print("Initializing class A")
        super().__init__()

class B(A):
    def __init__(self):
        print("Initializing class B")
        super().__init__()

class C(A):
    def __init__(self):
        print("Initializing class C")
        super().__init__()

class D(B, C):
    def __init__(self):
        print("Initializing class D")
        super().__init__()

# Create an instance of D
d = D()

Output:

Initializing class D
Initializing class B
Initializing class C
Initializing class A

In this example:

• D inherits from both B and C, and both inherit from A.
• By using super(), Python follows the MRO to initialize classes in the order: D → B → C → A.
• This avoids duplicate initializations and ensures that each class is properly initialized.

Checking the MRO:

You can view the MRO of a class by using the __mro__ attribute or the mro() method:

print(D.__mro__)

This will display the order in which classes are initialized, confirming the correct sequence.

Practical Use Cases for super().__init__()

1. Extending Parent Class Initialization

In many cases, a child class will need to extend the initialization of its parent class. By using super().__init__(), the child class can initialize inherited attributes and add its own.

class Vehicle:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

class Car(Vehicle):
    def __init__(self, brand, model, year):
        super().__init__(brand, model)
        self.year = year

car = Car("Toyota", "Camry", 2022)
print(car.brand, car.model, car.year)  # Output: Toyota Camry 2022

In this example, Car extends the initialization of Vehicle by adding a year attribute, in addition to brand and model.

2. Implementing Method Overriding

Using super().__init__() in method overriding allows the child class to add functionality to the parent class’s method without completely replacing it.

class Person:
    def __init__(self, name):
        self.name = name
        print(f"Hello, {self.name}!")

class Student(Person):
    def __init__(self, name, school):
        super().__init__(name)
        self.school = school
        print(f"{self.name} is a student at {self.school}.")

student = Student("Alice", "Greenwood High")

Output:

Hello, Alice!
Alice is a student at Greenwood High.

Here, Student overrides the __init__ method of Person to add the school attribute but still calls super().__init__(name) to retain the original initialization behavior.

Advantages of Using super().__init__()

1. Code Reusability: By reusing the parent class’s initialization logic, super() avoids code duplication and makes the code easier to maintain.
2. Better Support for Multiple Inheritance: super() respects the MRO, ensuring that all parent classes are initialized in the correct order without duplication.
3. Flexibility and Extensibility: super() makes it easy to extend the functionality of a parent class without needing to completely rewrite or override its methods.
4. Avoids Hardcoding Parent Class Names: By using super(), you avoid hardcoding the parent class name, making code refactoring and maintenance easier.

Best Practices for Using super() with __init__

1. Use super() Instead of Directly Calling Parent Class: Using super() is more flexible than directly calling the parent class’s __init__ method, especially when dealing with multiple inheritance.
2. Always Call super() When Overriding __init__: If you override __init__ in a child class, ensure you call super().__init__() to properly initialize the parent class. This ensures that attributes are inherited correctly and any necessary initialization is not skipped.
3. Check the MRO in Multiple Inheritance: When using multiple inheritance, be aware of the MRO to understand the order in which classes will be initialized. Use __mro__ to confirm the sequence.
4. Use super() Consistently: When working with multiple classes in an inheritance chain, be consistent in using super() to avoid unexpected behavior or skipped initializations.
5. Override with Caution: When overriding __init__ in a child class, make sure that all necessary initialization steps are still performed, either through super().__init__() or by adding additional code as needed.

Summary of Key Concepts

• super() is used in Python to access and initialize parent class methods, especially the __init__ method, in an inheritance hierarchy.
• Using super().__init__() allows child classes to extend and customize the initialization behavior of their parent classes.
• In multiple inheritance, super() respects the Method Resolution Order (MRO), ensuring that all classes are initialized in the correct sequence.
• super() promotes code reuse, extensibility, and flexibility by avoiding hardcoding parent class names and allowing for dynamic method resolution.
• Following best practices when using super() ensures clean, efficient, and maintainable code.

Check out our FREE Learn Python Programming Masterclass to hone your skills or learn from scratch.

The course covers everything from first principles to Graphical User Interfaces and Machine Learning

You can browse the official Python documentation on ‘super’ here.

FAQ

Q1: What is the main difference between calling super().__init__() and calling ParentClass.__init__(self) directly?

A1: The key difference is that super() dynamically resolves the parent class and follows the Method Resolution Order (MRO), which is especially useful in multiple inheritance scenarios. By using ParentClass.__init__(self), you bypass the MRO and hardcode the parent class, which can lead to issues if the class hierarchy changes or in multiple inheritance situations. super() is more flexible and recommended for clean and maintainable code.

Q2: Can I use super() in a class that doesn’t have inheritance?

A2: No, super() is only used in the context of inheritance, where a class needs to call a method (like __init__) from its parent class. If your class does not inherit from another class, super() has no use because there’s no parent class to refer to.

Q3: What happens if I don’t call super().__init__() in a child class?

A3: If you don’t call super().__init__() (or the parent class’s __init__ method) in a child class, the parent class’s initialization will not be executed. This means that any attributes or setup logic defined in the parent class’s __init__ method will not be applied to the child instance. This can lead to missing attributes or uninitialized states in your objects.

Q4: Can I call super() multiple times in a class?

A4: Yes, you can call super() multiple times within a class if needed. However, it’s important to understand the Method Resolution Order (MRO) to ensure that super() calls are made in the correct sequence. In general, calling super() once in each method that overrides a parent method is sufficient.

Example:

class A:
    def __init__(self):
        print("A's __init__")

class B(A):
    def __init__(self):
        super().__init__()
        print("B's __init__")

class C(B):
    def __init__(self):
        super().__init__()
        print("C's __init__")

c = C()
# Output: 
# A's __init__
# B's __init__
# C's __init__

Q5: Can I use super() to access methods other than __init__?

A5: Yes, super() can be used to call any method from the parent class, not just __init__. It is commonly used to extend or override any parent class method in a child class.

Example:

class Animal:
    def sound(self):
        return "Generic animal sound"

class Dog(Animal):
    def sound(self):
        return super().sound() + ", Woof!"

dog = Dog()
print(dog.sound())  # Output: Generic animal sound, Woof!

Q6: How does super() handle multiple inheritance in Python?

A6: In multiple inheritance, super() follows the Method Resolution Order (MRO) to determine which class’s method to call next. Python’s MRO ensures that each class is only initialized once, in the correct order. You can view the MRO by using the __mro__ attribute or calling the mro() method on the class.

Example:

print(D.mro())  # Output: [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

This shows the order in which Python will resolve calls to methods like __init__ when using super().

Q7: Can I pass additional arguments to super().__init__()?

A7: Yes, you can pass additional arguments to super().__init__() to match the signature of the parent class’s __init__ method. For example, if the parent class’s __init__ accepts multiple arguments, you should pass them when calling super().__init__().

Example:

“`python
class Animal:
def init(self, name, age):
self.name