Wie funktionieren Klassen und Objekte in Python?

Question

Accepted Answer

Eine **Klasse** ist ein Bauplan zum Erstellen von **Objekten** (Instanzen), die Daten (Attribute) und Verhalten (Methoden) bündeln. Pythons OOP ist flexibel und hat einige charakteristische Konventionen, besonders das explizite `self`.

## Definieren einer 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"
```

## Das explizite self

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

Im Gegensatz zu vielen Sprachen mit implizitem `this` erfordert Python **`self`** als expliziten ersten Parameter jeder Instanzmethode — es bezieht sich auf die Instanz, auf der die Methode aufgerufen wird. Sie geben es nicht manuell an; `d.bark()` übergibt `d` automatisch als `self`.

## Klassenattribute versus Instanzattribute

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

Klassenattribute werden von allen Instanzen geteilt; Instanzattribute (gesetzt via `self.x =`) sind pro Objekt.

## Methodentypen

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

## Kapselungskonventionen

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

Python hat keine echten privaten Member — führende Unterstriche sind Konventionen, die Absicht signalisieren ("nicht anfassen"), nicht strikte Durchsetzung.

## Warum es wichtig ist

Klassen sind der Weg, wie Sie Entitäten modellieren und Code in objektorientiertem Python organisieren — durch Bündelung von zusammenhängenden Daten und Verhalten, umfassend verwendet in Frameworks, Domain Modeling und großen Anwendungen.

Das Verständnis der charakteristischen Python-Konventionen — das explizite `self`, der `__init__`-Konstruktor, Klassenattribute versus Instanzattribute, die drei Methodentypen (`instance`/`@classmethod`/`@staticmethod`) und die Unterstrich-Datenschutzkonventionen — ist essentiell für das Schreiben und Lesen von objektorientiertem Python.

Diese unterscheiden sich genug von anderen Sprachen (explizites self, konventionsbasierter Datenschutz), dass deren gutes Verständnis häufige Verwirrung vermeidet.