The __init__ Constructor

By the end of this lesson you can:

• Define __init__(self, ...) with parameters for every required attribute.
• Pass arguments when constructing: Hero("Aisyah", 100, 12).
• Use default parameter values for optional attributes.
• Recognise __init__ as a dunder (double-underscore) method and know there are more coming.

Yesterday's Hero needed four lines of attribute setup every time:

aisyah = Hero()
aisyah.name   = "Aisyah"
aisyah.hp     = 100
aisyah.max_hp = 100
aisyah.attack = 12

For three heroes, that's twelve lines of grunt work. Plus it's easy to forget one and crash later when a method reads a missing attribute.

Today: one line.

aisyah = Hero("Aisyah", 100, 12)

The shape

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

Three new things:

• __init__ with double underscores on both sides — pronounced "dunder init".
• Parameters after self become the arguments you pass when constructing.
• Each assignment puts a value on self — the new instance's attributes.

Constructing

aisyah = Hero("Aisyah", 100, 12)
wei_jie = Hero("Wei Jie", 85, 18)

print(aisyah.name, aisyah.hp, aisyah.attack)    # → Aisyah 100 12
print(wei_jie.name, wei_jie.hp, wei_jie.attack) # → Wei Jie 85 18

You don't pass self at the call site — Python fills it in. You pass the rest of the parameters.

Default parameters

Make some attributes optional with defaults — same syntax as a regular function.

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

a = Hero("Aisyah")                   # uses defaults
b = Hero("Wei Jie", 85)              # custom hp, default attack
c = Hero("Priya", attack=25)         # custom attack only, default hp
d = Hero("Iman", hp=70, attack=15)   # both custom

Defaults shine for "sensible starting values" — most heroes start at 100 HP, some at different.

Default to an empty list — the famous trap

You'd think this is fine:

class Hero:
    def __init__(self, name, inventory=[]):    # ❌ DON'T DO THIS
        self.name = name
        self.inventory = inventory

a = Hero("Aisyah")
b = Hero("Wei Jie")

a.inventory.append("sword")
print(b.inventory)        # → ['sword']  -- WHAT?!

Bug! The default [] is created once at function-definition time and reused. Both heroes share the same list.

Fix: use None and check inside.

class Hero:
    def __init__(self, name, inventory=None):
        self.name = name
        self.inventory = inventory if inventory is not None else []

This trap catches every Python developer at least once. Remember the rule: never use mutable defaults (list, dict, set). Use None and create a fresh one inside.

__init__ can do more than assignments

It can call other methods, validate input, compute derived values, even print.

class Hero:
    def __init__(self, name, hp=100, attack=10):
        if hp <= 0:
            raise ValueError(f"hp must be positive, got {hp}")
        self.name   = name
        self.hp     = hp
        self.max_hp = hp
        self.attack = attack
        print(f"  ✦ Hero {name} created with {hp} HP")

a = Hero("Aisyah")
# → ✦ Hero Aisyah created with 100 HP

Validation in __init__ means a bad Hero never exists in the first place — better than letting it slip through and crash later.

Dunders are coming

__init__ is the first of many "dunder" (double-underscore) methods. They let you hook into Python's built-in behaviour. Coming up later in Level 3:

__init__   construction       Hero("Aisyah")
__str__    print formatting    print(hero)         → PY-L3-14
__eq__     equality            hero1 == hero2      → PY-L3-15
__lt__     ordering            hero1 < hero2       → PY-L3-15
__add__    addition            a + b               → PY-L3-16
__len__    len()               len(hero)           → PY-L3-16

Each dunder is Python's way of saying "customise this builtin". __init__ customises construction — the rest customise other operators.

Save as hero_v2.py:

# hero_v2.py — Hero with __init__

class Hero:
    def __init__(self, name, hp=100, attack=10, inventory=None):
        if hp <= 0:
            raise ValueError(f"hp must be positive, got {hp}")
        self.name      = name
        self.hp        = hp
        self.max_hp    = hp
        self.attack    = attack
        self.inventory = inventory if inventory is not None else []

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

    def heal(self, amount):
        self.hp = min(self.max_hp, self.hp + amount)

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

    def report(self):
        items = ", ".join(self.inventory) or "(empty)"
        return f"{self.name:<10} HP {self.hp:>3}/{self.max_hp:<3} ATK {self.attack:>2}  inventory: {items}"

# One-line construction!
party = [
    Hero("Aisyah", hp=100, attack=12, inventory=["sword", "potion"]),
    Hero("Wei Jie", hp=85, attack=18, inventory=["bow"]),
    Hero("Priya", attack=25),                  # uses default hp
    Hero("Iman"),                              # all defaults
]

print(f"Party of {len(party)}:")
for h in party:
    print("  " + h.report())

# Test the validation
try:
    bad = Hero("Bug", hp=-1)
except ValueError as e:
    print(f"\nCorrectly rejected: {e}")

Output

Party of 4:
  Aisyah     HP 100/100 ATK 12  inventory: sword, potion
  Wei Jie    HP  85/85  ATK 18  inventory: bow
  Priya      HP 100/100 ATK 25  inventory: (empty)
  Iman       HP 100/100 ATK 10  inventory: (empty)

Correctly rejected: hp must be positive, got -1

Read the diff

Four heroes, four one-liners. Compare to PY-L3-03 — sixteen lines of attribute setup replaced by four constructor calls. The __init__ handles defaults, the mutable-default trap, validation, derived attributes (max_hp from hp), and is impossible to forget — Python has to call it.

__init__ is the constructor — Python calls it automatically when you build an instance. Put every attribute assignment in there. Use default parameter values for optional attributes. Never use a mutable default like [] or {} — use None and create a fresh one inside. __init__ can also validate input by raising exceptions; bad instances never exist. __init__ is just the first of many dunders — more coming through Level 3.