Metodi Magici

In Python, i metodi magici sono metodi speciali che puoi definire per aggiungere funzionalità alle tue classi. Sono anche noti come metodi dunder, a causa dei doppi underscore __ che precedono e seguono i loro nomi. Hai già incontrato due di questi metodi: __init__ e __str__. Dai un'occhiata a un semplice esempio:

class Circle:
    def __init__(self, radius):                     # Inizializza l'oggetto
        self.radius = radius

    def __str__(self):                              # Rappresenta come stringa
        return f'Circle with radius {self.radius}'

c = Circle(5)    # Crea un oggetto Circle chiamato c
print(c)         # Circle with radius 5

Nell'esempio, abbiamo definito due metodi magici:

__init__ è un metodo costruttore che viene chiamato quando viene creata un'istanza della classe. Qui, imposta il raggio del Circle.

__str__ definisce come un'istanza della classe dovrebbe essere convertita in una stringa quando viene utilizzata in contesti come print().

Ma questi non sono gli unici metodi magici in Python. Ce ne sono molti altri. Alcuni sono presentati di seguito e ci permettono di fare in modo che le istanze della classe possano essere sommate con un + o confrontate con < o >:

class Circle:
    def __init__(self, radius):                     # Inizializza l'oggetto
        self.radius = radius

    def __str__(self):                              # Rappresenta come stringa
        return f'Circle with radius {self.radius}'

    def __add__(self, other):                       # Somma due cerchi
        return Circle(self.radius + other.radius)   # Restituisci un nuovo cerchio

    def __lt__(self, other):                        # Confronto "minore di" tra due cerchi
        return self.radius < other.radius           # Confronta i raggi

c1 = Circle(5)
c2 = Circle(7)
c3 = c1 + c2     # Questo crea un nuovo Circle con raggio 12
print(c3)        # Circle with radius 12
print(c1 < c2)   # True

In questo caso:

__add__ ci permette di utilizzare l'operatore + con le istanze di Circle. Somma i raggi dei cerchi e restituisce un nuovo Circle.

__lt__ (less than) ci permette di confrontare due istanze di Circle con l'operatore <. Verifica se il raggio del primo cerchio è minore del raggio del secondo.

I metodi magici rendono le nostre classi Python più espressive e intuitive, comportandosi più come oggetti integrati di Python.

Ricorda di mantenere la speciale doppia sottolineatura nei nomi, perché l'interprete Python cerca questi metodi con nomi specifici per eseguire determinate operazioni. Puoi trovare la lista di tutti i metodi magici disponibili in Python seguendo questo link. Di seguito sono riportati alcuni dei metodi magici più popolari:

Metodo Magico	Operatore	Descrizione
`__eq__`	`==`	Restituisce `True` se `self` è uguale a `other`.
`__lt__`	`<`	Restituisce `True` se `self` è minore di `other`.
`__le__`	`<=`	Restituisce `True` se `self` è minore o uguale a `other`.
`__gt__`	`>`	Restituisce `True` se `self` è maggiore di `other`.
`__ge__`	`>=`	Restituisce `True` se `self` è maggiore o uguale a `other`.
`__add__(self, other)`	`+`	Implementa l'addizione con l'operatore `+`.
`__sub__(self, other)`	`-`	Implementa la sottrazione con l'operatore `-`.
`__mul__(self, other)`	`*`	Implementa la moltiplicazione con l'operatore `*`.
`__truediv__(self, other)`	`/`	Implementa la divisione con l'operatore `/`.
`__floordiv__(self, other)`	`//`	Implementa la divisione intera con l'operatore `//`.
`__mod__(self, other)`	`%`	Implementa il modulo con l'operatore `%`.
`__pow__(self, other)`	`**`	Implementa l'operatore potenza `**`.
`__abs__(self)`	`abs()`	Implementa il comportamento per la funzione integrata `abs()`.
`__round__(self, n)`	`round()`	Implementa il comportamento per la funzione integrata `round()`.
`__neg__(self)`	`-`	Implementa la negazione con l'operatore unario `-`.

💡

Nota che non tutti i metodi hanno senso per tutte le classi; dovresti implementare solo quelli che sono utili per il tuo problema.

Sfida: Crea una Classe Vector

Ti viene chiesto di definire una classe, Vector, che rappresenta un vettore tridimensionale con attributi x, y e z.

La classe dovrebbe includere l'implementazione dei metodi speciali __add__, __sub__ e __mul__ per l'addizione, la sottrazione e il prodotto scalare dei vettori rispettivamente.

Oltre a questi, implementa un metodo magnitude per calcolare la magnitudine del vettore.

I metodi richiesti:

__add__: Questo metodo dovrebbe accettare un altro oggetto Vector e restituire un nuovo Vector che è il risultato dell'addizione delle componenti x, y e z dei due vettori.

__sub__: Questo metodo dovrebbe accettare un altro oggetto Vector e restituire un nuovo Vector che è il risultato della sottrazione delle componenti x, y e z del secondo vettore dal primo.

__mul__: Questo metodo dovrebbe accettare un altro oggetto Vector e restituire il prodotto scalare dei due vettori, calcolato come $$(x1 \cdot x2) + (y1 \cdot y2) + (z1 \cdot z2)$$.

magnitude: Questo metodo dovrebbe restituire la magnitudine (lunghezza) del vettore, calcolata come $$\sqrt{x^2 + y^2 + z^2}$$.

Input	Output
`v1 = Vector(1, 2, 3); v2 = Vector(4, 5, 6); v3 = v1 + v2; v4 = v1 - v2; print(v1 * v2); print(v1.magnitude()); v4 = Vector(-3, -3, -3)`	32 3.74165

Sfida: Crea una Classe Vector

Constraints

To check your solution you need to sign in

Sign in to continue