0 dní v řadě · 0 bodů

Objekty · 25 min

Speciální metody a datový model

Naučíš vlastní objekty sčítat, porovnávat, vypisovat a procházet cyklem stejně přirozeně jako čísla a seznamy.

Hloubka
Úkoly
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)
Výstup
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))
Výstup

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))
Výstup

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"))
Výstup
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 == ba.__eq__(b)rovnost
a < ba.__lt__(b)řazení
hash(a)a.__hash__()použití v množině a jako klíč slovníku
a + ba.__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 aa.__contains__(x)test členství
for x in aa.__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.

Kvíz

Co ve skutečnosti spustí výraz a + b, když je a instance tvé třídy?

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)])
Výstup
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))
Výstup
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))
Výstup
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)}))
Výstup
{Stopaz(95)}
2

Platí 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.

Úkol

Čí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
Výstup

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)
Výstup
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)]))
Výstup

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)))
Výstup
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.

Úkol

Peníze

Napiš třídu Penize, která drží celé koruny v atributu kc.

  • repr vrátí například Penize(100), str vrátí 100 Kč.
  • Dvě částky se rovnají, když mají stejné kc. Porovnání s číslem dá False.
  • Penize + Penize vrátí nový objekt Penize. Přičtení obyčejného čísla skončí TypeError.
  • Funguje sum přes seznam částek.
class Penize:
    def __init__(self, kc):
        self.kc = kc

    # doplň speciální metody
Výstup

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)
Výstup
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: Tramvaj

Index -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.")
Výstup
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])))
Výstup
200.0
[80.0, 792.0]
Úkol

Č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
Výstup
Kvíz

Třída má __len__, ale nemá __bool__. Co udělá if objekt:, když len(objekt) je 0?

Kvíz

Proč metoda __eq__ vrací u cizího typu NotImplemented, a ne rovnou False?

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__())
Výstup
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:

text
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: TypeError

Bod 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)
Výstup
'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á indexy 0, 1, 2…, dokud nepřijde IndexError. Stejnou cestou funguje in, lineárně. isinstance(x, collections.abc.Iterable) ale vrátí False, takže spolehlivý test je iter(x) v try.
  • Bez __contains__ projde in celý __iter__. Hodnota __contains__ = None členství zakáže. Stejně funguje __iter__ = None a __hash__ = None.
  • object.__format__ s neprázdnou specifikací vyhodí TypeError. f"{s:>8}" tedy selže, i když máš __str__. Oprava je f"{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)
Výstup
[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.