`__init__` constructor — initializing attributes

2.1.2 · Coding › OOP Fundamentals

WHY `init` exist karta hai?

Intuition Constructor ki zarurat kyun hai

Ek setup method ke bina, har object khali paida hota, aur tumhe creation ke baad manually data attach karna padta:

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

Yeh fragile hai — ek line bhool gaye aur tumhara object toot gaya. __init__ attribute setup ko mandatory aur automatic banata hai: data creation ke waqt hi dena padta hai, isliye har object guaranteed valid hota hai.

WHAT exactly hai `init`?

HOW actually ek call kaam karta hai? (Scratch se derivation)

Chalte hain derive karte hain ki obj = Person("Asha", 30) step by step actually kya karta hai. Kuch bhi magic nahi hai.

Step 1 — Class ko call karna type.__call__ trigger karta hai. Kyun? Ek class khud ek object hai (type ka instance). Usmein () use karna type.__call__ invoke karta hai.

Step 2 — __call__ ek blank object allocate karne ke liye __new__ call karta hai.

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

Kyun? Fill karne se pehle tumhe ek memory shell chahiye.

Step 3 — __call__ us blank object par __init__ call karta hai.

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

Yeh step kyun? Yahan self.name = name actually run hota hai, data attach karta hai.

Step 4 — __call__ obj return karta hai. Kyun? Taaki obj = Person(...) ko finished object mile.

Toh equivalence jo tum derive aur verify kar sakte ho:

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 — kyun? Left side self.name object par ek attribute hai; right side name local parameter hai. Yeh alag-alag cheezein hain jinhe ek hi naam share karna hota hai. Hum parameter ko object mein copy karte hain taaki __init__ khatam hone ke baad bhi woh bana rahe.

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)

Default kyun? Taaki callers common values skip kar sakein. balance=0 define hone par evaluate hota hai — theek hai kyunki 0 immutable hai (Mistake 3 dekho).

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

Yahan compute kyun karein? Agar area kabhi nahi badalta, toh har access ki jagah __init__ mein ek baar compute kar lo. (Agar radius baad mein badal sakta, toh tum property use karte.)

Worked example 4. Constructor mein validation

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

Yahan validate kyun karein? __init__ woh single gateway hai jisse har object guzarta hai, isliye yeh invariants guarantee karne ki perfect jagah hai — koi bhi invalid object kabhi exist nahi kar sakta.

Common Mistakes (Steel-manned)

Common mistake 1.

self bhool jaana

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

Kyun sahi lagta hai: name = name lagta hai "name set karo." Kyun galat hai: self. ke bina, tum sirf local variable ko touch kar rahe ho, jo __init__ return hone par gayab ho jaata hai. Fix: self.name = name.

Common mistake 2. Object "banana" ke liye ise directly call karna

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

Kyun sahi lagta hai: __init__ lagta hai woh cheez jo objects build karti hai. Kyun galat hai: __init__ sirf object fill karta hai; yeh None return karta hai. Fix: class ko call karo: p = Person("Asha", 30).

Common mistake 3. Mutable default argument

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

Kyun sahi lagta hai: "har naya object khali list se start hota hai." Kyun galat hai: [] function definition ke waqt ek baar create hota hai aur sabhi objects ke beech share hota hai jo default use karte hain — appends instances ke paar leak ho jaate hain. Fix:

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

Common mistake 4.

__init__ se value return karna

def __init__(self):
    return self          # WRONG -> TypeError

Fix: __init__ ko None return karna zaroori hai. Sirf attributes set karo; kabhi value return mat karo.

Forecast-then-Verify

Recall Run karne se pehle predict karo

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

Output forecast karo, phir confirm karo. (Answer: 12 — __init__ w=3, h=4 ke saath run hota hai aur unka product store karta hai.)

Flashcards

__init__ kab call hota hai?

Automatically, naya object create hone ke turant baad (Cls(...) ke dauran).

Kya __init__ object create karta hai?

Nahi — __new__ blank object create karta hai; __init__ sirf uske attributes initialize karta hai.

self kya hai?

Us specific instance ka reference jo initialize ho raha hai; automatically pehle parameter ke roop mein pass hota hai.

__init__ ko kya return karna chahiye?

None (kuch aur return karne par TypeError aata hai).

__init__ mein self.name = name aur name = name mein kya fark hai?

Pehla object par data store karta hai (persist karta hai); doosra sirf ek local variable reassign karta hai (jo __init__ khatam hone par chala jaata hai).

def __init__(self, x=[]) kyun dangerous hai?

Default list ek baar create hoti hai aur sab instances mein share hoti hai; x=None use karo phir andar [] assign karo.

Cls(args) kismein expand hota hai?

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

__init__ ke andar validation kyun rakhein?

Yeh woh single gateway hai jisse sab objects guzarte hain, isliye yeh guarantee karta hai ki koi invalid object exist nahi karta.

Recall Feynman: ek 12-saal ke bacche ko explain karo

Socho tum ek brand-new school bag khareed rahe ho. Dukaan pehle tumhe ek khali bag deta hai (yeh __new__ hai). Phir, tumhe dene se pehle, woh usmein tumhara name tag, books, aur pencils fill karta hai taaki woh use ke liye ready ho (yeh __init__ hai). self bas "yeh bag" hai — jab woh likhte hain "is bag ka naam = Asha," unka matlab hai tumhara specific bag, kisi aur ka nahi. Har bag usi filling station se guzarta hai, isliye koi bag kabhi khali ya toota hua nahi jaata.

Connections

OOP Fundamentals — __init__ object creation ki foundation hai.
self and instance attributes — self.x = ... actually kya store karta hai.
__new__ vs __init__ — allocation vs initialization.
Class vs Instance Attributes — __init__ instance attributes set karta hai.
Properties and computed attributes — __init__ mein compute karne ka alternative.
Mutable default argument pitfall — shared-default trap.
Dunder methods — __init__ kai special methods mein se ek hai.

`init` constructor — initializing attributes