Einführung in magische Methoden

Magische Methoden, auch Dunder-Methoden genannt (kurz für „double underscore“), sind spezielle Methoden in Python, mit denen Sie festlegen können, wie sich Objekte in bestimmten Situationen verhalten.

In dieser Lektion lernen Sie, wie Sie häufig verwendete magische Methoden wie __str__, __repr__ und weitere verwenden.

Was sind magische Methoden?

Magische Methoden sind vordefinierte Methoden in Python, die automatisch aufgerufen werden, wenn bestimmte Operationen mit Objekten ausgeführt werden. Sie sind an ihren doppelten Unterstrichen zu erkennen, etwa bei __init__ oder __str__.

Die __init__-Methode

Die __init__-Methode ist ein Konstruktor, der ein neues Objekt initialisiert. Sie wird automatisch aufgerufen, wenn ein Objekt erstellt wird:

# Using the __init__ method to initialize attributes
class Person:
    def __init__(self, name, age):
        self.name = name  # Initialize the name attribute
        self.age = age  # Initialize the age attribute

# Creating an instance of Person
person = Person("Alice", 30)
print(person.name, person.age)  # Outputs: Alice 30

Die __str__-Methode

Die __str__-Methode legt die String-Darstellung eines Objekts fest, wenn print() aufgerufen wird:

# Defining the __str__ method
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"  # String representation

person = Person("Alice", 30)
print(person)  # Outputs: Name: Alice, Age: 30

Die __repr__-Methode

Die __repr__-Methode liefert eine offizielle String-Darstellung eines Objekts, die häufig zum Debuggen verwendet wird:

# Defining the __repr__ method
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person('{self.name}', {self.age})"  # Debug-friendly representation

person = Person("Alice", 30)
print(repr(person))  # Outputs: Person('Alice', 30)

Operatoren mit magischen Methoden überladen

Sie können magische Methoden verwenden, um das Verhalten von Operatoren wie + oder == anzupassen:

# Overloading the + operator with __add__
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)  # Adding two points

    def __str__(self):
        return f"({self.x}, {self.y})"

point1 = Point(1, 2)
point2 = Point(3, 4)
result = point1 + point2  # Calls __add__
print(result)  # Outputs: (4, 6)

Häufig verwendete magische Methoden

Hier sind einige häufig verwendete magische Methoden:

• __len__: Legt das Verhalten der Funktion len() fest.
• __getitem__: Ermöglicht die Indizierung wie bei einer Liste oder einem Dictionary.
• __eq__: Passt den Gleichheitsvergleich mit == an.

__len__ und __getitem__ verwenden

Sie können __len__ verwenden, um die Länge eines benutzerdefinierten Objekts festzulegen, und __getitem__, um es indizierbar zu machen:

# Using __len__ and __getitem__ in a custom class
class CustomList:
    def __init__(self, items):
        self.items = items

    def __len__(self):
        return len(self.items)  # Defines the behavior of len()

    def __getitem__(self, index):
        return self.items[index]  # Enables indexing

custom_list = CustomList([1, 2, 3])
print(len(custom_list))  # Outputs: 3
print(custom_list[1])  # Outputs: 2

Häufige Fehler bei magischen Methoden

Hier sind einige Fehler, die Sie vermeiden sollten:

• Eine magische Methode definieren, ohne ihr vorgesehenes Verhalten einzuhalten.
• Operatoren unnötigerweise überladen.
• Erforderliche magische Methoden in benutzerdefinierten Datentypen nicht implementieren.

Was haben wir gelernt?

In dieser Lektion haben Sie Folgendes gelernt:

• Was magische Methoden sind und warum sie nützlich sind.
• Wie Sie häufig verwendete magische Methoden wie __init__, __str__ und __repr__ verwenden.
• Wie Sie Operatoren mithilfe magischer Methoden überladen.

Sehr gut! Fahren Sie mit dem nächsten Thema fort.