2.1.16
Intuition 30-second pictureJab bhi tum Python mein ek "plain data holder" class likhte ho, tumhe baar baar wahi boilerplate likhni padti hai: ek __init__ jo args ko self mein copy kare, ek __repr__ taaki printing garbage na lage, ek __eq__ taaki do objects value se compare ho sakein. @dataclass ek code generator hai jo woh boilerplate tumhare liye likhta hai class ke annotated fields se. Tum declare karte ho kya data hold karna hai ; Python fill karta hai kaise construct/print/compare karna hai .
Ek class jo @dataclass se decorated hoti hai (dataclasses module se). Yeh decorator class ke type-annotated class attributes (uske fields ) ko inspect karta hai aur automatically dunder methods generate karta hai jaise __init__, __repr__, aur __eq__.
from dataclasses import dataclass
@dataclass class Point : x: float # field (must be annotated!) y: float label: str = "P" # field with default Yeh single declaration roughly equivalent hai haath se likhne ke:
class Point : def __init__ (self, x: float , y: float , label: str = "P" ): self .x = x self .y = y self .label = label def __repr__ (self): return f "Point(x= {self .x !r } , y= {self .y !r } , label= {self .label !r } )" def __eq__ (self, other): if other. __class__ is not self . __class__ : return NotImplemented return ( self .x, self .y, self .label) == (other.x, other.y, other.label)
Intuition WHY annotations mandatory hainDecorator fields dhundta hai __annotations__ padh ke. Ek bare x = 5 jisme koi annotation nahi hai woh usse invisible hai — woh sirf ek ordinary class attribute hai, field nahi . Type khud (float, str) runtime pe kabhi enforce nahi hoti; yeh sirf ek signal hai "yeh ek field hai."
Chalte hain step by step mental model banate hain — Feynman-style — taaki magic gayab ho jaaye.
Step 1 — Fields collect karo. Python cls.__annotations__ padhta hai, ek ordered dict {name: type}. Order = source order. Kyun? __init__ ka parameter order field order se match karna chahiye.
Step 2 — Defaults dhundho. Har annotated name ke liye check karo ki koi class-level value exist karti hai (label = "P"). Agar hai toh woh default hai. Kyun? Taaki __init__(... label="P") generate kiya ja sake.
Common mistake Mutable default trapKyun galat idea sahi lagta hai: normal functions mein tum likhte def f(items=[]) aur (galti se) sochte ke har call ko fresh list milti hai. Dataclasses mein, items: list = [] toh banned hi hai — Python ValueError raise karta haisaare instances mein shared ho jaati.
Fix: field(default_factory=list) use karo.
from dataclasses import field @dataclass class Cart : items: list = field( default_factory = list ) # fresh list per instance Kyun yeh kaam karta hai: default_factory ek callable hai jo har __init__ pe ek baar call hoti hai , isliye har object ko apni list milti hai.
Step 3 — __init__ generate karo. Ek function string banao: parameters field order mein, defaults attached, body = self.<name> = <name>. Kyun generated function? Runtime pe reflection ke mukable speed + correctness.
Step 4 — __repr__ / __eq__ generate karo jab tak tumne disable na kiya ho (@dataclass(repr=False)). __eq__ fields ka tuple compare karta hai. Kyun tuple? Tuple comparison lexicographic, field-by-field equality free mein deta hai.
Intuition WHY yeh exist karta haiGenerated __init__ sirf dumb assignment karta hai self.x = x. Lekin kabhi kabhi tumhe derived fields ya validation chahiye hoti hai construction ke turant baad. Kyunki tumne __init__ nahi likha, tumhare paas woh logic rakhne ki jagah nahi hai. __post_init__ woh hook hai jo generated __init__ apne bilkul end mein call karta hai.
__post_init__
Ek method jo tum manually define karte ho. Agar present hai, toh auto-generated __init__ self.__post_init__() ko apne last statement ke roop mein call karta hai, saare fields assign hone ke baad. Isse validation aur derived values compute karne ke liye use karo.
from dataclasses import dataclass, field
@dataclass class Rectangle : width: float height: float area: float = field( init = False ) # NOT a constructor arg; we compute it
def __post_init__ (self): if self .width <= 0 or self .height <= 0 : raise ValueError ( "dimensions must be positive" ) self .area = self .width * self .height
field(init=False)
WHY: area derived hai, caller ke dwara supply nahi hoti. init=False isse __init__ ki parameter list se hata deta hai, isliye Rectangle(3, 4) valid hai aur area __post_init__ mein fill hoti hai.
Worked example Example 1 — equality for free@dataclass class Color : r: int ; g: int ; b: int
Color( 255 , 0 , 0 ) == Color( 255 , 0 , 0 ) # True Color( 255 , 0 , 0 ) == Color( 0 , 0 , 0 ) # False True kyun?__eq__ (255,0,0) == (255,0,0) ko tuples ki tarah compare karta hai → equal. Yeh step kyun matter karta hai: ek plain class yahan False print karta, kyunki default __eq__ identity (memory address) compare karta hai, values nahi.
Worked example Example 2 —__post_init__ validation + derivation
@dataclass class Celsius : temp: float fahrenheit: float = field( init = False ) def __post_init__ (self): if self .temp < - 273.15 : raise ValueError ( "below absolute zero" ) self .fahrenheit = self .temp * 9 / 5 + 32
c = Celsius( 100 ) c.fahrenheit # 212.0 Yeh step kyun? temp pehle auto-__init__ se assign hoti hai; phir __post_init__ run karta hai, isliye self.temp pehle se available hai fahrenheit compute karne ke liye. Order matter karta hai — derived logic assignment ke baad honi chahiye.
Worked example Example 3 — frozen (immutable) + hashable@dataclass ( frozen = True ) class Money : amount: int currency: str
m = Money( 10 , "USD" ) # m.amount = 20 -> raises FrozenInstanceError {m: "ten dollars" } # works: frozen dataclasses get __hash__ Frozen hash kyun deta hai? Mutable objects safe dict keys nahi ho sakte (unki value change ho sakti hai), isliye by default mutable dataclasses __hash__ = None set karte hain. frozen=True attribute writes forbid karta hai → values stable hain → Python __hash__ generate kar sakta hai. Yeh step kyun matter karta hai: sirf frozen dataclasses set members / dict keys ke roop mein usable hain.
Common mistake Frozen dataclass ke__post_init__ mein field modify karna
Kyun sahi lagta hai: tum "sirf ek derived field set karna chahte ho." Lekin frozen=True saare self.x = ... block karta hai, __post_init__ ke andar bhi. Fix: ek derived field ke liye freeze bypass karne ke liye object.__setattr__(self, "name", value) use karo.
Recall Feynman: 12-year-old ko explain karoSocho tum har baar naya toy banate waqt wahi form bharte ho: naam, colour, size. @dataclass ek robot stamp hai — tum sirf blanks list karo (naam, colour, size) aur robot poora form likhta hai, plus ek tarika usse zor se padhne ka aur ek tarika check karne ka ki do toys same hain ki nahi . __post_init__ ek "ab double-check karo" step hai: robot form fill karne ke baad, woh tumhari chhoti checklist run karta hai ("size zero nahi ho sakta!") aur extra cheezein compute kar sakta hai ("total price = price × quantity").
Mnemonic Pipeline yaad rakho"FIDE-P" — F ields collected → I nit generated → D efaults applied → E q/repr made → P ost_init runs last.
What does the @dataclass decorator auto-generate from annotated fields? __init__, __repr__, aur __eq__ (plus __hash__ agar frozen ho).
Why must dataclass fields be type-annotated? Decorator fields dhundta hai __annotations__ padh ke; ek un-annotated x = 5 sirf ek class attribute hai, field nahi.
When is __post_init__ called? Auto-generated __init__ ke last statement ke roop mein, saare fields assign hone ke baad.
Why is items: list = [] an error in a dataclass? Ek mutable list saare instances mein shared ho jaati; Python ValueError raise karta hai. field(default_factory=list) use karo.
What does field(init=False) do? Field ko __init__ ke parameters se hata deta hai; typically baad mein __post_init__ mein set hoti hai.
Why does frozen=True make a dataclass hashable? Fields creation ke baad change nahi ho sakte, isliye hash stable rehta hai; Python __hash__ generate karta hai. Mutable dataclasses __hash__ = None set karte hain.
How do you assign a derived field inside __post_init__ of a frozen dataclass? object.__setattr__(self, "name", value) freeze bypass karne ke liye.
How does the generated __eq__ compare two instances? Woh saare fields ka tuple field-by-field compare karta hai (aur same class require karta hai).
What's default_factory and why use it over default? Ek zero-arg callable jo mutable defaults ke liye har instance pe ek baar invoke hoti hai, har object ko apna object deti hai.
OOP Fundamentals — dataclasses classes ke data-holding pattern ka shortcut hain.Dunder Methods __init__ __repr__ __eq__ — woh jo decorator actually generate karta hai.Immutability and Hashing — frozen=True aur __hash__.Default Arguments and Mutable Default Trap — same bug, different syntax.NamedTuple vs Dataclass vs TypedDict — kab kaunsa choose karna hai.Type Annotations in Python — kyun annotations field detection drive karti hain.
Declare what data you hold
field(default_factory=list)
