Erstellung von Klassen und Objekten

3.1 Erstellung einer Klasse

Die Erstellung von Klassen in Python ist ein wichtiger Teil der objektorientierten Programmierung (OOP). Klassen ermöglichen es, neue Datentypen zu erstellen, die ihre eigenen Attribute und Methoden haben können. Lass uns die grundlegenden Konzepte und Beispiele zur Erstellung von Klassen in Python anschauen.

Grundlegende Konzepte

• Klasse: eine Vorlage zur Erstellung von Objekten. Die Klasse definiert Attribute und Methoden, die die Objekte dieser Klasse haben werden.
• Objekt: eine Instanz der Klasse. Ein Objekt besitzt alle Attribute und Methoden, die in der Klasse definiert sind.
• Attribut: eine Variable, die mit der Klasse oder dem Objekt verbunden ist.
• Methode: eine Funktion, die mit der Klasse oder dem Objekt verbunden ist.

Attribute sind im Wesentlichen die internen Variablen des Objekts oder der Klasse. Methoden sind Funktionen, die innerhalb der Klasse definiert sind. Diese Begriffe stammen aus der OOP und werden genauso wie Funktionen und Variablen verwendet.

Um eine neue Klasse zu deklarieren (zu erstellen), wird das Schlüsselwort class verwendet. Die allgemeine Syntax dieser Operation sieht folgendermaßen aus:

class KlassenName:
    variable1 = wert1
    variableN = wertN
          
    def funktion1(self):
        # Funktion Code
            
    def funktionM(self):
        # Funktion Code

Grundsätzlich kann man sagen, dass eine Klasse ein kleines Programm (Variablen + Funktionen) ist, das in einen separaten benannten Bereich — KlassenName — eingebettet ist.

Nachdem du eine Klasse erstellt hast, kannst du Objekte (Instanzen) dieser Klasse erstellen. Dieser Code sieht sogar noch einfacher aus:

variableX = KlassenName()

Wichtig! In Python ist es üblich, Variablen- und Methodennamen klein zu schreiben. Klassennamen beginnen mit einem Großbuchstaben. Außerdem werden bei Klassennamen keine Unterstriche verwendet. Wenn ein Klassenname aus mehreren Wörtern bestehen soll, wird jedes Wort mit einem Großbuchstaben begonnen.

Wenn du auf eine Klassen-/Objektvariable zugreifen möchtest, sieht dieser Code normalerweise so aus:

variableX.variable1 = 10
variableX.funktionM()       

Aber es gibt hier einige Feinheiten, die wir später entdecken…

3.2 Arbeiten mit einem Objekt

Sowohl die Klasse als auch die Klasseninstanz (das Klassenobjekt) sind Objekte, daher können sowohl der erste als auch der zweite ihre eigenen Variablen und Methoden haben.

Es gibt zwei Typen von Variablen:

• Klassenattribut/Variable/Feld (class property)
• Objektattribut/Variable/Feld (object property)

Und ganze drei Typen von Methoden:

• Methoden/Funktionen der Klasse (class method)
• Methoden/Funktionen des Objekts (instance method)
• Statische Methoden (static method)

Methoden unterscheiden sich durch ihre Deklarationsweise und wie sie aufgerufen werden.

Objektmethoden

Bei der Deklaration einer Objektmethode muss man den ersten obligatorischen Parameter — self — übergeben. Beim Aufruf der Methode wird in diesem Parameter ein Verweis auf das Objekt (instance) übergeben.

class MyClass:

    def instance_method(self):
        print(type(self))  # <class 'MyClass'>
                   

my_object = MyClass()
my_object.instance_method()
        

Im obigen Beispiel, als die Funktion instance_method() ausgeführt wurde, wurde der Parameter self eine Referenz auf das Objekt my_object übergeben.

Klassenmethoden

Bei der Deklaration einer Klassenmethode muss man ebenfalls den ersten obligatorischen Parameter — cls — übergeben. Beim Aufruf der Methode wird in diesem Parameter ein Verweis auf die Klasse (class object) übergeben. Außerdem muss die Klassenmethode mit dem Decorator classmethod gekennzeichnet werden, wie im folgenden Beispiel:

class MyClass:
    def instance_method(self):
        print(type(self))  # <class 'MyClass'>
        
    @classmethod
    def class_method(cls):
        print(type(cls))  # <class 'type'>
                   

my_object = MyClass()
my_object.instance_method()
MyClass.class_method()
        

Im obigen Beispiel, als die Funktion class_method() ausgeführt wurde, wurde der Parameter cls eine Referenz auf die Klasse MyClass übergeben.

Statische Methoden

Bei der Deklaration einer statischen Methode muss nichts übergeben werden, aber sie kann auch nicht auf die internen Daten der Klasse zugreifen. Außerdem muss die Methode mit dem Decorator staticmethod gekennzeichnet werden, wie im folgenden Beispiel:

class MyClass:
    def instance_method(self):
        print(type(self))  # <class 'MyClass'>
        
    @classmethod
    def class_method(cls):
        print(type(cls))  # <class 'type'>
        
    @staticmethod
    def static_method():
        return "Diese Methode ist unabhängig von der Instanz oder der Klasse"
                   
my_object = MyClass()
my_object.instance_method()
MyClass.class_method()
MyClass.static_method() 
        

Eine statische Methode wird sehr ähnlich wie eine Klassenmethode aufgerufen, aber weder ein Verweis auf das Objekt noch ein Verweis auf die Klasse wird in diese übergeben.

3.3 Klassenvariablen

Klassenvariablen

Um eine Klassenvariable (Attribut) zu deklarieren, musst du sie einfach irgendwo innerhalb der Klasse deklarieren. Normalerweise geschieht das am Anfang, vor der Deklaration der Klassenmethoden. Beispiel:

class MyClass:
    attribute = "Ich bin ein Klassenattribut"
        
    @classmethod
    def class_method(cls):
        print(cls.attribute)  # Ich bin ein Klassenattribut
                  
my_object = MyClass()
MyClass.class_method()

Wenn du einen Wert in eine Klassenvariable lesen oder schreiben möchtest, nutze das Objekt cls.

Grundsätzlich kann man auf eine Klassenvariable auch über den Klassennamen zugreifen:

class MyClass:
    attribute = "Ich bin ein Klassenattribut"
        
    @classmethod
    def class_method(cls):
        print(MyClass.attribute)  # Ich bin ein Klassenattribut
                  
my_object = MyClass()

print(MyClass.attribute)  # Ich bin ein Klassenattribut

Objektvariablen/Felder

Objektvariablen (instance) sind die Felder des Objekts self. Du arbeitest einfach mit ihnen über self.name. Genau dafür wird das Objekt self an jede Objektmethode übergeben.

Beispiel:

class MyClass:
    attribute = "Ich bin ein Klassenattribut"
        
    def set_name(self, name):
        self.name = name
        
    def print_name(self):
        print(self.name)    
                 
my_object = MyClass()
my_object.set_name("Objektfeld mit dem Namen name") 
my_object.print_name()  # "Objektfeld mit dem Namen name"
        

Jedes Mal, wenn du eine Objektmethode aufrufst, wird als erster Parameter (self) ein Verweis auf das Objekt übergeben, bei dem du die Methode aufrufst. Verschiedene Objektmethoden können auf gemeinsame Daten über das Objekt self zugreifen.