0Pricing
Python Academy · Leçon

__slots__ et optimisation de la mémoire

Utilisez __slots__ pour réduire la surcharge mémoire de chaque instance.

__slots__ et optimisation de la mémoire est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

La surcharge du __dict__ par défaut

Par défaut, chaque instance Python stocke ses attributs dans un dictionnaire __dict__, ce qui entraîne une surcharge mémoire importante : généralement 200 à 400 octets par instance.

import sys

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

p = Point(1, 2)
print(sys.getsizeof(p.__dict__))   # ~200 bytes

Déclarer __slots__

Définissez __slots__ comme une séquence de noms d'attributs. Python alloue un tableau de taille fixe au lieu d'un dictionnaire, ce qui économise de la mémoire.

class SlottedPoint:
    __slots__ = ("x", "y")

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

p = SlottedPoint(1, 2)
print(p.x, p.y)   # 1 2
# p.z = 3   # AttributeError: no __dict__

Économies de mémoire

Avec __slots__, chaque instance utilise généralement 30 à 50 % de mémoire en moins qu'une instance fondée sur un dictionnaire, ce qui est considérable lorsque vous créez des millions d'objets.

import sys

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

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

print(sys.getsizeof(Reg(1,2)))      # ~56 bytes + ~200 dict
print(sys.getsizeof(Slotted(1,2)))  # ~56 bytes (no dict)

Pas de __dict__ par défaut

Une classe utilisant __slots__ ne possède pas de __dict__ : vous ne pouvez donc pas ajouter d'attributs arbitraires après sa création.

class Config:
    __slots__ = ("host", "port")
    def __init__(self, h, p): self.host, self.port = h, p

c = Config("localhost", 8080)
# c.debug = True   # AttributeError
print(hasattr(c, "__dict__"))   # False

Conserver __dict__ avec __slots__

Incluez "__dict__" dans __slots__ pour conserver un dictionnaire propre à chaque instance tout en déclarant à l'avance les attributs courants comme emplacements.

class Hybrid:
    __slots__ = ("x", "__dict__")

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

h = Hybrid(1)
h.extra = "dynamic"   # allowed
print(h.extra)

__weakref__ dans __slots__

Les classes utilisant __slots__ perdent la prise en charge des références faibles. Ajoutez "__weakref__" à __slots__ pour la réactiver.

import weakref

class Node:
    __slots__ = ("value", "__weakref__")
    def __init__(self, v): self.value = v

n = Node(42)
ref = weakref.ref(n)
print(ref())  # <Node object>

Héritage et __slots__

Si une classe parente n'utilise pas __slots__, la classe enfant possède tout de même un __dict__. Pour bénéficier d'économies maximales, toute la hiérarchie doit définir __slots__.

class Base:
    __slots__ = ("x",)

class Child(Base):
    __slots__ = ("y",)   # no __dict__

class WithoutSlots(Base):
    pass   # gets __dict__ from object

Mesurer la mémoire

Utilisez tracemalloc ou pympler pour mesurer l'utilisation réelle de la mémoire avant et après l'ajout de __slots__.

import tracemalloc

tracemalloc.start()
points = [SlottedPoint(i, i) for i in range(100_000)]
current, peak = tracemalloc.get_traced_memory()
tracemalloc.stop()
print(f"Peak: {peak/1024/1024:.1f} MB")

__slots__ et la sérialisation avec pickle

Les objets utilisant __slots__ peuvent être sérialisés avec pickle si vous définissez __getstate__ et __setstate__, ou si vous utilisez le protocole pickle par défaut, qui gère automatiquement les emplacements depuis Python 3.

import pickle

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

p = Point(3, 4)
data = pickle.dumps(p)
p2 = pickle.loads(data)
print(p2.x, p2.y)   # 3 4

Classes de données avec __slots__ — Python 3.10+

Transmettez slots=True à @dataclass pour générer automatiquement __slots__.

from dataclasses import dataclass

@dataclass(slots=True)
class Vector:
    x: float
    y: float

v = Vector(1.0, 2.0)
print(v.x, v.y)   # 1.0 2.0
print(hasattr(v, "__dict__"))   # False

Quand utiliser __slots__

Utilisez __slots__ lorsque vous créez des millions d'instances, que la mémoire est limitée ou que la vitesse d'accès aux attributs est essentielle. Évitez-le pour les classes à usage général lorsque la flexibilité est plus importante.

# Good candidates:
# - Nodes in a large graph or tree
# - Records in a large dataset
# - High-frequency event objects

# Bad candidates:
# - Configuration objects added to ad-hoc
# - Classes that mix-in dynamic attributes

Vérification rapide

Que se passe-t-il lorsque vous essayez de définir, sur une instance utilisant __slots__, un attribut qui n'y est pas répertorié ?

Récapitulatif

__slots__ remplace le __dict__ propre à chaque instance par un tableau de taille fixe, ce qui économise 30 à 50 % de mémoire. Incluez "__dict__" ou "__weakref__" si vous en avez besoin. Toute la chaîne d'héritage doit utiliser __slots__ pour bénéficier d'économies maximales. Avec Python 3.10+, utilisez @dataclass(slots=True).

Questions Fréquemment Posées

La leçon « __slots__ et optimisation de la mémoire » est-elle gratuite ?

Oui — le texte complet de « __slots__ et optimisation de la mémoire » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « __slots__ et optimisation de la mémoire » ?

Utilisez __slots__ pour réduire la surcharge mémoire de chaque instance. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « __slots__ et optimisation de la mémoire » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Comment les classes Python sont créées
  2. Écrire des métaclasses personnalisées
  3. Descripteurs : __get__, __set__, __delete__
  4. __slots__ et optimisation de la mémoire
← Retour à Python Academy