Cum să personalizați comportamentul clasei în Python folosind metode magice

În Python, clasele oferă un mijloc curat de a grupa datele și funcționalitățile împreună în elemente reutilizabile. Crearea de clase personalizate vă permite să modelați entități din lumea reală, cum ar fi utilizatori, produse și angajați.

Clasele Python definesc metode magice pe care le puteți personaliza pentru a vă permite să modelați comportamentul claselor pentru situații unice.

Înțelegerea metodelor magice

Imaginați-vă metode magice, numite și metode dunder, ca vrăji secrete sau scandări ascunse pe care Python le apelează automat atunci când efectuați anumite acțiuni asupra unui obiect.

Python oferă o mulțime de comportament încorporat pentru clase metode de exemplu, statice și de clasă. Puteți creați clase Pythonși personalizați-le și mai mult folosind metode magice.

Metodele magice sunt metode de instanță în Python care au două caractere de subliniere (__metodă__) înainte și după numele metodei.

Aceste metode speciale oferă lui Python instrucțiuni despre cum să gestioneze obiectele unei clase. Iată câteva metode magice utilizate în mod obișnuit în clasele Python:

• __gt__: Această metodă verifică dacă un obiect este mai mare decât altul.
• __init__: Această metodă rulează atunci când creați o instanță a unei clase și este în principal pentru inițializarea atributelor.
• __str__: Aceasta returnează o reprezentare șir a clasei care descrie obiectul.
• __repr__: Această metodă oferă o ieșire care vă permite să recreați obiectul folosind eval().
• __len__: Când utilizați len() funcția pe un obiect această metodă returnează lungimea obiectului.
• __eq__: Această metodă permite compararea între obiecte folosind dublu egal cu (==) operator.
• __lt__: Implementează o comparație mai mică decât (
• __adăuga__: Când utilizați adăugarea (+) operator pe obiecte rulează această metodă și efectuează operații de adăugare.
• __getitem__: Vă permite să preluați elemente dintr-un obiect folosind sintaxa indexului, cum ar fi obj[cheie].

Implementarea metodelor magice

Cel mai bun mod de a înțelege metodele magice este folosirea lor.

Reprezentarea în șir a unui obiect

Puteți personaliza reprezentarea în șir a unui obiect pentru lizibilitate sau procesare ulterioară.

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

Aici ai un simplu Persoană clasa cu o __init__ metoda magică pentru a-l inițializa. Când imprimați p1 obiect, folosește reprezentarea implicită șir furnizată de Python.

Pentru a personaliza reprezentarea șirului, definiți __str__ și __repr__ metode magice:

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)

Acum aveți o reprezentare mai lizibilă și mai cuprinzătoare a șirurilor p1 obiect:

Proprietatea de lungime a unui obiect

Imaginați-vă că, când suni la len() metoda unui obiect Person, doriți înălțimea lor. Implementați __len__ metoda magică pentru Persoană clasă:

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

The __len__ metoda magică returnează atributul de înălțime al lui a Persoană instanță. Când suni len (p2), va apela __len__ metoda magică care returnează automat înălțimea p2 obiect.

Manipularea comparației între obiecte

Dacă trebuie să comparați obiectele unei clase pe baza anumitor proprietăți ale clasei. Puteți defini __eq__ metoda magică și implementați logica de comparație.

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)

The __eq__ metoda compară Nume și vârstă atributele celor doi Al persoanei obiecte pentru a determina egalitatea.

Dublu egal cu (==) folosește această metodă pentru a verifica egalitatea, mai degrabă decât pentru a compara identitățile. Deci doi Persoană instanțele sunt egale dacă au atribute de nume și vârstă care se potrivesc. Acest lucru vă permite să suprascrieți comportamentul implicit de verificare a egalității pentru clasa dvs. personalizată.

Prin implementarea acestor metode magice, puteți defini un comportament personalizat care va fi în concordanță cu încorporațiile Python.

Metode magice avansate

Iată câteva exemple avansate de utilizare a metodelor magice pentru a personaliza clasele.

Făcând clasele să se comporte ca niște containere

Folosind metode magice puteți defini clase care se comportă ca niște containere. Poți să folosești containere, cum ar fi tuplurile, pentru a stoca colecții de elemente de date. Ele oferă diverse metode de manipulare, accesare și iterare prin elementele conținute.

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

Acum un obiect Person se poate comporta ca un container:

Personalizarea accesului la atribute

Folosind __getattr__ metoda magică puteți personaliza modul în care atributele Persoană clasele sunt accesate în anumite condiții.

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

The __getattr__ metoda va rula atunci când încercați să accesați un atribut care nu există direct în obiect. În acest caz, verifică dacă numele atributului este vârstă și returnează 40.

Pentru orice alt nume de atribut, ridică un AttributeError cu un mesaj corespunzător.

Faceți ca clasele să se comporte ca apelabile

The __apel__ metoda vă permite să tratați o instanță a clasei ca pe un obiect apelabil (adică, o funcție).

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

Când creați o instanță de Sumator și apoi numiți-o cu argumente, __apel__ metoda rulează și efectuează adăugarea înainte de a returna rezultatul.

Supraîncărcarea operatorului

Folosind metode magice puteți efectua supraîncărcarea operatorului. Supraîncărcarea operatorului vă permite să definiți comportamente personalizate pentru operatorii încorporați atunci când sunt utilizate cu instanțe ale propriilor clase. Iată un exemplu comun care explică supraîncărcarea operatorului.

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)

Rezultatul este un vector nou:

The Vector clasa defineste __adăuga__ metoda, care rulează atunci când utilizați + operator între două instanțe ale clasei. Metoda adaugă componentele corespunzătoare ale celor doi vectori și returnează un nou Vector exemplu cu rezultatul.

Aici ați văzut metode magice fundamentale pe care le puteți implementa pentru a vă personaliza comportamentul clasei. Python are mult mai multe metode magice care oferă mai multă flexibilitate la crearea claselor. Consultați documentație oficială pentru o listă completă.

Programare orientată pe obiecte în Python

Metodele magice din Python oferă modalități puternice de personalizare și îmbunătățire a comportamentului claselor. Metodele magice merg împreună cu conceptul de programare orientată pe obiecte (OOP) în Python. Prin urmare, este important să înțelegeți conceptul de POO atunci când încercați să utilizați metode magice.