Jak přizpůsobit chování třídy v Pythonu pomocí magických metod

V Pythonu třídy poskytují čisté prostředky pro spojení dat a funkcí do znovu použitelných prvků. Vytváření vlastních tříd vám umožňuje modelovat entity reálného světa, jako jsou uživatelé, produkty a zaměstnanci.

Třídy Pythonu definují magické metody, které si můžete přizpůsobit, aby vám umožnily utvářet chování vašich tříd pro jedinečné situace.

Pochopení magických metod

Představte si magické metody, nazývané také dunderovy metody, jako tajná kouzla nebo skryté zpěvy, které Python automaticky volá, když s objektem provádíte určité akce.

Python poskytuje třídám mnoho vestavěného chování metody instance, statické a třídy. Můžeš vytvářet třídy Pythona ještě více je upravte pomocí magických metod.

Magické metody jsou instanční metody v Pythonu, které mají dvě podtržítka (__metoda__) před a za názvem metody.

Tyto speciální metody dávají Pythonu pokyny, jak zacházet s objekty třídy. Zde jsou některé běžně používané magické metody ve třídách Pythonu:

• __gt__: Tato metoda kontroluje, zda je jeden objekt větší než jiný.
• __init__: Tato metoda se spustí, když vytvoříte instanci třídy, a slouží hlavně k inicializaci atributů.
• __str__: Vrátí řetězcovou reprezentaci třídy popisující objekt.
• __repr__: Tato metoda poskytuje výstup, který vám umožňuje znovu vytvořit objekt pomocí eval().
• __len__: Když použijete délka() funkce na objektu tato metoda vrací délku objektu.
• __eq__: Tato metoda umožňuje porovnání mezi objekty pomocí dvojitého rovno (==) operátor.
• __lt__: Implementuje méně než (
• __přidat__: Když použijete doplněk (+) operátor na objektech tato metoda spouští a provádí operace sčítání.
• __getitem__: Umožňuje načíst položky z objektu pomocí syntaxe indexu, např obj[klíč].

Implementace magických metod

Nejlepší způsob, jak porozumět magickým metodám, je používat je.

Řetězcová reprezentace objektu

Řetězcovou reprezentaci objektu můžete upravit pro čitelnost nebo další zpracování.

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

Tady máte jednoduchý Osoba třída s an __init__ magická metoda k jeho inicializaci. Když vytisknete p1 používá výchozí řetězcovou reprezentaci poskytovanou Pythonem.

Chcete-li upravit reprezentaci řetězce, definujte __str__ a __repr__ magické metody:

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)

Nyní máte čitelnější a komplexnější reprezentaci řetězce p1 objekt:

Délka vlastnosti objektu

Představte si to, když zavoláte délka() metoda objektu Osoba, chcete jejich výšku. Implementujte __len__ magická metoda pro Osoba třída:

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á metoda vrací atribut výšky a Osoba instance. Když zavoláte len (p2), bude to volat __len__ magická metoda automaticky, která vrací výšku p2 objekt.

Zpracování porovnávání mezi objekty

Pokud potřebujete porovnat objekty třídy na základě určitých vlastností třídy. Můžete definovat __eq__ magickou metodu a implementujte svou srovnávací 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__ metoda porovnává název a stáří atributy těch dvou Osobní objektů k určení rovnosti.

Dvojnásobek se rovná (==Operátor ) používá tuto metodu ke kontrole rovnosti spíše než k porovnávání identit. Takže dva Osoba instance jsou stejné, pokud mají odpovídající atributy jména a věku. To vám umožní přepsat výchozí chování kontroly rovnosti pro vaši vlastní třídu.

Implementací těchto magických metod můžete definovat vlastní chování, které bude konzistentní s vestavěnými moduly Pythonu.

Pokročilé magické metody

Zde je několik pokročilých příkladů použití magických metod k přizpůsobení tříd.

Aby třídy fungovaly jako kontejnery

Pomocí magických metod můžete definovat třídy, které se chovají jako kontejnery. Můžeš použít nádoby, jako n-ticek ukládání kolekcí datových prvků. Poskytují různé metody pro manipulaci s obsaženými prvky, přístup k nim a jejich iteraci.

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

Nyní se objekt Osoba může chovat jako kontejner:

Přizpůsobení přístupu k atributům

Za použití __getattr__ magickou metodou si můžete přizpůsobit způsob, jakým atributy Osoba třídy jsou přístupné za určitých podmínek.

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 se spustí, když se pokusíte o přístup k atributu, který neexistuje přímo v objektu. V tomto případě zkontroluje, zda je název atributu stáří a vrací se 40.

Pro jakýkoli jiný název atributu vyvolá an AttributeError s odpovídající zprávou.

Aby se třídy chovaly jako volatelné

The __volání__ metoda umožňuje zacházet s instancí třídy jako s volatelným objektem (tj. funkcí).

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

Když vytvoříte instanci Zmije a pak to zavolejte pomocí argumentů, __volání__ metoda se spustí a provede sčítání před vrácením výsledku.

Přetížení operátora

Pomocí magických metod můžete provést přetížení operátora. Přetížení operátorů vám umožňuje definovat vlastní chování pro vestavěné operátory při použití s ​​instancemi vašich vlastních tříd. Zde je běžný příklad, který vysvětluje přetížení 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ýsledkem je nový vektor:

The Vektor třída definuje __přidat__ metoda, která se spustí, když použijete + operátor mezi dvěma instancemi třídy. Metoda přidá odpovídající složky dvou vektorů a vrátí nový Vektor příklad s výsledkem.

Zde jste viděli základní magické metody, které můžete implementovat, abyste si přizpůsobili své chování ve třídě. Python má mnohem více magických metod, které nabízejí větší flexibilitu při vytváření tříd. Odkazovat na oficiální dokumentace pro úplný seznam.

Objektově orientované programování v Pythonu

Magické metody v Pythonu poskytují výkonné způsoby, jak přizpůsobit a zlepšit chování tříd. Magické metody jdou ruku v ruce s konceptem objektově orientovaného programování (OOP) v Pythonu. Při pokusu o použití magických metod je tedy důležité porozumět konceptu OOP.