Reusing Behaviour Without Copying It

$ >>> class Animal:$ ...     def __init__(self, name):$ ...         self.name = name$ ...     def describe(self):$ ...         return f"{self.name} is an animal"$ ...$ >>> class Dog(Animal):$ ...     pass$ ...$ >>> rex = Dog("Rex")$ >>> rex.describe()$ 'Rex is an animal'

class Dog(Animal): makes Dog a subclass of Animal. Even though Dog defines nothing of its own yet, it already has __init__ and describe, inherited in full.

$ >>> isinstance(rex, Dog)$ True$ >>> isinstance(rex, Animal)$ True

Every Dog is also an Animal, as far as Python is concerned — isinstance confirms both at once. That single fact is what “is a kind of” means in code, not just in the way you would describe it in English.

Define a method with the same name in the subclass, and it replaces the parent's version for that subclass only — Animal itself, and anything else that inherits from it, is untouched.

$ >>> class Dog(Animal):$ ...     def describe(self):$ ...         return f"{self.name} is a dog"$ ...$ >>> rex = Dog("Rex")$ >>> rex.describe()$ 'Rex is a dog'

Sometimes you do not want to replace the parent's version outright — you want the child's version to do its own thing and still run the parent's. Rewriting describe()'s whole body to include what Animal already did means copying that line; there is a way to avoid the copy.

super() gets you a reference to the parent class's version of a method, callable from inside the child's own override — without naming Animal directly, which matters more once a program has several levels of inheritance.

class Animal:    def __init__(self, name):        self.name = name     def describe(self):        return f"{self.name} is an animal" class Dog(Animal):    def describe(self):        base = super().describe()        return f"{base}, specifically a dog" print(Animal("Tom").describe())print(Dog("Rex").describe())

Try itAdd a Cat subclass with its own describe(), and print one.

__init__ is the most common place to reach for super(): a child that adds one new field, like a breed, still wants the parent to set up name the way it always has, rather than duplicating that line.

$ >>> class Dog(Animal):$ ...     def __init__(self, name, breed):$ ...         super().__init__(name)$ ...         self.breed = breed$ ...$ >>> rex = Dog("Rex", "Labrador")$ >>> rex.name$ 'Rex'$ >>> rex.breed$ 'Labrador'

Inheritance says this thing is a kind of that thing — a dog is a kind of animal. It fits badly the moment the relationship is really this thing has one of those instead — a car is not a kind of engine, it has an engine. Forcing that second shape into inheritance tends to produce a class hierarchy that fights the problem rather than describing it.

class Engine:    def start(self):        return "vroom" class Car:    def __init__(self):        self.engine = Engine()     def start(self):        return self.engine.start() print(Car().start())

Try itWrite an ElectricEngine whose start() returns something quieter, and give the car one.

Car does not inherit from Engine — it holds one, stored as an ordinary attribute, and start() delegates to it. Nothing about Car's own methods needs to know how the engine actually works, and swapping in an ElectricEngine later means changing one line, not restructuring a class hierarchy.