# Sådan oprettes og bruges Python-klassevariabler

Python-klassevariabler er en struktureret måde at dele data mellem forskellige instanser af en klasse. Hvis du foretager **ændringer i en klassevariabel**, påvirker det alle instanser af klassen. Det betyder, at du ikke behøver at omdefinere dem hver gang, de instansieres.

## Hvad er Python-klassevariabler?

I Python opretter vi klassevariabler inden for en klasse. I modsætning til instansvariabler, som er specifikke for hver instans af en klasse, **bevarer klassevariabler den samme værdi for alle instanser**. Klassevariabler oprettes typisk før konstruktøren og kan tilgås af enhver instans af klassen.

Python-klassevariabler er nyttige til lagring af **data**, der gælder for alle forekomster af en klasse, såsom konfigurationsindstillinger, standardværdier eller delte tilstande på tværs af en klassehierarki. Klassevariabler giver dig også mulighed for at definere klassemetoder eller attributter, som alle forekomster kan få adgang til, hvilket forbedrer både funktionaliteten og strukturen i din kode.

## Hvad er syntaksen for Python-klassevariabler?

Python-klassevariabler oprettes **inden for klassedefinitionen** og uden for metoderne.

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

Inden for klasse `Car` definerer vi klassevariablen `total_cars` for at holde styr på det samlede antal biler. Konstruktoren `__init__` kaldes, når en ny instans af klassen oprettes. Ved hver instansiering indstilles **instansvariablerne** `brand` og `model`, og klassevariablen `total_cars` øges med 1.

Ved at kalde metoden `display_details()` kan vi vise detaljerne for de respektive bilinstanser. I en **f-streng**, en Python-strengformatmetode, kan vi få adgang til klassevariablen `total_cars` for at vise det samlede antal oprettede biler.

## Eksempler på brug af Python-klassevariabler

Adgang, ændring og arv spiller en central rolle i sikker håndtering af klassevariabler i Python.

### Adgang til klassevariabler

Python-klassevariabler tilgås **via klassens navn eller instans**, efterfulgt af en prik og variabelnavnet.

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

I Python kan du få adgang til klassevariabler forskellige steder:

- **I konstruktøren**: Du kan kalde klassevariablen i konstruktøren ved hjælp af enten nøgleordet `self` eller klassens navn.
- **I instansmetoder**: Du kan kalde klassevariablen i instansmetoder ved hjælp af enten nøgleordet `self` eller klassens navn.
- **Uden for klassen**: Du kan få adgang til klassevariablen uden for klassen via objektreferencen eller ved hjælp af klassens navn.

### Ændring af klassevariabler

Python-klassevariabler kan ændres direkte via klassens navn. Hvis en instansvariabel har samme navn som en klassevariabel, og du forsøger at ændre variablen via instansen, **oprettes der** imidlertid **en ny instansvariabel**, og klassevariablen forbliver uændret.

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

I dette eksempel har vi overskrevet klassevariablen `class_var` ved at tildele den en ny værdi ved hjælp af klassen `MyClass`. Ændringen bliver derefter automatisk overtaget af instansen `obj`.

### Klassevariabler og arv

Arv gør det muligt for afledte klasser at **få adgang til** og bruge basisklassens klassevariabler uden at skulle omdefinere dem.

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

Her definerer vi en basisklasse `BaseClass`, som indeholder klassevariablen `base_var`. Den afledte klasse `DerivedClass` arver fra `BaseClass`. Gennem arv kan `DerivedClass` få adgang til klassevariablen `base_var` i basisklassen og bruge den uden at omdefinere den.


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-class-variables/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-class-variables/) for AI/LLM consumption.