Inheritance and super()

By the end of this lesson you can:

• Write a child class with class Child(Parent): and use what it inherits.
• Override a method so the child behaves differently.
• Call super() to reuse the parent's __init__ or method instead of copying it.
• Decide whether two classes really are parent and child, or just similar.

Two classes, written a week apart. Predict the last line.

class Hero:
    def __init__(self, name, hp=100):
        self.name = name
        self.hp = hp

    def take_damage(self, amount):
        self.hp = max(0, self.hp - amount)


class Monster:
    def __init__(self, name, hp=40):
        self.name = name
        self.hp = hp

    def take_damage(self, amount):
        self.hp = self.hp - amount


felix = Hero("Felix")
slime = Monster("Slime")
felix.take_damage(150)
slime.take_damage(150)
print(felix.hp, slime.hp)

0 -110

Write the shared part once, in a parent class:

class Character:
    """Anything in the game with a name that can be hurt."""

    def __init__(self, name, hp):
        self.name = name
        self.max_hp = hp
        self.hp = hp

    def take_damage(self, amount):
        """Lower hp, never below zero."""
        self.hp = max(0, self.hp - amount)

    def is_alive(self):
        return self.hp > 0

    def __str__(self):
        return f"{self.name}: {self.hp}/{self.max_hp} HP"

Then say that a hero is a character. The brackets after the class name are the whole syntax:

class Hero(Character):
    """A character the player controls."""

That child already works, and it has everything:

felix = Hero("Felix", 100)
felix.take_damage(30)
print(felix)
print(felix.is_alive())

Output

Felix: 70/100 HP
True

Nothing was copied. Hero borrows the parent's __init__, its methods and its rules — including the "never below zero" fix, which now exists in exactly one place.

Adding things the parent has not got means writing the child's own __init__ — and calling the parent's from inside it, so you do not retype the three lines it already does:

class Hero(Character):
    """A character the player controls. Carries potions."""

    def __init__(self, name, hp=100, potions=2):
        super().__init__(name, hp)
        self.potions = potions

super() means "the parent of this class". So super().__init__(name, hp) runs Character.__init__ on this same object, and then the child adds one more attribute.

Overriding is writing a method the parent already has. The child's version wins:

class Monster(Character):
    """A character the game controls. Tough hide."""

    def take_damage(self, amount):
        """Monsters ignore the first 2 points of every hit."""
        super().take_damage(max(0, amount - 2))

Notice what the override did not do: it did not rewrite the "never below zero" rule. It adjusts the number and hands the work to the parent. That is the difference between replacing a method and extending it, and extending is nearly always the one you want.

The same trick works on __str__:

    def __str__(self):
        return super().__str__() + f" - potions: {self.potions}"

Type this out and run it. Look at how little is in the two child classes.

class Character:
    """Anything in the game with a name that can be hurt."""

    def __init__(self, name, hp):
        self.name = name
        self.max_hp = hp
        self.hp = hp

    def take_damage(self, amount):
        """Lower hp, never below zero."""
        self.hp = max(0, self.hp - amount)

    def is_alive(self):
        """Return True while there is any hp left."""
        return self.hp > 0

    def __str__(self):
        return f"{self.name}: {self.hp}/{self.max_hp} HP"


class Hero(Character):
    """A character the player controls. Carries potions."""

    def __init__(self, name, hp=100, potions=2):
        super().__init__(name, hp)
        self.potions = potions

    def drink_potion(self):
        """Heal 30 hp, never above max. Return False if none are left."""
        if self.potions == 0:
            return False
        self.potions = self.potions - 1
        self.hp = min(self.max_hp, self.hp + 30)
        return True

    def __str__(self):
        return super().__str__() + f" - potions: {self.potions}"


class Monster(Character):
    """A character the game controls. Tough hide, drops loot."""

    def __init__(self, name, hp, loot):
        super().__init__(name, hp)
        self.loot = loot

    def take_damage(self, amount):
        """Monsters ignore the first 2 points of every hit."""
        super().take_damage(max(0, amount - 2))


felix = Hero("Felix")
slime = Monster("Slime", 40, "5 gold")

print(felix)
print(slime)

slime.take_damage(12)
print("Felix attacks!", slime)

felix.take_damage(25)
print("The slime hits back.", felix)

felix.drink_potion()
print("Felix drinks a potion.", felix)

slime.take_damage(32)
print("Felix attacks again.", slime)

if not slime.is_alive():
    print("The slime is defeated. You find", slime.loot)

Output

Felix: 100/100 HP - potions: 2
Slime: 40/40 HP
Felix attacks! Slime: 30/40 HP
The slime hits back. Felix: 75/100 HP - potions: 2
Felix drinks a potion. Felix: 100/100 HP - potions: 1
Felix attacks again. Slime: 0/40 HP
The slime is defeated. You find 5 gold

Two experiments worth doing now:

• Add self.gold = 0 to Character.__init__. Both children get it, immediately, with no other edit.
• Ask Python about the family: print(isinstance(slime, Character)) prints True, because a monster really is a character.

class Child(Parent): gives the child every attribute and method the parent has. Write a method the parent already has and the child's version wins — that is overriding. super() reaches the parent's version, so super().__init__(name, hp) reuses its setup and super().take_damage(...) extends its behaviour instead of replacing it. Never pass self to super(), and never write it without brackets. Use inheritance only when "a child is a parent" is a true sentence.