Ako prispôsobiť správanie triedy v Pythone pomocou magických metód

V Pythone triedy poskytujú čisté prostriedky na spojenie údajov a funkcií do opakovane použiteľných prvkov. Vytváranie vlastných tried vám umožňuje modelovať entity v reálnom svete, ako sú používatelia, produkty a zamestnanci.

Triedy Pythonu definujú magické metódy, ktoré si môžete prispôsobiť, aby vám umožnili tvarovať správanie vašich tried pre jedinečné situácie.

Pochopenie magických metód

Predstavte si magické metódy, nazývané aj dunderove metódy, ako tajné kúzla alebo skryté spevy, ktoré Python automaticky volá, keď s objektom vykonávate určité akcie.

Python poskytuje triedam množstvo vstavaného správania metódy inštancie, statické a triedy. Môžeš vytvárať triedy Pythonua ešte viac ich prispôsobte pomocou magických metód.

Magické metódy sú metódy inštancie v Pythone, ktoré majú dve podčiarkovníky (__metóda__) pred a za názvom metódy.

Tieto špeciálne metódy dávajú Pythonu pokyny, ako zaobchádzať s objektmi triedy. Tu sú niektoré bežne používané magické metódy v triedach Pythonu:

• __gt__: Táto metóda kontroluje, či je jeden objekt väčší ako druhý.
• __init__: Táto metóda sa spustí, keď vytvoríte inštanciu triedy a slúži hlavne na inicializáciu atribútov.
• __str__: Toto vráti reťazcovú reprezentáciu triedy popisujúcej objekt.
• __repr__: Táto metóda poskytuje výstup, ktorý vám umožňuje znovu vytvoriť objekt pomocou eval().
• __len__: Keď použijete len() funkcia na objekte, táto metóda vráti dĺžku objektu.
• __eq__: Táto metóda umožňuje porovnanie medzi objektmi pomocou dvojitého rovného (==) operátor.
• __lt__: Implementuje menej ako (
• __pridať__: Keď použijete doplnok (+) operátor na objektoch táto metóda spúšťa a vykonáva operácie sčítania.
• __getitem__: Umožňuje vám získať položky z objektu pomocou syntaxe indexu, napr obj[kľúč].

Implementácia magických metód

Najlepší spôsob, ako pochopiť magické metódy, je ich použitie.

Reťazcová reprezentácia objektu

Reťazecovú reprezentáciu objektu môžete prispôsobiť čitateľnosti alebo ďalšiemu spracovaniu.

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

Tu máte jednoduchý Osoba trieda s an __init__ magická metóda na jej inicializáciu. Keď vytlačíte p1 používa predvolenú reťazcovú reprezentáciu poskytovanú Pythonom.

Ak chcete prispôsobiť reprezentáciu reťazca, definujte __str__ a __repr__ magické metódy:

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)

Teraz máte čitateľnejšiu a komplexnejšiu reprezentáciu reťazca p1 objekt:

Dĺžka vlastnosti objektu

Predstavte si, že keď zavoláte len() metóda objektu Osoba, chcete ich výšku. Implementovať __len__ magická metóda pre Osoba trieda:

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__ magická metóda vracia atribút výšky a Osoba príklad. Keď zavoláte len (p2), bude to volať __len__ magická metóda automaticky, ktorá vráti výšku p2 objekt.

Spracovanie porovnania medzi objektmi

Ak potrebujete porovnať objekty triedy na základe určitých vlastností triedy. Môžete definovať __eq__ magickú metódu a implementujte svoju porovnávaciu logiku.

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__ metóda porovnáva názov a Vek atribúty týchto dvoch osoby objekty na určenie rovnosti.

Dvojnásobok sa rovná (==Operátor ) používa túto metódu skôr na kontrolu rovnosti než na porovnávanie identít. Takže dve Osoba inštancie sú rovnaké, ak majú zhodné atribúty mena a veku. To vám umožňuje prepísať predvolené správanie pri kontrole rovnosti pre vašu vlastnú triedu.

Implementáciou týchto magických metód môžete definovať vlastné správanie, ktoré bude konzistentné so vstavanými modulmi Pythonu.

Pokročilé magické metódy

Tu je niekoľko pokročilých príkladov použitia magických metód na prispôsobenie tried.

Aby triedy fungovali ako kontajnery

Pomocou magických metód môžete definovať triedy, ktoré sa správajú ako kontajnery. Môžeš použiť nádoby, ako sú n-ticena ukladanie kolekcií dátových prvkov. Poskytujú rôzne metódy na manipuláciu, prístup a opakovanie obsiahnutých prvkov.

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

Teraz sa objekt Osoba môže správať ako kontajner:

Prispôsobenie prístupu k atribútom

Pomocou __getattr__ magic metóda môžete prispôsobiť spôsob, akým atribúty Osoba triedy sú prístupné na základe určitých podmienok.

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

The __getattr__ metóda sa spustí, keď sa pokúsite získať prístup k atribútu, ktorý neexistuje priamo v objekte. V tomto prípade skontroluje, či je názov atribútu Vek a vráti sa 40.

Pre akýkoľvek iný názov atribútu vyvoláva an AttributeError so zodpovedajúcou správou.

Aby sa triedy správali ako volateľné

The __zavolať__ metóda vám umožňuje zaobchádzať s inštanciou triedy ako s volateľným objektom (t. j. funkciou).

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

Keď vytvoríte inštanciu Adder a potom to nazvite argumentmi, __volať__ metóda sa spustí a vykoná sčítanie pred vrátením výsledku.

Preťaženie operátora

Pomocou magických metód môžete vykonať preťaženie operátora. Preťaženie operátorov vám umožňuje definovať vlastné správanie pre vstavané operátory pri použití s ​​inštanciami vašich vlastných tried. Tu je bežný príklad, ktorý vysvetľuje preťaženie operátora.

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)

Výsledkom je nový vektor:

The Vektor trieda definuje __pridať__ metóda, ktorá sa spustí pri použití + operátor medzi dvoma inštanciami triedy. Metóda pridá zodpovedajúce komponenty dvoch vektorov a vráti nový Vektor príklad s výsledkom.

Tu ste videli základné magické metódy, ktoré môžete použiť na prispôsobenie svojho správania v triede. Python má oveľa viac magických metód, ktoré ponúkajú väčšiu flexibilitu pri vytváraní tried. Pozrite si oficiálna dokumentácia pre úplný zoznam.

Objektovo orientované programovanie v Pythone

Magické metódy v Pythone poskytujú účinné spôsoby na prispôsobenie a zlepšenie správania tried. Magické metódy idú spolu s konceptom objektovo orientovaného programovania (OOP) v Pythone. Preto je dôležité pochopiť koncept OOP, keď sa pokúšate použiť magické metódy.