Delegating Inheritance in Python: Navigating the MRO with super()

1. Syntax & Formal Parameter Specifications 🔝

In modern Python 3, super() can be called with zero arguments inside methods, or with explicit parameters:

proxy = super()
proxy = super(type[, object_or_type])

2. Basic Usage: Single Inheritance & __init__ 🔝

The most common usage is delegating initialization from a derived class to its parent:

class Animal:
    home = "Jungle"

    def __init__(self, name: str, height: float):
        self.name = name
        self.height = height

    def legs(self):
        print("has four legs")

class Wild(Animal):
    def __init__(self, name: str, weight: int):
        # Delegate name and default height=5.0 to parent Animal
        super().__init__(name, 5.0)
        self.weight = weight

tiger = Wild("Tom", 300)
print("Weight:", tiger.weight)
print("Height:", tiger.height)
tiger.legs()

Output:

Weight: 300
Height: 5.0
has four legs

3. Direct Base Call vs. super() Delegation 🔝

While calling ParentClass.__init__(self, ...) works in simple single inheritance, super() provides crucial architectural advantages:

4. Method Resolution Order (MRO) Mechanics 🔝

Python calculates a linear search path for every class called the Method Resolution Order (MRO) using the C3 Linearization algorithm. You can inspect it via __mro__:

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass

# Inspect the calculated MRO list
mro_names = [cls.__name__ for cls in D.__mro__]
print("Class D MRO:", mro_names)

Output:

Class D MRO: ['D', 'B', 'C', 'A', 'object']

5. Cooperative Multiple Inheritance & The Diamond Problem 🔝

When multiple inheritance forms a diamond shape, calling base classes directly causes the root class to initialize multiple times. super() ensures every class initializes exactly once:

class Root:
    def __init__(self):
        print("Root initialized")

class Left(Root):
    def __init__(self):
        print("Left entering")
        super().__init__()
        print("Left exiting")

class Right(Root):
    def __init__(self):
        print("Right entering")
        super().__init__()
        print("Right exiting")

class Bottom(Left, Right):
    def __init__(self):
        print("Bottom entering")
        super().__init__()
        print("Bottom exiting")

b = Bottom()

Output:

Bottom entering
Left entering
Right entering
Root initialized
Right exiting
Left exiting
Bottom exiting

6. Delegating Non-Init Methods 🔝

super() is not limited to __init__. You can extend any parent method by wrapping or post-processing its return value:

class Notifier:
    def send(self, msg: str) -> str:
        return f"Sent: {msg}"

class LoggedNotifier(Notifier):
    def send(self, msg: str) -> str:
        original = super().send(msg)
        return f"[LOGGED] {original}"

n = LoggedNotifier()
print(n.send("System reboot"))

Output:

[LOGGED] Sent: System reboot

7. Production Recipes & Real-World Use Cases 🔝

Recipe A: Cooperative Mixin Architecture

Compose reusable functionality across independent classes using mixins:

class JsonMixin:
    def to_dict(self) -> dict:
        # Safely delegate up MRO
        data = super().to_dict() if hasattr(super(), "to_dict") else {}
        data.update({k: v for k, v in self.__dict__.items() if not k.startswith("_")})
        return data

class User(JsonMixin):
    def __init__(self, username: str):
        self.username = username

u = User("alice")
print("Mixin serialized:", u.to_dict())

Output:

Mixin serialized: {'username': 'alice'}

Recipe B: Forwarding Dynamic Arguments (*args, **kwargs)

Ensure robust cooperative chaining by accepting and passing variable keyword arguments:

class BaseConfig:
    def __init__(self, env: str = "prod", **kwargs):
        super().__init__(**kwargs)
        self.env = env

class DatabaseConfig(BaseConfig):
    def __init__(self, port: int = 5432, **kwargs):
        super().__init__(**kwargs)
        self.port = port

cfg = DatabaseConfig(port=3306, env="staging")
print("Config:", cfg.env, cfg.port)

Output:

Config: staging 3306

8. Common Pitfalls & Developer Traps 🔝

9. Interactive Notebook & Practice Exercises 🔝

Practice MRO linearization, cooperative diamonds, and mixin patterns in our companion Jupyter Notebook:

Self-Verifying Assertion Suite

Run these unit checks directly in Python or your local environment to verify super() mechanics:

def test_super_mechanics():
    class A:
        def __init__(self, val: int):
            self.val = val
            
    class B(A):
        def __init__(self, val: int, extra: str):
            super().__init__(val)
            self.extra = extra
            
    b = B(42, "data")
    assert b.val == 42
    assert b.extra == "data"
    print("All super() unit assertions passed! 100% verified.")

test_super_mechanics()

Output:

All super() unit assertions passed! 100% verified.

10. Related Built-in Functions & OOP Decorators 🔝

Subhendu Mohapatra

Author & Instructor at plus2net

I write and maintain practical tutorials on Python, PHP, SQL, JavaScript, HTML, jQuery, and web development at plus2net. The tutorials focus on clear explanations, working examples, and code that readers can test and adapt while learning.

About the author   Watch on YouTube

Connect: