The Right Way to Call Parent Class Constructors in Python Multiple Inheritance

In Python object-oriented programming, multiple inheritance is a powerful yet complex feature, particularly when dealing with parent class constructor calls. When a subclass needs to invoke multiple parent __init__ methods, developers face two main choices: direct method calls or using the super() function. This article, based on best practices from the technical community, provides a thorough analysis of both approaches' appropriate use cases and potential pitfalls.

Fundamental Challenges of Multiple Inheritance

Consider this typical multiple inheritance scenario:

class A(object):
    def __init__(self):
        print("Entering A")
        super(A, self).__init__()
        print("Leaving A")

class B(object):
    def __init__(self):
        print("Entering B")
        super(B, self).__init__()
        print("Leaving B")

class C(A, B):
    def __init__(self):
        print("Entering C")
        A.__init__(self)
        B.__init__(self)
        print("Leaving C")

This implementation causes B.__init__ to be called twice because the super() call in A.__init__ also triggers B.__init__. Conversely, if some parent classes don't properly use super(), certain parent constructors might not be called at all.

Comparative Analysis of Two Approaches

The direct method call approach is straightforward:

class FooBar(Foo, Bar):
    def __init__(self, bar='bar'):
        Foo.__init__(self)
        Bar.__init__(self, bar)

This method explicitly specifies which parent classes to call, making the code readable but inflexible. When inheritance order changes, manual adjustments are needed, and it doesn't support dependency injection.

The super() function offers greater flexibility:

class FooBar(Foo, Bar):
    def __init__(self, bar='bar'):
        super().__init__()
        super(Foo, self).__init__(bar)

This approach follows the Method Resolution Order (MRO), automatically handling the call chain and supporting cooperative multiple inheritance. However, it requires all related classes to be designed for cooperative inheritance; otherwise, calls may be missed or duplicated.

Solutions for Three Design Scenarios

Scenario 1: Base Classes as Independent Non-Cooperative Classes

When base classes are designed as independent entities without considering multiple inheritance, they typically don't call super().__init__(). In this case, subclasses must explicitly call each parent's constructor:

class BaseClass(object):
    def __init__(self):
        pass  # Explicit empty constructor to avoid implicit super calls

class Foo(BaseClass):
    def __init__(self):
        self.foo = 'foo'
        # No super() call

class Bar(BaseClass):
    def __init__(self, bar):
        self.bar = bar
        # No super() call

class FooBar(Foo, Bar):
    def __init__(self, bar='bar'):
        Foo.__init__(self)
        Bar.__init__(self, bar)

Scenario 2: One Class as a Mixin

Mixin classes are specifically designed for multiple inheritance and pass arguments through super():

class FooMixin:
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.foo = 'foo'

class Bar:
    def __init__(self, bar):
        self.bar = bar

class FooBar(FooMixin, Bar):
    def __init__(self, bar='bar'):
        super().__init__(bar)

The key is placing the mixin first in the inheritance list to ensure its __init__ is called.

Scenario 3: All Base Classes Designed for Cooperative Inheritance

Cooperative inheritance requires all classes to use super() and pass unused arguments:

class CoopFoo:
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.foo = 'foo'

class CoopBar:
    def __init__(self, bar, **kwargs):
        super().__init__(**kwargs)
        self.bar = bar

class CoopFooBar(CoopFoo, CoopBar):
    def __init__(self, bar='bar'):
        super().__init__(bar=bar)

This approach is the most flexible, allowing arbitrary inheritance order, but requires all participating classes to follow the same design pattern.

Handling Third-Party Library Challenges

When inheriting from third-party libraries with inconsistent designs, Raymond Hettinger's "Super Considered Super" article recommends using the adapter pattern. Create wrapper classes to unify interfaces:

class AdaptedA(A):
    def __init__(self, *args, **kwargs):
        # Adapt A's constructor for cooperative inheritance
        super().__init__(*args, **kwargs)
        # Call original A's initialization logic
        A.__init__(self)

class C(AdaptedA, B):
    def __init__(self):
        super().__init__()

Although this increases complexity, it provides a viable path for integrating with third-party libraries.

Best Practice Recommendations

1. Understand Class Design Intentions: Before using multiple inheritance, determine whether base classes are designed for cooperative inheritance. Review documentation or source code to confirm if __init__ methods call super().

2. Maintain Consistency: Within the same inheritance hierarchy, all classes should follow the same initialization pattern. Mixing direct calls and super() leads to unpredictable behavior.

3. Consider Alternatives: When multiple inheritance becomes overly complex, consider using composition. By encapsulating functionality in separate classes and instantiating them within the main class, you gain clearer control flow.

4. Test Inheritance Behavior: Write test cases to verify all parent constructors are called correctly without duplication. Use print statements or debuggers to trace initialization order.

Multiple inheritance is an advanced Python feature whose proper use requires deep understanding of MRO mechanisms and class design principles. By analyzing base class design patterns and selecting appropriate initialization strategies, developers can avoid common pitfalls and build robust, extensible systems. When facing inconsistently designed third-party libraries, the adapter pattern offers practical solutions despite added complexity. Ultimately, clear documentation and consistent coding standards are key to ensuring correct implementation of multiple inheritance.