Dataclasses (@dataclass, Python 3.7+) génèrent automatiquement des méthodes boilerplate pour les classes qui contiennent principalement des données. __slots__ est une optimisation qui réduit la mémoire et accélère l'accès aux attributs en évitant le __dict__ par instance.
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 génère __init__, __repr__, __eq__ (et optionnellement l'ordre/hachage) à partir des champs annotés — supprime les boilerplate fastidieux et sujets aux erreurs.
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 rend les instances immuables ; field(default_factory=list) fournit en toute sécurité des valeurs par défaut mutables (évite le piège des valeurs par défaut mutables partagées).
# 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__
Normalement, chaque instance stocke les attributs dans un __dict__ dynamique. __slots__ déclare à la place un ensemble fixe d'attributs stockés dans une structure fixe et compacte — économise une mémoire significative et accélère l'accès, au détriment de la flexibilité (ne peut pas ajouter d'attributs arbitraires).
@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)
Les dataclasses sont une fonctionnalité moderne largement utilisée qui élimine les boilerplate répétitifs pour les classes contenant des données — rend le code plus propre, moins sujet aux erreurs et plus lisible (auto-généré __init__/__repr__/__eq__, plus immuabilité et valeurs par défaut sûres).
C'est l'alternative moderne idiomatique à l'écriture manuelle de telles classes ou à l'utilisation de namedtuple lorsque vous avez besoin de mutabilité/méthodes. __slots__ est une optimisation de performance ciblée qui réduit significativement la mémoire et accélère l'accès aux attributs lorsque vous instanciez un énorme nombre d'objets.
Connaître les deux — @dataclass pour la modélisation de données propre au quotidien et __slots__ (maintenant combinable via slots=True) pour les chemins critiques en mémoire — reflète les meilleures pratiques actuelles pour écrire des classes Python efficaces et maintenables.