Introduzione ai metodi magici

I metodi magici, noti anche come metodi dunder (abbreviazione di "double underscore", ovvero "doppio underscore"), sono metodi speciali di Python che consentono di definire il comportamento degli oggetti in situazioni specifiche.

In questa lezione imparerà a utilizzare metodi magici comuni come __str__, __repr__ e altri.

Che cosa sono i metodi magici?

I metodi magici sono metodi predefiniti di Python che vengono chiamati automaticamente quando vengono eseguite operazioni specifiche sugli oggetti. Sono identificati dai doppi caratteri di sottolineatura, come __init__ o __str__.

Il metodo __init__

Il metodo __init__ è un costruttore che inizializza un nuovo oggetto. Viene chiamato automaticamente quando viene creato un oggetto:

# 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

Il metodo __str__

Il metodo __str__ definisce la rappresentazione sotto forma di stringa di un oggetto quando viene chiamato 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

Il metodo __repr__

Il metodo __repr__ fornisce una rappresentazione ufficiale sotto forma di stringa di un oggetto, spesso utilizzata per il debug:

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

Sovraccaricare gli operatori con i metodi magici

È possibile utilizzare i metodi magici per personalizzare il comportamento di operatori come + o ==:

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

Metodi magici usati più frequentemente

Ecco alcuni metodi magici usati frequentemente:

• __len__: definisce il comportamento della funzione len().
• __getitem__: consente di utilizzare gli indici come in una lista o in un dizionario.
• __eq__: personalizza il confronto di uguaglianza tramite ==.

Utilizzare __len__ e __getitem__

È possibile utilizzare __len__ per definire la lunghezza di un oggetto personalizzato e __getitem__ per renderlo indicizzabile:

# 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

Errori comuni con i metodi magici

Ecco alcuni errori da evitare:

• Definire un metodo magico senza rispettarne il comportamento previsto.
• Sovraccaricare gli operatori senza necessità.
• Dimenticare di implementare i metodi magici richiesti nei tipi di dati personalizzati.

Che cosa abbiamo imparato?

In questa lezione ha imparato:

• Che cosa sono i metodi magici e perché sono utili.
• Come utilizzare metodi magici comuni come __init__, __str__ e __repr__.
• Come sovraccaricare gli operatori utilizzando i metodi magici.

Ottimo lavoro! Passiamo al prossimo argomento.