Wprowadzenie do metod magicznych

Metody magiczne, nazywane także metodami dunder (skrót od angielskiego określenia „double underscore”), to specjalne metody w języku Python, które pozwalają definiować zachowanie obiektów w określonych sytuacjach.

W tej lekcji nauczą się Państwo korzystać z popularnych metod magicznych, takich jak __str__, __repr__ i inne.

Czym są metody magiczne?

Metody magiczne to predefiniowane metody w języku Python, które są wywoływane automatycznie podczas wykonywania określonych operacji na obiektach. Rozpoznaje się je po podwójnych znakach podkreślenia, na przykład __init__ lub __str__.

Metoda __init__

Metoda __init__ jest konstruktorem, który inicjalizuje nowy obiekt. Jest wywoływana automatycznie podczas tworzenia obiektu:

# 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

Metoda __str__

Metoda __str__ definiuje tekstową reprezentację obiektu wyświetlaną po wywołaniu funkcji print():

# 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

Metoda __repr__

Metoda __repr__ zapewnia oficjalną tekstową reprezentację obiektu, często używaną podczas debugowania:

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

Przeciążanie operatorów za pomocą metod magicznych

Za pomocą metod magicznych można dostosować działanie operatorów, takich jak + lub ==:

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

Często używane metody magiczne

Oto kilka często używanych metod magicznych:

• __len__: definiuje działanie funkcji len().
• __getitem__: umożliwia indeksowanie tak jak w przypadku listy lub słownika.
• __eq__: dostosowuje porównywanie równości za pomocą operatora ==.

Korzystanie z __len__ i __getitem__

Można użyć __len__ do zdefiniowania długości niestandardowego obiektu, a __getitem__ do umożliwienia jego indeksowania:

# 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

Typowe błędy związane z metodami magicznymi

Oto kilka błędów, których należy unikać:

• Definiowanie metody magicznej w sposób niezgodny z jej przeznaczeniem.
• Niepotrzebne przeciążanie operatorów.
• Zapominanie o implementacji wymaganych metod magicznych w niestandardowych typach danych.

Czego się nauczyliśmy

W tej lekcji dowiedzieli się Państwo:

• Czym są metody magiczne i dlaczego są przydatne.
• Jak korzystać z popularnych metod magicznych, takich jak __init__, __str__ i __repr__.
• Jak przeciążać operatory za pomocą metod magicznych.

Świetna praca! Przejdźmy do następnego tematu.