How does inheritance and the MRO work in Python?

When a class is defined, Python computes a method resolution order using C3 linearisation. It preserves the order of bases and ensures a consistent, monotonic lookup for diamond-shaped hierarchies. print(Cls.__mro__) shows the exact path.

class Base:
    def describe(self):
        return "base"

class Logged(Base):
    def describe(self):
        return "logged " + super().describe()

class Cached(Base):
    def describe(self):
        return "cached " + super().describe()

class Service(Logged, Cached):
    pass

print(Service().describe())
print([cls.__name__ for cls in Service.__mro__])

Using inheritance well

• Subclass when the subtype genuinely is a specialisation and honours the parent contract
• Use mixins for small, orthogonal behaviour such as logging or retry support
• Use abstract base classes to define required methods and catch incomplete implementations
• Prefer composition when the relationship is has-a rather than is-a

Deep hierarchies become fragile because a change in a base class can alter many subclasses. In tests, inheritance is often harder to isolate than composition with injected collaborators. If a subclass overrides a method and ignores the parent's contract, callers relying on the base type will break.