Come personalizzare il comportamento della classe in Python utilizzando metodi magici

In Python, le classi forniscono un mezzo pulito per raggruppare dati e funzionalità in elementi riutilizzabili. La creazione di classi personalizzate ti consente di modellare entità del mondo reale come utenti, prodotti e dipendenti.

Le classi Python definiscono metodi magici che puoi personalizzare per consentirti di modellare il comportamento delle tue classi per situazioni uniche.

Comprendere i metodi magici

Immagina i metodi magici, chiamati anche metodi dunder, come incantesimi segreti o canti nascosti che Python chiama automaticamente quando esegui determinate azioni su un oggetto.

Python fornisce molti comportamenti integrati per le classi attraverso metodi di istanza, statici e di classe. Puoi creare classi Pythone personalizzali ulteriormente utilizzando metodi magici.

I metodi Magic sono metodi di istanza in Python che hanno due caratteri di sottolineatura (__metodo__) prima e dopo il nome del metodo.

Questi metodi speciali forniscono istruzioni a Python su come gestire gli oggetti di una classe. Ecco alcuni metodi magici comunemente usati nelle classi Python:

• __gt__: Questo metodo controlla se un oggetto è maggiore di un altro.
• __dentro__: questo metodo viene eseguito quando crei un'istanza di una classe ed è principalmente per l'inizializzazione degli attributi.
• __str__: Restituisce una rappresentazione di stringa della classe che descrive l'oggetto.
• __repr__: questo metodo fornisce un output che consente di ricreare l'oggetto utilizzando valutazione().
• __len__: Quando usi il lente() su un oggetto questo metodo restituisce la lunghezza dell'oggetto.
• __eq__: Questo metodo consente il confronto tra oggetti utilizzando il doppio uguale a (==) operatore.
• __lt__: Implementa il confronto inferiore a (
• __aggiungere__: Quando si utilizza l'addizione (+) sugli oggetti, questo metodo viene eseguito ed esegue operazioni di addizione.
• __getoggetto__: consente di recuperare elementi da un oggetto utilizzando la sintassi dell'indice, come oggetto[chiave].

Implementazione di metodi magici

Il modo migliore per comprendere i metodi magici è usarli.

Rappresentazione di stringhe di un oggetto

È possibile personalizzare la rappresentazione della stringa di un oggetto per la leggibilità o l'ulteriore elaborazione.

classPerson:
def__init__(self, name, age):
 self.name = name
 self.age = age
p1 = Person('John', 25)
print(p1)

Qui hai un semplice Persona lezione con un __dentro__ metodo magico per inizializzarlo. Quando stampi il p1 oggetto, utilizza la rappresentazione di stringa predefinita fornita da Python.

Per personalizzare la rappresentazione della stringa, definire il file __str__ E __repr__ metodi magici:

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
p1 = Person('John', 25, 78) 
print(p1)

Ora hai una rappresentazione di stringa più leggibile e completa del file p1 oggetto:

Proprietà della lunghezza di un oggetto

Immagina che, quando chiami il lente() metodo di un oggetto Person, vuoi la loro altezza. Implementare il __len__ metodo magico per il Persona classe:

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
def__len__(self):
return self.height
p2 = Person('Issac', 25, 89) 
print(len(p2))

IL __len__ Il metodo magic restituisce l'attributo altezza di a Persona esempio. Quando chiami lente (p2), chiamerà il __len__ metodo magico automaticamente che restituisce l'altezza del p2 oggetto.

Gestione del confronto tra oggetti

Se è necessario confrontare gli oggetti di una classe in base a determinate proprietà della classe. Puoi definire __eq__ metodo magico e implementa la tua logica di confronto.

classPerson:
def__init__(self, name, age, height):
 self.name = name
 self.age = age
 self.height = height
def__str__(self):
returnf'{self.name} is {self.age} years old'
def__repr__(self):
returnf'{self.name} is {self.age} years old'
def__len__(self):
return self.height
def__eq__(self, other):
return self.name == other.name and self.age == other.age
p1 = Person('John', 25, 56)
p2 = Person('John', 25, 61)
print(p1 == p2)

IL __eq__ metodo confronta il nome E età attributi dei due Di persona oggetti per determinare l'uguaglianza.

Il doppio uguale a (==) utilizza questo metodo per verificare l'uguaglianza anziché confrontare le identità. Quindi due Persona le istanze sono uguali se hanno attributi nome ed età corrispondenti. Ciò ti consente di sovrascrivere il comportamento predefinito di controllo dell'uguaglianza per la tua classe personalizzata.

Implementando questi metodi magici, puoi definire un comportamento personalizzato che sarà coerente con le funzionalità integrate di Python.

Metodi magici avanzati

Ecco alcuni esempi avanzati di utilizzo di metodi magici per personalizzare le lezioni.

Fare in modo che le classi si comportino come contenitori

Usando metodi magici puoi definire classi che si comportano come contenitori. Puoi usare contenitori, come le tuple, per archiviare raccolte di elementi di dati. Forniscono vari metodi per manipolare, accedere e scorrere gli elementi contenuti.

classPerson:
def__init__(self):
 self.data = []
def__len__(self):
return len(self.data)
def__getitem__(self, index):
return self.data[index]
def__setitem__(self, index, value):
 self.data[index] = value
def__delitem__(self, index):
del self.data[index]
p1 = Person()
p1.data = [10, 2, 7]
print(len(p1)) # 3
p1[0] = 5
print(p1[0]) # 5

Ora un oggetto Person può comportarsi come un contenitore:

Personalizzazione dell'accesso agli attributi

Usando il __getattr__ metodo magico è possibile personalizzare il modo in cui gli attributi del Persona si accede alle lezioni in base a determinate condizioni.

classPerson:
def__getattr__(self, name):
if name == 'age':
return40
else:
raise AttributeError(f'No attribute {name}')
p1 = Person()
print(p1.age) # 40

IL __getattr__ Il metodo verrà eseguito quando tenti di accedere a un attributo che non esiste direttamente nell'oggetto. In questo caso, controlla se il nome dell'attributo lo è età e restituisce 40.

Per qualsiasi altro nome di attributo, solleva un Errore attributo con un messaggio corrispondente.

Fare in modo che le classi si comportino come richiamabili

IL __chiamata__ Il metodo ti consente di trattare un'istanza della classe come un oggetto chiamabile (cioè una funzione).

classAdder:
def__call__(self, x, y):
return x + y
adder = Adder()
print(adder(2, 3)) # 5

Quando crei un'istanza di Sommatore e poi chiamalo con argomenti, __chiamata__ Il metodo viene eseguito ed esegue l'addizione prima di restituire il risultato.

Sovraccarico degli operatori

Usando metodi magici puoi eseguire l'overload dell'operatore. L'overload degli operatori ti consente di definire comportamenti personalizzati per gli operatori integrati quando utilizzati con istanze delle tue classi. Ecco un esempio comune che spiega l'overload degli operatori.

classVector:
def__init__(self, x, y):
 self.x = x
 self.y = y
def__add__(self, other):
if isinstance(other, Vector):
 new_x = self.x + other.x
 new_y = self.y + other.y
return Vector(new_x, new_y)
else:
raise TypeError("Unsupported operand type for +")
def__str__(self):
returnf"({self.x}, {self.y})"
# Creating two Vector instances
v1 = Vector(2, 3)
v2 = Vector(1, 4)
# Adding two Vector instances using the + operator
v3 = v1 + v2
# Printing the result
print(v3) # Output: (3, 7)

Il risultato è un nuovo vettore:

IL Vettore la classe definisce il __aggiungere__ metodo, che viene eseguito quando si utilizza il metodo + operatore tra due istanze della classe. Il metodo somma i componenti corrispondenti dei due vettori e ne restituisce uno new Vettore esempio con il risultato.

Qui hai visto i metodi magici fondamentali che puoi implementare per personalizzare il comportamento della tua classe. Python ha molti altri metodi magici che offrono maggiore flessibilità durante la creazione di classi. Fare riferimento al documentazione ufficiale per un elenco completo.

Programmazione orientata agli oggetti in Python

I metodi magici in Python forniscono modi potenti per personalizzare e migliorare il comportamento delle classi. I metodi magici vanno di pari passo con il concetto di programmazione orientata agli oggetti (OOP) in Python. Quindi è importante comprendere il concetto di OOP quando si tenta di utilizzare metodi magici.