Introduzione ai metodi magici

I metodi magici, chiamati anche metodi dunder (abbreviazione di 'double underscore'), sono metodi speciali di Python che consentono di definire il comportamento degli oggetti in situazioni specifiche.

In questa lezione si imparerà a utilizzare alcuni 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 si eseguono operazioni specifiche sugli oggetti. Sono identificati dai doppi underscore, 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 utilizzati comunemente

Ecco alcuni metodi magici utilizzati comunemente:

• __len__: definisce il comportamento della funzione len().
• __getitem__: consente l'accesso tramite indice, come per una lista o un dizionario.
• __eq__: personalizza il confronto di uguaglianza mediante ==.

Utilizzare __len__ e __getitem__

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

# 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 che sia necessario.
• Dimenticare di implementare i metodi magici richiesti nei tipi di dati personalizzati.

Che cosa abbiamo imparato?

In questa lezione si è 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! Si può passare all'argomento successivo.