Python Class Variables: So erstellen und nutzen Sie Klassenvariablen

Python Class Variables stellen eine strukturierte Möglichkeit dar, Daten zwischen verschiedenen Instanzen einer Klasse zu teilen. Zudem wirken sich Änderungen an einer Klassenvariable auf alle Instanzen der Klasse aus. Dadurch müssen sie nicht bei jeder Instanziierung neu definiert werden.

Was sind Python Class Variables?

In Python erstellen wir Class Variables innerhalb einer Klasse. Anders als Instanzvariablen, die spezifisch für jede Instanz einer Klasse sind, behalten Klassenvariablen denselben Wert für alle Instanzen bei. Diese Variablen werden in der Regel vor dem Konstruktor definiert und sind für alle Instanzen der Klasse zugänglich.

Python Class Variables werden oft verwendet, um Informationen zu speichern, die für alle Instanzen einer Klasse gemeinsam sind, wie beispielsweise Konfigurationswerte, Standardwerte oder gemeinsame Zustände innerhalb einer Klassenhierarchie. Darüber hinaus können Sie Klassenvariablen nutzen, um Klassenmethoden oder -attribute festzulegen, die von allen Instanzen einer Klasse geteilt werden und so die Funktionalität und Organisation des Codes verbessern.

Das ist die Syntax von Python Class Variables

Python Class Variables werden innerhalb der Klassendefinition und außerhalb von Methoden erstellt.

class Car:
    total_cars = 0  # Class variable to track the total number of cars
    def __init__(self, brand, model):
        self.brand = brand  # Instance variable for the car brand
        self.model = model  # Instance variable for the car model
        Car.total_cars += 1  # Increment the total number of cars upon each instantiation
    def display_details(self):
        print(f"Brand: {self.brand}, Model: {self.model}")
car1 = Car("BMW", "X3")
car2 = Car("Audi", "A4")
# Accessing class variable and instance variables
print(f"Total number of cars: {Car.total_cars}")  # Output: 2
car1.display_details()  # Output: Brand: BMW, Model: X3
car2.display_details()  # Output: Brand: Audi, Model: A4

Innerhalb der Klasse Car definieren wir die Klassenvariable total_cars, um die Gesamtanzahl der Autos zu verfolgen. Der Konstruktor __init__ wird aufgerufen, wenn eine neue Instanz der Klasse erzeugt wird. Bei jeder Instanziierung werden die Instanzvariablen brand und model gesetzt und die Klassenvariable total_cars um 1 erhöht.

Durch den Aufruf der Methode display_details() geben wir die Details der jeweiligen Auto-Instanzen aus. In einem f-String, einer Python-String-Format-Methode, greifen wir auf die Klassenvariable total_cars zu, um die Gesamtanzahl der erstellten Autos anzuzeigen.

Beispiele für die Anwendung von Python Class Variables

Für den sicheren Umgang mit Klassenvariablen in Python spielen vor allem der Zugriff, die Modifikation und Vererbung eine Rolle.

Auf Klassenvariablen zugreifen

Der Zugriff auf Python Class Variables erfolgt über den Klassennamen oder die Instanz, gefolgt von einem Punkt und dem Variablennamen.

class MyClass:
    class_var = "This is a class variable"
# using class name to access class variable
print(MyClass.class_var)  # Output: This is a class variable
# using instance to access class variable
obj = MyClass()
print(obj.class_var)  # Output: This is a class variable

In Python können Sie Klassenvariablen an verschiedenen Stellen abrufen:

• Im Konstruktor: Die Klassenvariable kann innerhalb des Konstruktors entweder über das self-Schlüsselwort oder den Klassennamen aufgerufen werden.
• In Instanzmethoden: Der Aufruf der Class Variable erfolgt innerhalb von Instanzmethoden entweder über das self-Schlüsselwort oder den Klassennamen.
• Außerhalb der Klasse: Außerhalb der Klasse kann auf die Class Variable entweder über die Objektreferenz oder über den Klassennamen zugegriffen werden.

Klassenvariablen modifizieren

Python Class Variables können Sie direkt über den Klassennamen modifizieren. Wenn aber eine Instanzvariable denselben Namen hat wie eine Klassenvariable und Sie versuchen, die Variable über die Instanz zu ändern, wird eine neue Instanzvariable geschaffen und die Klassenvariable bleibt unverändert.

class MyClass:
    class_var = "Original class variable"
obj = MyClass()
print(obj.class_var)  # Output: Original class variable
MyClass.class_var = "Modified class variable"
print(obj.class_var)  # Output: Modified class variable

In diesem Beispiel überschreiben wir die Klassenvariable class_var, indem wir ihr einen neuen Wert über die Klasse MyClass zuweisen. Die Änderung wird automatisch von der Instanz obj übernommen.

Class Variables und Vererbung

Durch Vererbung können abgeleitete Klassen auf die Klassenvariablen der Basisklasse zugreifen und diese nutzen, ohne sie neu festlegen zu müssen.

class BaseClass:
    base_var = "Base variable"
class DerivedClass(BaseClass):
    pass
print(DerivedClass.base_var)  # Output: Base variable

Hier definieren wir eine Basisklasse BaseClass, die die Klassenvariable base_var enthält. Die abgeleitete Klasse DerivedClass erbt von BaseClass. Durch die Vererbung kann DerivedClass auf die Klassenvariable base_var der Basisklasse zugreifen und sie ohne erneute Definition verwenden.