Lidsky řečeno
Každý spotřebič s běžnou vidlicí funguje v každé zásuvce. Zásuvce je jedno, jestli do ní strčíš lampu, nebo vysavač, a výrobce zásuvky o tvém vysavači nikdy neslyšel. Speciální metody jsou taková vidlice. Když je tvoje třída má, zapojí se do +, len, print nebo cyklu for, i když je jejich autoři nikdy neviděli.
Tvůj objekt zatím neumí nic
Píšeš přehrávač hudby a délku skladby chceš držet v samostatné třídě. Vypadá to rozumně, dokud ji nezačneš používat.
class Stopaz:
def __init__(self, sekundy):
self.sekundy = sekundy
a = Stopaz(200)
b = Stopaz(200)
print(a == b)
print(a is b)
False False
Dvě stejně dlouhé skladby si podle Pythonu nejsou rovny. Python neví, co u tvé třídy znamená „stejný“, a tak se ptá jen na to, jestli jde o tentýž objekt. Sčítání dopadne ještě hůř.
class Stopaz:
def __init__(self, sekundy):
self.sekundy = sekundy
print(Stopaz(200) + Stopaz(40))
A výpis je k ničemu. Spusť to a uvidíš něco jako <__main__.Stopaz object at 0x7f...>, tedy jméno třídy a adresu v paměti.
class Stopaz:
def __init__(self, sekundy):
self.sekundy = sekundy
print(Stopaz(200))
Co se skrývá za operátory
Znaménko + není v Pythonu kouzlo vyhrazené číslům. Je to zkratka za volání metody se zvláštním jménem. Stejně tak len, in a spousta dalších věcí.
print(2 + 3)
print((2).__add__(3))
print(len("ahoj"))
print("ahoj".__len__())
print("a" in "ahoj")
print("ahoj".__contains__("a"))
5 5 4 4 True True
Těmto metodám se říká speciální metody. Programátoři je přezdívají dunder z anglického double underscore, dvojité podtržítko. Jednu už znáš: __init__. Souhrn pravidel, která říkají, jaká syntaxe volá jakou metodu, se jmenuje datový model.
| Napíšeš | Python zavolá | K čemu to je |
|---|---|---|
repr(a) | a.__repr__() | popis pro programátora |
str(a), print(a) | a.__str__() | text pro člověka |
a == b | a.__eq__(b) | rovnost |
a < b | a.__lt__(b) | řazení |
hash(a) | a.__hash__() | použití v množině a jako klíč slovníku |
a + b | a.__add__(b) | sčítání |
len(a) | a.__len__() | počet prvků |
a[i] | a.__getitem__(i) | přístup na index nebo klíč |
x in a | a.__contains__(x) | test členství |
for x in a | a.__iter__() | procházení |
bool(a), if a: | a.__bool__() | pravdivost |
a(x) | a.__call__(x) | volání objektu jako funkce |
Ty tyhle metody píšeš, ale skoro nikdy je přímo nevoláš. Napíšeš len(x), ne x.__len__(). Vlastní jména s dvojitými podtržítky nevymýšlej, ta si Python rezervuje pro sebe.
Co ve skutečnosti spustí výraz a + b, když je a instance tvé třídy?
Operátor je jen hezčí zápis volání metody. Proto ho může podporovat i tvoje třída.
Jak se objekt představí
Objekt má dvě textové podoby. __repr__ je pro programátora: má být přesná a ideálně vypadat jako kód, kterým objekt znovu vytvoříš. __str__ je pro člověka, který výsledek čte.
Funkce divmod v ukázce vrátí najednou podíl a zbytek po dělení.
class Stopaz:
def __init__(self, sekundy):
self.sekundy = sekundy
def __repr__(self):
return f"Stopaz({self.sekundy})"
def __str__(self):
minuty, zbytek = divmod(self.sekundy, 60)
return f"{minuty}:{zbytek:02d}"
s = Stopaz(215)
print(s)
print(repr(s))
print(f"Délka: {s}")
print(f"Ladění: {s!r}")
print([s, Stopaz(61)])
3:35 Stopaz(215) Délka: 3:35 Ladění: Stopaz(215) [Stopaz(215), Stopaz(61)]
Všimni si posledního řádku. Seznam své prvky vypisuje přes repr, ne přes str. Díky tomu v něm rozeznáš číslo 1 od textu '1'.
Porovnávání a řazení
__eq__ určí, co znamená „stejný“. __lt__ (less than, menší než) určí pořadí. Stačí to, aby začaly fungovat sorted, min a max.
class Stopaz:
def __init__(self, sekundy):
self.sekundy = sekundy
def __repr__(self):
return f"Stopaz({self.sekundy})"
def __eq__(self, other):
if not isinstance(other, Stopaz):
return NotImplemented
return self.sekundy == other.sekundy
def __lt__(self, other):
if not isinstance(other, Stopaz):
return NotImplemented
return self.sekundy < other.sekundy
skladby = [Stopaz(240), Stopaz(95), Stopaz(180)]
print(Stopaz(95) == Stopaz(95))
print(Stopaz(95) != Stopaz(96))
print(Stopaz(95) == 95)
print(Stopaz(96) > Stopaz(95))
print(sorted(skladby))
print(max(skladby))
True True False True [Stopaz(95), Stopaz(180), Stopaz(240)] Stopaz(240)
Fungovalo i != a >, přestože jsme je nenapsali. != si Python odvodí z __eq__. U a > b zkusí obrácenou otázku b < a.
Zvláštní hodnota NotImplemented znamená: „s tímhle typem si nevím rady, zeptej se druhé strany.“ Je to něco jiného než výjimka NotImplementedError. Díky ní je Stopaz(95) == 95 obyčejné False a neskončí to pádem na chybějícím atributu other.sekundy.
Když chceš i <= a >=, nemusíš je psát ručně. Dekorátor functools.total_ordering je dopočítá z __eq__ a jedné metody pořadí.
from functools import total_ordering
@total_ordering
class Stopaz:
def __init__(self, sekundy):
self.sekundy = sekundy
def __eq__(self, other):
if not isinstance(other, Stopaz):
return NotImplemented
return self.sekundy == other.sekundy
def __lt__(self, other):
if not isinstance(other, Stopaz):
return NotImplemented
return self.sekundy < other.sekundy
print(Stopaz(60) <= Stopaz(60))
print(Stopaz(90) >= Stopaz(120))
True False
Oprava je krátká. Hash je číslo odvozené z hodnoty, podle kterého množina a slovník objekt rychle najdou. Počítej ho ze stejných údajů, které porovnává __eq__.
class Stopaz:
def __init__(self, sekundy):
self.sekundy = sekundy
def __repr__(self):
return f"Stopaz({self.sekundy})"
def __eq__(self, other):
if not isinstance(other, Stopaz):
return NotImplemented
return self.sekundy == other.sekundy
def __hash__(self):
return hash(self.sekundy)
print({Stopaz(95), Stopaz(95)})
print(len({Stopaz(95), Stopaz(96)}))
{Stopaz(95)}
2Platí to za jedné podmínky: údaje, ze kterých se hash počítá, se nesmí změnit, dokud objekt leží v množině nebo slovníku. Jinak ho tam Python už nenajde.
Čísla verzí
Verze programu se porovnávají po číslech: 1.10.0 je novější než 1.9.3. Obyčejné porovnání textů to poplete, protože znak 1 je před znakem 9.
Doplň třídu Verze. Konstruktor dostane text jako "1.10.0". Metoda __str__ vrátí původní text, __eq__ a __lt__ porovnávají verze číselně a __hash__ umožní použití v množině. Porovnání s jiným typem vrátí NotImplemented.
class Verze:
def __init__(self, text):
self.text = text
# doplň: rozděl text na čísla
# doplň speciální metody
Počítání
Metoda __add__ má vrátit nový objekt a oba původní nechat být. Tak to dělají čísla a každý to tak čeká. U násobení je jeden háček: s * 3 zavolá metodu stopáže, ale 3 * s by se ptalo čísla 3. To tvou třídu nezná, vrátí NotImplemented a Python pak zkusí obrácenou metodu __rmul__ na pravém operandu.
class Stopaz:
def __init__(self, sekundy):
self.sekundy = sekundy
def __repr__(self):
return f"Stopaz({self.sekundy})"
def __add__(self, other):
if not isinstance(other, Stopaz):
return NotImplemented
return Stopaz(self.sekundy + other.sekundy)
def __mul__(self, kolikrat):
if not isinstance(kolikrat, int):
return NotImplemented
return Stopaz(self.sekundy * kolikrat)
__rmul__ = __mul__
a = Stopaz(200)
print(a + Stopaz(40))
print(a * 3)
print(3 * a)
print(a)
Stopaz(240) Stopaz(600) Stopaz(600) Stopaz(200)
Celý playlist bys rád sečetl funkcí sum. Ta ale začíná od nuly, takže první krok je 0 + Stopaz(...), a to neprojde.
class Stopaz:
def __init__(self, sekundy):
self.sekundy = sekundy
def __add__(self, other):
if not isinstance(other, Stopaz):
return NotImplemented
return Stopaz(self.sekundy + other.sekundy)
print(sum([Stopaz(200), Stopaz(40)]))
Pomůže __radd__, která nulu na začátku přijme.
class Stopaz:
def __init__(self, sekundy):
self.sekundy = sekundy
def __repr__(self):
return f"Stopaz({self.sekundy})"
def __add__(self, other):
if not isinstance(other, Stopaz):
return NotImplemented
return Stopaz(self.sekundy + other.sekundy)
def __radd__(self, other):
if other == 0:
return self
return NotImplemented
print(sum([Stopaz(200), Stopaz(40), Stopaz(15)]))
print(sum([], Stopaz(0)))
Stopaz(255) Stopaz(0)
Druhý řádek ukazuje jiné řešení: sum dostane počáteční hodnotu. Hodí se i pro prázdný seznam, kde by sum jinak vrátil obyčejnou nulu.
Peníze
Napiš třídu Penize, která drží celé koruny v atributu kc.
reprvrátí napříkladPenize(100),strvrátí100 Kč.- Dvě částky se rovnají, když mají stejné
kc. Porovnání s číslem dáFalse. Penize + Penizevrátí nový objektPenize. Přičtení obyčejného čísla skončíTypeError.- Funguje
sumpřes seznam částek.
class Penize:
def __init__(self, kc):
self.kc = kc
# doplň speciální metody
Vlastní kontejner
Playlist je v podstatě seznam s názvem. Dědit z list by znamenalo převzít i sort, clear a desítky metod, které nechceš. Lepší je seznam schovat dovnitř a navenek nabídnout jen to, co dává smysl. Několik krátkých metod předá práci vnitřnímu seznamu.
class Playlist:
def __init__(self, nazev, skladby=()):
self.nazev = nazev
self._skladby = list(skladby)
def __repr__(self):
return f"Playlist({self.nazev!r}, {self._skladby!r})"
def __len__(self):
return len(self._skladby)
def __getitem__(self, index):
return self._skladby[index]
def __contains__(self, skladba):
return skladba in self._skladby
def __iter__(self):
return iter(self._skladby)
ranni = Playlist("Ráno", ["Budík", "Káva", "Tramvaj"])
print(ranni)
print(len(ranni))
print(ranni[0], ranni[-1])
print(ranni[:2])
print("Káva" in ranni)
print(sorted(ranni))
for skladba in ranni:
print("hraje:", skladba)
Playlist('Ráno', ['Budík', 'Káva', 'Tramvaj'])
3
Budík Tramvaj
['Budík', 'Káva']
True
['Budík', 'Káva', 'Tramvaj']
hraje: Budík
hraje: Káva
hraje: TramvajIndex -1 i řez [:2] fungují zadarmo, protože __getitem__ je jen předá seznamu. Jak přesně funguje iter, rozebírá lekce Iterátorový protokol.
Prázdný seznam je v podmínce nepravdivý. Tvůj objekt se chová stejně, jakmile má __len__: Python se na jeho pravdivost zeptá přes délku. Vlastní __bool__ by měl přednost.
class Playlist:
def __init__(self, skladby=()):
self._skladby = list(skladby)
def __len__(self):
return len(self._skladby)
if not Playlist():
print("Není co hrát.")
if Playlist(["Káva"]):
print("Hrajeme.")
Není co hrát. Hrajeme.
Metoda __call__ udělá z objektu něco, co jde zavolat jako funkci. Hodí se, když funkce potřebuje nosit nastavení.
class Sleva:
def __init__(self, procenta):
self.procenta = procenta
def __call__(self, cena):
return cena * (100 - self.procenta) / 100
zimni = Sleva(20)
print(zimni(250))
print(list(map(zimni, [100, 990])))
200.0 [80.0, 792.0]
Čekárna
Napiš třídu Cekarna. Vnitřně drží seznam jmen, nový objekt je prázdný. Metoda prijde(jmeno) přidá člověka na konec. Potom musí fungovat len(c), c[0], "Eva" in c a for jmeno in c. Prázdná čekárna je v podmínce nepravdivá.
class Cekarna:
def __init__(self):
self._lide = []
def prijde(self, jmeno):
pass # doplň
# doplň speciální metody
Třída má __len__, ale nemá __bool__. Co udělá if objekt:, když len(objekt) je 0?
Python nejdřív hledá __bool__, potom __len__. Teprve když chybí obě, je objekt pravdivý.
Proč metoda __eq__ vrací u cizího typu NotImplemented, a ne rovnou False?
False je konečný verdikt. NotImplemented znamená „nevím“ a Python zkusí druhou stranu. Když neví ani ta, == porovná identitu.
Pod kapotou · metody se hledají na typu, ne na instanci
Implicitní volání speciální metody obchází instanci i __getattribute__. CPython sáhne přímo do slotů typu (tp_as_sequence->sq_length a podobně). Je to rychlejší a řeší to i metatřídní past: repr(int) musí zavolat type(int).__repr__, ne int.__repr__, což je metoda pro čísla.
class Krabice:
pass
k = Krabice()
k.__len__ = lambda: 3
print(k.__len__())
try:
len(k)
except TypeError as e:
print(e)
Krabice.__len__ = lambda self: 5
print(len(k))
print(k.__len__())
3 object of type 'Krabice' has no len() 5 3
Proto nefungují proxy objekty postavené jen na __getattr__: len(proxy) se na __getattr__ vůbec nezeptá a každou speciální metodu musíš definovat explicitně. Při přiřazení do třídy CPython sloty aktualizuje, takže monkeypatch na úrovni typu funguje. Viz Special method lookup.
Pod kapotou · pořadí u binárních operátorů a past s +=
a + b se vyhodnocuje takto:
1. Je type(b) podtřída type(a) a má jinou implementaci __radd__?
Pak se zkusí nejdřív b.__radd__(a).
2. a.__add__(b)
3. b.__radd__(a), pokud jsou typy různé
4. Všude NotImplemented: TypeErrorBod 1 dovolí podtřídě přebít chování rodiče, ať stojí na kterékoli straně. U porovnávání platí podobné pravidlo, jen se tam nevyžaduje jiná implementace. Když == skončí na obou stranách s NotImplemented, Python porovná identitu. U < vyhodí TypeError.
a += b nejdřív hledá __iadd__, a pak vždy přiřadí výsledek zpět do a. To vede ke klasice s n-ticí: seznam se změní a přiřazení do n-tice potom selže.
t = ([1], 2)
try:
t[0] += [99]
except TypeError as e:
print(e)
print(t)
'tuple' object does not support item assignment ([1, 99], 2)
Vlastní __iadd__ musí vrátit self. Když zapomeneš, proměnná skončí s hodnotou None.
Pod kapotou · protokoly, které fungují i bez metody
Datový model má záložní cesty a ty občas překvapí:
- Třída jen s
__getitem__jde iterovat. Python volá indexy0, 1, 2…, dokud nepřijdeIndexError. Stejnou cestou fungujein, lineárně.isinstance(x, collections.abc.Iterable)ale vrátíFalse, takže spolehlivý test jeiter(x)vtry. - Bez
__contains__projdeincelý__iter__. Hodnota__contains__ = Nonečlenství zakáže. Stejně funguje__iter__ = Nonea__hash__ = None. object.__format__s neprázdnou specifikací vyhodíTypeError.f"{s:>8}"tedy selže, i když máš__str__. Oprava jef"{s!s:>8}"nebo vlastní__format__.
class Mocniny:
def __getitem__(self, i):
if i >= 4:
raise IndexError
return 2 ** i
from collections.abc import Iterable
m = Mocniny()
print(list(m))
print(8 in m, 9 in m)
print(isinstance(m, Iterable))
print(iter(m) is not None)
[1, 2, 4, 8] True False False True
total_ordering je pohodlný, ale dopočítané operátory jsou pomalejší a mají delší zásobník, jak uvádí i dokumentace. U třídy, která se řadí v horké smyčce, je lepší key= v sorted nebo ruční metody. Další protokoly přijdou později: Context managery a Deskriptory a metatřídy.