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.")
{'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
orazitkujpatří 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)
Jana 3 Petr Karta True False
Co se tu stalo:
Karta()se závorkami vyrobí nový objekt. Protože vznikl podle třídyKarta, říkáme mu instance třídyKarta.jana.jmenoje atribut: proměnná, která je připnutá ke konkrétnímu objektu. Čteš ji přes tečku.janaapetrjsou 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)
Jana 0 Petr 4
Při zápisu Karta("Jana") proběhne tohle:
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é janaself 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)
3 Odmítnuto: Razítek může být 0 až 10.
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
Kolik argumentů dostane __init__(self, jmeno) při zápisu Karta("Jana")?
Objekt do self doplní Python sám. Ty předáváš jen zbytek.
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())
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)
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.
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ň
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)
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):
<__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))
Jana 3 Ota 6 Petr 9 18
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ň
Co vypíše tenhle kód? a = Karta("Eva"), potom b = a, potom b.jmeno = "Iva" a nakonec print(a.jmeno).
Přiřazení nic nekopíruje. Změna přes jedno jméno je vidět i přes druhé.
Co udělá podmínka if karta.ma_kavu_zdarma: bez závorek?
Bez závorek jen sáhneš na objekt metody. Takový objekt je v podmínce pravdivý.
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__)
{'x': 1}
False True
True True
ahoj
AttributeErrorKaž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áří.