In Python bilden Klassen und Objekte die Grundlage der objektorientierten Programmierung (OOP). Klassen bieten eine Möglichkeit, einen Entwurf für die Erstellung von Objekten zu definieren, die Instanzen einer Klasse sind. Mit diesem leistungsstarken Programmierparadigma kannst Du Deinen Code organisieren und strukturieren, indem Du zusammengehörige Daten und Funktionen in wiederverwendbaren Objekten kapselst.

Dieses Konzept ist von realen Objekten inspiriert. So wie Objekte in der realen Welt Attribute und Verhaltensweisen haben, haben sie in Python Attribute (Daten) und Methoden (Funktionen), die mit ihnen verbunden sind. Klassen dienen als Vorlage oder Blaupause für die Erstellung von Objekten mit vordefinierten Attributen und Verhaltensweisen.

Durch die Verwendung dieser Konzepte kannst Du modularen, wiederverwendbaren und wartbaren Code erstellen. Du kannst Deine eigenen benutzerdefinierten Datentypen definieren, die abstrakte Konzepte, Entitäten oder komplexe Systeme darstellen. Darüber hinaus kannst Du mit Hilfe von Vererbung Hierarchien erstellen, die die Wiederverwendung und Erweiterung von Funktionen über verschiedene Objekte hinweg ermöglichen.

In diesem Artikel werden wir uns mit den Grundlagen von Klassen und Objekten in Python befassen. Wir werden untersuchen, wie man Klassen definiert, Objekte erstellt, auf Attribute und Methoden zugreift und die Mächtigkeit von OOP ausnutzt. Mit diesem Wissen wirst Du in der Lage sein, effizientere, besser organisierte und skalierbare Python-Anwendungen zu entwerfen und zu erstellen.

Was sind Klassen in Python?

In Python dient eine Klasse als grundlegende Struktur oder Muster für die Konstruktion von Instanzen. Sie fungiert als logischer Rahmen, der die Eigenschaften (Daten) und das Verhalten (Funktionen) einer von dieser Klasse abgeleiteten Instanz umreißt. Klassen bieten die Möglichkeit, miteinander verbundene Daten und Operationen in einer einheitlichen Einheit anzuordnen, was die Wiederverwendbarkeit des Codes und das modulare Design begünstigt.

Stelle Dir eine Klasse als eine benutzerdefinierte Form vor, die sowohl die Daten als auch die auf diese Daten anwendbaren Aktionen kapselt. Sie legt die Merkmale (Attribute) fest, die die von ihr erzeugten Instanzen definieren, sowie die Funktionalitäten (Methoden), die veranschaulichen, was diese Instanzen leisten können.

Wenn Du eine Klasse erzeugst, führst Du im Wesentlichen eine neue Kategorie in Python ein. Du kannst einen Namen vergeben, der das Wesen der Instanzen widerspiegelt, die er repräsentiert. Wenn Du z. B. eine Klasse zur Darstellung von Autos formulierst, kannst Du sie als “Car” bezeichnen. Damit werden die gemeinsamen Attribute eines Autos, wie Farbe, Marke und Modell, sowie die Methoden, die eine Interaktion mit den Auto-Instanzen ermöglichen, umrissen.

Um eine Instanz aus einer Klasse zu erzeugen, rufe die Klasse durch Deinen Konstruktor auf. Diese Aktion erzeugt ein eindeutiges Vorkommen, das als Instanz bezeichnet wird. Jedes Objekt verfügt über eine eigene Sammlung von Attributen und kann die in den Methoden angegebenen Operationen ausführen.

Mit Klassen kannst Du mehrere Instanzen derselben Kategorie erzeugen, die jeweils mit einem eigenen Datensatz ausgestattet sind. Sie bieten einen organisierten und übersichtlichen Ansatz für die Strukturierung Deines Codes und vereinfachen die Verwaltung und Wartung, wenn Dein Programm an Komplexität zunimmt.

Im Wesentlichen dienen Klassen in Python als grundlegende Entwürfe für die Konstruktion von Instanzen. Sie spezifizieren die Attribute und Methoden, die den Instanzen der Klasse eigen sind. Mit ihrer Hilfe kannst Du benutzerdefinierte Datentypen erstellen, zusammenhängende Daten und Funktionen organisieren und die Möglichkeiten der objektorientierten Programmierung nutzen.

Wie erstellt man Objekte aus Klassen?

Sobald Du eine Klasse in Python definiert hast, kannst Du Objekte oder Instanzen erstellen, indem Du die folgenden Schritte ausführst:

1. Definition: Definiere zunächst die Klasse mit dem Schlüsselwort class, gefolgt von ihrem Namen. In ihr kannst Du Attribute und Methoden definieren, die die Eigenschaften und das Verhalten der Instanzen beschreiben.
2. Konstruktor: Definiere eine spezielle Methode, den Konstruktor, der innerhalb der Klasse als __init()__ bezeichnet wird. Der Konstruktor ist für die Initialisierung der Attribute einer Instanz verantwortlich, wenn diese erstellt wird. Er nimmt den self-Parameter, der sich auf die zu erstellende Instanz bezieht, zusammen mit allen anderen Parametern, die Sie zur Initialisierung übergeben wollen, entgegen.
3. Objektinstanziierung: Um ein Objekt aus der Klasse zu erstellen, rufst Du einfach den Namen, gefolgt von Klammern, auf. Dadurch wird der Konstruktor aufgerufen und eine neue Instanz erzeugt. Du kannst es einer Variablen zur späteren Verwendung zuweisen.
4. Zugriff auf Attribute und Methoden: Sobald das Objekt erstellt ist, kannst Du auf seine Attribute und Methoden in Punktschreibweise zugreifen. Der Zugriff auf Attribute erfolgt in der Form instance_name.attribute_name, während Methoden in der Form instance_name.method_name() aufgerufen werden. Der self-Parameter in Methoden bezieht sich auf die Instanz selbst und ermöglicht den Zugriff auf ihre Attribute und die Durchführung von Operationen.

Hier ist ein Beispiel, das den Erstellungsprozess veranschaulicht:

In diesem Beispiel definieren wir eine Klasse Car mit den Attributen make, model und color sowie einer Methode start_engine(). Anschließend erstellen wir zwei Auto-Instanzen, car1 und car2, indem wir die Klasse aufrufen und die erforderlichen Parameter übergeben. Wir können auf die Attribute jedes Autoobjekts mit der Punktnotation zugreifen und die Methode start_engine() für jede Instanz aufrufen.

Indem Du mehrere Objekte einer Klasse erstellst, kannst Du mit verschiedenen Instanzen von Daten arbeiten und für jede Variable spezifische Operationen durchführen. Auf diese Weise kannst Du reale Szenarien modellieren und einen flexibleren und wiederverwendbaren Code erstellen.

Was ist der Unterschied zwischen Klassen- und Instanzmethoden?

Der Unterschied zwischen Klassenmethoden und Instanzmethoden liegt darin, wie auf sie zugegriffen wird und wie sie verwendet werden.

Klassenmethoden:

• Definition: Sie werden mit dem @classmethod-Dekorator vor der Methodendeklaration definiert. Sie erhalten die Klasse selbst (normalerweise durch cls dargestellt) als ersten Parameter.
• Zugriff: Auf diese Methoden kann über den Klassennamen oder eine Instanz der Klasse zugegriffen werden.
• Verwendung: Klassenmethoden werden üblicherweise verwendet, wenn Du Operationen durchführen musst, die nicht spezifisch für eine bestimmte Instanz sind, sondern sich auf die Klasse als Ganzes beziehen. Du kannst auf Attribute zugreifen und diese ändern oder Berechnungen auf Klassenebene durchführen.

Instanzmethoden

• Definition: Instanzmethoden werden ohne Dekoratoren definiert. Sie erhalten die Instanz (normalerweise durch self repräsentiert) als ersten Parameter.
• Zugriff: Auf Instanzmethoden kann nur über eine Instanz der Klasse zugegriffen werden.
• Verwendung: Instanzmethoden werden typischerweise verwendet, um die Attribute einer bestimmten Instanz zu manipulieren. Sie können auf Attribute auf Instanzebene zugreifen und diese ändern, Berechnungen auf der Grundlage des Instanzstatus durchführen oder Funktionen bereitstellen, die für jedes Objekt einzigartig sind.

Hauptunterschiede

• Klassenmethoden wirken auf die Klasse selbst, während Instanzmethoden auf einzelne Instanzen der Klasse wirken.
• Klassenmethoden können auf Attribute auf Klassenebene zugreifen und diese ändern, während Instanzmethoden auf Attribute auf Instanzebene zugreifen und diese ändern können.
• Auf Klassenmethoden wird über den Klassennamen oder eine Instanz zugegriffen, während auf Instanzmethoden nur über eine Instanz zugegriffen werden kann.

Hier ist ein Beispiel, um den Unterschied zu verdeutlichen:

In diesem Beispiel verfügt die Klasse Circle über eine Instanzmethode calculate_area(), die auf eine bestimmte Kreisinstanz wirkt und deren Fläche berechnet. Außerdem verfügt sie über eine Klassenmethode from_diameter(), die eine Kreisinstanz auf der Grundlage des angegebenen Durchmessers erzeugt. Die Klassenmethode erhält die Klasse selbst (cls) als Parameter und gibt eine neue Instanz zurück.

Durch die Verwendung von Klassenmethoden kannst Du alternative Wege zur Erstellung von Instanzen oder zur Durchführung von Operationen anbieten, die nicht an eine bestimmte Instanz gebunden sind. Instanzmethoden hingegen ermöglichen es Dir, mit den Attributen und dem Verhalten einzelner Instanzen zu arbeiten.

Was sind Spezialmethoden und Operatorüberladung?

Spezialmethoden, auch bekannt als Dunder-Methoden (kurz für “double underscore”-Methoden) oder magische Methoden, sind vordefinierte Methoden in Python, mit denen Du das Verhalten von Objekten anpassen kannst. Sie werden implizit als Reaktion auf bestimmte Operationen oder Funktionsaufrufe aufgerufen. Ein wichtiger Aspekt spezieller Methoden ist die Operatorüberladung, bei der Du festlegst, wie sich Operatoren bei der Anwendung auf Instanzen Deiner benutzerdefinierten Klasse verhalten.

Grundlegende Spezialmethoden

• __init__(self, …): Initialisiert ein neu erstelltes Objekt. Wird automatisch aufgerufen, wenn es aus der Klasse erzeugt wird.
• __str__(self): Gibt eine String-Repräsentation des Objekts zurück. Sie wird von der eingebauten Funktion str() aufgerufen oder wenn ein Objekt gedruckt wird.
• __repr__(self): Gibt eine Zeichenkette zurück, die das Objekt repräsentiert und verwendet werden kann, um es neu zu erstellen. Sie wird von der eingebauten Funktion repr() aufgerufen.

Vergleich und Gleichheit

• __eq__(self, other): Implementiert den Gleichheitsvergleich (==).
• __ne__(self, other): Implementiert den Ungleichheitsvergleich (!=).
• __lt__(self, other): Implementiert den Kleiner-als-Vergleich (<).
• __gt__(self, other): Implementiert den Größer-als-Vergleich (>).
• __le__(self, other): Implementiert den Kleiner-als-oder-Gleich-Vergleich (<=).
• __ge__(self, other): Implementiert den Größer-als-oder-Gleich-Vergleich (>=).

Arithmetische und mathematische Operationen

• __add__(self, other): Implementiert Addition (+).
• __sub__(self, other): Führt die Subtraktion (-) aus.
• __mul__(self, other): Implementiert die Multiplikation (*).
• __truediv__(self, other): Implementiert echte Division (/).
• __floordiv__(self, other): Implementiert die Bodenteilung (//).
• __mod__(self, other): Implementiert Modulo-Division (%).
• __pow__(self, other): Implementiert die Potenzierung (**).

Andere übliche Spezialmethoden

• __len__(self): Gibt die Länge des Objekts zurück. Wird von der eingebauten Funktion len() aufgerufen.
• __getitem__(self, key): Erlaubt die Indizierung mit eckigen Klammern ([]).
• __setitem__(self, key, value): Erlaubt die Zuweisung mit eckigen Klammern ([]).
• __delitem__(self, key): Erlaubt das Löschen mit der Anweisung del.

Indem Du diese speziellen Methoden in Ihrer Klasse implementierst, kannst Du festlegen, wie sich Deine Objekte verhalten sollen, wenn sie auf verschiedene Weise bedient werden oder mit ihnen interagieren. Das folgende Beispiel veranschaulicht die Verwendung dieser Methoden:

In diesem Beispiel definiert die Klasse Point die speziellen Methoden __init__, __str__, __add__ und __eq__. Die Methode __add__ ermöglicht das Hinzufügen von zwei Point-Objekten oder das Hinzufügen eines Einzelwerts zu einem Point-Objekt. Die Methode __eq__ ermöglicht den Vergleich zweier Point-Variablen auf Gleichheit. Die __str__-Methode liefert eine String-Darstellung der Variablen.

Durch die Nutzung spezieller Methoden und die Überladung von Operatoren kannst Du dafür sorgen, dass sich Deine benutzerdefinierten Klassen intuitiv verhalten und sich nahtlos in die integrierten Funktionen und Operatoren von Python integrieren.

Was ist der Unterschied zwischen Klassenvariablen und Instanzvariablen?

In Python werden sowohl Klassenvariablen als auch Instanzvariablen zum Speichern von Daten verwendet, aber sie haben unterschiedliche Eigenschaften und Einsatzszenarien.

Klassenvariablen

• Sie werden innerhalb der Klasse, aber außerhalb einer Methode definiert.
• Sie werden von allen Instanzen der Klasse gemeinsam genutzt.
• Der Zugriff auf diese Variablen erfolgt über den Klassennamen selbst oder über eine Instanz der Klasse.
• Wenn eine Klassenvariable geändert wird, wirkt sich diese Änderung auf alle Instanzen der Klasse aus.
• Klassenvariablen werden in der Regel verwendet, um Daten zu speichern, die allen Instanzen der Klasse gemeinsam sind.

Instanzvariablen

• Instanzvariablen sind spezifisch für jede Instanz einer Klasse.
• Sie werden innerhalb von Methoden oder der __init__-Methode der Klasse definiert und mit dem Präfix self. versehen, um sie von Klassenvariablen zu unterscheiden.
• Jede Instanz der Klasse hat ihre eigene Kopie der Instanzvariablen.
• Auf Instanzvariablen wird über die Instanz der Klasse zugegriffen und sie werden verändert.
• Änderungen an Instanzvariablen sind nur für die jeweilige Instanz gültig und haben keine Auswirkungen auf andere Instanzen der Klasse.
• Instanzvariablen werden häufig verwendet, um eindeutige Daten oder Zustände zu speichern, die für jedes Objekt spezifisch sind.

Unterschiede zwischen Klassen- und Instanzvariablen

1. Geltungsbereich: Klassenvariablen haben einen größeren Anwendungsbereich, da sie für alle Instanzen der Klasse zugänglich sind, während Instanzvariablen für jede Instanz spezifisch sind.
2. Speicherzuweisung: Klassenvariablen wird nur einmal Speicher zugewiesen, während jede Instanz der Klasse ihre eigene Speicherzuweisung für Instanzvariablen hat.
3. Gemeinsame vs. individuelle Daten: Klassenvariablen speichern Daten, die von allen Instanzen gemeinsam genutzt werden, während Instanzvariablen Daten enthalten, die für jedes Objekt spezifisch sind.
4. Zugriff: Auf Klassenvariablen kann über den Klassennamen oder eine beliebige Instanz der Klasse zugegriffen werden, während der Zugriff auf Instanzvariablen über die Instanz selbst erfolgt.
5. Modifizierbarkeit: Die Änderung einer Klassenvariable wirkt sich auf alle Instanzen aus, während sich die Änderung einer Instanzvariable nur auf diese spezielle Instanz auswirkt.

Es ist wichtig, die Unterschiede zwischen Klassen- und Instanzvariablen zu kennen, um eine ordnungsgemäße Datenverwaltung zu gewährleisten und das gewünschte Verhalten Ihrer klassenbasierten Objekte zu erhalten.

Was sind die Prinzipien im Klassendesign?

Beim Entwurf von Klassen in Python ist es wichtig, bestimmte Prinzipien zu befolgen, die eine gute Codeorganisation, Wiederverwendbarkeit und Wartbarkeit fördern. Hier sind einige wichtige Prinzipien, die zu beachten sind:

(1) Das Prinzip der einzigen Verantwortung (SRP):

• Klassen sollten eine einzige Verantwortung oder einen einzigen Zweck haben und sich auf eine bestimmte Aufgabe oder Funktionalität konzentrieren.
• Dies fördert die Modularität des Codes und macht ihn leichter verständlich, testbar und wartbar.

(2) Verkapselung:

• Unter Kapselung versteht man die Bündelung von Daten und Methoden.
• Daten sollten gekapselt werden, indem man sie privat oder geschützt macht und Namenskonventionen wie das Voranstellen von Unterstrichen (_) verwendet.
• Öffentliche Methoden ermöglichen einen kontrollierten Zugriff auf die gekapselten Daten, wodurch Datenintegrität und Kapselung durchgesetzt werden.

(3) Vererbung:

• Die Vererbung ermöglicht die Erstellung von Unterklassen auf der Grundlage bestehender Elternklassen.
• Sie fördert die Wiederverwendung von Code durch Vererbung von Attributen und Methoden aus der übergeordneten Struktur.
• Die Vererbung sollte jedoch mit Bedacht eingesetzt werden, wobei gegebenenfalls die Komposition der Vererbung vorzuziehen ist.

(4) Komposition:

• Bei der Komposition werden Klassen erstellt, indem Objekte anderer Klassen als Attribute kombiniert werden.
• Sie fördert die Flexibilität, da Objekte aus mehreren kleineren Instanzen zusammengesetzt werden können, um das gewünschte Verhalten zu erreichen.
• Die Komposition ermöglicht eine bessere Kontrolle und eine lose Kopplung zwischen den Klassen.

(5) Polymorphismus:

• Polymorphismus ermöglicht es, Objekte verschiedener Klassen austauschbar zu verwenden, wenn sie eine gemeinsame Schnittstelle haben.
• Sie fördert die Flexibilität, Erweiterbarkeit und Anpassbarkeit des Codes.
• Polymorphismus kann durch Vererbung erreicht werden.

(6) Lesbarkeit des Codes und Dokumentation:

• Klassen sollten klare und aussagekräftige Namen haben, die ihren Zweck und ihre Funktionalität widerspiegeln.
• Der Code sollte gut dokumentiert sein, einschließlich Dokumentationsstrings auf Klassenebene und Kommentaren innerhalb der Methoden, die deren Zweck, Eingaben und Ausgaben erläutern.
• Klarer und prägnanter Code, der den Namenskonventionen folgt und sich an den Python Style Guide (PEP 8) hält, verbessert die Lesbarkeit und Wartbarkeit.

Wenn Du diese Prinzipien befolgst, kannst Du Klassen entwerfen, die modular, wiederverwendbar und leicht zu verstehen sind, was Deinen Code robuster macht und die Zusammenarbeit mit anderen Entwicklern erleichtert.

Das solltest Du mitnehmen

• Klassen und Objekte in Python bieten einen leistungsstarken Mechanismus zur Organisation und Strukturierung von Code.
• Klassen kapseln Daten und Verhalten und ermöglichen so eine bessere Organisation und Wiederverwendbarkeit des Codes. Objekte sind Instanzen von Klassen, die bestimmte Einheiten oder Konzepte in Ihrem Code darstellen.
• Klassenvariablen werden von allen Instanzen einer Klasse gemeinsam genutzt, während Instanzvariablen spezifisch für jedes Objekt sind.
• Methoden definieren das Verhalten von Objekten und können entweder Klassenmethoden, Instanzmethoden oder statische Methoden sein.
• Vererbung ermöglicht die Wiederverwendung von Code und die Erstellung spezialisierter Klassen auf der Grundlage bestehender Klassen.
• Spezielle Methoden und das Überladen von Operatoren bieten Flexibilität und Anpassungsmöglichkeiten für integrierte Operationen.
• Ein gutes Design folgt Prinzipien wie der einzigen Verantwortung, der Kapselung und der Komposition.
• Durch Polymorphismus können Objekte verschiedener Klassen über eine gemeinsame Schnittstelle austauschbar verwendet werden.
• Lesbarkeit und Dokumentation sind entscheidend für die Erstellung von wartbarem und verständlichem Code.

Vielen Dank an Deepnote für das Sponsoring dieses Artikels! Deepnote bietet mir die Möglichkeit, Python-Code einfach und schnell auf dieser Website einzubetten und auch die zugehörigen Notebooks in der Cloud zu hosten.

Andere Beiträge zum Thema Klassen und Objekte in Python

Dieser Link führt Dich zu meiner Deepnote-App, in der Du den gesamten Code findest, den ich in diesem Artikel verwendet habe, und ihn selbst ausführen kannst.