`__init__` constructor — initializing attributes

WHY does `init` exist?

Intuition Why we need a constructor at all

Without a setup method, every object would be born empty, and you'd have to manually attach data after creating it:

p = Person()          # empty object
p.name = "Asha"       # easy to forget!
p.age = 30            # easy to forget!

This is fragile — forget one line and your object is broken. __init__ makes attribute setup mandatory and automatic: the data must be supplied at creation time, so every object is guaranteed valid.

WHAT exactly is `init`?

HOW does a call actually work? (Derivation from scratch)

Let's derive what obj = Person("Asha", 30) really does, step by step. Nothing is magic.

Step 1 — Calling the class triggers type.__call__. Why? A class is itself an object (instance of type). Using () on it invokes type.__call__.

Step 2 — __call__ calls __new__ to allocate a blank object.

obj = Person.__new__(Person)     # empty Person, no attributes yet

Why? You need a memory shell before you can fill it.

Step 3 — __call__ calls __init__ on that blank object.

Person.__init__(obj, "Asha", 30) # self=obj, name="Asha", age=30

Why this step? This is where self.name = name actually runs, attaching data.

Step 4 — __call__ returns obj. Why? So obj = Person(...) gets the finished object.

So the equivalence you can derive and verify:

Figure — `__init__` constructor — initializing attributes

Worked Examples

Worked example 1. Basic constructor

class Person:
    def __init__(self, name, age):
        self.name = name      # store arg on the object
        self.age = age
 
p = Person("Asha", 30)
print(p.name, p.age)          # Asha 30

self.name = name — why? Left side self.name is an attribute on the object; right side name is the local parameter. They are different things that happen to share a name. We copy the parameter into the object so it survives after __init__ ends.

Worked example 2. Default values

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
 
a = Account("Ravi")          # balance defaults to 0
b = Account("Sita", 500)

Why a default? So callers can omit common values. balance=0 is evaluated when defined — fine because 0 is immutable (see Mistake 3).

Worked example 3. Derived / computed attributes

class Circle:
    def __init__(self, radius):
        self.radius = radius
        self.area = 3.14159 * radius ** 2   # computed once at build time
 
c = Circle(2)
print(c.area)   # 12.56636

Why compute here? If area never changes, compute it once in __init__ instead of every access. (If radius could change later, you'd use a property instead.)

Worked example 4. Validation in the constructor

class Temperature:
    def __init__(self, celsius):
        if celsius < -273.15:
            raise ValueError("Below absolute zero!")
        self.celsius = celsius

Why validate here? __init__ is the single gateway every object passes through, so it's the perfect place to guarantee invariants — no invalid object can ever exist.

Common Mistakes (Steel-manned)

Common mistake 1. Forgetting

self

def __init__(self, name):
    name = name          # WRONG: just reassigns the local

Why it feels right: name = name looks like "set name." Why it's wrong: with no self., you only touch the local variable, which vanishes when __init__ returns. Fix: self.name = name.

Common mistake 2. Calling it directly to "make" an object

p = Person.__init__("Asha", 30)   # WRONG — returns None

Why it feels right: __init__ looks like the thing that builds objects. Why it's wrong: __init__ only fills an object; it returns None. Fix: call the class: p = Person("Asha", 30).

Common mistake 3. Mutable default argument

def __init__(self, items=[]):   # DANGER
    self.items = items

Why it feels right: "every new object starts with an empty list." Why it's wrong: the [] is created once at function definition and shared by all objects that use the default — appends leak across instances. Fix:

def __init__(self, items=None):
    self.items = items if items is not None else []

Forecast-then-Verify

Recall Predict before you run

class Box:
    def __init__(self, w, h):
        self.area = w * h
 
b = Box(3, 4)
print(b.area)

Forecast the output, then confirm. (Answer: 12 — __init__ runs with w=3, h=4 and stores their product.)

Flashcards

When is __init__ called?

Automatically, right after a new object is created (during Cls(...)).

Does __init__ create the object?

No — __new__ creates the blank object; __init__ only initializes its attributes.

What is self?

A reference to the specific instance being initialized; passed automatically as the first parameter.

What must __init__ return?

None (returning anything else raises TypeError).

Difference between self.name = name and name = name in __init__?

The first stores data on the object (persists); the second only reassigns a local variable (lost when __init__ ends).

Why is def __init__(self, x=[]) dangerous?

The default list is created once and shared across all instances; use x=None then assign [] inside.

What does Cls(args) expand to?

o = Cls.__new__(Cls); Cls.__init__(o, args); return o.

Why put validation inside __init__?

It's the single gateway all objects pass through, so it guarantees no invalid object exists.

Recall Feynman: explain to a 12-year-old

Imagine buying a brand-new schoolbag. The shop first hands you an empty bag (that's __new__). Then, before giving it to you, they fill it with your name tag, books, and pencils so it's ready to use (that's __init__). self is just "this bag" — when they write "this bag's name = Asha," they mean your specific bag, not someone else's. Every bag goes through the same filling station, so no bag ever leaves empty or broken.

Connections

OOP Fundamentals — __init__ is the foundation of object creation.
self and instance attributes — what self.x = ... actually stores.
__new__ vs __init__ — allocation vs initialization.
Class vs Instance Attributes — __init__ sets instance attributes.
Properties and computed attributes — alternative to computing in __init__.
Mutable default argument pitfall — the shared-default trap.
Dunder methods — __init__ is one of many special methods.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, jab tum p = Person("Asha", 30) likhte ho, toh do alag cheezein hoti hain. Pehle Python ek khaali object banata hai (ye __new__ ka kaam hai), aur phir turant __init__ naam ka special method chalata hai jo us khaali object ke andar data bharta hai. Isliye __init__ ko constructor ya setup method bolte hain — iska kaam object create karna nahi, balki uske attributes initialize karna hai.

self ka matlab hai "yehi object jo abhi ban raha hai". Jab tum self.name = name likhte ho, toh iska matlab hai "is object ke upar name naam ka attribute store kar do". Yahan left side self.name object ka hissa hai jo baad tak rahega, aur right side name sirf ek local parameter hai jo __init__ khatam hote hi gaayab ho jaata hai. Agar tum sirf name = name likh do bina self. ke, toh data kahin save nahi hota — ye sabse common galti hai.

Constructor important kyun hai? Kyunki ye ek single gateway hai jise har object ko paar karna padta hai. Yahan tum default values de sakte ho, validation laga sakte ho (jaise temperature -273.15 se neeche nahi), aur guarantee kar sakte ho ki koi bhi galat object kabhi bane hi na. Bas ek warning: default argument me kabhi mutable cheez ([] ya {}) mat do — woh saare objects me share ho jaati hai. Uski jagah None do aur andar [] bana lo.

`init` constructor — initializing attributes

WHY does `init` exist?

WHAT exactly is `init`?

HOW does a call actually work? (Derivation from scratch)

Worked Examples

Common Mistakes (Steel-manned)

Forecast-then-Verify

Flashcards

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — OOP Fundamentals

Connections