Python-Klassen: __init__, self, Methoden, Vererbung und Dataclasses

Eine Klasse umhüllt Daten und was du damit tust

Eine Klasse erlaubt dir, eine Art Ding zu definieren — eine Nutzerin, ein Bankkonto, eine Konfiguration, eine Anfrage — und alles, was dieses Ding tun können soll. Das Ding ist eine Instanz der Klasse. Die Aktionen heißen Methoden.

Die einfachste mögliche Klasse:

Zerlegt:

• class User: beginnt eine Klassendefinition. Klassennamen nutzen PascalCase per Konvention.
• __init__ ist der Initialisierer. Er läuft automatisch, wenn du eine neue Instanz erzeugst, und richtet die Attribute der Instanz über self.whatever = ... ein.
• greet ist eine Methode. self ist, wie eine Methode auf die Instanz zugreift, auf der sie läuft.
• User("Rosa", "rosa@example.com") erzeugt eine Instanz. Python ruft __init__ mit self als neue Instanz und den weiteren Argumenten auf.
• user.greet() ruft die Methode auf. Python reicht user automatisch als self hinein.

self ist einfach das erste Argument

self ist kein Schlüsselwort. Es ist der Name, mit dem Python den ersten Parameter von Instanzmethoden anspricht — die Instanz, auf der die Methode läuft. Du könntest es anders nennen; alle nutzen self, weil alle es tun.

Jede Instanzmethode nimmt self als ersten Parameter. So weiß eine Methode, welche Instanz sie lesen oder ändern soll.

Verhalten hinzufügen

Methoden können Zustand lesen und verändern:

__repr__ ist eine weitere besondere Methode — ein Haken für „wie zeige ich dieses Objekt beim Drucken?“. Ein gutes __repr__ lohnt sich beim Debuggen.

Klassenattribute vs. Instanzattribute

Attribute, die im Klassenrumpf (außerhalb von __init__) definiert werden, sind über alle Instanzen geteilt. An self zugewiesene Attribute sind pro Instanz:

Nutz Klassenattribute für wirklich geteilte Werte — Konstanten, Zähler, Konfiguration. Instanzspezifische Daten gehören in __init__.

Vererbung

Eine Klasse kann von einer anderen erben, bekommt ihre Methoden und Attribute umsonst und kann hinzufügen oder überschreiben, wie nötig:

super() gibt dir Zugriff auf die Elternklasse — häufig in __init__, um die Attribute der Elternklasse zu initialisieren, bevor du eigene hinzufügst:

Vererbung ist nützlich, wird aber leicht überstrapaziert. Einsteigerinnen greifen oft zu Vererbung, wo Komposition — ein Objekt als Attribut halten — klarer wäre. Fang mit einer flachen Klassenstruktur an und führ Vererbung nur dort ein, wo du eine echte „ist-ein“-Beziehung hast.

Dataclasses: ein angenehmerer Default für Datensätze

Willst du eine Klasse vor allem dafür, ein paar Attribute samt Gleichheits- und Darstellungsverhalten zu halten, erspart dir @dataclass viel Boilerplate:

Vergleich das mit dem Von-Hand-Schreiben von __init__, __repr__ und __eq__. Dataclasses sind die richtige erste Wahl, wenn du sonst class Thing mit nichts außer einem __init__ schreiben würdest, das Attribute setzt.

Properties: berechnete Attribute

Manchmal willst du ein „Attribut“, das eigentlich berechnet wird. @property lässt es wie Attributzugriff aussehen:

Setz Properties ein, wo du sonst obj.get_something() schreiben würdest — eine Property macht die API natürlicher. Nutz sie nicht, um teure Operationen zu verstecken; eine Nutzerin erwartet, dass Attributzugriff schnell ist.

Privat per Konvention

Python hat kein echtes Privat. Per Konvention gelten Attribute mit führendem Unterstrich als als privat gemeint — Leserinnen sollen sie von außerhalb der Klasse nicht anfassen:

class Cache:
    def __init__(self):
        self._store = {}

    def put(self, key, value):
        self._store[key] = value

    def get(self, key, default=None):
        return self._store.get(key, default)

Namen mit doppeltem Unterstrich (__name) lösen Name Mangling aus, das den Klassennamen dem Attribut voranstellt. Das ist ein Werkzeug, Kollisionen bei Vererbung zu vermeiden, keine Sicherheitsmaßnahme.

Wann du keine Klasse nutzt

Hast du nur ein Bündel zusammenhängender Daten, reicht ein dataclass, ein simples Dict oder ein Named Tuple. Hast du nur eine Funktion, braucht sie keine Klasse als Hülle. Greif zu Klassen, wenn du Zustand und Verhalten gebunden hast — besonders wenn du viele Instanzen derselben Art haben wirst.

Ein Abschlussbeispiel

Ein kleiner dateiähnlicher Log-Puffer:

Beachte __len__ — eine weitere Magic-Methode. Sie zu definieren lässt len(logger) funktionieren, denn len(x) ist in Wahrheit ein Aufruf von x.__len__(). Python hat Dutzende solcher Haken; du eignest sie dir nach Bedarf an.

Als Nächstes: Generatoren

Klassen binden Daten und Verhalten zusammen. Das nächste Kapitel behandelt eine andere Abstraktion — Iteration — und beginnt mit Generatoren: Funktionen, die Werte einzeln produzieren und dazwischen pausieren. Sie passen wunderbar zu with-Anweisungen / Context Managern, die direkt danach kommen.