# Hvordan lage Python-klasser og -objekter

Python-klasser er som **byggeplaner eller maler**. Du kan bruke dem til å skrive gjenbrukbar kode i form av klasseattributter og metoder.

## Hva er Python-klasser?

En klasse er et **abstrakt begrep** som beskriver attributter og metoder for objekter. En Python-klasse fungerer som en mal for å lage konkrete objekter, som er instanser av klassen. For eksempel kan `Car` definere attributter som farge og merke, sammen med metoder som `__drive__` eller `__brake__`.

Selv om hvert objekt i en klasse kan ha unike attributtverdier, **deler** objekter i samme klasse **metoder og grunnleggende atferdsrammeverk med andre forekomster** i klassen. For eksempel kan objektet `my_car` i klassen `Car` opprettes med fargen `__red__` og merket `__Toyota__`, men metodene `__drive__` og `__brake__` vil automatisk overføres til forekomsten.

## Hvordan lage Python-klasser

I Python definerer du klasser ved hjelp av nøkkelordet `class`.

```python
class MyClass:
    # Constructor method called when creating an object
    def __init__(self, attribute1, attribute2):
        self.attribute1 = attribute1
        self.attribute2 = attribute2
    
    # Method defined within the class
    def my_method(self):
        return f"Attribute 1: {self.attribute1}, Attribute 2: {self.attribute2}"
```

Koden ovenfor definerer en klasse med navnet `MyClass`. Den har en **konstruktør** `__init__`, som påkalles ved opprettelse av objektet, og initialiserer to attributter: `attribute1` og `attribute2`. Metoden `my_method` returnerer en formatert streng som inneholder verdiene til disse attributtene.

For å avlede et objekt fra denne klassen, bruk klassens navn etterfulgt av parenteser:

```python
object1 = MyClass("Value 1", "Value 2")
# Calling a method of the object
result = object1.my_method()
```

## Eksempler på hvordan man bruker Python-klasser

Python-klasser kan skape komplekse systemer og relasjoner mellom ulike enheter. I de følgende avsnittene viser vi deg hvordan du arbeider med Python-klasser.

### `__str()__` funksjon

Funksjonen `__str__()` i Python er en spesiell metode som du kan definere innenfor Python-klasser. Når den implementeres, returnerer den en streng som representerer en **brukervennlig fremstilling av et objekt**. Du kan bruke funksjonen `str()` direkte på et objekt eller kombinere den med en `print()` ning.

```python
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"
person1 = Person("Alice", 30)
print(person1) # Output: Name: Alice, Age: 30
```

I koden ovenfor oppretter metoden `__str__()` i klassen `Person` en **formatert streng** som viser en persons navn og alder. Når `print(person1)` utføres, kaller den automatisk metoden `__str__()` i objektet `person1` og sender ut strengen som returneres av metoden.

### Definere metoder i Python-klasser

I Python kan du definere **metoder innenfor en klasse** for å utføre operasjoner på objektene i klassen. Disse metodene kan deretter kalles av objektene som er opprettet.

```python
class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
    
    def area(self):
        return self.length * self.width
    def perimeter(self):
        return 2 * (self.length + self.width)
# Creating an object of the class
my_rectangle = Rectangle(5, 10)
# Calling methods of the object
area = my_rectangle.area()
perimeter = my_rectangle.perimeter()
# Printing the calculated values
print("Area =", area) # Output: Area = 50
print("Perimeter =", perimeter) # Output: Perimeter = 30
```

I Python-eksemplet definerer vi klassen `Rectangle` med to metoder `area()` og `perimeter()`, som beregner rektanglets areal og omkrets ved hjelp av lengden og bredden som angis under objektinitialiseringen. I Python fungerer `self` i en klassemetode som en **referanse til objektet** som metoden for øyeblikket brukes på.

Objektet `my_rectangle` opprettes med en lengde på 5 og en bredde på 10. Deretter kaller vi metodene `area()` og `perimeter()` på dette objektet for å beregne de tilsvarende verdiene.

### Endre egenskapene til objekter

`.` punktsoperatøren kan brukes til å få tilgang til **objektets spesifikke attributter** og oppdatere verdiene deres. Du kan tilordne nye verdier direkte til attributtet.

```python
person1.name = "Sarah"
person1.age = 35
```

Nøkkelordet `del` brukes til å slette egenskapene til et objekt.

```python
del person1.name
```

Note Husk at instansvariabler er forskjellige fra [Python-klassevariabler](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-klassevariabler/). Klassevariabler defineres **utenfor konstruktøren** og kan bare endres ved å bruke klassenavnet.


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