Magic Methods (__str__, __repr__ usw.)

Magic Methods, auch Dunder-Methoden genannt (kurz für „Double Underscore“), sind spezielle Methoden in Python. Sie ermöglichen es, festzulegen, wie sich Objekte in bestimmten Situationen verhalten.

In dieser Lektion lernen Sie, wie Sie gängige Magic Methods wie __str__, __repr__ und weitere verwenden.

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

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 legt die Zeichenfolgendarstellung 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 stellt eine offizielle Zeichenfolgendarstellung eines Objekts bereit, 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)

Sie können Magic Methods 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)

Hier sind einige häufig verwendete Magic Methods:

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

Sie können mit __len__ die Länge eines benutzerdefinierten Objekts festlegen und es mit __getitem__ indizierbar 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

Diese Fehler sollten Sie vermeiden:

• Eine Magic Method zu definieren, ohne ihr vorgesehenes Verhalten zu berücksichtigen.
• Operatoren unnötigerweise zu überladen.
• Erforderliche Magic Methods in benutzerdefinierten Datentypen nicht zu implementieren.

In dieser Lektion haben Sie Folgendes gelernt:

• Was Magic Methods sind und warum sie nützlich sind.
• Wie Sie gängige Magic Methods wie __init__, __str__ und __repr__ verwenden.
• Wie Sie mithilfe von Magic Methods Operatoren überladen.

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