# Hoe Python-klassevariabelen maken en gebruiken

Python-klassenvariabelen zijn een gestructureerde manier om gegevens te delen tussen verschillende instanties van een klasse. Als u **wijzigingen** aanbrengt **in een klassenvariabele**, heeft dit invloed op alle instanties van de klasse. Dit betekent dat u ze niet telkens opnieuw hoeft te definiëren wanneer ze worden geïnstantieerd.

## Wat zijn Python-klassevariabelen?

In Python maken we klassevariabelen binnen een klasse. In tegenstelling tot instantievariabelen, die specifiek zijn voor elke instantie van een klasse, **behouden klassevariabelen dezelfde waarde voor alle instanties**. Klassevariabelen worden doorgaans vóór de constructor ingesteld en zijn toegankelijk voor elke instantie van de klasse.

Python-klassevariabelen zijn handig voor het opslaan van **gegevens** die van toepassing zijn op alle instanties van een klasse, zoals configuratie-instellingen, standaardwaarden of gedeelde statussen binnen een klassenhiërarchie. Met klassevariabelen kunt u ook klassemethoden of -attributen definiëren waartoe elke instantie toegang heeft, waardoor zowel de functionaliteit als de structuur van uw code wordt verbeterd.

## Wat is de syntaxis van Python-klassevariabelen?

Python-klassevariabelen worden aangemaakt **binnen de klassedefinitie** en buiten methoden.

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

Binnen klasse `Car` definiëren we de klassevariabele `total_cars` om het totale aantal auto’s bij te houden. De constructor `__init__` wordt aangeroepen wanneer een nieuw exemplaar van de klasse wordt aangemaakt. Bij elke instantiëring worden de **instantievariabelen** `brand` en `model` ingesteld en wordt de klassevariabele `total_cars` met 1 verhoogd.

Door de methode `display_details()` aan te roepen, kunnen we de details van de respectieve auto-instanties weergeven. In een **f-string**, een Python-stringformaatmethode, kunnen we toegang krijgen tot de klassevariabele `total_cars` om het totale aantal aangemaakte auto’s weer te geven.

## Voorbeelden van het gebruik van Python-klassevariabelen

Toegang, wijziging en overerving spelen een belangrijke rol bij het veilig omgaan met klassevariabelen in Python.

### Toegang tot klassevariabelen

Python-klassevariabelen zijn toegankelijk **via de klassenaam of instantie**, gevolgd door een punt en de variabelenaam.

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

In Python kun je op verschillende plaatsen toegang krijgen tot klassevariabelen:

- **In de constructor**: Je kunt de klassevariabele in de constructor aanroepen met behulp van het sleutelwoord `self` of de klassenaam.
- **In instantiemethoden**: U kunt de klassevariabele in instantiemethoden aanroepen met behulp van het `self` -sleutelwoord of de klassenaam.
- **Buiten de klasse**: U kunt de klassevariabele buiten de klasse openen via de objectreferentie of met behulp van de klassenaam.

### Klassevariabelen wijzigen

Python-klassevariabelen kunnen rechtstreeks via de klassenaam worden gewijzigd. Als een instantievariabele echter dezelfde naam heeft als een klassevariabele en u probeert de variabele via de instantie te wijzigen, **wordt er een nieuwe instantievariabele aangemaakt** en blijft de klassevariabele ongewijzigd.

```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 dit voorbeeld hebben we de klassevariabele `class_var` overschreven door deze een nieuwe waarde toe te kennen met behulp van de klasse `MyClass`. De wijziging wordt vervolgens automatisch overgenomen door de `obj`.

### Klassevariabelen en overerving

Door overerving kunnen afgeleide klassen **toegang krijgen tot** de klassevariabelen van de basisklasse en deze gebruiken zonder ze opnieuw te hoeven definiëren.

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

Hier definiëren we een basisklasse `BaseClass`, die de klassevariabele `base_var` bevat. De afgeleide klasse `DerivedClass` erft van `BaseClass`. Door middel van overerving heeft `DerivedClass` toegang tot de klassevariabele `base_var` van de basisklasse en kan deze gebruiken zonder deze opnieuw te definiëren.


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/python-klassenvariabelen/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/python-klassenvariabelen/) for AI/LLM consumption.