__slots__ : le __dict__ a un coût __slots__: the __dict__ has a cost

Chaque instance porte, par défaut, son propre __dict__ — une table de hachage complète, allouée dynamiquement, prête à accueillir n'importe quel attribut à n'importe quel moment. Ce confort a un prix en mémoire, multiplié par chaque objet créé. __slots__ le supprime : les attributs deviennent des descripteurs à taille fixe. La mémoire économisée se paie en flexibilité perdue. Every instance carries, by default, its own __dict__ — a full hash table, dynamically allocated, ready to welcome any attribute at any moment. That comfort has a memory price, multiplied by every object created. __slots__ removes it: attributes become fixed-size descriptors. The memory saved is paid for in lost flexibility.

Audience
Dev qui a ajouté __slots__ à une classe et vu une AttributeError surgir sur un attribut qui marchait la veille Dev who added __slots__ to a class and watched an AttributeError appear on an attribute that worked yesterday
ChapitresChapters
5
LectureReading
≈ 18 min
NiveauLevel
●●●●
Date
Juil 2026 Jul 2026

__slots__MémoireDescripteurs

SommaireContents ·
№ 01CadrageFraming3 min

Le mot de l'éditeur précédent posait la question : combien coûte ce __dict__ que chaque instance porte, sans qu'on l'ait demandé ?The previous editorial's note posed the question: how much does that __dict__ every instance carries, unasked, actually cost?

Les numéros 16 et 17 ont supposé, sans jamais le questionner, qu'une instance porte un __dict__ — un dictionnaire ordinaire, capable d'accueillir n'importe quel attribut, à n'importe quel moment de la vie de l'objet. C'est ce confort qui permet self.nouvel_attribut = valeur sans jamais déclarer nouvel_attribut à l'avance. Ce confort a un coût mesurable : un dictionnaire alloué dynamiquement, avec sa table de hachage, ses collisions possibles, sa capacité qui grandit par paliers — même pour une classe aussi simple qu'un point à deux coordonnées, fixées une fois pour toutes dans __init__ et jamais renommées. Depuis Python 3.11, CPython retarde la construction de ce dictionnaire tant que personne ne le demande : le coût a fondu, il n'a pas disparu.Issues 16 and 17 both assumed, without ever questioning it, that an instance carries a __dict__ — an ordinary dictionary, able to welcome any attribute, at any point in the object's life. That comfort is what lets self.new_attribute = value work without ever declaring new_attribute ahead of time. That comfort has a measurable cost: a dynamically allocated dictionary, with its hash table, its possible collisions, its capacity growing in steps — even for a class as simple as a two-coordinate point, fixed once and for all in __init__ and never renamed. Since Python 3.11, CPython delays building that dictionary until someone asks for it: the cost has shrunk, not vanished.

Chaque instance reste prête à devenir un dictionnaire — et le paieEvery instance stays ready to become a dictionary — and pays for it
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2)
print(p.__dict__)    # {'x': 1, 'y': 2} -- un vrai dict, fabriqué à la demande

# depuis Python 3.11, CPython range x et y directement dans l'objet et ne
# construit ce dictionnaire que si on le réclame (comme ci-dessus) --
# mais chaque instance reste prête à accueillir n'importe quel nom,
# alors que Point n'en utilise que 2, toujours les mêmes, fixés dès __init__.
# Le coût réel se mesure au chapitre 3.
Le sous-réflexe du numéroThis issue's sub-reflex

Face à une classe qui crée des milliers d'instances aux attributs fixes et connus d'avance, demande : ai-je vraiment besoin qu'on puisse ajouter n'importe quel attribut, n'importe quand — ou est-ce que je paie pour une flexibilité que je n'utilise jamais ?Facing a class that creates thousands of instances with fixed, known-in-advance attributes, ask: do I really need the ability to add any attribute, at any time — or am I paying for flexibility I never use?

Un coût qui ne se voit que multipliéA cost only visible once multiplied

Une quarantaine d'octets par instance ne pèsent rien pour un objet unique. Multipliés par un million d'instances — un parseur, un jeu de données, une simulation — la différence se compte en dizaines de mégaoctets, davantage si le __dict__ finit par être matérialisé.Forty-odd bytes per instance weigh nothing for a single object. Multiplied by a million instances — a parser, a dataset, a simulation — the difference adds up to tens of megabytes, more if the __dict__ ends up materialized.

№ 02La surpriseThe surprise4 min

__slots__ ne réduit pas seulement la mémoire — il supprime le comportement le plus élémentaire d'un objet Python.__slots__ doesn't just shrink memory — it removes the most basic behavior a Python object has.

Ajouter un attribut à une instance, à tout moment, sans jamais le déclarer à l'avance, est l'un des comportements les plus universels de Python — presque aucune classe ordinaire ne le refuse. __slots__ déclare une liste fermée de noms autorisés et, ce faisant, retire purement et simplement le __dict__ de l'instance : tenter d'assigner un nom absent de cette liste lève une AttributeError, pas parce que le nom est mal orthographié, mais parce qu'il n'existe littéralement plus nulle part où l'écrire.Adding an attribute to an instance, at any time, without ever declaring it in advance, is one of the most universal behaviors in Python — almost no ordinary class refuses it. __slots__ declares a closed list of allowed names and, in doing so, plainly removes the instance's __dict__: attempting to assign a name absent from that list raises AttributeError, not because the name is misspelled, but because there's literally nowhere left to write it.

Sans __slots__, ajouter un attribut ne demande jamais rienWithout __slots__, adding an attribute never asks for anything
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2)
p.couleur = "rouge"      # AUCUN problème -- Python ne refuse presque jamais ça
print(p.couleur)          # "rouge"
print(p.__dict__)         # {'x': 1, 'y': 2, 'couleur': 'rouge'}
__slots__ n'ajoute rien. Il retire — le __dict__, et avec lui, la liberté d'improviser un attribut.__slots__ adds nothing. It removes — the __dict__, and with it, the freedom to improvise an attribute.
№ 03La mécaniqueThe mechanics5 min

Un slot n'est pas une case dans un dict plus petit. C'est le même protocole de descripteur que le numéro 17, à un emplacement fixe.A slot isn't a slot in a smaller dict. It's the same descriptor protocol from issue 17, at a fixed location.

__slots__ ne se contente pas de dire à Python « limite-toi à ces noms » : il déclenche, à la création de la classe, la génération automatique d'un descripteur de donnée pour chaque nom listé — exactement le protocole __get__/__set__ du numéro 17, mais écrit par l'interpréteur lui-même plutôt qu'à la main. Chaque descripteur pointe vers un emplacement fixe dans la structure C de l'objet, alloué une fois à la taille exacte du nombre de slots — au lieu d'un dictionnaire entier, capable de grandir pour accueillir un nombre de clés inconnu à l'avance.__slots__ doesn't just tell Python "limit yourself to these names": it triggers, at class-creation time, the automatic generation of a data descriptor for each listed name — the exact same __get__/__set__ protocol from issue 17, but written by the interpreter itself rather than by hand. Each descriptor points to a fixed location in the object's C structure, allocated once at the exact size of the slot count — instead of an entire dictionary, able to grow to accommodate an unknown number of keys ahead of time.

Un slot est un member_descriptor, généré par PythonA slot is a member_descriptor, generated by Python
class Point:
    __slots__ = ("x", "y")

    def __init__(self, x, y):
        self.x = x
        self.y = y

print(type(Point.__dict__["x"]))
# <class 'member_descriptor'>  -- "x" est un DESCRIPTEUR, pas une valeur !

print(Point.__dict__["x"].__get__)   # <method-wrapper '__get__' ...>
print(Point.__dict__["x"].__set__)   # <method-wrapper '__set__' ...>

# exactement le protocole du numéro 17 : __slots__ transforme "x" et "y"
# en descripteurs DE DONNÉE, générés automatiquement par Python -- chacun
# pointe vers un EMPLACEMENT FIXE dans la structure C de l'objet, au lieu
# d'une entrée dans un dictionnaire
D'où vient l'économie : une structure fixe remplace un dictionnaireWhere the savings come from: a fixed structure replaces a dictionary
import tracemalloc

class SansSlots:
    def __init__(self, x, y):
        self.x, self.y = x, y

class AvecSlots:
    __slots__ = ("x", "y")
    def __init__(self, x, y):
        self.x, self.y = x, y

def octets_par_instance(cls, n=100_000):
    tracemalloc.start()
    objets = [cls(1, 2) for _ in range(n)]
    taille, _ = tracemalloc.get_traced_memory()
    tracemalloc.stop()
    return taille / n

print(octets_par_instance(SansSlots))   # ~96 (CPython 3.14, pointeur de liste compris)
print(octets_par_instance(AvecSlots))   # ~56
# la structure à taille fixe (deux "cases" C, une par slot) remplace la
# place réservée au dictionnaire -- l'économie vient de LÀ, pas d'une magie.
# (sys.getsizeof trompe ici : il ne compte ni les valeurs rangées en ligne,
# ni le __dict__ tant qu'il n'existe pas.)
Plus léger, oui ; plus rapide, à peineLighter, yes; faster, barely

Un accès via descripteur (offset fixe, calculé une fois) évite tout hachage. Mais depuis Python 3.11, l'interpréteur spécialisé lit aussi les attributs d'une instance ordinaire sans hacher le nom — valeurs rangées dans l'objet, emplacement mis en cache à chaque site d'accès. Mesuré en 3.14, l'écart de vitesse est de l'ordre de quelques pour cent : le vrai gain de __slots__, c'est la mémoire.A descriptor-based access (fixed offset, computed once) skips hashing entirely. But since Python 3.11, the specializing interpreter also reads an ordinary instance's attributes without hashing the name — values stored in the object, location cached at each access site. Measured on 3.14, the speed gap is a few percent at most: __slots__' real gain is memory.

№ 04Le piègeThe trap4 min

Une sous-classe sans son propre __slots__ ressuscite le __dict__ — silencieusement, et annule tout le gain.A subclass without its own __slots__ resurrects __dict__ — silently, and cancels the entire gain.

__slots__ ne se propage pas automatiquement : une sous-classe qui n'en déclare pas hérite quand même de tous les slots de son parent, mais reçoit en prime un __dict__ ordinaire pour tout le reste — annulant discrètement l'économie mémoire recherchée. Un second piège, plus bruyant celui-là, surgit quand un nom de slot entre en collision avec un attribut de classe du même nom : Python refuse la classe entière avant même la première instance. Le vrai prix, cependant, n'est ni l'un ni l'autre : c'est la perte de flexibilité — monkey-patching, attributs dynamiques, sérialisation par défaut — sur des classes qui n'en avaient de toute façon jamais assez d'instances pour justifier l'optimisation.__slots__ doesn't propagate automatically: a subclass that declares none still inherits all its parent's slots, but gets an ordinary __dict__ thrown in for everything else — quietly canceling the memory savings being sought. A second, noisier trap appears when a slot name collides with a class attribute of the same name: Python refuses the entire class before the first instance even exists. The real price, though, is neither one — it's the loss of flexibility — monkey-patching, dynamic attributes, default serialization — on classes that never had enough instances to justify the optimization in the first place.

Une sous-classe muette sur __slots__ récupère un __dict__ completA subclass silent on __slots__ gets a full __dict__ back
class Point:
    __slots__ = ("x", "y")

class Point3D(Point):
    pass                        # PAS de __slots__ dans la sous-classe

p = Point3D()
p.x, p.y = 1, 2   # OK -- hérités du parent, toujours des slots
p.z = 3            # AUCUNE erreur !
print(p.__dict__)   # {'z': 3} -- le __dict__ est DE RETOUR

# une sous-classe qui n'annonce pas SON PROPRE __slots__ reçoit un __dict__
# par défaut -- toute l'économie mémoire du parent est annulée pour "z"
# (et implicitement réactivée pour tout le reste, via ce __dict__)
Le réflexe avant d'ajouter __slots__The reflex before adding __slots__

Mesure d'abord — tracemalloc, un profileur mémoire, un nombre réel d'instances en production — avant de sacrifier la flexibilité du __dict__. Un __slots__ ajouté par réflexe, sur une classe qui n'en crée que quelques dizaines d'instances, est une optimisation qui coûte plus qu'elle ne rapporte.Measure first — tracemalloc, a memory profiler, a real instance count in production — before sacrificing __dict__'s flexibility. A __slots__ added by reflex, on a class that only ever creates a few dozen instances, is an optimization that costs more than it earns.

№ 05Bilan & éditoWrap-up & editorial2 min

Le modèle d'attributs, refermé : chaque case a un prix, et Python te laisse toujours choisir lequel payer.The attribute model, closed: every slot has a price, and Python always lets you choose which one to pay.

Trois numéros pour une seule idée, creusée sous trois angles. Le №16 a posé la recherche d'attribut comme un algorithme à étages — instance, puis MRO — jamais un simple accès direct. Le №17 a montré qu'un de ces étages peut ne pas contenir une valeur, mais un descripteur qui exécute du code, avec la priorité que cela lui donne. Ce numéro a fermé la boucle en révélant que le __dict__ d'instance, présupposé partout jusqu'ici, est lui-même une conception parmi d'autres — remplaçable par des descripteurs à taille fixe, plus légers, au prix de la liberté d'improviser un attribut.Three issues for one idea, dug from three angles. №16 laid out attribute lookup as a tiered algorithm — instance, then MRO — never a plain direct access. №17 showed that one of those tiers might hold not a value but a descriptor running code, with the priority that grants it. This issue closed the loop by revealing that the instance __dict__, assumed everywhere until now, is itself just one design among others — replaceable by fixed-size descriptors, lighter, at the price of the freedom to improvise an attribute.

NuméroIssueCe qu'il a poséWhat it established
№ 16obj.x cherche d'abord l'instance, puis la classe dans l'ordre du MRO ; un attribut de classe mutable est partagé par toutes les instances.obj.x checks the instance first, then the class in MRO order; a mutable class attribute is shared by every instance.
№ 17Un descripteur de donnée (property) exécute du code et passe avant le __dict__ de l'instance — l'inverse de la règle du 16.A data descriptor (property) runs code and outranks the instance's __dict__ — the reverse of issue 16's rule.
№ 18__slots__ remplace le __dict__ par des descripteurs à taille fixe : mémoire gagnée, flexibilité perdue.__slots__ replaces __dict__ with fixed-size descriptors: memory gained, flexibility lost.
obj.x n'a jamais été gratuit. Une recherche, un descripteur, ou un __dict__ entier — quelqu'un paie toujours la facture.obj.x was never free. A search, a descriptor, or a whole __dict__ — someone always pays the bill.
Mot de l'éditeurFrom the editor

Le Vol. VI a résolu où vit un attribut. Le suivant pose une question tout aussi silencieuse : qui garantit qu'une ressource se referme ?Vol. VI resolved where an attribute lives. The next one asks an equally quiet question: who guarantees a resource gets closed?

Le numéro 08 avait montré que la syntaxe de Python passe par des dunders ; with n'y échappe pas, avec __enter__ et __exit__. Le prochain volume les met au travail : with ouvre un fichier, verrouille une ressource, ou établit une connexion — et garantit son nettoyage même si une exception traverse le bloc, là où compter sur le simple retour d'une fonction ne suffit jamais tout à fait. Ce n'est pas une nouvelle syntaxe de confort ; c'est un contrat, au même titre que le protocole d'itération du Vol. IV.Issue 08 showed that Python's syntax runs through dunders; with is no exception, with __enter__ and __exit__. The next volume puts them to work: with opens a file, locks a resource, or establishes a connection — and guarantees its cleanup even if an exception crosses the block, where relying on a function's plain return is never quite enough. This isn't a new convenience syntax; it's a contract, on the same footing as Vol. IV's iteration protocol.

Prochain numéro : with, le nettoyage garanti. __enter__/__exit__ ; pourquoi f.close() en fin de fonction ne suffit pas ; le context manager comme invariant de ressource. Ouverture du Vol. VII.Next issue: with, guaranteed cleanup. __enter__/__exit__; why f.close() at the end of a function isn't enough; the context manager as a resource invariant. Opening Vol. VII.