Inheritance — single inheritance, method resolution order (MRO)

WHY does inheritance exist?

The key relationship is is-a (not has-a).

• A Car is-a Vehicle → inheritance.
• A Car has-a Engine → composition (a field, not a parent).

WHAT is single inheritance?

class Animal:                 # parent / base / superclass
    def __init__(self, name):
        self.name = name
    def speak(self):
        return "..."
 
class Dog(Animal):            # child / derived / subclass
    def speak(self):          # OVERRIDE
        return "Woof"
 
d = Dog("Rex")
print(d.name)      # 'Rex'   -> inherited __init__ from Animal
print(d.speak())   # 'Woof'  -> overridden in Dog

class Puppy(Dog):
    def speak(self):
        base = super().speak()        # 'Woof' from Dog
        return base + " (tiny)"       # extend it

HOW does Python find a method? — The MRO

For single inheritance the MRO is literally the chain: $\text{MRO}(C) = [\,C,\; \text{Parent}(C),\; \text{Parent}(\text{Parent}(C)),\; \dots,\; \texttt{object}\,]$

object is always last — it's the root of every Python class.

Deriving the lookup algorithm from scratch

When you write obj.speak(), Python conceptually does:

1. Let T = type(obj).
2. Compute order = T.__mro__ (the precomputed list).
3. For each class K in order in order:
   • if 'speak' is in K.__dict__ → use K.__dict__['speak'], stop.
4. If none found → AttributeError.

That's it — no magic. super() simply means "start the same search, but at the position after the current class in the MRO."

Worked Example 1 — basic chain

class A:
    def who(self): return "A"
class B(A):
    pass
class C(B):
    def who(self): return "C"
 
c = C()
print(C.__mro__)   # (C, B, A, object)
print(c.who())     # 'C'

Why (C, B, A, object)? Single inheritance → just the parent chain, then object. Why this step? C is most specific so it's first; object roots everything so it's last.

Why c.who() == 'C'? Search order is C, B, A, object. C defines who → first match → stop. Why this step? B has no who, but we never reach it because C already matched.

Worked Example 2 — inheritance fills the gap

b = B()
print(b.who())     # 'A'

Why 'A'? B.__mro__ = (B, A, object). B has no who, A does. Why this step? Lookup keeps walking until a class defines the name; B is skipped, A wins.

Worked Example 3 — super() to extend, not replace

class Account:
    def __init__(self, balance):
        self.balance = balance
    def describe(self):
        return f"balance={self.balance}"
 
class Savings(Account):
    def __init__(self, balance, rate):
        super().__init__(balance)     # run parent's __init__
        self.rate = rate
    def describe(self):
        return super().describe() + f", rate={self.rate}"
 
s = Savings(100, 0.05)
print(s.describe())   # 'balance=100, rate=0.05'

Why call super().__init__? Because Account.__init__ sets self.balance. If we skip it, self.balance never exists. Why this step? The child is responsible for initializing the parent's part of the object.

Why does super().describe() give the Account version? super() inside Savings starts lookup at the class after Savings in the MRO (Savings, Account, object) → that's Account. Why this step? super() is "next in MRO", not "literal parent" — for single inheritance they coincide.

Worked Example 4 — Forecast-then-Verify

The 80/20 — what actually matters

Active Recall

Connections

• OOP Fundamentals
• Polymorphism and Method Overriding
• super() and cooperative multiple inheritance
• Composition over Inheritance
• C3 Linearization (the algorithm behind multiple-inheritance MRO)
• Encapsulation and Attribute Lookup
• object — the root class

Concept Map

Hinglish (regional understanding)