0 dní v řadě · 0 bodů

Objekty · 22 min

Třídy a instance

Z rozsypaných slovníků a funkcí složíš vlastní datový typ. Naučíš se class, __init__, self a co se děje, když vznikne objekt.

Hloubka
Úkoly
Lidsky řečeno

Kavárna má jednu předlohu věrnostní karty: políčko na jméno, deset koleček na razítka a pravidlo, že za plnou kartu je káva zdarma. Předloha sama žádné razítko nedostane. Razítka sbírají vytištěné karty a každý zákazník má svou. Předloha je třída, vytištěná karta je instance.

Když se data a funkce rozejdou

Věrnostní kartu už umíš uložit do slovníku a napsat k ní funkci. Dokud je kód krátký, funguje to dobře.

def orazitkuj(karta):
    karta["razitka"] += 1

jana = {"jmeno": "Jana", "razitka": 0}
petr = {"jmeno": "Petr"}  # someone forgot the stamps

orazitkuj(jana)
print(jana)

orazitkuj(petr)
print("Sem se program nedostane.")
Výstup
{'jmeno': 'Jana', 'razitka': 1}

Chyba vznikla na řádku s Petrem, ale spadlo to až uvnitř orazitkuj. Ve velkém programu mezi těmi dvěma místy může být deset souborů. Problémy jsou tři:

  • Nikde není napsáno, co přesně musí karta obsahovat.
  • Kartu si může kdokoli vyrobit po svém a špatně.
  • Že funkce orazitkuj patří ke kartám, víš jen ty. Python o tom neví.

Třída tohle řeší jedním tahem. Popíše, jak věc vypadá, co umí, a drží to na jednom místě.

První třída

Třída se založí slovem class. Její jméno se podle zvyklosti píše s velkým počátečním písmenem a bez podtržítek, třeba Karta nebo VernostniKarta. Slovo pass znamená „zatím nic“.

class Karta:
    pass

jana = Karta()
petr = Karta()

jana.jmeno = "Jana"
jana.razitka = 3
petr.jmeno = "Petr"

print(jana.jmeno, jana.razitka)
print(petr.jmeno)
print(type(jana).__name__)
print(isinstance(jana, Karta))
print(jana is petr)
Výstup
Jana 3
Petr
Karta
True
False

Co se tu stalo:

  • Karta() se závorkami vyrobí nový objekt. Protože vznikl podle třídy Karta, říkáme mu instance třídy Karta.
  • jana.jmeno je atribut: proměnná, která je připnutá ke konkrétnímu objektu. Čteš ji přes tečku.
  • jana a petr jsou dva různé objekty a každý má své atributy.

Petr ale pořád nemá razítka. Zatím jsme si moc nepomohli. Potřebujeme, aby každá karta byla kompletní hned od první chvíle.

__init__: karta je hotová hned

Když ve třídě definuješ funkci se jménem __init__ (dvě podtržítka z každé strany), Python ji zavolá pokaždé, když vzniká nová instance.

class Karta:
    def __init__(self, jmeno):
        self.jmeno = jmeno
        self.razitka = 0

jana = Karta("Jana")
petr = Karta("Petr")
petr.razitka = 4

print(jana.jmeno, jana.razitka)
print(petr.jmeno, petr.razitka)
Výstup
Jana 0
Petr 4

Při zápisu Karta("Jana") proběhne tohle:

text
Karta("Jana")
  1. Python vyrobí prázdný objekt
  2. zavolá __init__(ten_objekt, "Jana")
  3. __init__ objekt naplní: self.jmeno, self.razitka
  4. celý výraz má hodnotu hotového objektu, ten jde do proměnné jana

self je ten právě vznikající objekt. Zápis self.jmeno = jmeno znamená: „do atributu jmeno tohohle objektu ulož hodnotu parametru jmeno“. Stejné jméno na obou stranách je běžné a nic se nepere, vlevo je atribut, vpravo obyčejná lokální proměnná.

__init__ je taky ideální místo na kontrolu vstupu. Když se špatná karta vůbec nevyrobí, nemusí se s ní nikdo potýkat později.

class Karta:
    def __init__(self, jmeno, razitka=0):
        if not jmeno:
            raise ValueError("Karta musí mít jméno.")
        if not 0 <= razitka <= 10:
            raise ValueError("Razítek může být 0 až 10.")
        self.jmeno = jmeno
        self.razitka = razitka

print(Karta("Jana", 3).razitka)

try:
    Karta("Petr", 25)
except ValueError as chyba:
    print("Odmítnuto:", chyba)
Výstup
3
Odmítnuto: Razítek může být 0 až 10.
Úkol

Rezervace stolu

Napiš třídu Rezervace. Při vytvoření dostane jmeno a pocet_osob a uloží je do stejně pojmenovaných atributů. Atribut potvrzena bude na začátku False. Když je pocet_osob menší než 1, vyvolej ValueError.

class Rezervace:
    def __init__(self, jmeno, pocet_osob):
        # doplň
        pass
Výstup
Kvíz

Kolik argumentů dostane __init__(self, jmeno) při zápisu Karta("Jana")?

Metody: co karta umí

Funkce definovaná uvnitř třídy se jmenuje metoda. Pravidla karty teď můžou bydlet přímo u jejích dat.

class Karta:
    def __init__(self, jmeno):
        self.jmeno = jmeno
        self.razitka = 0

    def orazitkuj(self):
        if self.razitka < 10:
            self.razitka += 1

    def ma_kavu_zdarma(self):
        return self.razitka == 10

    def uplatni_kavu(self):
        if not self.ma_kavu_zdarma():
            return False
        self.razitka = 0
        return True

jana = Karta("Jana")
for _ in range(12):
    jana.orazitkuj()

print(jana.razitka)
print(jana.ma_kavu_zdarma())
print(jana.uplatni_kavu())
print(jana.razitka)
print(jana.uplatni_kavu())
Výstup
10
True
True
0
False

Dvanáct razítek se nevešlo, karta jich přijala deset. Pravidlo je na jediném místě a nikdo, kdo volá orazitkuj, ho nemusí znát. Všimni si i self.ma_kavu_zdarma(): metoda volá jinou metodu téhož objektu.

Záhadné self není kouzlo. objekt.metoda() je jen pohodlnější zápis pro Trida.metoda(objekt).

class Lampa:
    def __init__(self):
        self.sviti = False

    def prepni(self):
        self.sviti = not self.sviti

kuchyn = Lampa()
loznice = Lampa()

kuchyn.prepni()          # the usual way
Lampa.prepni(loznice)    # what Python does for you

print(kuchyn.sviti, loznice.sviti)
Výstup
True True

Metoda je v paměti jen jedna a sdílejí ji všechny lampy. Podle self pozná, se kterou zrovna pracuje. Slovo self není klíčové, ale je to tak silná dohoda, že jiné jméno nepoužívej.

Úkol

Kasička

Doplň metody třídy Kasicka. vloz(castka) přičte částku k zustatek. vyber(castka) částku odečte a vrátí True. Když v kasičce tolik není, zůstatek nechá být a vrátí False.

class Kasicka:
    def __init__(self):
        self.zustatek = 0

    def vloz(self, castka):
        pass  # doplň

    def vyber(self, castka):
        pass  # doplň
Výstup

Objekt je samostatná věc

Přiřazení objekt nekopíruje, jen na něj přidá další jméno. Platí tu totéž, co u seznamů v lekci Reference, mutabilita a kopie. Funkce, která objekt dostane, ho proto může změnit.

class Karta:
    def __init__(self, jmeno):
        self.jmeno = jmeno
        self.razitka = 0

def pridej_bonus(karta):
    karta.razitka += 2

jana = Karta("Jana")
stejna = jana
stejna.razitka = 5
pridej_bonus(jana)
print(jana.razitka)

dvojnice = Karta("Jana")
dvojnice.razitka = 7
print(jana is stejna)
print(jana is dvojnice)
print(jana == dvojnice)
Výstup
7
True
False
False

jana a dvojnice mají stejná data, a přesto nejsou ==. Python zatím neví, co u karet znamená „stejné“, takže porovnává, jestli jde o tentýž objekt. Podobně nic moc neřekne ani print(jana):

text
<__main__.Karta object at 0x000001F3A2B4C7D0>

Číslo na konci je pokaždé jiné. Vlastní porovnání a čitelný výpis doplníš v lekci Speciální metody a datový model.

Objekty se chovají jako každá jiná hodnota. Můžeš je dát do seznamu, řadit je a předávat funkcím.

class Karta:
    def __init__(self, jmeno, razitka):
        self.jmeno = jmeno
        self.razitka = razitka

karty = [Karta("Jana", 3), Karta("Petr", 9), Karta("Ota", 6)]

for karta in sorted(karty, key=lambda k: k.razitka):
    print(karta.jmeno, karta.razitka)

print(sum(k.razitka for k in karty))
Výstup
Jana 3
Ota 6
Petr 9
18
Úkol

Nejvěrnější zákazník

Napiš funkci nejvernejsi(karty), která dostane seznam objektů Karta a vrátí jméno toho, kdo má nejvíc razítek.

class Karta:
    def __init__(self, jmeno, razitka):
        self.jmeno = jmeno
        self.razitka = razitka

def nejvernejsi(karty):
    pass  # doplň
Výstup
Kvíz

Co vypíše tenhle kód? a = Karta("Eva"), potom b = a, potom b.jmeno = "Iva" a nakonec print(a.jmeno).

Kvíz

Co udělá podmínka if karta.ma_kavu_zdarma: bez závorek?

Pod kapotou · co přesně vzniká při class a při volání třídy

class je spustitelný příkaz. Python provede tělo třídy, ze vzniklého jmenného prostoru a seznamu předků zavolá metatřídu, standardně type(name, bases, namespace), a výsledek přiřadí ke jménu. Třída je tedy obyčejný objekt typu type.

Karta("Jana") spustí type.__call__. Ten zavolá Karta.__new__(Karta, "Jana") a pokud výsledek je instance Karta, zavolá nad ním __init__. Objekt v té chvíli už existuje, takže __init__ je přesně řečeno inicializátor, ne konstruktor. Musí vracet None, jinak dostaneš TypeError. __new__ potřebuješ jen výjimečně, například u potomků neměnných typů jako int nebo tuple.

Atributy instance logicky žijí v __dict__. Díky key-sharing slovníkům (PEP 412) sdílejí instance jedné třídy tabulku klíčů a od verze 3.11 CPython skutečný __dict__ vytváří až ve chvíli, kdy si o něj řekneš. Výhodu si udržíš tak, že všechny atributy nastavíš v __init__, vždy ve stejném pořadí. Atributy přilepované později tuhle optimalizaci mohou rozbít a hůř se v nich orientují lidé i typové kontroly.

__slots__ pevně určí povolené atributy: ušetří paměť a překlep skončí chybou. Cena: bez __dict__ nejde přidávat nic dalšího, pro slabé reference musíš přidat slot __weakref__ a dva předci s neprázdnými sloty se v jedné třídě nesnesou.

class Bod:
    def __init__(self, x):
        self.x = x

    def ukaz(self):
        return self.x

class UzkyBod:
    __slots__ = ("x",)

    def __init__(self, x):
        self.x = x

b = Bod(1)
print(vars(b))
print(b.ukaz is b.ukaz, b.ukaz == b.ukaz)
print(b.ukaz.__self__ is b, b.ukaz.__func__ is Bod.ukaz)

Rucne = type("Rucne", (), {"pozdrav": lambda self: "ahoj"})
print(Rucne().pozdrav())

u = UzkyBod(1)
try:
    u.y = 2
except AttributeError as e:
    print(type(e).__name__)
Výstup
{'x': 1}
False True
True True
ahoj
AttributeError

Každé čtení b.ukaz vyrobí nový objekt vázané metody, proto is vrací False. Z toho plynou dvě produkční chyby. Vázaná metoda v WeakSet okamžitě zmizí, protože na ni nic silně neukazuje, a řešením je weakref.WeakMethod. A functools.lru_cache na metodě drží v klíčích self, takže instance žijí, dokud je cache nevytlačí. Přímé volání b.ukaz() je v CPythonu optimalizované a vázaný objekt zbytečně nevytváří.