Best practices for multiple inheritance in Python

Introduction

Multiple inheritance lets a class use features from more than one parent class. It helps reuse code but can get tricky if not done carefully.

When you want a class to have behaviors from two or more different classes.

When you want to combine features like logging and data processing in one class.

When you need to extend functionality without rewriting existing code.

When you want to mix small reusable pieces of code (mixins) into a class.

When you want to organize code logically by separating concerns into different classes.

Syntax

Python

class ChildClass(ParentClass1, ParentClass2):
    pass

List parent classes separated by commas inside parentheses.

Python uses Method Resolution Order (MRO) to decide which parent method to call first.

Examples

This class combines logging and calculation features by inheriting from both Logger and Calculator.

Python

class Logger:
    def log(self, message):
        print(f"Log: {message}")

class Calculator:
    def add(self, a, b):
        return a + b

class LoggingCalculator(Logger, Calculator):
    pass

Shows how Python chooses which greet() method to call based on the order of inheritance (A before B).

Python

class A:
    def greet(self):
        print("Hello from A")

class B:
    def greet(self):
        print("Hello from B")

class C(A, B):
    pass

c = C()
c.greet()

Using a mixin class to add extra methods to a base class.

Python

class Mixin:
    def mixin_method(self):
        print("Mixin method")

class Base:
    def base_method(self):
        print("Base method")

class Combined(Mixin, Base):
    pass

Sample Program

This program shows a class that inherits from Logger and Calculator. It adds two numbers and logs the operation.

Python

class Logger:
    def log(self, message):
        print(f"Log: {message}")

class Calculator:
    def add(self, a, b):
        return a + b

class LoggingCalculator(Logger, Calculator):
    def add_and_log(self, a, b):
        result = self.add(a, b)
        self.log(f"Adding {a} + {b} = {result}")
        return result

calc = LoggingCalculator()
print(calc.add_and_log(3, 4))

Important Notes

Always be careful with the order of parent classes; it affects which methods run first.

Use super() to call parent methods safely and follow the MRO.

Prefer small, focused mixin classes to keep code clear and reusable.

Summary

Multiple inheritance lets a class use features from several parents.

Order of parent classes matters because of Python's method resolution order.

Use mixins and super() to write clean, maintainable multiple inheritance code.