0Pricing
Python Academy · Lektion

__slots__ und Speicheroptimierung

Verwenden Sie __slots__, um den Speicheraufwand pro Instanz zu reduzieren.

__slots__ und Speicheroptimierung ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Der zusätzliche Speicherbedarf von __dict__

Standardmäßig speichert jede Python-Instanz Attribute in einem __dict__-Dictionary, das einen erheblichen Speicher-Overhead verursacht – typischerweise 200–400 Bytes pro Instanz.

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__ deklarieren

Definieren Sie __slots__ als Sequenz von Attributnamen. Python reserviert statt eines Dicts ein Array fester Größe und spart dadurch Speicher.

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__

Speichereinsparungen

Mit __slots__ spart jede Instanz im Vergleich zu einer auf einem Dict basierenden Instanz typischerweise 30–50 % Speicher ein – besonders relevant bei der Erstellung von Millionen Objekten.

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)

Standardmäßig kein __dict__

Eine Klasse mit __slots__ besitzt kein __dict__. Daher können Sie nach der Erstellung keine beliebigen Attribute hinzufügen.

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__ mit __slots__ beibehalten

Nehmen Sie "__dict__" in __slots__ auf, um ein Dictionary pro Instanz beizubehalten und häufig verwendete Attribute weiterhin vorab als Slots zu deklarieren.

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 mit __slots__ verlieren die Unterstützung für schwache Referenzen. Fügen Sie "__weakref__" zu __slots__ hinzu, um sie wieder zu aktivieren.

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>

Vererbung und __slots__

Wenn eine übergeordnete Klasse __slots__ nicht verwendet, besitzt auch die untergeordnete Klasse ein __dict__. Für die vollständige Einsparung muss die gesamte Vererbungshierarchie __slots__ definieren.

class Base:
    __slots__ = ("x",)

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

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

Speicherverbrauch messen

Verwenden Sie tracemalloc oder pympler, um den tatsächlichen Speicherverbrauch vor und nach dem Hinzufügen von __slots__ zu messen.

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__ und Pickling

Objekte mit __slots__ können serialisiert werden, wenn Sie __getstate__ und __setstate__ definieren oder das Standard-Pickle-Protokoll verwenden, das Slots ab Python 3 automatisch verarbeitet.

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 mit __slots__ — Python 3.10+

Übergeben Sie slots=True an @dataclass, um __slots__ automatisch zu erzeugen.

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

Wann __slots__ verwenden

Verwenden Sie __slots__, wenn Sie Millionen von Instanzen erstellen, der Speicher begrenzt ist oder die Geschwindigkeit des Attributzugriffs entscheidend ist. Verzichten Sie bei allgemeinen Klassen darauf, wenn Flexibilität wichtiger ist.

# 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

Kurzer Test

Was geschieht, wenn Sie bei einer Instanz mit __slots__ versuchen, ein nicht in __slots__ aufgeführtes Attribut zu setzen?

Zusammenfassung

__slots__ ersetzt das __dict__ pro Instanz durch ein Array fester Größe und spart dadurch 30–50 % Speicher. Nehmen Sie "__dict__" oder "__weakref__" auf, wenn Sie diese benötigen. Für die vollständige Einsparung muss die gesamte Vererbungskette __slots__ verwenden. Verwenden Sie in Python 3.10+ @dataclass(slots=True).

Häufig gestellte Fragen

Ist die Lektion „__slots__ und Speicheroptimierung“ kostenlos?

Ja — der vollständige Text von „__slots__ und Speicheroptimierung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „__slots__ und Speicheroptimierung“?

Verwenden Sie __slots__, um den Speicheraufwand pro Instanz zu reduzieren. Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „__slots__ und Speicheroptimierung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Wie Python-Klassen erstellt werden
  2. Benutzerdefinierte Metaklassen schreiben
  3. Deskriptoren: __get__, __set__, __delete__
  4. __slots__ und Speicheroptimierung
← Zurück zu Python Academy