Třídy a objekty

Cíl hodiny: Chápeš, že třída je předpis a objekt je konkrétní věc, a umí napsat vlastní třídu s metodami.

Koncepty: class, __init__, self, atributy, metody, __str__, více instancí
Projekt: PyQuest má třídy Postava a Prisera

Jak stránku používat: vpravo nahoře je tlačítko Prezentace — schová všechno kromě jednoho bloku a přepíná se šipkami. U ukázek a cvičení je kód vlevo editovatelný: uprav ho a klikni na Spustit (nebo Ctrl+Enter), výsledek se objeví vpravo. Běží to přímo v prohlížeči, bez instalace.

1. Vysvětlení a souvislosti

Blok 1Kam jsme došli a co chybí1. Vysvětlení a souvislosti

1.1 Kam jsme došli a co chybí

Zrekapitulujte cestu:

Nejdřív jsi měl proměnné. Pak seznam, aby jich mohlo být víc. Pak slovník, aby měly jména. Pak funkce, aby se s nimi dalo pracovat.

Ale pořád máš data zvlášť a funkce zvlášť. Musíš si pamatovat, které funkce patří ke kterým datům. To je poslední problém, který vyřešíme.

# Doteď:
hrdina = {"jmeno": "Arkon", "zivoty": 100}
uber_zivoty(hrdina, 20)         # data a funkce zvlášť

# Nově:
hrdina = Postava("Arkon", 100)
hrdina.uber_zivoty(20)          # funkce PATŘÍ k datům

Třída spojí data a to, co se s nimi dá dělat, do jednoho balíčku.

Blok 2Třída je předpis, objekt je výrobek1. Vysvětlení a souvislosti

1.2 Třída je předpis, objekt je výrobek

Toto je nejdůležitější věta hodiny. Pomůže analogie, kterou znáš:

Třída je formička na perník. Objekt je perník. Z jedné formičky uděláš stovky perníků a každý může mít jinou polevu.

Nebo: třída je stavební plán domu. Objekt je konkrétní postavený dům. Plán je jeden, domů podle něj postavíš kolik chceš.

class Postava:      # předpis
    ...

arkon = Postava("Arkon", 100)    # konkrétní objekt
bela = Postava("Bela", 80)       # jiný objekt, stejný předpis

arkon a bela jsou dvě různé postavy. Když ubereš životy jedné, ta druhá o tom neví. Každý objekt má vlastní data.

Blok 3Anatomie třídy1. Vysvětlení a souvislosti

1.3 Anatomie třídy

Část	Co to je
`class Postava:`	začátek předpisu, název velkým písmenem
`__init__`	konstruktor — spustí se při vytvoření objektu
`self`	odkaz na konkrétní objekt, se kterým právě pracuješ
`self.jmeno`	atribut — data, která si objekt nese
`uber_zivoty`	metoda — funkce, která patří k objektu

Blok 4self — nejtěžší část hodiny1. Vysvětlení a souvislosti

1.4 self — nejtěžší část hodiny

Tohle je potřeba pochopit pomalu a klidně i dvakrát.

self znamená „tenhle konkrétní objekt". Když napíšeš arkon.uber_zivoty(20), Python zavolá metodu a jako self jí podá arkon. Kdybys volal bela.uber_zivoty(20), jako self by dostala bela.

Proto v metodě píšeš self.zivoty — říkáš tím „životy TOHOHLE objektu", ne nějaké obecné životy.

Podívej se, co se stane bez self:

def uber_zivoty(self, kolik):
    zivoty = zivoty - kolik      # UnboundLocalError - to je jiná proměnná!

Bez self. vytváříš obyčejnou lokální proměnnou, která po skončení metody zmizí. Objekt se vůbec nezmění.

Pravidlo: v každé metodě je self první parametr. Vždycky. Při volání ho ale nepíšeš — Python ho doplní sám.

Blok 5__init__ — konstruktor1. Vysvětlení a souvislosti

1.5 init — konstruktor

arkon = Postava("Arkon", 100)

Když napíšeš název třídy se závorkami, Python vytvoří nový prázdný objekt a hned na něm spustí __init__. Tam si objekt nastaví, co má mít.

Ty dvě podtržítka z každé strany znamenají „tohle je speciální jméno, které Python zná". Říká se jim dunder metody.

def __init__(self, jmeno, zivoty=100, sila=10):
    ...

Postava("Arkon")              # zivoty 100, sila 10
Postava("Bela", 80)           # zivoty 80, sila 10
Postava("Cedrik", 60, 20)     # všechno vlastní

Výchozí hodnoty fungují stejně jako u obyčejných funkcí:

Blok 6__str__ — jak se objekt vypíše1. Vysvětlení a souvislosti

1.6 str — jak se objekt vypíše

class Postava:
    ...
    def __str__(self):
        return f"{self.jmeno} ({self.zivoty} HP)"

st.write(str(arkon))        # "Arkon (85 HP)"

Bez __str__ by ti Python vypsal něco jako <__main__.Postava object at 0x104a2f10>, což je k ničemu. __str__ mu řekne, jak se má tvůj objekt představit.

Blok 7Atributy třídy versus atributy objektu1. Vysvětlení a souvislosti

1.7 Atributy třídy versus atributy objektu

Co je nahoře v těle třídy, mají všechny objekty stejné. Co je v __init__ se self., má každý objekt vlastní.

Pro začátek stačí, že konstanty (MAX_ZIVOTY) patří nahoru.

Poznámky pro učiteleObjekty ve Streamlitu — praktická poznámka1. Vysvětlení a souvislosti

1.8 Objekty ve Streamlitu — praktická poznámka

Objekt se dá uložit do session_state úplně normálně:

if "hrdina" not in st.session_state:
    st.session_state.hrdina = Postava("Arkon")

h = st.session_state.hrdina
h.uber_zivoty(10)             # změna se uchová, objekt je odkaz

Ale pozor — při každé změně souboru Streamlit modul znovu načte a třída se vytvoří znovu. Starý objekt v session_state pak patří „staré" třídě. Projeví se to divnými chybami po editaci kódu. Řešení: po větší úpravě třídy stiskněte tlačítko „Nová hra" nebo obnovte stránku.

Tohle dětem řekněte předem, ušetříte si zmatek.

Blok 8Kdy použít třídu a kdy stačí slovník1. Vysvětlení a souvislosti

1.9 Kdy použít třídu a kdy stačí slovník

Buďme poctiví:

Použij slovník	Použij třídu
Jen data, žádné chování	Data i chování patří k sobě
Data jdou rovnou do JSON	Objekt má svá pravidla a kontroly
Jednorázová struktura	Vytváříš víc podobných věcí

Třída není vždycky lepší. Ale jakmile ke stejným datům píšeš tři funkce, které je mění, je čas na třídu.

Poznámky pro učiteleTechnické pozadí pro učitele1. Vysvětlení a souvislosti

1.10 Technické pozadí pro učitele

Python nemá private. Konvence: _atribut znamená „interní, nesahat". Dvojité podtržítko __x spouští name mangling, ale to sem nepatří.
@property umožňuje počítané atributy — pěkný bonus pro pokročilé: @property def procenta(self): return self.zivoty / self.MAX * 100
@dataclass z modulu dataclasses výrazně zkracuje zápis datových tříd. Ukažte až pokročilým, jinak zastíní pochopení __init__.
Pro C# programátora: __init__ je konstruktor, self je this, ale musí být explicitně první parametr. Všechny metody jsou virtuální, vše je veřejné.
Serializace objektu do JSON nejde přímo — potřebuje metodu to_dict(). To využijeme v hodině 17.

Poznámky pro učiteleČasté chyby1. Vysvětlení a souvislosti

1.11 Časté chyby

Chyba	Příčina	Řešení
`TypeError: missing 1 required positional argument: 'self'`	Chybí `self` v definici metody	Přidat jako první parametr
Objekt se nezmění	Chybí `self.` před atributem	`self.zivoty = ...`
`AttributeError: object has no attribute`	Atribut se nenastavil v `__init__`	Doplnit do konstruktoru
Všechny objekty mají stejná data	Měnitelná hodnota v hlavičce třídy	Vytvářet v `__init__`
`<object at 0x...>` při výpisu	Chybí `__str__`	Doplnit metodu
Divné chyby po úpravě třídy	Starý objekt v `session_state`	Reset hry / obnovit stránku

2. Ukázky pro projekci

Blok 9Ukázka 1 — Od slovníku ke třídě2. Ukázky pro projekci

demo/demo1_slovnik_vs_trida.py

import streamlit as st

st.title("Slovník vs. třída")

def uber_zivoty_slovnik(h, kolik):
    h["zivoty"] = max(0, h["zivoty"] - kolik)

class Postava:
    """Postava, která si sama umí ubrat životy."""

MAX_ZIVOTY = 100

def __init__(self, jmeno, zivoty=100, sila=10):
        self.jmeno = jmeno
        self.zivoty = zivoty
        self.sila = sila
        self.inventar = []

def uber_zivoty(self, kolik):
        self.zivoty = max(0, self.zivoty - kolik)

def uzdrav(self, kolik):
        self.zivoty = min(self.MAX_ZIVOTY, self.zivoty + kolik)

def je_ziva(self):
        return self.zivoty > 0

def __str__(self):
        return f"{self.jmeno} ({self.zivoty}/{self.MAX_ZIVOTY} HP)"

levy, pravy = st.columns(2)

with levy:
    st.subheader("📋 Slovník + funkce")
    st.code(
        "hrdina = {'jmeno': 'Arkon', 'zivoty': 100}\n"
        "\n"
        "def uber_zivoty(h, kolik):\n"
        "    h['zivoty'] -= kolik\n"
        "\n"
        "uber_zivoty(hrdina, 20)"
    )
    st.caption("Musíš vědět, která funkce patří ke kterým datům.")

with pravy:
    st.subheader("🏗️ Třída")
    st.code(
        "class Postava:\n"
        "    def __init__(self, jmeno, zivoty=100):\n"
        "        self.jmeno = jmeno\n"
        "        self.zivoty = zivoty\n"
        "\n"
        "    def uber_zivoty(self, kolik):\n"
        "        self.zivoty -= kolik\n"
        "\n"
        "hrdina = Postava('Arkon')\n"
        "hrdina.uber_zivoty(20)"
    )
    st.caption("Metoda patří k objektu. Nemusíš nic hledat.")

st.divider()

st.subheader("Dva objekty z jedné třídy")

if "arkon" not in st.session_state:
    st.session_state.arkon = Postava("Arkon", 100, 15)
    st.session_state.bela = Postava("Bela", 80, 12)

arkon = st.session_state.arkon
bela = st.session_state.bela

a, b = st.columns(2)

with a:
    st.metric("🧙 " + arkon.jmeno, arkon.zivoty)
    st.progress(arkon.zivoty / Postava.MAX_ZIVOTY)
    if st.button("👊 Zraň Arkona"):
        arkon.uber_zivoty(20)
        st.rerun()
    if st.button("🧪 Uzdrav Arkona"):
        arkon.uzdrav(15)
        st.rerun()

with b:
    st.metric("🏹 " + bela.jmeno, bela.zivoty)
    st.progress(bela.zivoty / Postava.MAX_ZIVOTY)
    if st.button("👊 Zraň Belu"):
        bela.uber_zivoty(20)
        st.rerun()
    if st.button("🧪 Uzdrav Belu"):
        bela.uzdrav(15)
        st.rerun()

st.divider()

st.info(
    "Zraň jednu postavu. Druhá se nezmění — každý objekt má vlastní data. "
    "Ale metoda `uber_zivoty` je napsaná jenom jednou."
)

st.code(f"str(arkon)  ->  {arkon}\nstr(bela)   ->  {bela}")
st.caption("Takhle vypadá objekt díky metodě __str__.")

if st.button("🔄 Reset"):
    st.session_state.clear()
    st.rerun()

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

Blok 10Ukázka 2 — self pod lupou2. Ukázky pro projekci

demo/demo2_self.py

import streamlit as st

st.title("Co přesně dělá self")

class Ukazka:
    def __init__(self, jmeno):
        self.jmeno = jmeno
        self.pocet_volani = 0

def kdo_jsem(self):
        self.pocet_volani += 1
        return f"Jsem {self.jmeno}, volali mě {self.pocet_volani}×"

st.code(
    "class Ukazka:\n"
    "    def __init__(self, jmeno):\n"
    "        self.jmeno = jmeno\n"
    "\n"
    "    def kdo_jsem(self):\n"
    "        return f'Jsem {self.jmeno}'"
)

st.divider()

if "a" not in st.session_state:
    st.session_state.a = Ukazka("První")
    st.session_state.b = Ukazka("Druhý")

levy, pravy = st.columns(2)

with levy:
    st.subheader("Objekt A")
    if st.button("Zavolat A.kdo_jsem()"):
        st.session_state.vysledek_a = st.session_state.a.kdo_jsem()
    st.write(st.session_state.get("vysledek_a", "—"))
    st.caption(f"self = objekt A (jmeno='{st.session_state.a.jmeno}')")

with pravy:
    st.subheader("Objekt B")
    if st.button("Zavolat B.kdo_jsem()"):
        st.session_state.vysledek_b = st.session_state.b.kdo_jsem()
    st.write(st.session_state.get("vysledek_b", "—"))
    st.caption(f"self = objekt B (jmeno='{st.session_state.b.jmeno}')")

st.divider()

st.subheader("Stejná metoda, jiný self")
st.code(
    "a.kdo_jsem()    →  Python zavolá kdo_jsem(a)     →  self je a\n"
    "b.kdo_jsem()    →  Python zavolá kdo_jsem(b)     →  self je b"
)

st.divider()

st.subheader("Co se stane BEZ self")
st.code(
    "# ❌ ŠPATNĚ\n"
    "def uber_zivoty(self, kolik):\n"
    "    zivoty = zivoty - kolik      # UnboundLocalError\n"
    "\n"
    "# ✅ SPRÁVNĚ\n"
    "def uber_zivoty(self, kolik):\n"
    "    self.zivoty = self.zivoty - kolik"
)
st.error("Bez `self.` vyrábíš lokální proměnnou. Objekt se vůbec nezmění.")

if st.button("🔄 Reset"):
    st.session_state.clear()
    st.rerun()

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

Blok 11Ukázka 3 — Souboj dvou objektů2. Ukázky pro projekci

demo/demo3_souboj_objekty.py

import random

import streamlit as st

st.set_page_config(page_title="Souboj objektů", page_icon="⚔️")
st.title("⚔️ Souboj dvou objektů")

class Bojovnik:
    """Bojovník, který umí útočit a přijímat poškození."""

def __init__(self, jmeno, zivoty, sila, emoji="🧙"):
        self.jmeno = jmeno
        self.zivoty = zivoty
        self.max_zivoty = zivoty
        self.sila = sila
        self.emoji = emoji

def je_zivy(self):
        return self.zivoty > 0

def utoc(self, cil):
        """Zaútočí na cíl. Vrátí popis útoku."""
        hod = random.randint(1, 6)
        poskozeni = self.sila + hod
        cil.prijmi_poskozeni(poskozeni)
        return f"{self.emoji} {self.jmeno} zasáhl za {poskozeni} (hod {hod})"

def prijmi_poskozeni(self, kolik):
        self.zivoty = max(0, self.zivoty - kolik)

def podil_zivotu(self):
        return self.zivoty / self.max_zivoty

def __str__(self):
        return f"{self.emoji} {self.jmeno} ({self.zivoty}/{self.max_zivoty})"

if "hrdina" not in st.session_state:
    st.session_state.hrdina = Bojovnik("Arkon", 100, 12, "🧙")
    st.session_state.prisera = Bojovnik("Skřet", 80, 9, "👹")
    st.session_state.log = []
    st.session_state.kolo = 0

h = st.session_state.hrdina
p = st.session_state.prisera

a, b = st.columns(2)

with a:
    st.subheader(f"{h.emoji} {h.jmeno}")
    st.metric("Životy", f"{h.zivoty}/{h.max_zivoty}")
    st.progress(h.podil_zivotu())

with b:
    st.subheader(f"{p.emoji} {p.jmeno}")
    st.metric("Životy", f"{p.zivoty}/{p.max_zivoty}")
    st.progress(p.podil_zivotu())

st.caption(f"Kolo: {st.session_state.kolo}")

st.divider()

if h.je_zivy() and p.je_zivy():
    if st.button("⚔️ Zaútoč!"):
        st.session_state.kolo += 1
        st.session_state.log.append(h.utoc(p))
        if p.je_zivy():
            st.session_state.log.append(p.utoc(h))
        st.rerun()
elif not p.je_zivy():
    st.success(f"🏆 {h.jmeno} zvítězil po {st.session_state.kolo} kolech!")
else:
    st.error(f"💀 {h.jmeno} padl v {st.session_state.kolo}. kole.")

if st.button("🔄 Nový souboj"):
    st.session_state.clear()
    st.rerun()

if st.session_state.log:
    st.divider()
    st.text("\n".join(st.session_state.log[-10:]))

st.divider()
st.caption(
    "Všimni si `cil.prijmi_poskozeni(...)` uvnitř metody `utoc`. "
    "Objekt volá metodu jiného objektu."
)

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

3. Cvičení na hodinu

Blok 12Cvičení 1 — První třída (15 min)3. Cvičení na hodinu

Zadání:

Napiš třídu Postava s __init__(self, jmeno, zivoty=100)

Přidej metodu uber_zivoty(self, kolik), která nikdy nejde pod nulu

Přidej metodu je_ziva(self) vracející True/False

Vytvoř dva různé objekty a ukaž, že se navzájem neovlivňují

Přidej __str__, aby se postava hezky vypsala

Úroveň	Co má zvládnout
Minimum	Body 1–3
Rozšíření	Bod 4 se dvěma tlačítky
Výzva	Bod 5 + metoda `uzdrav` s limitem maxima

Očekávaný výsledek: dvě nezávislé postavy ovládané tlačítky.

cviceni/cviceni1_prvni_trida.py

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

Na co si dát pozor

V každé metodě má být self jako první parametr.
Častá chyba je práce bez self. (zivoty = ... místo self.zivoty = ...).
Ověř si na dvou objektech, že změna jedné postavy neovlivní druhou.

Řešení 1 — jedna z možných variant

reseni/reseni1_prvni_trida.py

import streamlit as st

class Postava:
    """Postava se jménem a životy."""

MAX_ZIVOTY = 100

def __init__(self, jmeno, zivoty=100):
        self.jmeno = jmeno
        self.zivoty = zivoty

def uber_zivoty(self, kolik):
        """Ubere životy, nikdy nejde pod nulu."""
        self.zivoty = max(0, self.zivoty - kolik)

def uzdrav(self, kolik):
        """Přidá životy, nikdy nepřekročí maximum."""
        self.zivoty = min(self.MAX_ZIVOTY, self.zivoty + kolik)

def je_ziva(self):
        return self.zivoty > 0

def __str__(self):
        stav = "živá" if self.je_ziva() else "mrtvá"
        return f"{self.jmeno} — {self.zivoty}/{self.MAX_ZIVOTY} HP ({stav})"

st.title("🏗️ První třída")

if "arkon" not in st.session_state:
    st.session_state.arkon = Postava("Arkon")
    st.session_state.bela = Postava("Bela", 80)

arkon = st.session_state.arkon
bela = st.session_state.bela

a, b = st.columns(2)

for sloupec, postava in [(a, arkon), (b, bela)]:
    with sloupec:
        st.subheader(postava.jmeno)
        st.metric("Životy", f"{postava.zivoty}/{postava.MAX_ZIVOTY}")
        st.progress(postava.zivoty / postava.MAX_ZIVOTY)

if st.button("👊 Zraň (−20)", key=f"zran_{postava.jmeno}"):
            postava.uber_zivoty(20)
            st.rerun()

if st.button("🧪 Uzdrav (+15)", key=f"lec_{postava.jmeno}"):
            postava.uzdrav(15)
            st.rerun()

if postava.je_ziva():
            st.success("Naživu")
        else:
            st.error("Padla")

st.divider()

st.subheader("Výpis přes __str__")
st.code(f"{arkon}\n{bela}")

st.info("Zraň jednu postavu — druhá se nezmění. Každý objekt má vlastní data.")

if st.button("🔄 Reset"):
    st.session_state.clear()
    st.rerun()

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

Blok 13Cvičení 2 — Třída s inventářem (20 min)3. Cvičení na hodinu

Zadání:

Rozšiř Postava o atribut inventar (prázdný seznam v __init__)

Přidej metodu seber(self, vec) přidávající do inventáře

Přidej metodu ma(self, vec) vracející True/False

Přidej metodu vyhod(self, vec), která bezpečně odebere věc

Přidej metodu pocet_veci(self) a __str__ s výpisem inventáře

Úroveň	Co má zvládnout
Minimum	Body 1–3
Rozšíření	Bod 4 s kontrolou existence
Výzva	Bod 5 + limit velikosti batohu jako atribut třídy

Očekávaný výsledek: postava, která si sama spravuje batoh.

cviceni/cviceni2_inventar_trida.py

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

Na co si dát pozor

inventar má vzniknout v __init__, ne jako sdílený atribut třídy.
U metody vyhod připomeňte kontrolu existence věci před odebráním.
Když je někdo hotový, ať si výpis inventáře ověří přes vlastní __str__.

Řešení 2 — jedna z možných variant

reseni/reseni2_inventar_trida.py

import streamlit as st

NABIDKA = ["meč", "štít", "lektvar", "klíč", "mapa", "prsten"]

class Postava:
    """Postava, která si spravuje vlastní batoh."""

MAX_VECI = 5

def __init__(self, jmeno, zivoty=100):
        self.jmeno = jmeno
        self.zivoty = zivoty
        self.inventar = []

def seber(self, vec):
        """Přidá věc do batohu. Vrátí True při úspěchu."""
        if len(self.inventar) >= self.MAX_VECI:
            return False
        self.inventar.append(vec)
        return True

def ma(self, vec):
        return vec in self.inventar

def vyhod(self, vec):
        """Bezpečně odebere věc. Vrátí True při úspěchu."""
        if not self.ma(vec):
            return False
        self.inventar.remove(vec)
        return True

def pocet_veci(self):
        return len(self.inventar)

def je_plny(self):
        return self.pocet_veci() >= self.MAX_VECI

def __str__(self):
        obsah = ", ".join(self.inventar) if self.inventar else "prázdno"
        return f"{self.jmeno} ({self.pocet_veci()}/{self.MAX_VECI}): {obsah}"

st.title("🎒 Postava s inventářem")

if "hrdina" not in st.session_state:
    st.session_state.hrdina = Postava("Arkon")

h = st.session_state.hrdina

st.progress(h.pocet_veci() / h.MAX_VECI)
st.caption(f"Batoh: {h.pocet_veci()}/{h.MAX_VECI}")

a, b = st.columns(2)

with a:
    st.subheader("Sebrat")
    vec = st.selectbox("Co jsi našel?", NABIDKA)
    if st.button("➕ Sebrat"):
        if h.seber(vec):
            st.rerun()
        else:
            st.error("Batoh je plný!")

with b:
    st.subheader("Vyhodit")
    if h.inventar:
        pryc = st.selectbox("Co vyhodíš?", h.inventar)
        if st.button("➖ Vyhodit"):
            h.vyhod(pryc)
            st.rerun()
    else:
        st.caption("Batoh je prázdný.")

st.divider()

st.subheader("Obsah batohu")
if h.inventar:
    for i, v in enumerate(h.inventar, start=1):
        st.write(f"**{i}.** {v}")
else:
    st.info("Batoh je prázdný.")

st.divider()

st.subheader("Kontrola metodou ma()")
hledana = st.selectbox("Má hrdina tuto věc?", NABIDKA, key="kontrola")
if h.ma(hledana):
    st.success(f"✅ Ano, {hledana} v batohu je.")
else:
    st.warning(f"❌ Ne, {hledana} v batohu není.")

st.code(str(h))

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

Blok 14Cvičení 3 — Třída Příšera a souboj (20 min)3. Cvičení na hodinu

Zadání:

Napiš třídu Prisera s jménem, životy, silou a zlatem

Přidej metodu utoc(self, cil), která volá metodu cíle

Přidej prijmi_poskozeni(self, kolik) do obou tříd

Udělej tlačítko, které provede jedno kolo souboje

Po smrti příšery přidej hrdinovi její zlato

Úroveň	Co má zvládnout
Minimum	Body 1–3
Rozšíření	Bod 4 s logem
Výzva	Bod 5 + hod kostkou k útoku

Očekávaný výsledek: dva objekty, které se navzájem ovlivňují.

cviceni/cviceni3_prisera.py

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

Na co si dát pozor

Žáci často zapomenou implementovat prijmi_poskozeni v obou třídách.
utoc(self, cil) má volat metodu na cíli, ne měnit cíl bokem.
Omez životy přes max(0, ...), aby HP nešla do mínusu.

Řešení 3 — jedna z možných variant

reseni/reseni3_prisera.py

import random

import streamlit as st

class Bojovnik:
    """Základ pro hrdinu i příšeru."""

def __init__(self, jmeno, zivoty, sila, emoji="🧙"):
        self.jmeno = jmeno
        self.zivoty = zivoty
        self.max_zivoty = zivoty
        self.sila = sila
        self.emoji = emoji

def je_zivy(self):
        return self.zivoty > 0

def prijmi_poskozeni(self, kolik):
        self.zivoty = max(0, self.zivoty - kolik)

def utoc(self, cil):
        """Zaútočí na cíl a vrátí popis."""
        hod = random.randint(1, 6)
        poskozeni = self.sila + hod
        cil.prijmi_poskozeni(poskozeni)
        return f"{self.emoji} {self.jmeno} zasáhl za {poskozeni} (hod {hod})"

def __str__(self):
        return f"{self.emoji} {self.jmeno} ({self.zivoty}/{self.max_zivoty})"

class Hrdina(Bojovnik):
    def __init__(self, jmeno, zivoty=100, sila=12):
        super().__init__(jmeno, zivoty, sila, "🧙")
        self.zlato = 0

def pridej_zlato(self, kolik):
        self.zlato += kolik

class Prisera(Bojovnik):
    def __init__(self, jmeno, zivoty, sila, zlato, emoji="👹"):
        super().__init__(jmeno, zivoty, sila, emoji)
        self.zlato = zlato

st.title("⚔️ Souboj tříd")

if "hrdina" not in st.session_state:
    st.session_state.hrdina = Hrdina("Arkon")
    st.session_state.prisera = Prisera("Skřet", 60, 8, 45)
    st.session_state.log = []
    st.session_state.odmeneno = False

h = st.session_state.hrdina
p = st.session_state.prisera

a, b = st.columns(2)

with a:
    st.subheader(f"{h.emoji} {h.jmeno}")
    st.metric("❤️ Životy", f"{h.zivoty}/{h.max_zivoty}")
    st.metric("💰 Zlato", h.zlato)
    st.progress(h.zivoty / h.max_zivoty)

with b:
    st.subheader(f"{p.emoji} {p.jmeno}")
    st.metric("❤️ Životy", f"{p.zivoty}/{p.max_zivoty}")
    st.metric("💰 Nese zlata", p.zlato)
    st.progress(p.zivoty / p.max_zivoty)

st.divider()

if h.je_zivy() and p.je_zivy():
    if st.button("⚔️ Zaútoč!"):
        st.session_state.log.append(h.utoc(p))
        if p.je_zivy():
            st.session_state.log.append(p.utoc(h))
        st.rerun()
elif not p.je_zivy():
    if not st.session_state.odmeneno:
        h.pridej_zlato(p.zlato)
        st.session_state.odmeneno = True
        st.session_state.log.append(f"💰 Získal jsi {p.zlato} zlata!")
        st.rerun()
    st.success(f"🏆 {h.jmeno} zvítězil a získal {p.zlato} zlata!")
else:
    st.error(f"💀 {h.jmeno} padl.")

if st.button("🔄 Nový souboj"):
    st.session_state.clear()
    st.rerun()

if st.session_state.log:
    st.divider()
    st.text("\n".join(st.session_state.log[-10:]))

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

Blok 15Cvičení 4 — Družina objektů (20 min)3. Cvičení na hodinu

Zadání:

Vytvoř seznam tří objektů Postava s různými jmény a životy

Vypiš je cyklem, každou jako kartu s st.metric a st.progress

Přidej ke každé tlačítko „Zraň" s parametrem key odvozeným od jména

Spočítej, kolik členů družiny je ještě naživu

Přidej metodu stav(self) vracející slovní popis a použij ji v kartě

Úroveň	Co má zvládnout
Minimum	Body 1–2
Rozšíření	Body 3–4
Výzva	Bod 5 + najít cyklem nejzraněnějšího člena

Očekávaný výsledek: tři karty generované jedním kusem kódu.

cviceni/cviceni4_druzina.py

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

Na co si dát pozor

Klíčové je použít cyklus přes seznam objektů místo kopírování kódu.
U tlačítek je nutný unikátní key, jinak se budou tlačítka plést.
Pro statistiku "naživu" a nejzraněnějšího ukažte průchod seznamem krok za krokem.

Řešení 4 — jedna z možných variant

reseni/reseni4_druzina.py

import streamlit as st

class Postava:
    """Člen družiny."""

MAX_ZIVOTY = 100

def __init__(self, jmeno, zivoty, emoji="🧙"):
        self.jmeno = jmeno
        self.zivoty = zivoty
        self.emoji = emoji

def uber_zivoty(self, kolik):
        self.zivoty = max(0, self.zivoty - kolik)

def uzdrav(self, kolik):
        self.zivoty = min(self.MAX_ZIVOTY, self.zivoty + kolik)

def je_ziva(self):
        return self.zivoty > 0

def podil(self):
        return self.zivoty / self.MAX_ZIVOTY

def stav(self):
        """Slovní popis stavu."""
        if self.zivoty <= 0:
            return "💀 padlá"
        if self.podil() < 0.3:
            return "🩸 kriticky zraněná"
        if self.podil() < 0.7:
            return "😰 zraněná"
        return "💪 v pořádku"

def __str__(self):
        return f"{self.emoji} {self.jmeno} ({self.zivoty} HP) — {self.stav()}"

st.title("🧑‍🤝‍🧑 Družina objektů")

if "druzina" not in st.session_state:
    st.session_state.druzina = [
        Postava("Arkon", 85, "🧙"),
        Postava("Bela", 45, "🏹"),
        Postava("Cedrik", 20, "🗡️"),
    ]

druzina = st.session_state.druzina

for clen in druzina:
    st.subheader(f"{clen.emoji} {clen.jmeno}")

a, b = st.columns([2, 1])
    a.progress(clen.podil())
    b.metric("HP", clen.zivoty)

st.caption(clen.stav())

x, y = st.columns(2)
    if x.button("👊 Zraň", key=f"zran_{clen.jmeno}"):
        clen.uber_zivoty(20)
        st.rerun()
    if y.button("🧪 Ošetři", key=f"lec_{clen.jmeno}"):
        clen.uzdrav(25)
        st.rerun()

st.divider()

zivi = 0
for clen in druzina:
    if clen.je_ziva():
        zivi += 1

nejzranenejsi = druzina[0]
for clen in druzina:
    if clen.zivoty < nejzranenejsi.zivoty:
        nejzranenejsi = clen

a, b = st.columns(2)
a.metric("Naživu", f"{zivi}/{len(druzina)}")
b.metric("Nejzraněnější", nejzranenejsi.jmeno)

if zivi == 0:
    st.error("💀 Celá družina padla.")

st.divider()
for clen in druzina:
    st.text(str(clen))

if st.button("🔄 Reset"):
    st.session_state.clear()
    st.rerun()

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

Blok 16Cvičení 5 — PyQuest na třídách (25 min)3. Cvičení na hodinu

Zadání:

Převeď hrdinu na objekt třídy Hrdina s metodami uber_zivoty, pridej_zlato, seber

Přidej metodu muze_do_veze(self) vracející True/False

Ulož objekt do session_state a používej ho v celé hře

Přidej metodu karta(self), která vykreslí hrdinu v postranním panelu

Přidej metodu vyprava(self, data) vracející text zápisu do deníku

Úroveň	Co má zvládnout
Minimum	Body 1–3
Rozšíření	Bod 4
Výzva	Bod 5 + metoda `to_dict()` pro pozdější ukládání

Očekávaný výsledek: hra běží na objektu, hlavní kód je krátký.

cviceni/cviceni5_pyquest_tridy.py

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

Na co si dát pozor

Objekt Hrdina musí být uložený v st.session_state, jinak se při každém běhu ztratí změny.
Pravidlo věže (klíč) patří do metody, ne jen do hlavního těla programu.
Když žáci upraví třídu a objeví se podivné chyby, pomůže reset hry.

Řešení 5 — jedna z možných variant

reseni/reseni5_pyquest_tridy.py

import streamlit as st

st.set_page_config(page_title="PyQuest", page_icon="⚔️")

MISTA = {
    "Les": {"nebezpeci": 20, "odmena": 30, "korist": "lano", "emoji": "🌲"},
    "Jeskyně": {"nebezpeci": 45, "odmena": 80, "korist": "klíč", "emoji": "🕳️"},
    "Věž": {"nebezpeci": 70, "odmena": 200, "korist": "prsten", "emoji": "🏰"},
}

class Hrdina:
    """Hrdina hry PyQuest."""

MAX_ZIVOTY = 100

def __init__(self, jmeno="Arkon"):
        self.jmeno = jmeno
        self.zivoty = self.MAX_ZIVOTY
        self.zlato = 50
        self.inventar = ["meč"]
        self.vypravy = 0

def uber_zivoty(self, kolik):
        self.zivoty = max(0, self.zivoty - kolik)

def uzdrav(self, kolik):
        self.zivoty = min(self.MAX_ZIVOTY, self.zivoty + kolik)

def pridej_zlato(self, kolik):
        self.zlato += kolik

def seber(self, vec):
        self.inventar.append(vec)

def ma(self, vec):
        return vec in self.inventar

def je_zivy(self):
        return self.zivoty > 0

def muze_do_veze(self):
        return self.ma("klíč")

def karta(self):
        """Vykreslí hrdinu v postranním panelu."""
        st.header(f"🧙 {self.jmeno}")
        st.metric("❤️ Životy", f"{self.zivoty}/{self.MAX_ZIVOTY}")
        st.metric("💰 Zlato", self.zlato)
        st.metric("🗺️ Výprav", self.vypravy)
        st.progress(self.zivoty / self.MAX_ZIVOTY)
        if self.inventar:
            st.write(f"🎒 {', '.join(self.inventar)}")
        else:
            st.caption("🎒 prázdno")

def vyprava(self, misto, data):
        """Provede výpravu a vrátí text zápisu."""
        self.vypravy += 1
        c = self.vypravy

if self.zivoty > data["nebezpeci"]:
            self.pridej_zlato(data["odmena"])
            self.uber_zivoty(data["nebezpeci"] // 3)
            self.seber(data["korist"])
            return f"{c}. ✅ {misto}: +{data['odmena']} zlata, {data['korist']}"

self.uber_zivoty(data["nebezpeci"] // 2)
        return f"{c}. ❌ {misto}: útěk se ztrátami"

def to_dict(self):
        """Převede hrdinu na slovník (pro ukládání)."""
        return {
            "jmeno": self.jmeno,
            "zivoty": self.zivoty,
            "zlato": self.zlato,
            "inventar": self.inventar,
            "vypravy": self.vypravy,
        }

def __str__(self):
        return f"{self.jmeno} ({self.zivoty} HP, {self.zlato} zlata)"

if "hrdina" not in st.session_state:
    st.session_state.hrdina = Hrdina()
    st.session_state.denik = []

h = st.session_state.hrdina

st.title("⚔️ PyQuest")

with st.sidebar:
    h.karta()

st.divider()
    if st.button("🧪 Odpočinek (+20 HP, −10 zlata)"):
        if h.zlato >= 10:
            h.zlato -= 10
            h.uzdrav(20)
            st.rerun()
        else:
            st.error("Nemáš dost zlata.")

if st.button("🔄 Nová hra"):
        st.session_state.clear()
        st.rerun()

if not h.je_zivy():
    st.error(f"💀 {h.jmeno} padl po {h.vypravy} výpravách.")
else:
    misto = st.selectbox("Kam vyrazíš?", list(MISTA.keys()))
    d = MISTA[misto]

st.header(f"{d['emoji']} {misto}")
    a, b, c = st.columns(3)
    a.metric("⚠️ Nebezpečí", d["nebezpeci"])
    b.metric("💎 Odměna", d["odmena"])
    c.metric("🎁 Kořist", d["korist"])

if misto == "Věž" and not h.muze_do_veze():
        st.error("🔒 Bez klíče se do věže nedostaneš.")
    elif st.button("🚶 Vyrazit"):
        st.session_state.denik.append(h.vyprava(misto, d))
        st.rerun()

if st.session_state.denik:
    st.divider()
    st.subheader("📜 Deník")
    st.text("\n".join(reversed(st.session_state.denik[-12:])))

st.divider()
st.caption("Hlavní část programu má jen pár řádků — všechno umí objekt sám.")

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

4. Domácí úkol

Blok 17Domácí úkol na příští hodinu4. Domácí úkol

Napiš třídu Lektvar s atributy nazev, sila_leceni a cena a metodou pouzij(self, postava), která postavě přidá životy. Vytvoř tři různé lektvary a nech hrdinu vybrat, který vypije.

Zobrazit ukázkové řešení domácího úkolu

Toto je jedna z možných variant, jak mohl úkol dopadnout. Tvoje řešení se může lišit a to je v pořádku.

domaci/domaci_ukol13.py

import streamlit as st

st.set_page_config(page_title="PyQuest — lektvary", page_icon="🧪")
st.title("🧪 Lektvary pro hrdinu")

class Hrdina:
    MAX_ZIVOTY = 120

def __init__(self, jmeno="Arkon", zivoty=62, zlato=140):
        self.jmeno = jmeno
        self.zivoty = zivoty
        self.zlato = zlato
        self.denik = []

def uzdrav(self, kolik):
        self.zivoty = min(self.MAX_ZIVOTY, self.zivoty + kolik)

def podil_zivotu(self):
        return self.zivoty / self.MAX_ZIVOTY

class Lektvar:
    def __init__(self, nazev, sila_leceni, cena):
        self.nazev = nazev
        self.sila_leceni = sila_leceni
        self.cena = cena

def pouzij(self, postava):
        pred = postava.zivoty
        postava.uzdrav(self.sila_leceni)
        return postava.zivoty - pred

def __str__(self):
        return f"{self.nazev} (+{self.sila_leceni} HP, {self.cena} zlata)"

if "hrdina" not in st.session_state:
    st.session_state.hrdina = Hrdina()

h = st.session_state.hrdina

nabidka = [
    Lektvar("Malý léčivý lektvar", 20, 25),
    Lektvar("Střední léčivý lektvar", 45, 55),
    Lektvar("Velký léčivý lektvar", 80, 95),
]

with st.sidebar:
    st.subheader(f"🧙 {h.jmeno}")
    a, b = st.columns(2)
    a.metric("❤️ Životy", f"{h.zivoty}/{h.MAX_ZIVOTY}")
    b.metric("💰 Zlato", h.zlato)
    st.progress(h.podil_zivotu())

if st.button("🔄 Reset hrdiny"):
        st.session_state.clear()
        st.rerun()

volba_text = st.selectbox("Vyber lektvar", [str(lektvar) for lektvar in nabidka])
vybrany_lektvar = next(lektvar for lektvar in nabidka if str(lektvar) == volba_text)

if st.button("🥤 Vypít vybraný lektvar"):
    if h.zlato < vybrany_lektvar.cena:
        st.error("Nemáš dost zlata na tento lektvar.")
    elif h.zivoty >= h.MAX_ZIVOTY:
        st.warning("Máš plné životy, lektvar by se promrhal.")
    else:
        h.zlato -= vybrany_lektvar.cena
        vyleceno = vybrany_lektvar.pouzij(h)
        h.denik.append(
            f"Použit {vybrany_lektvar.nazev}: +{vyleceno} HP, -{vybrany_lektvar.cena} zlata"
        )
        st.success(f"{vybrany_lektvar.nazev} tě vyléčil o {vyleceno} HP.")

st.divider()
st.subheader("📜 Deník použití")
if h.denik:
    for zaznam in reversed(h.denik[-8:]):
        st.write(f"- {zaznam}")
else:
    st.caption("Zatím jsi žádný lektvar nepoužil.")

Tady se objeví výsledekKlikni na Spustit. Kód vlevo můžeš měnit a spouštět opakovaně klávesami Ctrl+Enter.

Kód vlevo jde upravovat. Tab odsazuje o čtyři mezery.

Blok 18Oficiální dokumentace4. Domácí úkol

Oficiální dokumentace se hodí, když si chceš ověřit, jak Python zapisuje třídy, co přesně dělá __init__ nebo proč se u metod objevuje self. Je v angličtině, ale často stačí projít názvy částí, krátké ukázky a příklady použití.

Co jsme použili	Oficiální dokumentace	Co tam najdeš
třídy obecně	Python tutorial — Classes	základní vysvětlení tříd, objektů, atributů a metod
`class`	Class definitions	přesný zápis definice třídy v Pythonu
`__init__`	`object.__init__`	konstruktor a inicializaci nového objektu
`self` a instance	A first look at classes	proč metody pracují s konkrétní instancí
metody objektu	Method objects	jak funguje volání metod přes tečku
`__str__`	`object.__str__`	jak si nastavit hezký textový výpis objektu

5. Umíme informatiku

Blok 19Navazující cvičení na Umíme informatiku5. Umíme informatiku

Cvičení	Odkaz	Proč se hodí
Kódování a modelování	umimeinformatiku.cz	Modelování skutečnosti
Programování v Pythonu	umimeinformatiku.cz	Struktura programu
Algoritmické myšlení	umimeinformatiku.cz	Rozklad na části
Tabulky	umimeinformatiku.cz	Objekty jako řádky dat