Python-Klassenvariablen: So erstellst und nutzt du sie
Python Class Variables bieten eine strukturierte Möglichkeit, Daten zwischen verschiedenen Instanzen einer Klasse zu teilen. Zudem wirken sich Änderungen an einer Klassenvariable direkt auf alle Instanzen der Klasse aus. Dadurch ersparst du dir die Neudefinition bei jeder Instanziierung.
Was sind Python Class Variables?
In Python legst du Class Variables innerhalb einer Klasse fest. Im Gegensatz zu Instanzvariablen, die individuell für jede Instanz gelten, behalten Klassenvariablen denselben Wert für alle Instanzen bei. Diese Variablen werden normalerweise vor dem Konstruktor definiert und sind für sämtliche Instanzen der Klasse erreichbar.
Python Class Variables kommen oft zum Einsatz, um Informationen zu speichern, die für alle Instanzen einer Klasse identisch sind – etwa Konfigurationswerte, Standards oder gemeinsame Zustände innerhalb einer Klassenhierarchie. Zudem kannst du Klassenvariablen nutzen, um Methoden oder Attribute zu definieren, die von allen Instanzen geteilt werden, was die Struktur deines Codes deutlich verbessert.
So sieht die Syntax von Python Class Variables aus
Python Class Variables erstellst du innerhalb der Klassendefinition, jedoch außerhalb von Methoden.
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}")
# Creating instances of Car
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: A4Innerhalb der Klasse Car definieren wir die Klassenvariable total_cars, um die Gesamtzahl der Autos mitzuzählen. Der Konstruktor __init__ startet immer dann, wenn eine neue Instanz der Klasse erzeugt wird. Bei jeder Instanziierung werden die Instanzvariablen brand und model festgelegt und die Klassenvariable total_cars um 1 erhöht.
Mit dem Aufruf der Methode display_details() geben wir die Details der jeweiligen Auto-Instanzen aus. In einem f-String, einer gängigen Python-String-Format-Methode, greifen wir auf die Klassenvariable total_cars zu, um die aktuelle Anzahl aller erstellten Autos anzuzeigen.
Anwendungsbeispiele für Python Class Variables
Damit du sicher mit Klassenvariablen in Python arbeitest, sind vor allem der Zugriff, die Modifikation sowie die Vererbung wichtig.
Auf Klassenvariablen zugreifen
Du greifst auf Python Class Variables über den Klassennamen oder die Instanz zu, gefolgt von einem Punkt und dem Namen der Variable.
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 variableIn Python stehen dir verschiedene Wege offen, um Klassenvariablen abzurufen:
- Im Konstruktor: Die Variable lässt sich innerhalb des Konstruktors entweder über das
self-Keyword oder direkt über den Klassennamen aufrufen. - In Instanzmethoden: Der Zugriff erfolgt innerhalb von Instanzmethoden ebenfalls über
selfoder den Klassennamen. - Außerhalb der Klasse: Hier kannst du die Class Variable entweder über die Objektreferenz oder den Klassennamen ansprechen.
Klassenvariablen modifizieren
Python Class Variables kannst du direkt über den Klassennamen ändern. Falls jedoch eine Instanzvariable den gleichen Namen wie eine Klassenvariable trägt und du versuchst, diese über die Instanz zu ändern, wird eine neue Instanzvariable erstellt – die ursprüngliche Klassenvariable bleibt davon unberührt.
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 variableIn diesem Beispiel überschreiben wir die Klassenvariable class_var, indem wir ihr über die Klasse MyClass einen neuen Wert geben. Diese Änderung wird automatisch für die Instanz obj wirksam.
Class Variables und Vererbung
Dank Vererbung können abgeleitete Klassen auf die Klassenvariablen der Basisklasse zugreifen. So nutzt du vorhandene Daten, ohne sie erneut definieren zu müssen.
class BaseClass:
base_var = "Base variable"
class DerivedClass(BaseClass):
pass
print(DerivedClass.base_var) # Output: Base variableHier legen wir eine Basisklasse BaseClass fest, welche die Klassenvariable base_var enthält. Die abgeleitete Klasse DerivedClass erbt von BaseClass. Durch diese Vererbung kann DerivedClass problemlos auf die Klassenvariable base_var der Basisklasse zugreifen.