Instance attributes vs class attributes — Hinglish notes

2.1.3 · Coding › OOP Fundamentals

DO TARAH ke attributes kyun hote hain?

Yeh precisely KYAN hain

class Dog:
    species = "Canis familiaris"      # class attribute (shared)
 
    def __init__(self, name):
        self.name = name              # instance attribute (per object)

Python actually attributes kaise lookup karta hai (key mechanism)

Yeh ek asymmetry (read = upar search karo, write = hamesha instance pe) neeche ki har tricky behaviour explain karti hai.

Figure — Instance attributes vs class attributes

Lookup rule se "shadowing" behaviour derive karna

Worked example Class attribute ko read karna phir write karna

class Dog:
    species = "Canis familiaris"
    def __init__(self, name): self.name = name
 
a = Dog("Rex")
b = Dog("Fido")
 
print(a.species)      # 'Canis familiaris'
print(b.species)      # 'Canis familiaris'

Yeh step kyun? Kisi bhi instance ke apne __dict__ mein species nahi hai, toh lookup class tak fall through karta hai → dono same shared value dekhte hain.

a.species = "Wolf"    # WRITE → `a` pe ek instance attribute banata hai
print(a.species)      # 'Wolf'   (instance copy class ko shadow karti hai)
print(b.species)      # 'Canis familiaris' (b abhi bhi class tak fall through karta hai)
print(Dog.species)    # 'Canis familiaris' (class untouched!)

Yeh step kyun? a.species likhna write rule follow karta hai: usne a.__dict__ mein ek brand-new key banayi. Ab a ki read usse pehle (step 1) dhundh leti hai, toh class value shadow ho gayi, overwrite nahi. b aur Dog unaffected hain.

Dog.species = "Doggo"   # class change karo → jo shadow nahi karte woh sab dekhte hain
print(a.species)        # 'Wolf'   (a shadows karta hai)
print(b.species)        # 'Doggo'  (b updated class tak fall through karta hai)

Yeh step kyun? Class pe editing karna single shared copy ko change karta hai; har wo instance jiske paas apna species nahi hai woh nayi value live dekhta hai.

Famous trap: mutable class attributes

Worked example Shared mutable list sabko kaatati hai

class Dog:
    tricks = []                 # class attribute — EK shared list
    def __init__(self, name): self.name = name
    def add_trick(self, t): self.tricks.append(t)   # KOI assignment nahi!
 
a, b = Dog("Rex"), Dog("Fido")
a.add_trick("roll")
print(b.tricks)     # ['roll']  😱 Fido ne Rex ki trick seekh li

Yeh kyun hota hai? self.tricks.append(...) ek read hai (shared class list dhundh leta hai) phir us object ko mutate karta hai. Koi self.tricks = ... assignment nahi hai, toh koi instance copy kabhi nahi banti. Dono dogs ek hi list share karte hain.

Fix — ise per-object instance attribute banao:

class Dog:
    def __init__(self, name):
        self.name = name
        self.tricks = []        # har instance ke liye fresh list (ek assignment!)
    def add_trick(self, t): self.tricks.append(t)

Fix kyun kaam karta hai? Har __init__ self.tricks = [] run karta hai, ek assignment → har instance ke __dict__ mein alag list create hoti hai.

Common mistakes (Steel-manned)

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

Socho ek classroom hai. Saamne ek whiteboard hai jo sabke saath share hoti hai — agar teacher uspe "Homework: page 5" likhe, toh har student wahi message dekhta hai. Yahi class attribute hai. Har student ke paas apni notebook bhi hai. Main apni notebook mein jo likhta hoon woh sirf mera hai; teri blank rehti hai. Yahi instance attribute hai. Tricky part: agar main "homework change" karna chahoon, toh ya toh (a) apni notebook mein naya note likhoon (ab sirf main apna version dekhta hoon — whiteboard unchanged hai), ya (b) chalkboard tak jaake whiteboard rewrite karoon (sab ka homework change ho jaata hai). Python ka self.x = ... hamesha "apni notebook mein likho" hai; ClassName.x = ... hai "whiteboard rewrite karo".

Active recall

Class attribute physically kahan stored hota hai?

Class ke namespace mein (ClassName.__dict__); saare instances ke liye ek shared copy.

Instance attribute kahan stored hota hai?

Us object ke apne namespace mein (obj.__dict__); har instance ki alag copy.

Python READ pe obj.x kaise resolve karta hai?

Pehle instance __dict__, phir class, phir MRO ke zariye base classes.

obj.x = value hamesha kya karta hai, chahe x class attribute tha ya nahi?

INSTANCE pe x create/update karta hai; class ko kabhi modify nahi karta.

"Shadowing" kya hai?

Jab ek instance attribute same naam ke class attribute ko lookup mein hide karta hai, kyunki instance pehle search hota hai.

Mutable class attribute (jaise tricks = []) instances mein kyun share hota hai?

Kyunki .append() single shared object ka read+mutate hai; bina assignment ke koi per-instance copy kabhi nahi banti.

Shared-mutable-default bug kaise fix karte hain?

__init__ ke andar har instance ke liye fresh object assign karo (self.tricks = []).

Ek class attribute ko SAB instances ke liye ek saath kaise change karte hain?

Class pe hi reassign karo: ClassName.attr = new_value.

a.species = "Wolf" ke baad, Dog.species kya return karega?

Unchanged original class value — a ne sirf ek shadowing instance attribute add kiya.

Kya Python mein class attributes immutable hote hain?

Nahi; "class" sirf batata hai woh kahan rehte hain, immutability nahi — inhe class name ke zariye reassign kiya ja sakta hai.

Connections

OOP Fundamentals
Classes and objects
The self parameter
__init__ constructor
Inheritance and MRO
Namespaces and scope
Mutable vs immutable objects