# 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.

```python
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: 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.

```python
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.

```python
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.

```python
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.


This is a markdown version of: [https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/python-class-variables/](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/python-class-variables/) for AI/LLM consumption.