# Hvordan opprette og bruke Python-klassevariabler

Python-klassevariabler er en strukturert måte å dele data mellom forskjellige instanser av en klasse. Hvis du gjør **endringer i en klassevariabel**, påvirker det alle instanser av klassen. Dette betyr at du ikke trenger å omdefinere dem hver gang de instansieres.

## Hva er Python-klassevariabler?

I Python oppretter vi klassevariabler innenfor en klasse. I motsetning til instansvariabler, som er spesifikke for hver instans av en klasse, **beholder klassevariabler samme verdi for alle instanser**. Klassevariabler settes vanligvis opp før konstruktøren og kan nås av alle instanser av klassen.

Python-klassevariabler er nyttige for lagring av **data** som gjelder for alle forekomster av en klasse, for eksempel konfigurasjonsinnstillinger, standardverdier eller delte tilstander på tvers av en klassehierarki. Klassevariabler lar deg også definere klassemetoder eller attributter som alle forekomster har tilgang til, noe som forbedrer både funksjonaliteten og strukturen i koden din.

## Hva er syntaksen for Python-klassevariabler?

Python-klassevariabler opprettes **innenfor klassedefinisjonen** og utenfor metodene.

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

Innenfor klasse `Car` definerer vi klassevariabelen `total_cars` for å holde oversikt over det totale antallet biler. Konstruktøren `__init__` kalles når en ny instans av klassen opprettes. Ved hver instansiering settes **instansvariablene** `brand` og `model`, og klassevariabelen `total_cars` økes med 1.

Ved å kalle opp metoden `display_details()` kan vi vise detaljene for de respektive bilinstansene. I en **f-streng**, en Python-strengformatmetode, kan vi få tilgang til klassevariabelen `total_cars` for å vise det totale antallet biler som er opprettet.

## Eksempler på hvordan man bruker Python-klassevariabler

Tilgang, modifisering og arv spiller en viktig rolle i sikker håndtering av klassevariabler i Python.

### Tilgang til klassevariabler

Python-klassevariabler tilgås **via klassenavnet eller instansen**, etterfulgt av en prikk 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å tilgang til klassevariabler på forskjellige steder:

- **I konstruktøren**: Du kan kalle opp klassevariabelen i konstruktøren ved å bruke enten nøkkelordet `self` eller klassens navn.
- **I instansmetoder**: Du kan kalle opp klassevariabelen i instansmetoder ved å bruke enten nøkkelordet `self` eller klassenavnet.
- **Utenfor klassen**: Du kan få tilgang til klassevariabelen utenfor klassen via objektreferansen eller ved å bruke klassens navn.

### Endre klassevariabler

Python-klassevariabler kan endres direkte via klassens navn. Hvis en instansvariabel har samme navn som en klassevariabel og du prøver å endre variabelen via instansen, **vil det** imidlertid **opprettes en ny instansvariabel**, og klassevariabelen vil forbli uendret.

```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 eksemplet overskrev vi klassevariabelen `class_var` ved å tildele den en ny verdi ved hjelp av klassen `MyClass`. Endringen blir deretter automatisk adoptert av `obj`.

### Klassevariabler og arv

Arv gjør det mulig for avledede klasser å **få tilgang til** og bruke klassevariablene til baseklassen uten å måtte omdefinere dem.

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

Her definerer vi en baseklasse `BaseClass`, som inneholder klassevariabelen `base_var`. Den avledede klassen `DerivedClass` arver fra `BaseClass`. Gjennom arv kan `DerivedClass` få tilgang til klassevariabelen `base_var` i baseklassen og bruke den uten å omdefinere den.


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-klassevariabler/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-klassevariabler/) for AI/LLM consumption.