Dataclasses (@dataclass, Python 3.7+) డేటాను ఎక్కువగా హోల్ డ్ చేసే క్లాసుల కోసం boilerplate పద్ధతులను ఆటోమేటిక్గా జెనరేట్ చేస్తుంది. __slots__ అనేది ఒక ఆప్టిమైజేషన్ ఇది ప్రతి-ఇన్స్టెన్స్ __dict__ను నివారించడం ద్వారా మెమరీని తగ్గిస్తుంది మరియు ఆట్రిబ్యూట్ యాక్సెస్ను వేగవంతం చేస్తుంది.
from dataclasses import dataclass
# ❌ without dataclass — lots of repetitive boilerplate
class Point:
def __init__(self, x, y):
self.x = x; self.y = y
def __repr__(self):
return f"Point(x={self.x}, y={self.y})"
def __eq__(self, other):
return (self.x, self.y) == (other.x, other.y)
# ✅ with @dataclass — all of the above generated automatically
@dataclass
class Point:
x: int
y: int
p = Point(1, 2)
p # Point(x=1, y=2) — __repr__ generated
p == Point(1, 2) # True — __eq__ generated
@dataclass annotateed ఫీల్డ్ల నుండి __init__, __repr__, __eq__ (మరియు ఐచ్ఛికంగా ordering/hashing)ను జెనరేట్ చేస్తుంది — అలసిపోయిన, ఎర్రర్-చిత్తశూన్య boilerplate ను తొలగిస్తుంది.
from dataclasses import dataclass, field
@dataclass(frozen=True) # frozen → immutable (hashable, usable as dict key)
class Config:
name: str
tags: list = field(default_factory=list) # mutable default done safely
timeout: int = 30 # default value
frozen=True ఇన్స్టెన్సెస్ను మార్పులేనిదిగా చేస్తుంది; field(default_factory=list) సురక్షితంగా mutable డిఫాల్ట్లను అందిస్తుంది (shared-mutable-default trap ను నివారించడం).
# normally, each instance has a __dict__ to store attributes (flexible but memory-heavy)
class Regular:
def __init__(self, x, y): self.x, self.y = x, y
# __slots__ → fixed attribute set, NO per-instance __dict__
class Slotted:
__slots__ = ("x", "y") # only these attributes allowed
def __init__(self, x, y): self.x, self.y = x, y
s = Slotted(1, 2)
s.z = 3 # ❌ AttributeError — can't add attributes not in __slots__
సాధారణంగా ప్రతి ఇన్స్టెన్స్ ఆట్రిబ్యూట్లను dynamic __dict__లో నిల్వ చేస్తుంది. __slots__ ఆట్రిబ్యూట్ల యొక్క స్థిర సెట్ను ప్రకటించుకుంటుంది, బదులుగా compact, స్థిర కట్టమైనవిలో నిల్వ చేయబడుతుంది — ముఖ్యమైన మెమరీని సేవ్ చేస్తుంది మరియు యాక్సెస్ను వేగవంతం చేస్తుంది, లెక్సిబిలిటీ ఖర్చుతో (నిరంకుశ ఆట్రిబ్యూట్లను జోడించలేము).
@dataclass(slots=True) # Python 3.10+ — dataclass WITH __slots__
class Point:
x: int
y: int
@dataclass → any class that's mostly data (DTOs, configs, records) — cleaner, less code
__slots__ → when you create MANY instances (millions) and memory/speed matters
(e.g. nodes in a big data structure, large simulations)
Dataclasses డేటా-హోల్డింగ్ క్లాసుల కోసం పునరావృత boilerplate ను తొలగించే విస్తృతంగా-ఉపయోగించబడే ఆధునిక లక్షణం — కోడ్ను స청్ఛార్, తక్కువ error-prone, మరియు మరింత readable చేస్తుంది (ఆటోమేటిక్గా-జెనరేట్ చేసిన __init__/__repr__/__eq__, ప్లస్ immutability మరియు safe defaults).
వాటిని మానవీయంగా వ్రాయడానికి లేదా మీకు mutability/methods కావాలనుకున్నప్పుడు namedtuple ఉపయోగించుటకు బదులుగా అవి idiomatic ఆధునిక ప్రత్యామ్నాయం. __slots__ అనేది targeted performance optimization ఇది huge numbers of objects ను instantiate చేసినప్పుడు మెమరీని meaningful పరిధిలో తగ్గిస్తుంది మరియు ఆట్రిబ్యూట్ యాక్సెస్ను వేగవంతం చేస్తుంది.
ఎరిపెరోజ్ రెండింటినీ తెలుసుకోవడం — రోజువారీ clean data modeling కోసం @dataclass మరియు memory-critical hot paths కోసం __slots__ (ఇప్పుడు slots=True ద్వారా కలపవచ్చు) — efficient, maintainable Python classes రాయటానికి ప్రస్తుత best practices ను ప్రతిబింబిస్తుంది.