Magische Methoden

In Python sind magische Methoden spezielle Methoden, die du definieren kannst, um deinen Klassen zusätzliche Funktionalität hinzuzufügen. Sie werden auch Dunder-Methoden genannt, wegen der doppelten Unterstriche __, die ihren Namen vorangestellt und nachgestellt sind. Du bist bereits zwei dieser Methoden begegnet: __init__ und __str__. Schauen wir uns ein einfaches Beispiel an:

class Circle:
    def __init__(self, radius):                     # Initialisiere das Objekt
        self.radius = radius

    def __str__(self):                              # Als String repräsentieren
        return f'Circle with radius {self.radius}'

c = Circle(5)    # Erstelle ein Circle-Objekt namens c
print(c)         # Circle with radius 5

In dem Beispiel haben wir zwei magische Methoden definiert:

__init__ ist eine Konstruktormethode, die aufgerufen wird, wenn eine Instanz der Klasse erstellt wird. Hier setzt sie den Radius des Kreises.

__str__ definiert, wie eine Instanz der Klasse in einen String umgewandelt werden soll, wenn sie in Kontexten wie print() verwendet wird.

Aber dies sind nicht die einzigen magischen Methoden in Python. Es gibt noch viele mehr. Einige davon werden unten präsentiert, die es uns ermöglichen, Klasseninstanzen mit einem + zu addieren oder mit < oder > zu vergleichen:

class Circle:
    def __init__(self, radius):                     # Initialisiere das Objekt
        self.radius = radius

    def __str__(self):                              # Als String repräsentieren
        return f'Circle with radius {self.radius}'

    def __add__(self, other):                       # Zwei Kreise addieren
        return Circle(self.radius + other.radius)   # Einen neuen Kreis zurückgeben

    def __lt__(self, other):                        # Kleiner-als-Vergleich zweier Kreise
        return self.radius < other.radius           # Radien vergleichen

c1 = Circle(5)
c2 = Circle(7)
c3 = c1 + c2     # Dies würde einen neuen Kreis mit Radius 12 erstellen
print(c3)        # Circle with radius 12
print(c1 < c2)   # True

In diesem Fall:

__add__ ermöglicht es uns, den +-Operator mit Circle-Instanzen zu verwenden. Es addiert die Radien der Kreise und gibt einen neuen Circle zurück.

__lt__ (less than) ermöglicht es uns, zwei Circle-Instanzen mit dem <-Operator zu vergleichen. Es prüft, ob der Radius des ersten Kreises kleiner ist als der Radius des zweiten.

Magische Methoden machen unsere Python-Klassen ausdrucksstärker und intuitiver, indem sie sich mehr wie eingebaute Python-Objekte verhalten.

Denke daran, die speziellen doppelten Unterstriche beizubehalten, da der Python-Interpreter nach diesen speziell benannten Methoden sucht, um bestimmte Operationen auszuführen. Du kannst die Liste aller verfügbaren magischen Methoden in Python finden, indem du diesem Link folgst. Unten sind einige der gängigsten magischen Methoden aufgeführt:

Magische Methode	Operator	Beschreibung
`__eq__`	`==`	Gibt `True` zurück, wenn `self` gleich `other` ist.
`__lt__`	`<`	Gibt `True` zurück, wenn `self` kleiner als `other` ist.
`__le__`	`<=`	Gibt `True` zurück, wenn `self` kleiner oder gleich `other` ist.
`__gt__`	`>`	Gibt `True` zurück, wenn `self` größer als `other` ist.
`__ge__`	`>=`	Gibt `True` zurück, wenn `self` größer oder gleich `other` ist.
`__add__(self, other)`	`+`	Implementiert Addition mit dem `+`-Operator.
`__sub__(self, other)`	`-`	Implementiert Subtraktion mit dem `-`-Operator.
`__mul__(self, other)`	`*`	Implementiert Multiplikation mit dem `*`-Operator.
`__truediv__(self, other)`	`/`	Implementiert Division mit dem `/`-Operator.
`__floordiv__(self, other)`	`//`	Implementiert Ganzzahldivision mit dem `//`-Operator.
`__mod__(self, other)`	`%`	Implementiert Modulo mit dem `%`-Operator.
`__pow__(self, other)`	`**`	Implementiert den Potenzoperator `**`.
`__abs__(self)`	`abs()`	Implementiert das Verhalten für die eingebaute Funktion `abs()`.
`__round__(self, n)`	`round()`	Implementiert das Verhalten für die eingebaute Funktion `round()`.
`__neg__(self)`	`-`	Implementiert Negation mit dem unären `-`-Operator.

💡

Hinweis

Herausforderung: Erstelle eine Vektor-Klasse

Du sollst eine Klasse Vector definieren, die einen dreidimensionalen Vektor mit den Attributen x, y und z repräsentiert.

Die Klasse sollte die Implementierung der speziellen Methoden __add__, __sub__ und __mul__ für Vektoraddition, -subtraktion und das Skalarprodukt beinhalten.

Zusätzlich dazu implementiere eine Methode magnitude, um den Betrag des Vektors zu berechnen.

Die geforderten Methoden:

__add__: Diese Methode sollte ein anderes Vector-Objekt akzeptieren und einen neuen Vektor zurückgeben, der das Ergebnis der Addition der x-, y- und z-Komponenten der beiden Vektoren ist.

__sub__: Diese Methode sollte ein anderes Vector-Objekt akzeptieren und einen neuen Vektor zurückgeben, der das Ergebnis der Subtraktion der x-, y- und z-Komponenten des zweiten Vektors vom ersten ist.

__mul__: Diese Methode sollte ein anderes Vector-Objekt akzeptieren und das Skalarprodukt der beiden Vektoren zurückgeben, berechnet als $$(x1 \cdot x2) + (y1 \cdot y2) + (z1 \cdot z2)$$.

magnitude: Diese Methode sollte den Betrag (die Länge) des Vektors zurückgeben, berechnet als $$\sqrt{x^2 + y^2 + z^2}$$.

Input	Output
`v1 = Vector(1, 2, 3); v2 = Vector(4, 5, 6); v3 = v1 + v2; v4 = v1 - v2; print(v1 * v2); print(v1.magnitude()); v4 = Vector(-3, -3, -3)`	32 3.74165

Herausforderung: Erstelle eine Vektor-Klasse

Constraints

To check your solution you need to sign in

Sign in to continue