16. Dědičnost — bestiář na třídách

Blok 1Problém, který dědičnost řeší1. Vysvětlení a souvislosti

Podívej se na tři třídy vedle sebe a zkus najít, co se opakuje:

Všechny umí to samé. Liší se jen v pár detailech. Kdybys chtěl přidat metodu uzdrav, musel bys ji napsat třikrát. A pak čtyřikrát. A pak…

Dědičnost znamená „tahle třída už umí všechno, co ten rodič, a navíc si přidá něco svého".

Blok 2Slovník pojmů1. Vysvětlení a souvislosti

Drž se jednoho názvosloví celý rok:

Termín	Význam
rodičovská / základní třída	ta obecná (`Prisera`)
odvozená / potomek	ta konkrétní (`Skret`)
dědit	automaticky převzít atributy a metody
přepsat metodu	napsat vlastní verzi zděděné metody

Analogie, která funguje:

„Zvíře" je obecné. „Pes" je zvíře, které navíc štěká. Nemusíš psovi znovu vysvětlovat, že dýchá a jí — to má po zvířeti. Stačí dopsat to štěkání.

Blok 3Základní zápis1. Vysvětlení a souvislosti

Když metoda v potomkovi není, Python ji hledá u rodiče. Když tam je, použije tu z potomka. Tomu se říká přepsání metody.

Blok 4super() — zavolej rodiče1. Vysvětlení a souvislosti

Nejdůležitější technická věc hodiny:

class Drak(Prisera):
    def __init__(self, jmeno, zivoty, sila, barva):
        super().__init__(jmeno, zivoty, sila)   # ať to udělá rodič
        self.barva = barva                       # a tohle je navíc

super().__init__(...) znamená „rodiči, udělej svoji část". Pak si dopíšeš, co má tvoje třída navíc.

Kdybys to nezavolal, drak by neměl jméno ani životy — rodičův kód by se nespustil.

def utoc(self, cil):
    poskozeni = super().utoc(cil)     # udělej to, co dělá rodič
    return poskozeni * 2               # a ještě to zdvojnásob

super() funguje i v obyčejných metodách:

Blok 5Polymorfismus — nejkrásnější část1. Vysvětlení a souvislosti

Tady obvykle docvakne, k čemu to celé je:

bestiar = [Skret("Skřet", 30, 8), Vlk("Vlk", 20, 12), Drak("Drak", 200, 40, "rudý")]

for p in bestiar:
    st.write(p.zvuk())      # každá udělá SVOJI verzi

V seznamu jsou tři různé typy příšer. Voláš na nich stejnou metodu, ale každá se zachová po svém. Ty nemusíš vědět, která je která.

To je polymorfismus: „mnoho tvarů". Jedno volání, různé chování.

Tohle je zásadní, protože to výrazně zjednoduší tvůj kód.

Blok 6isinstance — zjištění typu1. Vysvětlení a souvislosti

isinstance(s, Skret)        # True
isinstance(s, Prisera)      # True - Skřet JE příšera
isinstance(s, Drak)         # False

Skřet je zároveň skřet i příšera. Potomek je vždycky i typem rodiče.

Používej střídmě — pokud kód potřebuje moc isinstance, měl by tam být polymorfismus.

Blok 7Kdy dědit a kdy ne1. Vysvětlení a souvislosti

Zapamatuj si jednoduché pravidlo:

Dědičnost použij, když platí věta „X JE Y". Skřet je příšera. ✅ Meč je předmět. ✅ Hrdina má inventář — to není dědičnost, to je atribut. ❌

Špatné použití dědičnosti dělá kód horším, ne lepším.

Blok 8Praktický návrh bestiáře1. Vysvětlení a souvislosti

Všimni si, že konkrétní příšery mají __init__ bez parametrů. Samy vědí, jaké mají hodnoty. Vytvoříš je jednoduše: Skret().

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

Python podporuje vícenásobnou dědičnost a řeší ji přes MRO (C3 linearizace). Do výuky nepatří, ale vy o tom vědět máte, kdyby se někdo zeptal.
Abstraktní třídy: modul abc, dekorátor @abstractmethod. Pro pokročilé žáky je to hezké rozšíření (příšera, kterou nelze vytvořit přímo).
super() v Pythonu 3 nepotřebuje argumenty. Starý zápis super(Skret, self) uvidí děti ve starých návodech na internetu.
Pro C# programátora: class Skret(Prisera) je class Skret : Prisera, super().__init__() je : base(...). Rozdíl: v Pythonu jsou všechny metody virtuální, override se nepíše.
Kompozice je často lepší než dědičnost. Doporučená věta: „Dědi jen tehdy, když potomek skutečně může nahradit rodiče."

Blok 9Časté chyby1. Vysvětlení a souvislosti

Chyba	Příčina	Řešení
`AttributeError: no attribute 'jmeno'`	Chybí `super().__init__()`	Zavolat na začátku `__init__`
`TypeError: __init__ takes 1 argument`	Špatný počet argumentů u `super()`	Zkontrolovat rodičovskou hlavičku
Přepsaná metoda se nevolá	Překlep v názvu metody	Musí být přesně stejný název
Sdílený seznam mezi objekty	Seznam v těle třídy místo v `__init__`	Vytvářet v `__init__`
`NameError: Prisera is not defined`	Rodič definovaný až po potomkovi	Rodiče psát nahoru
Dědičnost tam, kde má být atribut	„má" místo „je"	Použít kompozici

Blok 10Ukázka 1 — Opakování versus dědičnost2. Ukázky pro projekci

demo/demo1_proc_dedicnost.py

import streamlit as st

st.title("Proč dědičnost")

levy, pravy = st.columns(2)

with levy:
    st.subheader("❌ Bez dědičnosti")
    st.code(
        "class Skret:\n"
        "    def __init__(self, zivoty, sila):\n"
        "        self.zivoty = zivoty\n"
        "        self.sila = sila\n"
        "    def je_zivy(self):\n"
        "        return self.zivoty > 0\n"
        "\n"
        "class Vlk:\n"
        "    def __init__(self, zivoty, sila):\n"
        "        self.zivoty = zivoty      # stejné\n"
        "        self.sila = sila          # stejné\n"
        "    def je_zivy(self):            # stejné\n"
        "        return self.zivoty > 0"
    )
    st.error("Nová metoda = přepsat všude.")

with pravy:
    st.subheader("✅ S dědičností")
    st.code(
        "class Prisera:\n"
        "    def __init__(self, jmeno, zivoty, sila):\n"
        "        self.jmeno = jmeno\n"
        "        self.zivoty = zivoty\n"
        "        self.sila = sila\n"
        "    def je_ziva(self):\n"
        "        return self.zivoty > 0\n"
        "    def zvuk(self):\n"
        "        return '...'\n"
        "\n"
        "class Skret(Prisera):\n"
        "    def zvuk(self):\n"
        "        return 'Grrrr!'"
    )
    st.success("Nová metoda = jedno místo.")

st.divider()

class Prisera:
    """Základní příšera."""

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

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

def zvuk(self):
        return "..."

def popis(self):
        return f"{self.emoji} {self.jmeno}: {self.zivoty} HP, síla {self.sila}"

class Skret(Prisera):
    def __init__(self):
        super().__init__("Skřet", 30, 8, 25, "👺")

def zvuk(self):
        return "Grrrr! Rozbiju ti hlavu!"

class Vlk(Prisera):
    def __init__(self):
        super().__init__("Vlk", 20, 12, 15, "🐺")

def zvuk(self):
        return "Aúúúú!"

class Drak(Prisera):
    def __init__(self, barva="rudý"):
        super().__init__("Drak", 200, 40, 500, "🐉")
        self.barva = barva

def zvuk(self):
        return f"RRRRR! {self.barva.title()} drak chrlí oheň!"

def popis(self):
        zaklad = super().popis()
        return f"{zaklad} — barva: {self.barva}"

st.subheader("Polymorfismus: stejné volání, různé chování")

bestiar = [Skret(), Vlk(), Drak("zlatý")]

for p in bestiar:
    st.write(f"**{p.popis()}**")
    st.caption(f"zvuk(): {p.zvuk()}")

st.divider()

st.code(
    "for p in bestiar:\n"
    "    st.write(p.zvuk())      # každá udělá SVOJI verzi"
)
st.info("Nemusíš vědět, která příšera to je. Ona sama ví, co má dělat.")

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 2 — super() krok za krokem2. Ukázky pro projekci

demo/demo2_super.py

import streamlit as st

st.title("Co dělá super()")

class Prisera:
    def __init__(self, jmeno, zivoty, sila):
        self.jmeno = jmeno
        self.zivoty = zivoty
        self.sila = sila
        self.kroky = [f"Prisera.__init__ nastavila jmeno={jmeno}, zivoty={zivoty}"]

def utoc(self):
        return self.sila

class Drak(Prisera):
    def __init__(self, barva):
        super().__init__("Drak", 200, 40)
        self.barva = barva
        self.kroky.append(f"Drak.__init__ nastavil barvu={barva}")

def utoc(self):
        zaklad = super().utoc()
        self.kroky.append(f"Prisera.utoc() vrátila {zaklad}")
        self.kroky.append(f"Drak.utoc() to zdvojnásobil na {zaklad * 2}")
        return zaklad * 2

class DrakBezSuper(Prisera):
    """Ukázka toho, co se stane, když super() zapomeneš."""

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

barva = st.selectbox("Barva draka", ["rudý", "zlatý", "černý", "ledový"])

drak = Drak(barva)

st.subheader("✅ Se super()")
st.code("\n".join(drak.kroky))

a, b, c = st.columns(3)
a.metric("Jméno", drak.jmeno)
b.metric("Životy", drak.zivoty)
c.metric("Barva", drak.barva)

st.metric("Útok (2× rodičovský)", drak.utoc())

st.divider()

st.subheader("❌ Bez super()")

spatny = DrakBezSuper(barva)

st.code(
    "class DrakBezSuper(Prisera):\n"
    "    def __init__(self, barva):\n"
    "        self.barva = barva        # super() chybí!"
)

st.write("Má barvu?", hasattr(spatny, "barva"))
st.write("Má jméno?", hasattr(spatny, "jmeno"))
st.write("Má životy?", hasattr(spatny, "zivoty"))

st.error(
    "Bez super().__init__() se rodičovský konstruktor nespustí. "
    "Objekt nemá jméno ani životy a při prvním použití spadne na AttributeError."
)

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 12Ukázka 3 — Bestiář s vlastními schopnostmi2. Ukázky pro projekci

demo/demo3_bestiar_tridy.py

import random

import streamlit as st

st.set_page_config(page_title="Bestiář", page_icon="👹")
st.title("👹 Bestiář na třídách")

class Prisera:
    """Základ pro všechny příšery."""

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

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

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

def utoc(self):
        """Vrátí (poškození, popis)."""
        hod = random.randint(1, 6)
        return self.sila + hod, f"{self.emoji} {self.jmeno} útočí"

def schopnost(self):
        return None

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

class Skret(Prisera):
    def __init__(self):
        super().__init__("Skřet", 30, 8, 25, "👺")

class Vlk(Prisera):
    def __init__(self):
        super().__init__("Vlk", 20, 12, 15, "🐺")

def utoc(self):
        """Vlk útočí dvakrát za kolo."""
        p1, _ = super().utoc()
        p2, _ = super().utoc()
        return p1 + p2, f"{self.emoji} {self.jmeno} útočí DVAKRÁT"

def schopnost(self):
        return "Rychlé tlapy: útočí dvakrát za kolo"

class Kostlivec(Prisera):
    def __init__(self):
        super().__init__("Kostlivec", 40, 10, 40, "💀")

def prijmi_poskozeni(self, kolik):
        """Kostlivec ignoruje polovinu poškození."""
        super().prijmi_poskozeni(kolik // 2)

def schopnost(self):
        return "Kostěná zbroj: přijímá jen poloviční poškození"

class Drak(Prisera):
    def __init__(self, barva="rudý"):
        super().__init__("Drak", 200, 40, 500, "🐉")
        self.barva = barva

def utoc(self):
        """Drak má 30% šanci chrlit oheň za trojnásobek."""
        poskozeni, popis = super().utoc()
        if random.random() < 0.30:
            return poskozeni * 3, f"{self.emoji} {self.barva.title()} drak CHRLÍ OHEŇ"
        return poskozeni, popis

def schopnost(self):
        return "Ohnivý dech: 30% šance na trojnásobné poškození"

BESTIAR = [Skret(), Vlk(), Kostlivec(), Drak("zlatý")]

st.subheader("Všechny příšery")

for p in BESTIAR:
    with st.container(border=True):
        st.write(f"### {p.emoji} {p.jmeno}")
        a, b, c = st.columns(3)
        a.metric("❤️ Životy", p.max_zivoty)
        b.metric("💪 Síla", p.sila)
        c.metric("💰 Zlato", p.zlato)

schopnost = p.schopnost()
        if schopnost:
            st.info(f"⭐ {schopnost}")
        else:
            st.caption("Žádná zvláštní schopnost.")

st.divider()

st.subheader("Test útoků")
st.caption("Každá příšera zaútočí desetkrát. Sleduj rozdíly.")

if st.button("🎲 Otestovat"):
    for p in BESTIAR:
        utoky = []
        for _ in range(10):
            poskozeni, _ = p.utoc()
            utoky.append(poskozeni)

st.write(
            f"{p.emoji} **{p.jmeno}**: {utoky} — "
            f"průměr {sum(utoky) / len(utoky):.1f}, max {max(utoky)}"
        )

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í 1 — Rodina příšer (15 min)3. Cvičení na hodinu

Zadání:

Napiš rodičovskou třídu Prisera se jménem, životy, silou a emoji

Přidej metodu zvuk(self) vracející "..."

Vytvoř tři potomky: Skret, Vlk, Kostlivec

V každém potomkovi zavolej super().__init__(...) s vlastními hodnotami

Přepiš zvuk() v každém potomkovi a vypiš je cyklem

Úroveň	Co má zvládnout
Minimum	Body 1–3
Rozšíření	Bod 4
Výzva	Bod 5 + přidat čtvrtou příšeru bez úpravy zbytku kódu

cviceni/cviceni1_rodina.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

Očekávaný výsledek: tři příšery, každá vydává jiný zvuk.

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

reseni/reseni1_rodina.py

import streamlit as st

class Prisera:
    """Základní příšera."""

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

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

def zvuk(self):
        return "..."

def __str__(self):
        return f"{self.emoji} {self.jmeno} ({self.zivoty} HP, síla {self.sila})"

class Skret(Prisera):
    def __init__(self):
        super().__init__("Skřet", 30, 8, "👺")

def zvuk(self):
        return "Grrrr! Rozbiju ti hlavu!"

class Vlk(Prisera):
    def __init__(self):
        super().__init__("Vlk", 20, 12, "🐺")

def zvuk(self):
        return "Aúúúú! Smečka je blízko."

class Kostlivec(Prisera):
    def __init__(self):
        super().__init__("Kostlivec", 40, 10, "💀")

def zvuk(self):
        return "Klap klap klap..."

class Slizoun(Prisera):
    def __init__(self):
        super().__init__("Slizoun", 15, 5, "🟢")

def zvuk(self):
        return "Blublublub..."

st.title("👹 Rodina příšer")

bestiar = [Skret(), Vlk(), Kostlivec(), Slizoun()]

for p in bestiar:
    with st.container(border=True):
        st.subheader(f"{p.emoji} {p.jmeno}")
        a, b = st.columns(2)
        a.metric("❤️ Životy", p.zivoty)
        b.metric("💪 Síla", p.sila)
        st.info(f"💬 {p.zvuk()}")

st.divider()

st.subheader("Polymorfismus")
st.code(
    "for p in bestiar:\n"
    "    st.write(p.zvuk())"
)
for p in bestiar:
    st.text(f"{p.jmeno:<12} → {p.zvuk()}")

st.success(
    "Metodu `je_ziva()` nemá napsanou ani jedna z příšer. "
    "Zdědily ji od rodiče."
)

st.caption(f"Kontrola zděděné metody: Skřet je živý? {bestiar[0].je_ziva()}")

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í 2 — Speciální schopnosti (20 min)3. Cvičení na hodinu

Zadání:

Přidej rodiči metodu utoc(self) vracející sila + hod kostkou

Ve třídě Vlk přepiš utoc tak, aby útočil dvakrát

Ve třídě Kostlivec přepiš prijmi_poskozeni na poloviční poškození

Použij v přepsaných metodách super(), ne kopírování kódu

Otestuj: nech každou příšeru desetkrát zaútočit a vypiš průměr

Úroveň	Co má zvládnout
Minimum	Body 1–2
Rozšíření	Body 3–4
Výzva	Bod 5 + přidat draka s 30% šancí na trojnásobný útok

cviceni/cviceni2_schopnosti.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

Očekávaný výsledek: čísla ukazují, že schopnosti opravdu fungují.

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

reseni/reseni2_schopnosti.py

import random

import streamlit as st

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

def utoc(self):
        return self.sila + random.randint(1, 6)

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

def schopnost(self):
        return "žádná"

class Skret(Prisera):
    def __init__(self):
        super().__init__("Skřet", 30, 8, "👺")

class Vlk(Prisera):
    def __init__(self):
        super().__init__("Vlk", 20, 12, "🐺")

def utoc(self):
        """Útočí dvakrát — použije rodičovský útok dvakrát."""
        return super().utoc() + super().utoc()

def schopnost(self):
        return "útočí dvakrát za kolo"

class Kostlivec(Prisera):
    def __init__(self):
        super().__init__("Kostlivec", 40, 10, "💀")

def prijmi_poskozeni(self, kolik):
        """Kostěná zbroj pohltí polovinu."""
        super().prijmi_poskozeni(kolik // 2)

def schopnost(self):
        return "přijímá jen poloviční poškození"

class Drak(Prisera):
    def __init__(self):
        super().__init__("Drak", 200, 40, "🐉")

def utoc(self):
        """30% šance na trojnásobný ohnivý dech."""
        zaklad = super().utoc()
        if random.random() < 0.30:
            return zaklad * 3
        return zaklad

def schopnost(self):
        return "30% šance na trojnásobný útok"

st.title("⭐ Speciální schopnosti")

BESTIAR = [Skret(), Vlk(), Kostlivec(), Drak()]

for p in BESTIAR:
    st.write(f"{p.emoji} **{p.jmeno}** — {p.schopnost()}")

st.divider()

pocet = st.slider("Kolik útoků otestovat?", 10, 500, 50)

if st.button("🎲 Otestovat útoky"):
    for p in BESTIAR:
        utoky = []
        for _ in range(pocet):
            utoky.append(p.utoc())

st.write(
            f"{p.emoji} **{p.jmeno}** — průměr "
            f"**{sum(utoky) / len(utoky):.1f}**, "
            f"min {min(utoky)}, max {max(utoky)}"
        )
        st.bar_chart(utoky[:50])

st.divider()

st.subheader("Test obrany kostlivce")

poskozeni = st.slider("Kolik mu dáš poškození?", 1, 50, 20)

if st.button("👊 Zaútočit na kostlivce a skřeta"):
    k = Kostlivec()
    s = Skret()

k.prijmi_poskozeni(poskozeni)
    s.prijmi_poskozeni(poskozeni)

a, b = st.columns(2)
    a.metric("💀 Kostlivec", f"{k.zivoty}/{k.max_zivoty}",
             delta=k.zivoty - k.max_zivoty)
    b.metric("👺 Skřet", f"{s.zivoty}/{s.max_zivoty}",
             delta=s.zivoty - s.max_zivoty)

st.info(f"Oba dostali {poskozeni}, ale kostlivec ztratil jen polovinu.")

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í 3 — Typy hrdinů (20 min)3. Cvičení na hodinu

Zadání:

Napiš rodiče Hrdina s životy, silou, magií a metodou utoc()

Vytvoř Bojovnik, který má víc životů a útočí silou

Vytvoř Kouzelnik, který má míň životů a útočí magií

Vytvoř Lupic, který má 25% šanci na dvojnásobné poškození

Nech uživatele vybrat typ hrdiny a vytvoř odpovídající objekt

Úroveň	Co má zvládnout
Minimum	Body 1–3
Rozšíření	Bod 4
Výzva	Bod 5 + porovnat všechny tři v tabulce

cviceni/cviceni3_hrdinove.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

Očekávaný výsledek: výběr povolání vytvoří objekt s jiným chováním.

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

reseni/reseni3_hrdinove.py

import random

import streamlit as st

class Hrdina:
    """Základní hrdina."""

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

def utoc(self):
        """Vrátí (poškození, popis)."""
        hod = random.randint(1, 6)
        return self.sila + hod, f"útočí za {self.sila + hod}"

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

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

def schopnost(self):
        return "žádná zvláštní schopnost"

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

class Bojovnik(Hrdina):
    def __init__(self, jmeno):
        super().__init__(jmeno, zivoty=140, sila=16, magie=4, emoji="🗡️")

def schopnost(self):
        return "Hodně životů a silný útok mečem"

class Kouzelnik(Hrdina):
    def __init__(self, jmeno):
        super().__init__(jmeno, zivoty=70, sila=5, magie=20, emoji="🧙")

def utoc(self):
        """Útočí magií místo síly."""
        hod = random.randint(1, 6)
        poskozeni = self.magie + hod
        return poskozeni, f"sesílá kouzlo za {poskozeni}"

def schopnost(self):
        return "Útočí magií, která je mnohem silnější než jeho síla"

class Lupic(Hrdina):
    def __init__(self, jmeno):
        super().__init__(jmeno, zivoty=90, sila=12, magie=8, emoji="🥷")

def utoc(self):
        """25% šance na zákeřný úder za dvojnásobek."""
        poskozeni, popis = super().utoc()
        if random.random() < 0.25:
            return poskozeni * 2, f"ZÁKEŘNÝ ÚDER za {poskozeni * 2}!"
        return poskozeni, popis

def schopnost(self):
        return "25% šance na dvojnásobné poškození"

st.title("🧙 Typy hrdinů")

jmeno = st.text_input("Jméno hrdiny", "Arkon")
typ = st.radio("Povolání", ["Bojovník", "Kouzelník", "Lupič"], horizontal=True)

if typ == "Bojovník":
    hrdina = Bojovnik(jmeno)
elif typ == "Kouzelník":
    hrdina = Kouzelnik(jmeno)
else:
    hrdina = Lupic(jmeno)

st.divider()

st.header(f"{hrdina.emoji} {hrdina.jmeno}")

a, b, c = st.columns(3)
a.metric("❤️ Životy", hrdina.max_zivoty)
b.metric("💪 Síla", hrdina.sila)
c.metric("✨ Magie", hrdina.magie)

st.info(f"⭐ {hrdina.schopnost()}")

st.divider()

st.subheader("Porovnání všech tří")

vsichni = [Bojovnik(jmeno), Kouzelnik(jmeno), Lupic(jmeno)]

tabulka = []
for h in vsichni:
    utoky = []
    for _ in range(200):
        p, _ = h.utoc()
        utoky.append(p)

tabulka.append({
        "Povolání": type(h).__name__,
        "Životy": h.max_zivoty,
        "Síla": h.sila,
        "Magie": h.magie,
        "Průměrný útok": round(sum(utoky) / len(utoky), 1),
        "Nejvyšší útok": max(utoky),
    })

st.dataframe(tabulka, use_container_width=True)
st.caption("Průměr počítán z 200 útoků každého typu.")

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í 4 — Souboj napříč třídami (20 min)3. Cvičení na hodinu

Zadání:

Nech uživatele vybrat typ hrdiny a typ příšery

Vytvoř oba objekty a ulož je do session_state

Tlačítkem proveď kolo souboje — obě strany zaútočí svou metodou

Do logu zapisuj popisy útoků, které metody vracejí

Po vítězství přidej hrdinovi zlato příšery

Úroveň	Co má zvládnout
Minimum	Body 1–3
Rozšíření	Bod 4
Výzva	Bod 5 + statistika, kolik kol souboj trval

cviceni/cviceni4_souboj_typu.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

Očekávaný výsledek: libovolná kombinace hrdiny a příšery funguje.

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

reseni/reseni4_souboj_typu.py

import random

import streamlit as st

class Bojujici:
    """Společný základ pro hrdiny i příšery."""

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):
        poskozeni = self.sila + random.randint(1, 6)
        cil.prijmi_poskozeni(poskozeni)
        return f"{self.emoji} {self.jmeno} útočí za {poskozeni}"

class Bojovnik(Bojujici):
    def __init__(self, jmeno="Hrdina"):
        super().__init__(jmeno, 140, 16, "🗡️")

class Kouzelnik(Bojujici):
    def __init__(self, jmeno="Hrdina"):
        super().__init__(jmeno, 70, 20, "🧙")

class Lupic(Bojujici):
    def __init__(self, jmeno="Hrdina"):
        super().__init__(jmeno, 90, 12, "🥷")

def utoc(self, cil):
        if random.random() < 0.25:
            poskozeni = (self.sila + random.randint(1, 6)) * 2
            cil.prijmi_poskozeni(poskozeni)
            return f"{self.emoji} {self.jmeno} ZÁKEŘNĚ útočí za {poskozeni}!"
        return super().utoc(cil)

class Skret(Bojujici):
    def __init__(self):
        super().__init__("Skřet", 30, 8, "👺")
        self.zlato = 25

class Kostlivec(Bojujici):
    def __init__(self):
        super().__init__("Kostlivec", 40, 10, "💀")
        self.zlato = 40

def prijmi_poskozeni(self, kolik):
        super().prijmi_poskozeni(kolik // 2)

class Drak(Bojujici):
    def __init__(self):
        super().__init__("Drak", 150, 25, "🐉")
        self.zlato = 500

def utoc(self, cil):
        if random.random() < 0.30:
            poskozeni = (self.sila + random.randint(1, 6)) * 3
            cil.prijmi_poskozeni(poskozeni)
            return f"{self.emoji} Drak CHRLÍ OHEŇ za {poskozeni}!"
        return super().utoc(cil)

HRDINOVE = {"Bojovník": Bojovnik, "Kouzelník": Kouzelnik, "Lupič": Lupic}
PRISERY = {"Skřet": Skret, "Kostlivec": Kostlivec, "Drak": Drak}

st.title("⚔️ Souboj napříč třídami")

a, b = st.columns(2)
typ_h = a.selectbox("Hrdina", list(HRDINOVE.keys()))
typ_p = b.selectbox("Příšera", list(PRISERY.keys()))

if st.button("🎬 Začít souboj"):
    st.session_state.h = HRDINOVE[typ_h]("Arkon")
    st.session_state.p = PRISERY[typ_p]()
    st.session_state.log = []
    st.session_state.kolo = 0
    st.session_state.zlato = 0
    st.rerun()

if "h" in st.session_state:
    h = st.session_state.h
    p = st.session_state.p

st.divider()

x, y = st.columns(2)
    with x:
        st.subheader(f"{h.emoji} {h.jmeno}")
        st.metric("Životy", f"{h.zivoty}/{h.max_zivoty}")
        st.progress(h.zivoty / h.max_zivoty)
    with y:
        st.subheader(f"{p.emoji} {p.jmeno}")
        st.metric("Životy", f"{p.zivoty}/{p.max_zivoty}")
        st.progress(p.zivoty / p.max_zivoty)

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

if h.je_zivy() and p.je_zivy():
        if st.button("⚔️ Kolo souboje"):
            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():
        if st.session_state.zlato == 0:
            st.session_state.zlato = p.zlato
        st.success(
            f"🏆 {h.jmeno} zvítězil po {st.session_state.kolo} kolech "
            f"a získal {st.session_state.zlato} zlata!"
        )
        st.balloons()
    else:
        st.error(f"💀 {h.jmeno} padl v {st.session_state.kolo}. kole.")

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

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 17Cvičení 5 — PyQuest: bestiář a povolání (25 min)3. Cvičení na hodinu

Zadání:

Převeď hrdinu na rodiče Hrdina a přidej tři povolání jako potomky

Vytvoř bestiář jako seznam tříd příšer

Při výpravě náhodně vyber příšeru a proveď souboj

Výsledek souboje zapiš do deníku včetně typu příšery

Zobraz v postranním panelu typ hrdiny a jeho zvláštní schopnost

Úroveň	Co má zvládnout
Minimum	Body 1–2
Rozšíření	Body 3–4
Výzva	Bod 5 + přidat bosse, který se objeví po deseti výpravách

cviceni/cviceni5_pyquest_bestiar.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

Očekávaný výsledek: hra s výběrem povolání a různorodými nepřáteli.

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

reseni/reseni5_pyquest_bestiar.py

import random

import streamlit as st

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

class Bojujici:
    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 sila_utoku(self):
        return self.sila + random.randint(1, 6)

class Hrdina(Bojujici):
    def __init__(self, jmeno, zivoty, sila, emoji):
        super().__init__(jmeno, zivoty, sila, emoji)
        self.zlato = 50
        self.inventar = ["meč"]
        self.vypravy = 0

def schopnost(self):
        return "žádná zvláštní schopnost"

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

class Bojovnik(Hrdina):
    def __init__(self, jmeno):
        super().__init__(jmeno, 140, 16, "🗡️")

def schopnost(self):
        return "Nejvíc životů v celé říši"

class Kouzelnik(Hrdina):
    def __init__(self, jmeno):
        super().__init__(jmeno, 70, 22, "🧙")

def schopnost(self):
        return "Nejsilnější útok, ale málo životů"

class Lupic(Hrdina):
    def __init__(self, jmeno):
        super().__init__(jmeno, 95, 12, "🥷")

def sila_utoku(self):
        zaklad = super().sila_utoku()
        if random.random() < 0.25:
            return zaklad * 2
        return zaklad

def schopnost(self):
        return "25% šance na zákeřný úder za dvojnásobek"

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

class Skret(Prisera):
    def __init__(self):
        super().__init__("Skřet", 30, 8, 25, "👺")

class Vlk(Prisera):
    def __init__(self):
        super().__init__("Vlk", 22, 11, 20, "🐺")

def sila_utoku(self):
        return super().sila_utoku() + super().sila_utoku()

class Kostlivec(Prisera):
    def __init__(self):
        super().__init__("Kostlivec", 45, 10, 45, "💀")

def prijmi_poskozeni(self, kolik):
        super().prijmi_poskozeni(kolik // 2)

class Drak(Prisera):
    def __init__(self):
        super().__init__("Drak", 180, 28, 600, "🐉")

def sila_utoku(self):
        zaklad = super().sila_utoku()
        if random.random() < 0.30:
            return zaklad * 3
        return zaklad

POVOLANI = {"Bojovník": Bojovnik, "Kouzelník": Kouzelnik, "Lupič": Lupic}
BESTIAR = [Skret, Vlk, Kostlivec]

st.title("⚔️ PyQuest")

if "hrdina" not in st.session_state:
    st.subheader("Vyber si hrdinu")
    jmeno = st.text_input("Jméno", "Arkon")
    typ = st.radio("Povolání", list(POVOLANI.keys()), horizontal=True)

ukazka = POVOLANI[typ](jmeno)
    a, b = st.columns(2)
    a.metric("❤️ Životy", ukazka.max_zivoty)
    b.metric("💪 Síla", ukazka.sila)
    st.info(f"⭐ {ukazka.schopnost()}")

if st.button("🎬 Začít dobrodružství"):
        st.session_state.hrdina = POVOLANI[typ](jmeno)
        st.session_state.denik = []
        st.rerun()

else:
    h = st.session_state.hrdina

with st.sidebar:
        st.header(f"{h.emoji} {h.jmeno}")
        st.caption(type(h).__name__)
        st.metric("❤️ Životy", f"{h.zivoty}/{h.max_zivoty}")
        st.metric("💰 Zlato", h.zlato)
        st.metric("🗺️ Výprav", h.vypravy)
        st.progress(h.zivoty / h.max_zivoty)
        st.info(f"⭐ {h.schopnost()}")
        st.write(f"🎒 {', '.join(h.inventar)}")

if st.button("🧪 Odpočinek (+25 HP, −15 zlata)"):
            if h.zlato >= 15:
                h.zlato -= 15
                h.uzdrav(25)
                st.rerun()

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:
        if h.vypravy >= 10:
            st.warning("🐉 Ve věži se probudil DRAK. Tohle bude těžké.")

if st.button("🚶 Vyrazit na výpravu"):
            h.vypravy += 1

if h.vypravy >= 10 and random.random() < 0.4:
                p = Drak()
            else:
                p = random.choice(BESTIAR)()

kolo = 0
            while h.je_zivy() and p.je_zivy() and kolo < 50:
                kolo += 1
                p.prijmi_poskozeni(h.sila_utoku())
                if p.je_zivy():
                    h.prijmi_poskozeni(p.sila_utoku())

if p.je_zivy():
                st.session_state.denik.append(
                    f"{h.vypravy}. 💀 {p.emoji} {p.jmeno} porazil hrdinu"
                )
            else:
                h.zlato += p.zlato
                st.session_state.denik.append(
                    f"{h.vypravy}. ✅ Porazil {p.emoji} {p.jmeno} "
                    f"za {kolo} kol, +{p.zlato} zlata"
                )

st.rerun()

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

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 18Domácí úkol na příští hodinu4. Domácí úkol

Přidej do bestiáře vlastní příšeru s nějakou zvláštní schopností, kterou vytvoříš přepsáním metody. Například příšera, která se po každém kole trochu uzdraví, nebo která má šanci útok úplně minout. Napiš do komentáře, kterou metodu jsi přepsal a proč.

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_ukol14.py

import random

import streamlit as st

st.set_page_config(page_title="PyQuest — domácí úkol 14", page_icon="👹")
st.title("👹 Vlastní příšera v bestiáři")

class Bojujici:
    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 sila_utoku(self):
        return self.sila + random.randint(1, 6)

class Hrdina(Bojujici):
    def __init__(self, jmeno="Arkon"):
        super().__init__(jmeno, 105, 14, "🧙")
        self.zlato = 80
        self.vypravy = 0
        self.denik = []

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

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

def schopnost(self):
        return "žádná"

class Skret(Prisera):
    def __init__(self):
        super().__init__("Skřet", 35, 9, 25, "👺")

class MlznaCarodejka(Prisera):
    def __init__(self):
        super().__init__("Mlžná čarodějka", 85, 14, 90, "🌫️")

# Přepsal jsem metodu `prijmi_poskozeni`, aby měla šanci útok úplně minout.
    def prijmi_poskozeni(self, kolik):
        if random.random() < 0.30:
            return
        super().prijmi_poskozeni(kolik)

# Přepsal jsem metodu `sila_utoku`, aby občas udeřila výrazně silněji.
    def sila_utoku(self):
        zaklad = super().sila_utoku()
        if random.random() < 0.25:
            return zaklad * 2
        return zaklad

def schopnost(self):
        return "30 % šance vyhnout se zásahu, 25 % šance na dvojnásobný útok"

BESTIAR = [Skret, MlznaCarodejka]

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

h = st.session_state.hrdina

with st.sidebar:
    st.subheader(f"{h.emoji} {h.jmeno}")
    a, b, c = st.columns(3)
    a.metric("❤️", f"{h.zivoty}/{h.max_zivoty}")
    b.metric("💰", h.zlato)
    c.metric("🗺️", h.vypravy)
    st.progress(h.zivoty / h.max_zivoty)

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

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

st.subheader("Bestiář")
for trida_prisery in BESTIAR:
    p = trida_prisery()
    with st.container(border=True):
        st.write(f"{p.emoji} **{p.jmeno}**")
        st.caption(f"Schopnost: {p.schopnost()}")
        st.write(f"Životy: {p.zivoty}/{p.max_zivoty}, síla: {p.sila}")

if not h.je_zivy():
    st.error(f"💀 {h.jmeno} padl po {h.vypravy} výpravách.")
elif st.button("⚔️ Vyrazit na výpravu"):
    h.vypravy += 1
    nepritel = random.choice(BESTIAR)()

kolo = 0
    while h.je_zivy() and nepritel.je_zivy() and kolo < 30:
        kolo += 1
        nepritel.prijmi_poskozeni(h.sila_utoku())
        if nepritel.je_zivy():
            h.prijmi_poskozeni(nepritel.sila_utoku())

if nepritel.je_zivy():
        h.denik.append(f"{h.vypravy}. ❌ {nepritel.emoji} {nepritel.jmeno} hrdinu porazil")
    else:
        h.zlato += nepritel.zlato
        h.denik.append(
            f"{h.vypravy}. ✅ Porazil jsi {nepritel.emoji} {nepritel.jmeno}, +{nepritel.zlato} zlata"
        )
    st.rerun()

st.divider()
st.subheader("📜 Deník")
if h.denik:
    st.text("\n".join(reversed(h.denik[-10:])))
else:
    st.caption("Zatím žádná výprava.")

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 19Oficiální dokumentace4. Domácí úkol

Oficiální dokumentace se hodí, když si chceš ověřit, jak Python dědí třídy, jak funguje super() nebo kdy použít isinstance(). Je v angličtině, ale i krátké ukázky a názvy metod ti často rychle napoví.

Co jsme použili	Oficiální dokumentace	Co tam najdeš
třídy a objekty	Classes	základ práce s třídami, metodami a instancemi
dědičnost	Inheritance	jak odvozovat třídy a přepisovat jejich chování
`super()`	`super`	zavolání rodičovského konstruktoru nebo metody
`isinstance()`	`isinstance`	ověření, jestli objekt patří do dané třídy
přepsání metod	A First Look at Classes	jak třídy skládají data a chování do společného základu

Cvičení	Odkaz	Proč se hodí
Kódování a modelování	umimeinformatiku.cz	Hierarchie a klasifikace
Algoritmické myšlení	umimeinformatiku.cz	Zobecňování
Programování v Pythonu	umimeinformatiku.cz	Struktura kódu
Týmovka	umimeinformatiku.cz	Společné řešení problému

Dědičnost — bestiář na třídách

1. Vysvětlení a souvislosti

2. Ukázky pro projekci

3. Cvičení na hodinu

4. Domácí úkol

5. Umíme informatiku