Kapitel 08: Operator Overloading & Dunder-Methoden

1. Was bedeutet "Dunder" & Operator Overloading?

In Python steht "Dunder" kurz für Double Underscore (doppelter Unterstrich), wie bei __init__ oder __str__. Man nennt sie auch magische Methoden (Magic Methods) oder spezielle Methoden.

🧙‍♂️ Der Universal-Übersetzer von Python:

Wenn du in Python schreibst: a + b, dann weiß Python von Natur aus nicht, was deine eigenen Klassen bedeuten. Python ruft stattdessen heimlich im Hintergrund die Methode a.__add__(b) auf!
Operator Overloading bedeutet einfach: Du schreibst die Methode __add__ in deine Klasse, und schon funktioniert das Plus-Zeichen + für deine Objekte!

Was Python im Hintergrund wirklich tut

# Was du im Code schreibst:
ergebnis = v1 + v2
ist_gleich = (v1 == v2)
laenge = len(meine_liste)

# Was Python intern daraus macht:
ergebnis = v1.__add__(v2)
ist_gleich = v1.__eq__(v2)
laenge = meine_liste.__len__()

2. Die wichtigste Dunder-Methoden-Tabelle

Hier sind die am häufigsten genutzten magischen Methoden in Python:

Kategorie	Operator / Funktion	Dunder-Methode	Bedeutung
Mathematik	`a + b`	`__add__(self, other)`	Addition
	`a - b`	`__sub__(self, other)`	Subtraktion
	`a * b`	`__mul__(self, other)`	Multiplikation (von links)
	`b * a`	`__rmul__(self, other)`	Rechts-Multiplikation (z.B. `3 * v`)
Vergleiche	`a == b`	`__eq__(self, other)`	Gleichheit (Equal)
	`a < b`	`__lt__(self, other)`	Kleiner als (Less Than)
	`a <= b`	`__le__(self, other)`	Kleiner gleich (Less or Equal)
Darstellung & Container	`print(a)` / `str(a)`	`__str__(self)`	Schöne Ausgabe für Menschen
	`repr(a)`	`__repr__(self)`	Eindeutige Debug-Ausgabe
	`abs(a)`	`__abs__(self)`	Betrag / Länge
	`len(a)`	`__len__(self)`	Anzahl von Elementen

💡 Unterschied zwischen __str__ und __repr__:

__str__ ist für Endbenutzer gedacht. Beispiel: (3.0, 4.0).
__repr__ ist für Entwickler & Debugger gedacht. Sie soll so präzise sein, dass man das Objekt idealerweise wieder nachbauen könnte: Vektor2D(3.0, 4.0).

3. Praxisbeispiel: Der 2D-Vektor 🚀

In Videospielen, Physiksimulationen und in der Geometrie rechnet man ständig mit 2D-Vektoren. Mit Dunder-Methoden liest sich dein Code wie echte Mathematik!

Beispiel: Vektor-Addition & Multiplikation

class Vektor2D:
    def __init__(self, x: float, y: float):
        self.x = float(x)
        self.y = float(y)

    def __add__(self, other: 'Vektor2D') -> 'Vektor2D':
        if isinstance(other, Vektor2D):
            return Vektor2D(self.x + other.x, self.y + other.y)
        return NotImplemented

    def __mul__(self, other):
        # Skalarmultiplikation mit Zahl: v * 3
        if isinstance(other, (int, float)):
            return Vektor2D(self.x * other, self.y * other)
        # Skalarprodukt mit anderem Vektor: v1 * v2
        elif isinstance(other, Vektor2D):
            return self.x * other.x + self.y * other.y
        return NotImplemented

    def __rmul__(self, other):
        # Ermöglicht: 3 * v (Zahl steht links)
        return self.__mul__(other)

4. 🎯 Deine Aufgaben in `aufgabe.py`

Öffne die Datei 08_operator_overloading_dunder/aufgabe.py und vervollständige die folgenden Klassen:

TODO 1: Vektor2D.__init__ mit x und y (als float konvertiert).
TODO 2: __repr__ ("Vektor2D(3.0, 4.0)") und __str__ ("(3.0, 4.0)").
TODO 3: laenge(self) ($\sqrt{x^2 + y^2}$) und __abs__(self).
TODO 4: __add__ und __sub__ für komponentenweise Vektor-Arithmetik.
TODO 5: __mul__ (für Zahlen & Skalarprodukt) und __rmul__ (für 3 * v).
TODO 6: __eq__ (Komponenten prüfen) sowie __lt__ und __le__ (nach Vektorlänge vergleichen).
TODO 7, 8, 9: Die Klasse Wegstrecke mit __len__, __getitem__ und gesamtlaenge() (nutzt Vektordifferenz und abs()).

💡 Lösungshinweise (Aufklappen bei Bedarf)

🔍 Tipp zu TODO 3 (Länge berechnen mit math.sqrt)

import math

def laenge(self) -> float:
    return math.sqrt(self.x**2 + self.y**2)

def __abs__(self) -> float:
    return self.laenge()

🔍 Tipp zu TODO 9 (Gesamtlänge der Wegstrecke berechnen)

Iteriere über alle Punkte von 0 bis len(self.punkte) - 2. Die Distanz zwischen zwei Punkten ist einfach abs(self.punkte[i+1] - self.punkte[i])!

5. 🧪 Lösung überprüfen

Führe im Terminal im Ordner 08_operator_overloading_dunder folgenden Befehl aus:

Terminal

python3 test_aufgabe.py