Method Overriding & super()

By the end of this lesson you can:

• Override a parent method by redefining it in the child with the same name.
• Call the parent's version from inside the override with super().method(...).
• Choose between "replace" and "extend" depending on whether you still want the parent's behaviour.
• Recognise when super() is necessary — and when it isn't.

In yesterday's homework, each Media child class redefined describe() with a custom format. That's overriding.

class Media:
    def describe(self):
        print(f"  {self.title} ({self.year})")

class Book(Media):
    def describe(self):                  # ← override
        print(f"  📖 {self.title} by {self.author}")

When you call book.describe(), Python uses the child's version. The parent's version is hidden — Python checks the child first.

Pure override · the "replace" pattern

When you want completely different behaviour, just redefine the method:

class Animal:
    def speak(self):
        print("Generic noise.")

class Dog(Animal):
    def speak(self):                # ← totally replaces
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow.")

Dog().speak()       # → Woof!
Cat().speak()       # → Meow.
Animal().speak()    # → Generic noise.

Same method name, different body. No call to super() — we don't want any of the parent's behaviour.

super() · the "extend" pattern

When you want the parent's behaviour plus a bit extra, call super().method(...) inside your override:

class Logger:
    def save(self, data):
        with open("log.txt", "a") as f:
            f.write(data + "\n")
        print("Saved.")

class TimestampLogger(Logger):
    def save(self, data):
        from datetime import datetime
        stamped = f"[{datetime.now().isoformat()}] {data}"
        super().save(stamped)          # ← parent does the heavy lifting

The child adds the timestamp; the parent still handles the file writing. Each class does its bit.

The classic example · __init__

Almost every child __init__ calls super().__init__(...):

class Vehicle:
    def __init__(self, wheels, max_speed):
        self.wheels    = wheels
        self.max_speed = max_speed

class Car(Vehicle):
    def __init__(self, brand, max_speed):
        super().__init__(wheels=4, max_speed=max_speed)
        self.brand = brand                  # extra Car-only attr

The parent handles wheels and max_speed. The child only writes the brand-new attribute. Clean.

The forgotten super() bug

If you forget super().__init__(), the parent's attributes are never set:

class Vehicle:
    def __init__(self, wheels):
        self.wheels = wheels

class Bike(Vehicle):
    def __init__(self):
        # forgot super!
        self.brand = "Schwinn"

b = Bike()
print(b.wheels)
# AttributeError: 'Bike' object has no attribute 'wheels'

The Bike has a brand but no wheels. Always call super().__init__ when overriding __init__ — unless you have a deliberate reason not to.

Calling another method via super

class Document:
    def save(self):
        print("Saving document...")

class SignedDocument(Document):
    def save(self):
        print("Signing...")
        super().save()
        print("Done signing + saving.")

SignedDocument().save()
# Signing...
# Saving document...
# Done signing + saving.

Three behaviours in one method — before, parent call, after. The classic "sandwich" pattern.

When you DON'T need super()

If the child's logic completely replaces the parent's — the "Dog says Woof, not generic noise" case — skip super entirely.

Save as animals.py:

# animals.py — override + super patterns

class Animal:
    def __init__(self, name, sound="generic noise"):
        self.name  = name
        self.sound = sound
        print(f"[Animal] {self.name} was born.")

    def speak(self):
        print(f"  {self.name} says: {self.sound}")

    def describe(self):
        print(f"=== {self.name} ===")
        self.speak()


class Dog(Animal):
    """Pure override — totally different speak."""

    def speak(self):
        print(f"  {self.name} barks: WOOF WOOF!")


class Cat(Animal):
    """Pure override — totally different speak."""

    def speak(self):
        print(f"  {self.name} purrs: meow~")


class TimestampedAnimal(Animal):
    """Extend pattern — wrap parent's speak with timestamps."""

    def speak(self):
        from datetime import datetime
        print(f"  [{datetime.now().strftime('%H:%M:%S')}]")
        super().speak()        # delegate to parent
        print(f"  (end of message)")


class Parrot(Animal):
    """Extend __init__ — add an extra attribute."""

    def __init__(self, name, vocabulary):
        super().__init__(name, sound="squawk")
        self.vocabulary = vocabulary           # Parrot-only

    def speak(self):
        super().speak()         # parent's speak first
        import random
        word = random.choice(self.vocabulary)
        print(f"  Then says: {word!r}")


# Test
print("\n--- Dog ---")
fido = Dog("Fido")
fido.describe()

print("\n--- Cat ---")
whiskers = Cat("Whiskers")
whiskers.describe()

print("\n--- Timestamped ---")
ts = TimestampedAnimal("Bear")
ts.describe()

print("\n--- Parrot ---")
polly = Parrot("Polly", vocabulary=["hello", "cracker", "pretty bird"])
polly.describe()
polly.describe()        # different word each time

Sample output

[Animal] Fido was born.

--- Dog ---
=== Fido ===
  Fido barks: WOOF WOOF!

[Animal] Whiskers was born.

--- Cat ---
=== Whiskers ===
  Whiskers purrs: meow~

[Animal] Bear was born.

--- Timestamped ---
=== Bear ===
  [22:31:04]
  Bear says: generic noise
  (end of message)

[Animal] Polly was born.

--- Parrot ---
=== Polly ===
  Polly says: squawk
  Then says: 'cracker'

Read the diff

Four children, three patterns. Dog and Cat replace speak entirely. TimestampedAnimal extends speak — same parent behaviour plus timestamps. Parrot extends both __init__ (super() + extra attribute) and speak (super() + extra print). Notice describe is inherited from Animal — it doesn't care which kind of animal it's describing; it just calls self.speak() and the right version runs. That's polymorphism, formalised in lesson 11.

Overriding a method = redefining it in the child. Python uses the child's version when called on a child instance. To extend the parent rather than replace it, call super().method(...) inside the override. The classic case is __init__ — almost every child __init__ starts with super().__init__(...). Forgetting that leaves the parent's attributes unset. Pure replace skips super; extend uses it.