Shape Calculator
The Inheritance Playground

🔍 The Method Resolution Order (MRO)

When you call a method on an instance, Python needs to decide which method to execute. In single inheritance, this is straightforward: search the child class, then the parent, then the grandparent, and so on. But with multiple inheritance, the order is more complex.

Python uses the C3 linearization algorithm to compute a consistent, monotonic MRO. You can see it with ClassName.__mro__. The MRO guarantees that a class always appears before its parents, and that the order is predictable across all classes in the hierarchy.

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

print(D.__mro__)
# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

🔧 super() — More Than Just a Parent Call

In most languages, super is a hard-coded reference to the immediate parent class. In Python, super() is far more dynamic. It returns a proxy object that delegates method calls to the next class in the MRO — which might not be the parent at all.

This is what makes super() so powerful in cooperative multiple inheritance. It ensures that in a diamond hierarchy (A → B, A → C, D → B, C), every class's method gets called exactly once, in the correct order, even if not every class explicitly calls super().

class Shape:
    def __init__(self, color: str):
        self.color = color
        print(f"Shape __init__: color={color}")

class ColoredCircle(Circle, Shape):
    def __init__(self, radius: float, color: str):
        super().__init__(radius)
        super(ColoredCircle, self).__init__(color)

# MRO: ColoredCircle → Circle → Shape → object

⚖️ Inheritance vs Composition — The Eternal Debate

"Favor composition over inheritance" is one of the most cited principles in OOP design. But what does it actually mean? And when should you still use inheritance?

Inheritance is an "is-a" relationship: a Dog is an Animal. Composition is a "has-a" relationship: a Car has an Engine. Inheritance is for specializing behavior; composition is for assembling capabilities.

# Inheritance: Shape → Circle (is-a)
class Circle(Shape): pass

# Composition: DrawingTool uses a Shape (has-a)
class DrawingTool:
    def __init__(self, shape: Shape):
        self.shape = shape

# Composition: Window has a list of Shapes
class Canvas:
    def __init__(self):
        self.shapes = []
    def add(self, shape: Shape):
        self.shapes.append(shape)

🏗️ Abstract Base Classes & Mixins — Advanced Patterns

Python's abc module lets you define abstract base classes that enforce a contract on subclasses. This is useful when you want to ensure that every subclass implements certain methods. Mixins are small classes that provide reusable behavior to be mixed into other classes via multiple inheritance.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float: pass

    def describe(self) -> str:
        return f"{type(self).__name__} area = {self.area():.2f}"

class JsonMixin:
    def to_json(self) -> str:
        return f'{{"type": "{type(self).__name__}", "area": {self.area()}}'

class Circle(Shape, JsonMixin):
    def __init__(self, radius: float):
        self.radius = radius
    def area(self) -> float:
        return 3.14159 * self.radius ** 2

c = Circle(5)
print(c.describe())
print(c.to_json())