Python Polymorphism and Inner Classes

Polymorphism pays off when several classes implement the same meaningful operation under the same name, so calling code doesn't need to know which class it has:

def print_itinerary(routes):
    for number, route in enumerate(routes, start=1):
        print(f"{number}. {route.describe()} ({route.minutes()} min)")

print_itinerary works with walks, ferries, buses and any route type added next year, without an if isinstance(...) chain. Adding a new route type means writing one new class; the function stays untouched.

Sharing a name isn't enough on its own: the methods must also share a meaning and a compatible signature. If Walk.minutes() returns minutes but Ferry.minutes() returns hours, the code runs and produces wrong itineraries. Agree what each method returns, document it, and test each implementation against that contract.

"If it walks like a duck and quacks like a duck, it's a duck." Python checks whether an object supports an operation when the operation is used, not whether the object's class inherits from a particular parent:

class Taxi:                       # no common base class with Walk or Ferry
    def describe(self): return "Taxi from the station"
    def minutes(self): return 8

A Taxi works in print_itinerary immediately. Built-in functions rely on the same idea: len() works on anything with __len__, and for works on anything iterable.

The flip side is that a missing method fails only at run time, with AttributeError: 'Bicycle' object has no attribute 'minutes'. Tests catch this, and so do static type checkers if you describe the expected interface with typing.Protocol:

from typing import Protocol

class Route(Protocol):
    def describe(self) -> str: ...
    def minutes(self) -> int: ...

mypy then reports any object passed as a Route that lacks those methods, while classes still don't have to inherit from Route.

Composition means an object holds other objects and delegates work to them, instead of inheriting behaviour. Inheritance models "is a"; composition models "has a":

class FareCalculator:
    def __init__(self, per_km):
        self.per_km = per_km
    def fare(self, km):
        return round(self.per_km * km, 2)

class FerryRoute:
    def __init__(self, km, fares):
        self.km = km
        self.fares = fares            # has a fare calculator
    def price(self):
        return self.fares.fare(self.km)

A ferry route is not a kind of fare calculator, so it shouldn't inherit from one. Composition keeps each class focused, lets you swap collaborators (a peak-time calculator, a test fake) without subclassing, and avoids deep inheritance chains. Use inheritance when the child truly is a specialised version of the parent and can be used anywhere the parent is expected.

A class defined inside another class is a nested (or inner) class. It's simply an attribute of the outer class: it's reached as Route.Stop, and it groups a helper type with the class that uses it.

class Route:
    class Stop:
        def __init__(self, name, minute):
            self.name, self.minute = name, minute

    def __init__(self, name):
        self.name = name
        self.stops = []

    def add_stop(self, name, minute):
        self.stops.append(Route.Stop(name, minute))

Unlike Java's inner classes, a Python nested class has no automatic link to an outer instance. A Stop doesn't know which route it belongs to unless you pass the route in explicitly, for example Route.Stop(name, minute, route=self). Nested classes are used for small helper types, such as Django's class Meta inside models, but a separate module-level class is often clearer and easier to import and test.

Task: create compatible route classes and pass a route explicitly to a nested stop record.

class Bus:
    class Stop:
        def __init__(self, bus, name):
            self.bus, self.name = bus, name
        def __str__(self):
            return f"{self.name} on route {self.bus.number}"

    def __init__(self, number):
        self.number = number
    def describe(self):
        return f"Bus {self.number}"

class Walk:
    def describe(self):
        return "Walk along the canal"

for route in [Bus(42), Walk()]:
    print(route.describe())
print(Bus.Stop(Bus(42), "Market Square"))

This prints Bus 42, Walk along the canal and Market Square on route 42. For the worked check: does a nested class automatically receive an outer instance? No. The Stop only knows its bus because the bus is passed to its constructor.

The documentation describes typing.Protocol for static duck typing and the glossary entry for duck typing. Continue with context managers and type checking. Practise with the Python exercises and Python quiz.