PricingLoginStart free
Python Academy · Les

__slots__ en geheugenoptimalisatie

Gebruik __slots__ om de geheugenoverhead per instantie te verminderen.

Les 4 van 413 stappen

__slots__ en geheugenoptimalisatie is een gratis Python Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Python Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Python Academy bevat in totaal 4 lessen.

De standaardoverhead van __dict__

Standaard slaat elke Python-instantie attributen op in een __dict__-woordenboek, wat een aanzienlijke geheugenoverhead veroorzaakt — doorgaans 200-400 bytes per instantie.

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

__slots__ declareren

Definieer __slots__ als een reeks attribuutnamen. Python wijst een array met vaste grootte toe in plaats van een woordenboek, waardoor je geheugen bespaart.

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__

Geheugenbesparing

Met __slots__ bespaart elke instantie doorgaans 30-50% geheugen ten opzichte van een instantie op basis van een woordenboek — een aanzienlijk verschil wanneer je miljoenen objecten maakt.

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)

Standaard geen __dict__

Een klasse met __slots__ heeft geen __dict__, dus je kunt na het maken ervan geen willekeurige attributen toevoegen.

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

__dict__ behouden met __slots__

Neem "__dict__" op in __slots__ om een woordenboek per instantie te behouden en tegelijkertijd veelgebruikte attributen vooraf als slots te declareren.

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

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

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

__weakref__ in __slots__

Klassen met slots verliezen ondersteuning voor zwakke verwijzingen. Voeg "__weakref__" toe aan __slots__ om die ondersteuning opnieuw in te schakelen.

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>

Overerving en __slots__

Als een bovenliggende klasse geen __slots__ gebruikt, krijgt de afgeleide klasse toch een __dict__. Voor volledige besparing moet de hele hiërarchie __slots__ definiëren.

class Base:
    __slots__ = ("x",)

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

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

Geheugengebruik meten

Gebruik tracemalloc of pympler om het werkelijke geheugengebruik te meten voordat en nadat je __slots__ toevoegt.

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")

Picklen van __slots__

Objecten met slots kunnen worden gepickled als je __getstate__ en __setstate__ definieert, of als je het standaard pickle-protocol gebruikt dat slots vanaf Python 3 automatisch verwerkt.

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

dataclasses met __slots__ — Python 3.10+

Geef slots=True door aan @dataclass om automatisch __slots__ te laten genereren.

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

Wanneer gebruik je __slots__

Gebruik __slots__ wanneer je miljoenen instanties maakt, weinig geheugen beschikbaar hebt of wanneer de snelheid van attribuuttoegang cruciaal is. Laat het weg bij algemene klassen waarbij flexibiliteit belangrijker is.

# 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

Korte controle

Wat gebeurt er wanneer je bij een instantie met slots een attribuut probeert in te stellen dat niet in __slots__ staat?

Beantwoord dit in de interactieve les

Samenvatting

__slots__ vervangt de __dict__ per instantie door een array met vaste grootte, waardoor je 30-50% geheugen bespaart. Neem "__dict__" of "__weakref__" op als je die nodig hebt. De volledige overervingsketen moet __slots__ gebruiken voor volledige besparing. Gebruik in Python 3.10+ @dataclass(slots=True).

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
76
Lessen
320
Gratis beginnen met lerenBekijk de volledige cursus

Veelgestelde vragen

Is de les “__slots__ en geheugenoptimalisatie” gratis?

Ja — de volledige tekst van “__slots__ en geheugenoptimalisatie” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Python Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Python Academy bevat in totaal 4 lessen.

Wat leer ik in “__slots__ en geheugenoptimalisatie”?

Gebruik __slots__ om de geheugenoverhead per instantie te verminderen. Je oefent met Python Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Python Academy te beginnen?

Ervaring vooraf is niet nodig. Python Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “__slots__ en geheugenoptimalisatie”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Python Academy?

Ja. Elke les over Python Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Hoe Python-klassen worden gemaakt
  2. Aangepaste metaklassen schrijven
  3. Descriptors: __get__, __set__, __delete__
  4. __slots__ en geheugenoptimalisatie
← Terug naar Python Academy