Dataclasses (@dataclass, Python 3.7+) முக்கியமாக data-ஐ வைத்திருக்கும் classes-க்கான boilerplate methods-ஐ தானாக உருவாக்குகின்றன. __slots__ என்பது per-instance __dict__-ஐ தவிர்ப்பதன் மூலம் memory-ஐ குறைத்து attribute access-ஐ வேகப்படுத்தும் ஒரு optimization ஆகும்.
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 annotate செய்யப்பட்ட fields-இலிருந்து __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 instances-ஐ immutable ஆக்குகிறது; field(default_factory=list) mutable defaults-ஐ பாதுகாப்பாக வழங்குகிறது (shared-mutable-default பொறியைத் தவிர்க்கிறது).
# 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__
பொதுவாக ஒவ்வொரு instance-ம் attributes-ஐ ஒரு dynamic __dict__-இல் சேமிக்கிறது. __slots__ அதற்குப் பதிலாக ஒரு compact, fixed structure-இல் சேமிக்கப்படும் fixed attributes தொகுப்பை அறிவிக்கிறது — குறிப்பிடத்தக்க memory-ஐ சேமித்து access-ஐ வேகப்படுத்துகிறது, நெகிழ்வுத்தன்மையின் செலவில் (தன்னிச்சையான attributes சேர்க்க முடியாது).
@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 பரவலாகப் பயன்படுத்தப்படும் நவீன அம்சமாகும், இது data-வைத்திருக்கும் classes-க்கான மீண்டும் வரும் boilerplate-ஐ நீக்குகிறது — code-ஐ தூய்மையாக, பிழைக்கு-குறைவான வாய்ப்புள்ளதாக, மற்றும் மிகவும் படிக்கக்கூடியதாக ஆக்குகிறது (தானாக உருவாக்கப்படும் __init__/__repr__/__eq__, கூடுதலாக immutability மற்றும் பாதுகாப்பான defaults).
இவை அத்தகைய classes-ஐ கைமுறையாக எழுதுவதற்கு அல்லது mutability/methods தேவைப்படும்போது namedtuple-ஐ பயன்படுத்துவதற்கு idiomatic நவீன மாற்றாகும். __slots__ என்பது நீங்கள் பெரும் எண்ணிக்கையிலான objects-ஐ உருவாக்கும்போது memory-ஐ அர்த்தமுள்ள வகையில் குறைத்து attribute access-ஐ வேகப்படுத்தும் ஒரு குறிப்பிட்ட performance optimization ஆகும்.
இரண்டையும் அறிந்துகொள்வது — அன்றாட தூய்மையான data modeling-க்கு @dataclass மற்றும் memory-முக்கிய hot paths-க்கு __slots__ (இப்போது slots=True வழியாக இணைக்கக்கூடியது) — திறமையான, பராமரிக்கக்கூடிய Python classes எழுதுவதற்கான தற்போதைய சிறந்த நடைமுறைகளைப் பிரதிபலிக்கிறது.