Polymorphism —
One Interface,
Many Forms.

Glossary

A 30-Second Experiment: Watch Python Choose

Three classes in a chain. Only A and C define hello. Predict what each object prints before pressing Run.

class A:
    def hello(self):
        return "A.hello"

class B(A):
    pass

class C(B):
    def hello(self):
        return "C.hello"

for obj in (A(), B(), C()):
    print(type(obj).__name__, "→", obj.hello())

print([cls.__name__ for cls in C.__mro__])
print(B.hello is A.hello, C.hello is A.hello)

Error Message Decoder

You will meet these while experimenting. Each points at a specific polymorphism mistake.

Which Tool, When?

The classic form. A base class defines what a shape can do; each subclass overrides how. Notice that describe() is written once, in the base class, yet prints a different area for each shape.

import math

class Shape:
    def __init__(self, name):
        self.name = name

    def area(self):
        raise NotImplementedError("Subclasses must implement area()")

    def describe(self):
        return f"{self.name}: area = {self.area():.2f}"

class Circle(Shape):
    def __init__(self, radius):
        super().__init__("Circle")
        self.radius = radius

    def area(self):
        return math.pi * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height, name="Rectangle"):
        super().__init__(name)
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side, name="Square")

class Blob(Shape):
    pass

shapes = [Circle(2), Rectangle(3, 4), Square(5)]
for shape in shapes:
    print(shape.describe())

print(f"Total area: {sum(s.area() for s in shapes):.2f}")

try:
    Blob("Blob").describe()
except NotImplementedError as err:
    print("NotImplementedError:", err)

🔍 Deep dive — how describe() finds the right area()

Follow one call: Square(5).describe(). The key is that Python restarts its search from the object's real class every time it sees self.something.

📖 Line-by-line walkthrough

1. class Shape: with __init__(self, name) — stores a label every shape needs. Shared state lives once, in the parent.
2. area() raises NotImplementedError — a placeholder that says "subclasses must override me". It is a plain class (no ABC), so you can still create a Shape; the error only fires when area() is called. For enforcement at creation time, use an abstract base class.
3. describe() — the shared, polymorphic method. {self.area():.2f} calls whichever area the object has and formats it to two decimals.
4. Circle.__init__ and super().__init__("Circle") — the subclass sets its own data (radius) and delegates the shared part to the parent. Skipping super() would leave self.name unset.
5. Circle.area = math.pi * r ** 2 — the override. Same name and signature as the parent's, different behavior.
6. Rectangle(width, height, name="Rectangle") — the extra name parameter has a default so a subclass can relabel it. This is what lets Square reuse the class cleanly.
7. Square(Rectangle) — overrides nothing except the constructor: it calls super().__init__(side, side, name="Square"). A square is a rectangle with equal sides, so it inherits area() as-is. Overriding is optional.
8. class Blob(Shape): pass — a subclass that forgot to override. It exists to demonstrate the failure path.
9. shapes = [Circle(2), Rectangle(3, 4), Square(5)] — a list holding three different classes. That works because they all promise the same interface.
10. The for loop — one line, shape.describe(), three behaviors. No isinstance, no if.
11. sum(s.area() for s in shapes) — a generator expression calling area() polymorphically: 12.57 + 12 + 25 = 49.57.
12. The final try / except — Blob("Blob").describe() reaches Shape.area, which raises. We catch NotImplementedError and print its message.

⚠️ Common mistakes

🧪 Try it yourself

Duck, Dog and Robot share no base class. make_noise() doesn't care — it only needs .speak() to exist. "If it walks like a duck and quacks like a duck, it's a duck."

from typing import Protocol, runtime_checkable

class Duck:
    def speak(self):
        return "Quack"

class Dog:
    def speak(self):
        return "Woof"

class Robot:
    def speak(self):
        return "Beep boop"

class Rock:
    pass

def make_noise(thing):
    return thing.speak()

for thing in [Duck(), Dog(), Robot()]:
    print(type(thing).__name__, "→", make_noise(thing))

try:
    make_noise(Rock())
except AttributeError as err:
    print("AttributeError:", err)

def safe_noise(thing):
    try:
        return thing.speak()
    except AttributeError:
        return "(silence)"

print(safe_noise(Rock()))

@runtime_checkable
class Speaker(Protocol):
    def speak(self) -> str:
        ...

print(isinstance(Duck(), Speaker), isinstance(Rock(), Speaker))

🔍 Deep dive — nominal vs structural typing

📖 Line-by-line walkthrough

1. Duck, Dog, Robot — three independent classes (each inherits only from object) with the same method name. Their only link is a promise made by convention.
2. class Rock: pass — deliberately has no speak. It is the control case.
3. make_noise(thing) — just return thing.speak(). No type annotation, no isinstance. The function trusts the caller.
4. The first loop — type(thing).__name__ prints each class name; make_noise works unchanged for all three.
5. make_noise(Rock()) inside try — the failure surfaces as AttributeError: 'Rock' object has no attribute 'speak'.
6. safe_noise() — the EAFP style: try the call and handle the failure, instead of checking first.
7. @runtime_checkable + class Speaker(Protocol) — a Protocol writes the duck-typing contract down: "anything with speak() -> str".
8. isinstance(Duck(), Speaker) — normally isinstance checks inheritance, but @runtime_checkable makes it check "does this object have a speak attribute?"

⚠️ Common mistakes

🧪 Try it yourself

Python turns a + b into a.__add__(b). By defining dunder methods, your own class gets natural syntax — and works with built-ins like sorted(), max() and sum().

from functools import total_ordering

@total_ordering
class Money:
    def __init__(self, amount, currency="PHP"):
        self.amount = round(amount, 2)
        self.currency = currency

    def _check(self, other):
        if other.currency != self.currency:
            raise ValueError("Currency mismatch")

    def __add__(self, other):
        if not isinstance(other, Money):
            return NotImplemented
        self._check(other)
        return Money(self.amount + other.amount, self.currency)

    def __mul__(self, factor):
        if not isinstance(factor, (int, float)):
            return NotImplemented
        return Money(self.amount * factor, self.currency)

    __rmul__ = __mul__

    def __eq__(self, other):
        if not isinstance(other, Money):
            return NotImplemented
        return (self.amount, self.currency) == (other.amount, other.currency)

    def __lt__(self, other):
        if not isinstance(other, Money):
            return NotImplemented
        self._check(other)
        return self.amount < other.amount

    def __hash__(self):
        return hash((self.amount, self.currency))

    def __repr__(self):
        return f"Money({self.amount}, {self.currency!r})"

    def __str__(self):
        return f"{self.currency} {self.amount:,.2f}"

price = Money(120.50)
tax = Money(14.46)
print(price + tax)
print(price * 3)
print(2 * price)
print(sorted([Money(30), Money(5), Money(12.5)]))
print(max(Money(30), Money(5)))
print(Money(10) == Money(10.0))
print(sum([Money(1), Money(2)], Money(0)))

try:
    price + 5
except TypeError as err:
    print("TypeError:", err)

try:
    Money(1) + Money(1, "USD")
except ValueError as err:
    print("ValueError:", err)

🔍 Deep dive — how Python translates each expression

📖 Line-by-line walkthrough

1. @total_ordering — a decorator from functools. You write __eq__ and __lt__; it fills in __le__, __gt__, __ge__.
2. __init__ rounds to 2 decimals — keeps display tidy. (Real money code should use decimal.Decimal; floats keep this lesson simple.)
3. _check(self, other) — a private helper shared by __add__ and __lt__: mixing currencies raises a clear ValueError.
4. __add__ — first isinstance(other, Money); if not, return NotImplemented. Then check currency and return a new Money.
5. __mul__ — accepts int or float only. Money * Money makes no sense, so it declines.
6. __rmul__ = __mul__ — multiplication is commutative here, so the reflected version reuses the same function. That makes 2 * price work.
7. __eq__ — compares (amount, currency) tuples. Money(10) == Money(10.0) is True.
8. __lt__ — the one ordering primitive @total_ordering needs.
9. __hash__ — defining __eq__ silently sets __hash__ to None, making objects unhashable. We restore it using the same fields as __eq__.
10. __repr__ vs __str__ — repr is for developers (shown in the sorted list); str is for users (printed with print()).
11. The demo lines — 120.50 + 14.46 = 134.96; price * 3 = 361.50; 2 * price = 241.00; sorted and max use __lt__; sum with a Money(0) start gives 3.00.
12. The two error cases — price + 5 ends in a standard TypeError that Python itself builds; Money(1) + Money(1, "USD") hits our own ValueError.

⚠️ Common mistakes

🧪 Try it yourself

Polymorphism is everywhere in Python's built-ins: len(), +, *, for, in. This program shows how, then adds your own class to the club and uses @singledispatch for per-type behavior you can't add as methods.

from functools import singledispatch

print(len("poetic"), len([1, 2, 3]), len({"a": 1}), len(range(10)))
print(1 + 2, "a" + "b", [1] + [2], (1,) + (2,))
print(3 * 2, "ab" * 3, [0] * 3)

class Playlist:
    def __init__(self, *songs):
        self._songs = list(songs)

    def __len__(self):
        return len(self._songs)

    def __iter__(self):
        return iter(self._songs)

mix = Playlist("Sunrise", "Tides", "Harbor")
print(len(mix), list(mix), "Tides" in mix, sorted(mix))

@singledispatch
def describe(value):
    return f"Something else: {value!r}"

@describe.register
def _(value: int):
    kind = "even" if value % 2 == 0 else "odd"
    return f"Integer {value} ({kind})"

@describe.register
def _(value: str):
    return f"Text with {len(value)} characters"

@describe.register(list)
def _(value):
    return f"List of {len(value)} items"

for item in [7, "poetic", [1, 2, 3], 3.5, None, True]:
    print(describe(item))

🔍 Deep dive — protocols behind the built-ins

📖 Line-by-line walkthrough

1. len(...) on four types — a string, list, dict and range all answer len() differently (6, 3, 1, 10).
2. + on numbers, strings, lists, tuples — addition, concatenation, list joining, tuple joining.
3. * on number, string, list — multiply, repeat, repeat.
4. Playlist.__init__(self, *songs) — *songs collects any number of positional arguments into a tuple; stored as a list.
5. __len__ — returns the count. That alone makes len(mix) work and also makes an empty playlist falsy.
6. __iter__ — returns an iterator. This one method powers list(mix), for, in and sorted().
7. print(len(mix), list(mix), "Tides" in mix, sorted(mix)) — four built-ins, one class, zero extra code.
8. @singledispatch def describe(value) — the base function is the fallback used for any unregistered type.
9. @describe.register with a type annotation — registers the function for the annotated type.
10. @describe.register(list) — the explicit form, passing the type as an argument.
11. The final loop — each value is dispatched by its type.
12. The last item, True — prints Integer True (odd)! bool is a subclass of int, so with no bool registration Python dispatches to the closest ancestor that is registered.

⚠️ Common mistakes

🧪 Try it yourself

The practical payoff. First, a fee calculator written as an if / elif ladder — which breaks the moment a new payment method (Maya) shows up. Then the same feature rebuilt with polymorphism, where adding Maya means one new class and zero edits elsewhere.

class Card:
    pass

class GCash:
    pass

class Cash:
    pass

def fee_ladder(method, amount):
    if isinstance(method, Card):
        return round(amount * 0.029 + 15, 2)
    elif isinstance(method, GCash):
        return round(amount * 0.02, 2)
    elif isinstance(method, Cash):
        return 0.0
    raise TypeError(f"No fee rule for {type(method).__name__}")

class Maya:
    pass

try:
    fee_ladder(Maya(), 1000)
except TypeError as err:
    print("Ladder failed:", err)

print("-" * 44)

class PaymentMethod:
    def fee(self, amount):
        raise NotImplementedError

    def checkout(self, amount):
        fee = self.fee(amount)
        name = type(self).__name__
        return f"{name:<14} total {amount + fee:>9,.2f} (fee {fee:,.2f})"

class CardPayment(PaymentMethod):
    def fee(self, amount):
        return round(amount * 0.029 + 15, 2)

class GCashPayment(PaymentMethod):
    def fee(self, amount):
        return round(amount * 0.02, 2)

class CashPayment(PaymentMethod):
    def fee(self, amount):
        return 0.0

class MayaPayment(PaymentMethod):
    def fee(self, amount):
        return round(amount * 0.015, 2)

for method in [CardPayment(), GCashPayment(), CashPayment(), MayaPayment()]:
    print(method.checkout(1000))

🔍 Deep dive — what changes when a new type arrives

📖 Line-by-line walkthrough

1. Card, GCash, Cash (empty classes) — stand-ins that only exist to be tested with isinstance. They carry no behavior, which is the whole problem.
2. fee_ladder — asks "what are you?" with isinstance three times, then raises TypeError for anything unknown.
3. class Maya: pass and the failing call — a brand-new method arrives. The ladder has no branch for it.
4. print("-" * 44) — a divider. Here * repeats a string.
5. PaymentMethod base class — declares fee() (placeholder) and implements checkout() once.
6. The format spec {name:<14} and {amount + fee:>9,.2f} — aligns the columns of output.
7. CardPayment, GCashPayment, CashPayment — each overrides only fee().
8. MayaPayment — the "later" addition at 1.5%. Nothing above it changed.
9. The final loop — method.checkout(1000) for four classes: totals 1,044.00, 1,020.00, 1,000.00 and 1,015.00.

⚠️ When isinstance is still fine

🧪 Try it yourself

Task: extend the shape family with Triangle(base, height) and find the shape with the biggest area using max() with a key function — without any isinstance.

import math

class Shape:
    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return math.pi * self.radius ** 2

class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = height

    def area(self):
        return 0.5 * self.base * self.height

shapes = [Circle(1), Triangle(6, 5), Circle(2)]
for s in shapes:
    print(f"{type(s).__name__:<9} {s.area():6.2f}")

biggest = max(shapes, key=lambda s: s.area())
print("Biggest:", type(biggest).__name__)

Task: write Vector2D(x, y) that supports +, -, multiplication by a number (both v * 2 and 2 * v), abs(v) for its length, ==, hashing, and a readable repr.

import math

class Vector2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if not isinstance(other, Vector2D):
            return NotImplemented
        return Vector2D(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        if not isinstance(other, Vector2D):
            return NotImplemented
        return Vector2D(self.x - other.x, self.y - other.y)

    def __mul__(self, k):
        if not isinstance(k, (int, float)):
            return NotImplemented
        return Vector2D(self.x * k, self.y * k)

    __rmul__ = __mul__

    def __abs__(self):
        return math.hypot(self.x, self.y)

    def __eq__(self, other):
        if not isinstance(other, Vector2D):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)

    def __hash__(self):
        return hash((self.x, self.y))

    def __repr__(self):
        return f"Vector2D({self.x}, {self.y})"

a = Vector2D(3, 4)
b = Vector2D(1, 2)
print(a + b)
print(a - b)
print(a * 2)
print(2 * a)
print(abs(a))
print(a == Vector2D(3, 4))
print({a, Vector2D(3, 4)})

Task: write log(writer, message) that works with anything having a write(text) method. Test it with your own ConsoleWriter, your own in-memory ListWriter, and Python's built-in io.StringIO — three unrelated classes.

import io

class ConsoleWriter:
    def write(self, text):
        print(text, end="")

class ListWriter:
    def __init__(self):
        self.lines = []

    def write(self, text):
        self.lines.append(text)

def log(writer, message):
    writer.write(message + "\n")

memory = ListWriter()
buffer = io.StringIO()

for writer in (ConsoleWriter(), memory, buffer):
    log(writer, "server started")

print(memory.lines)
print(repr(buffer.getvalue()))

Task: refactor the shipping calculator below into polymorphic classes. Then add a Poster that costs a flat 5.0 to ship — without editing any existing class.

def shipping_cost(item):
    if item["kind"] == "book":
        return 3.0
    elif item["kind"] == "laptop":
        return 12.0 + item["weight"] * 1.5
    elif item["kind"] == "ebook":
        return 0.0
    raise ValueError("unknown kind")

cart = [
    {"kind": "book"},
    {"kind": "laptop", "weight": 2},
    {"kind": "ebook"},
]
print([shipping_cost(item) for item in cart])
print(sum(shipping_cost(item) for item in cart))

class Item:
    def shipping_cost(self):
        raise NotImplementedError

class Book(Item):
    def shipping_cost(self):
        return 3.0

class Laptop(Item):
    def __init__(self, weight):
        self.weight = weight

    def shipping_cost(self):
        return 12.0 + self.weight * 1.5

class EBook(Item):
    def shipping_cost(self):
        return 0.0

class Poster(Item):
    def shipping_cost(self):
        return 5.0

cart = [Book(), Laptop(2), EBook(), Poster()]
print([item.shipping_cost() for item in cart])
print(sum(item.shipping_cost() for item in cart))

Task: using @singledispatch, write to_text(value) that turns nested data into readable text: booleans become yes / no, lists become [a, b], dicts become {key: value}, and everything else uses str(). It must handle nesting.

from functools import singledispatch

@singledispatch
def to_text(value):
    return str(value)

@to_text.register
def _(value: bool):
    return "yes" if value else "no"

@to_text.register
def _(value: list):
    return "[" + ", ".join(to_text(v) for v in value) + "]"

@to_text.register
def _(value: dict):
    pairs = (f"{k}: {to_text(v)}" for k, v in value.items())
    return "{" + ", ".join(pairs) + "}"

data = {"name": "Ana", "active": True, "scores": [90, 85.5, False]}
print(to_text(data))

Task: the program below has several bugs. Run it, read each error, fix it, and run again until all three lines print sensible results. Expect more than one bug.

class Temperature:
    def __init__(self, degrees):
        self.degrees = degrees

    def __eq__(self, other):
        return self.degrees == other.degrees

temps = [Temperature(30), Temperature(12), Temperature(21)]
print(sorted(temps))
print(Temperature(5) == 5)
print(len({Temperature(5), Temperature(5)}))

from functools import total_ordering

@total_ordering
class Temperature:
    def __init__(self, degrees):
        self.degrees = degrees

    def __eq__(self, other):
        if not isinstance(other, Temperature):
            return NotImplemented
        return self.degrees == other.degrees

    def __lt__(self, other):
        if not isinstance(other, Temperature):
            return NotImplemented
        return self.degrees < other.degrees

    def __hash__(self):
        return hash(self.degrees)

    def __repr__(self):
        return f"Temperature({self.degrees})"

temps = [Temperature(30), Temperature(12), Temperature(21)]
print(sorted(temps))
print(Temperature(5) == 5)
print(len({Temperature(5), Temperature(5)}))

Habits That Keep It Safe

Key Takeaways

• Polymorphism = one call, many behaviors — the receiving object decides what happens.
• Overriding works through the MRO: Python searches from the object's real class upward.
• Duck typing needs only matching method names — no shared parent — but fails late, so keep try blocks small.
• Dunder methods make your classes work with +, ==, len(), for and sorted().
• @singledispatch adds per-type behavior when you can't edit the class — remember bool is an int.
• Replace isinstance ladders with methods, and new types arrive without touching old code.