Magische methoden (__str__, __repr__, enz.)

Magische methoden, ook wel dunder-methoden genoemd (een afkorting van 'dubbele underscore'), zijn speciale methoden in Python waarmee je kunt definiëren hoe objecten zich in specifieke situaties gedragen.

In deze les leer je hoe je veelgebruikte magische methoden zoals __str__, __repr__ en andere gebruikt.

Magische methoden zijn vooraf gedefinieerde methoden in Python die automatisch worden aangeroepen wanneer specifieke bewerkingen op objecten worden uitgevoerd. Je herkent ze aan hun dubbele underscores, zoals bij __init__ of __str__.

De __init__-methode is een constructor die een nieuw object initialiseert. Deze wordt automatisch aangeroepen wanneer een object wordt gemaakt:

# 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

De __str__-methode bepaalt de stringrepresentatie van een object wanneer print() wordt aangeroepen:

# 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

De __repr__-methode biedt een officiële stringrepresentatie van een object, die vaak wordt gebruikt voor foutopsporing:

# 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)

Je kunt magische methoden gebruiken om het gedrag van operatoren zoals + of == aan te passen:

# 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)

Dit zijn enkele veelgebruikte magische methoden:

• __len__: Bepaalt het gedrag van de functie len().
• __getitem__: Maakt indexering mogelijk, zoals bij een lijst of woordenboek.
• __eq__: Past de gelijkheidsvergelijking met == aan.

Je kunt __len__ gebruiken om de lengte van een aangepast object te definiëren en __getitem__ om het indexeerbaar te maken:

# 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

Dit zijn enkele fouten die je moet vermijden:

• Een magische methode definiëren zonder het bedoelde gedrag ervan te volgen.
• Operatoren onnodig overladen.
• Vergeten om vereiste magische methoden in aangepaste gegevenstypen te implementeren.

In deze les heb je het volgende geleerd:

• Wat magische methoden zijn en waarom ze nuttig zijn.
• Hoe je veelgebruikte magische methoden zoals __init__, __str__ en __repr__ gebruikt.
• Hoe je operatoren met magische methoden overlaadt.

Goed gedaan! Laten we doorgaan naar het volgende onderwerp.