Python Tutorial — Learn Python Step by Step

Python Multiple Inheritance

Multiple inheritance allows a class to inherit from more than one parent class, combining their attributes and methods. Python uses the Method Resolution Order (MRO) to determine which method is called.

Basic Multiple Inheritance

# A class can inherit from multiple parent classes
class Flyable:
    def fly(self):
        return f"{self.name} is flying!"

class Swimmable:
    def swim(self):
        return f"{self.name} is swimming!"

class Walkable:
    def walk(self):
        return f"{self.name} is walking!"

# Duck inherits from all three
class Duck(Flyable, Swimmable, Walkable):
    def __init__(self, name):
        self.name = name

duck = Duck("Donald")
print(duck.fly())   # Donald is flying!
print(duck.swim())  # Donald is swimming!
print(duck.walk())  # Donald is walking!

Method Resolution Order (MRO)

# When multiple parents have the same method, Python uses MRO
# MRO follows C3 linearization: left-to-right, depth-first

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

class B(A):
    def greet(self):
        return "Hello from B"

class C(A):
    def greet(self):
        return "Hello from C"

class D(B, C):  # B is listed before C
    pass

d = D()
print(d.greet())  # "Hello from B" (B comes first in MRO)

# View the MRO
print(D.__mro__)
# (D, B, C, A, object)
# Python searches: D → B → C → A → object

# Or use .mro() method
print(D.mro())

Mixins — The Practical Pattern

# Mixins are small classes that add specific functionality
# They are not meant to be instantiated alone

class JsonMixin:
    """Add JSON serialization to any class."""
    def to_json(self):
        import json
        return json.dumps(self.__dict__, indent=2)

    @classmethod
    def from_json(cls, json_str):
        import json
        data = json.loads(json_str)
        return cls(**data)

class LogMixin:
    """Add logging capability to any class."""
    def log(self, message):
        print(f"[{type(self).__name__}] {message}")

class TimestampMixin:
    """Add creation timestamp."""
    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)

    def set_created(self):
        from datetime import datetime
        self.created_at = datetime.now().isoformat()

# Combine mixins with a main class
class User(JsonMixin, LogMixin):
    def __init__(self, name, email):
        self.name = name
        self.email = email

user = User("Alice", "alice@example.com")
user.log("User created")      # [User] User created
print(user.to_json())          # {"name": "Alice", "email": "alice@..."}

# Recreate from JSON
json_str = user.to_json()
user2 = User.from_json(json_str)
print(user2.name)  # Alice

super() with Multiple Inheritance

# super() follows the MRO — it calls the NEXT class in line, not the parent
class Base:
    def __init__(self):
        print("Base.__init__")

class Left(Base):
    def __init__(self):
        print("Left.__init__")
        super().__init__()  # calls Right (next in MRO), not Base!

class Right(Base):
    def __init__(self):
        print("Right.__init__")
        super().__init__()  # calls Base

class Child(Left, Right):
    def __init__(self):
        print("Child.__init__")
        super().__init__()  # calls Left

child = Child()
# Output (follows MRO: Child → Left → Right → Base):
# Child.__init__
# Left.__init__
# Right.__init__
# Base.__init__

# Cooperative multiple inheritance pattern
class Serializable:
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def serialize(self):
        return self.__dict__.copy()

class Validatable:
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.validate()

    def validate(self):
        pass  # override in subclass

class Product(Serializable, Validatable):
    def __init__(self, name, price, **kwargs):
        self.name = name
        self.price = price
        super().__init__(**kwargs)

    def validate(self):
        if self.price < 0:
            raise ValueError("Price cannot be negative")

Diamond Problem

# The diamond problem: D inherits B and C, both inherit A
#       A
#      / \
#     B   C
#      \ /
#       D

class A:
    def method(self):
        print("A.method")

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

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

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

D().method()
# D.method → B.method → C.method → A.method
# Each class called only ONCE thanks to MRO

# Python solves the diamond problem cleanly with C3 linearization
print(D.__mro__)
# (D, B, C, A, object)

• Python supports multiple inheritance — a class can have multiple parent classes.
• MRO (Method Resolution Order) determines which method is called — check with Class.__mro__.
• Use mixins (small, focused classes) as the primary pattern for multiple inheritance.
• super() follows the MRO chain, not necessarily the direct parent class.
• Python solves the diamond problem via C3 linearization — each class appears only once in the MRO.