Hvordan fungerer klasser og objekter i Python?

Question

Accepted Answer

En **klasse** er en blueprint for å lage **objekter** (instanser) som samler data (attributter) og atferd (metoder). Pythons OOP er fleksibel og har noen karakteristiske konvensjoner, særlig den eksplisitte `self`.

## Definering av en klasse

```python
class Dog:
    species = "Canis familiaris"     # CLASS attribute (shared by all instances)

def __init__(self, name, age):   # the constructor — runs on creation
        self.name = name              # INSTANCE attributes (per object)
        self.age = age

def bark(self):                   # a method — `self` is the instance
        return f"{self.name} says woof"

d = Dog("Rex", 3)        # create an instance (calls __init__)
d.name                   # "Rex"
d.bark()                 # "Rex says woof"
```

## Den eksplisitte self

```python
def bark(self):          # `self` is ALWAYS the first parameter of a method
    return self.name      # access instance data through self
```

I motsetning til mange språk med en implisitt `this`, krever Python **`self`** som den eksplisitte første parameteren i hver instansmetode — det refererer til instansen metoden kalles på. Du passerer den ikke manuelt; `d.bark()` passerer `d` som `self` automatisk.

## Klasseattributter vs instansattributter

```python
Dog.species          # "Canis familiaris" — shared by all dogs
d.species            # also accessible from an instance
d.name               # "Rex" — unique to this instance
```

Klasseattributter deles på tvers av alle instanser; instansattributter (satt via `self.x =`) er per-objekt.

## Metodtyper

```python
class Circle:
    def area(self): ...                    # instance method — needs self

@classmethod
    def from_diameter(cls, d):             # class method — receives the CLASS (cls)
        return cls(d / 2)                   # often used as alternative constructors

@staticmethod
    def pi(): return 3.14159               # static — no self/cls, just namespaced
```

## Inkapslingskonvensjoner

```python
self.public                # public
self._protected            # "internal use" by convention (not enforced)
self.__private             # name-mangled to _ClassName__private (stronger hiding)
```

Python har ingen ekte private medlemmer — ledende understreker er konvensjoner som signaliserer intensjon ("ikke ting dette"), ikke hard håndhevelse.

## Hvorfor det betyr noe

Klasser er hvordan du modellerer entiteter og organiserer kode i objektorientert Python — ved å samle relaterte data og atferd, brukt intensivt i frameworks, domenemodelering og store applikasjoner.

Å forstå de karakteristiske Python-konvensjonene — den eksplisitte `self`, `__init__`-konstruktør, klasseattributter vs instansattributter, de tre metodetypene (`instance`/`@classmethod`/`@staticmethod`), og underscore-privatkonvensjonene — er essensielt for å skrive og lese objektorientert Python.

Disse skiller seg nok fra andre språk (eksplisitt self, konvensjonsbasert privat) at det å kunne dem godt forhindrer vanlig forvirring.