10. Funkce — úklid v kódu

Blok 1Motivace: kód, který se opakuje1. Část pro učitele

Podívej se na tenhle případ:

Vidíš, jak je to skoro stejné? Liší se jen čísla. A když budeš chtít změnit způsob počítání, musíš to opravit na všech místech. A někde na to zapomeneš. To se stane vždycky.

Funkce je pojmenovaný recept. Napíšeš ho jednou a používáš kdykoliv. Když ho potřebuješ opravit, opravíš ho na jednom místě.

Blok 2Anatomie funkce1. Část pro učitele

Pojmenujte části přesně a držte se toho celý rok:

Část	Co to je
`def`	klíčové slovo „definuji funkci"
`pozdrav`	název, který si vymyslíš
`jmeno`	parametr — proměnná uvnitř funkce
`"Arkon"`	argument — konkrétní hodnota při volání
`return`	co funkce vrátí zpět

Definice funkci jen popíše. Nic se nestane, dokud ji nezavoláš. Je to jako recept v kuchařce — dokud podle něj nevaříš, žádné jídlo nemáš.

Blok 3return versus print/st.write1. Část pro učitele

Tohle je koncepčně nejtěžší část hodiny. Podívej se na obě verze vedle sebe:

st.write je jako říct výsledek nahlas — zazní a je pryč. return je jako podat ho v ruce — můžeš s ním pokračovat.

Když funkce nemá return, vrací None. To je „nic".

Pravidlo: funkce, která něco počítá, má vždycky return.

Blok 4Několik parametrů a výchozí hodnoty1. Část pro učitele

Parametr s = je nepovinný. Když ho nepředáš, použije se výchozí hodnota. Pojmenované argumenty jsou čitelnější — hlavně když je jich hodně.

Pravidlo: parametry s výchozí hodnotou musí být až za těmi bez ní.

Blok 5return několika hodnot1. Část pro učitele

def souboj(hrdina_hp, prisera_hp):
    ...
    return hrdina_hp, prisera_hp, kolo

h, p, kolo = souboj(100, 80)

Python umí vrátit víc věcí najednou — oddělíš je čárkou. Při přebírání je zase rozbalíš do tří proměnných.

Blok 6Rozsah platnosti (scope)1. Část pro učitele

def neco():
    x = 5          # x existuje JEN uvnitř funkce
    st.write(x)

neco()
st.write(x)        # NameError: name 'x' is not defined

Proměnná vytvořená ve funkci uvnitř funkce zůstane. Venku o ní nikdo neví. Je to dobře — funkce ti nerozhází zbytek programu.

Naopak číst zvenku jde:

Konstanty psané VELKÝMI písmeny je běžné číst přímo. Ale hodnoty, které se mění, si funkci raději předej jako parametr.

Blok 7Docstring — popis funkce1. Část pro učitele

Text v trojitých uvozovkách hned pod def je popis funkce. VS Code ti ho ukáže, když na funkci najedeš myší. Piš je česky, pro sebe.

Blok 8Jak poznat, že je čas na funkci1. Část pro učitele

Tři jasná pravidla:

Píšu to samé podruhé → funkce
Ten blok kódu jde pojmenovat jednou větou → funkce
Kód je delší než obrazovka → rozdělit na funkce

Dobrá funkce dělá jednu věc a její název to říká. Když musíš do názvu dát „a" (spocitej_a_vypis), jsou to nejspíš funkce dvě.

Blok 9Funkce a Streamlit1. Část pro učitele

Funkce může obsahovat Streamlit prvky — to je velmi užitečné:

def zobraz_hrdinu(h):
    st.subheader(f"🧙 {h['jmeno']}")
    a, b = st.columns(2)
    a.metric("Životy", h["zivoty"])
    b.metric("Zlato", h["zlato"])

zobraz_hrdinu(st.session_state.hrdina)

Takhle si uděláš vlastní „komponentu". Zavoláš ji kdekoliv a vypadá to všude stejně.

Pozor na widgety uvnitř funkce volané víckrát → DuplicateWidgetID. Řešení: parametr key.

Poznámky pro učiteleTechnické pozadí pro učitele1. Část pro učitele

Python předává argumenty odkazem na objekt. U neměnných typů (int, str) se tedy změna uvnitř neprojeví venku, u list a dict ano. Tohle děti překvapí a je dobré to jednou ukázat.
Nikdy nepoužívejte měnitelný objekt jako výchozí hodnotu (def f(x=[])) — vytvoří se jen jednou a sdílí se mezi voláními. Klasická past.
global existuje, ale ve výuce ho nepoužívejte. Vede k nepřehlednému kódu. Místo toho: předat parametrem, vrátit return.
Analogie pro C#: def bez typů odpovídá metodě, výchozí hodnoty fungují stejně jako optional parameters, return a, b je jako vrácení tuple.

Poznámky pro učiteleČasté chyby1. Část pro učitele

Chyba	Příčina	Řešení
Funkce vrací `None`	Chybí `return`	Doplnit `return`
`NameError` u proměnné z funkce	Lokální rozsah	Vrátit přes `return`
`TypeError: missing 1 required argument`	Málo argumentů	Doplnit nebo dát výchozí hodnotu
Funkce se neprovede	Jen definovaná, nezavolaná	Přidat `funkce()`
`DuplicateWidgetID`	Widget ve funkci volané 2×	Přidat parametr `key`
Změna seznamu se projeví venku	Seznam je odkaz	Předat `seznam.copy()`

Blok 10Ukázka 1 — Před a po zavedení funkce2. Ukázky pro projekci

demo/demo1_proc_funkce.py

import streamlit as st

st.title("Proč funkce")

levy, pravy = st.columns(2)

with levy:
    st.subheader("❌ Bez funkce")
    st.code(
        "if misto == 'Les':\n"
        "    hp -= 7\n"
        "    zlato += 30\n"
        "elif misto == 'Jeskyně':\n"
        "    hp -= 15\n"
        "    zlato += 80\n"
        "elif misto == 'Věž':\n"
        "    hp -= 23\n"
        "    zlato += 200"
    )
    st.error("Opakuje se to. Změna = tři opravy.")

with pravy:
    st.subheader("✅ S funkcí")
    st.code(
        "def vyprava(hp, zlato, ztrata, odmena):\n"
        "    return hp - ztrata, zlato + odmena\n"
        "\n"
        "hp, zlato = vyprava(hp, zlato, 7, 30)"
    )
    st.success("Jedno místo. Jedna oprava.")

st.divider()

st.subheader("Vyzkoušej si to")

def vyprava(hp, zlato, ztrata, odmena):
    """Vrátí nové životy a zlato po výpravě."""
    return hp - ztrata, zlato + odmena

hp = st.slider("Životy před", 0, 100, 100)
zlato = st.slider("Zlato před", 0, 500, 50)
ztrata = st.slider("Ztráta životů", 0, 50, 15)
odmena = st.slider("Odměna", 0, 300, 80)

novy_hp, nove_zlato = vyprava(hp, zlato, ztrata, odmena)

a, b = st.columns(2)
a.metric("❤️ Životy", novy_hp, delta=novy_hp - hp)
b.metric("💰 Zlato", nove_zlato, delta=nove_zlato - zlato)

st.code(f"vyprava({hp}, {zlato}, {ztrata}, {odmena})  ->  ({novy_hp}, {nove_zlato})")

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 — return versus st.write2. Ukázky pro projekci

demo/demo2_return.py

import streamlit as st

st.title("return vs. st.write")

def soucet_vypis(a, b):
    """Jen vypíše. Nic nevrací."""
    st.write(f"Součet je {a + b}")

def soucet_vrat(a, b):
    """Vrátí výsledek, dá se s ním pracovat dál."""
    return a + b

a = st.number_input("První číslo", 0, 100, 12)
b = st.number_input("Druhé číslo", 0, 100, 8)

st.divider()

levy, pravy = st.columns(2)

with levy:
    st.subheader("Funkce bez return")
    st.code("def soucet_vypis(a, b):\n    st.write(a + b)")
    vysledek1 = soucet_vypis(int(a), int(b))
    st.write("Co vrátila:", vysledek1)
    st.error("Vrátila None. Nemůžeš s tím počítat.")

with pravy:
    st.subheader("Funkce s return")
    st.code("def soucet_vrat(a, b):\n    return a + b")
    vysledek2 = soucet_vrat(int(a), int(b))
    st.write("Co vrátila:", vysledek2)
    st.success(f"Můžeš počítat dál: vysledek * 10 = {vysledek2 * 10}")

st.divider()

st.subheader("Výchozí hodnoty parametrů")

def utok(sila, bonus=0, kriticky=False):
    """Spočítá poškození útoku."""
    poskozeni = sila + bonus
    if kriticky:
        poskozeni *= 2
    return poskozeni

st.code(
    f"utok(10)                     ->  {utok(10)}\n"
    f"utok(10, 5)                  ->  {utok(10, 5)}\n"
    f"utok(10, 5, True)            ->  {utok(10, 5, True)}\n"
    f"utok(sila=10, kriticky=True) ->  {utok(sila=10, kriticky=True)}"
)

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 — Vlastní komponenty ze Streamlitu2. Ukázky pro projekci

demo/demo3_komponenty.py

import streamlit as st

st.set_page_config(page_title="Komponenty", page_icon="🧩")
st.title("🧩 Vlastní komponenty")

def karta_postavy(jmeno, zivoty, sila, emoji="🧙", max_hp=100):
    """Vykreslí jednotnou kartu postavy."""
    st.subheader(f"{emoji} {jmeno}")
    a, b = st.columns(2)
    a.metric("❤️ Životy", f"{zivoty}/{max_hp}")
    b.metric("💪 Síla", sila)
    st.progress(min(zivoty / max_hp, 1.0))

def stav_textem(zivoty, max_hp=100):
    """Vrátí slovní popis stavu."""
    podil = zivoty / max_hp
    if podil <= 0:
        return "mrtvý"
    if podil < 0.3:
        return "kriticky zraněný"
    if podil < 0.7:
        return "zraněný"
    return "v pořádku"

DRUZINA = [
    {"jmeno": "Arkon", "zivoty": 85, "sila": 15, "emoji": "🧙"},
    {"jmeno": "Bela", "zivoty": 40, "sila": 12, "emoji": "🏹"},
    {"jmeno": "Cedrik", "zivoty": 18, "sila": 20, "emoji": "🗡️"},
]

st.caption("Tři karty, jeden kód. Funkce se volá třikrát.")

for clen in DRUZINA:
    karta_postavy(
        clen["jmeno"], clen["zivoty"], clen["sila"], clen["emoji"]
    )
    st.caption(f"Stav: {stav_textem(clen['zivoty'])}")
    st.divider()

st.subheader("Kód komponenty")
st.code(
    "def karta_postavy(jmeno, zivoty, sila, emoji='🧙', max_hp=100):\n"
    "    st.subheader(f'{emoji} {jmeno}')\n"
    "    a, b = st.columns(2)\n"
    "    a.metric('Životy', f'{zivoty}/{max_hp}')\n"
    "    b.metric('Síla', sila)\n"
    "    st.progress(min(zivoty / max_hp, 1.0))"
)

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 — První funkce (15 min)3. Cvičení na hodinu

Zadání:

Napiš funkci pozdrav(jmeno), která vrátí uvítací větu

Zavolej ji s textem z st.text_input a výsledek zobraz

Přidej druhý parametr povolani s výchozí hodnotou „poutník"

Napiš funkci sila_utoku(sila, zbran_bonus), která vrátí součet

Ukaž, co se stane, když funkce nemá return — vypiš návratovou hodnotu

Úroveň	Co má zvládnout
Minimum	Body 1–2
Rozšíření	Body 3–4
Výzva	Bod 5 + napsat funkci vracející dvě hodnoty

Očekávaný výsledek: funkce se volají s různými argumenty a vracejí výsledky.

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

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

reseni/reseni1_prvni_funkce.py

import streamlit as st

def pozdrav(jmeno, povolani="poutník"):
    """Vrátí uvítací větu pro hrdinu."""
    return f"Vítej v Eldorii, {jmeno}! Jsi {povolani}."

def sila_utoku(sila, zbran_bonus=0):
    """Spočítá celkovou sílu útoku."""
    return sila + zbran_bonus

def bez_returnu(a, b):
    """Jen vypíše, nic nevrací."""
    st.write(f"Součet: {a + b}")

def statistiky(cisla):
    """Vrátí součet a průměr najednou."""
    return sum(cisla), sum(cisla) / len(cisla)

st.title("🔧 První funkce")

jmeno = st.text_input("Jméno hrdiny", "Arkon")
povolani = st.selectbox("Povolání", ["bojovník", "kouzelník", "lupič"])

st.success(pozdrav(jmeno, povolani))
st.info(pozdrav(jmeno))
st.caption("Druhé volání použilo výchozí hodnotu 'poutník'.")

st.divider()

sila = st.slider("Síla", 1, 20, 12)
bonus = st.slider("Bonus zbraně", 0, 15, 5)

st.metric("Síla útoku", sila_utoku(sila, bonus))
st.code(
    f"sila_utoku({sila})        ->  {sila_utoku(sila)}\n"
    f"sila_utoku({sila}, {bonus})     ->  {sila_utoku(sila, bonus)}"
)

st.divider()

st.subheader("Funkce bez return")
vysledek = bez_returnu(3, 4)
st.write("Návratová hodnota:", vysledek)
st.error("Je to None. Funkce bez `return` nic nevrací.")

st.divider()

st.subheader("Funkce vracející dvě hodnoty")
soucet, prumer = statistiky([10, 20, 30, 40])
st.code(f"soucet, prumer = statistiky([10, 20, 30, 40])\n"
        f"soucet = {soucet}, prumer = {prumer}")

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 — Kalkulačka poškození (20 min)3. Cvičení na hodinu

Zadání:

Napiš funkci poskozeni(sila, hod, obrana) vracející výsledné poškození

Poškození nesmí být záporné — použij max(0, ...)

Přidej nepovinný parametr kriticky=False, který poškození zdvojnásobí

Zavolej funkci se čtyřmi různými kombinacemi a všechny výsledky vypiš

Přidej funkci popis_zasahu(poskozeni), která vrátí slovní hodnocení

Úroveň	Co má zvládnout
Minimum	Body 1–2
Rozšíření	Body 3–4
Výzva	Bod 5 + spojit obě funkce dohromady

Očekávaný výsledek: tabulka útoků s hodnocením.

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

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

reseni/reseni2_kalkulacka.py

import streamlit as st

def poskozeni(sila, hod, obrana, kriticky=False):
    """Spočítá skutečné poškození. Nikdy není záporné."""
    zaklad = sila + hod - obrana
    if kriticky:
        zaklad = zaklad * 2
    return max(0, zaklad)

def popis_zasahu(hodnota):
    """Vrátí slovní hodnocení zásahu."""
    if hodnota == 0:
        return "🛡️ Odraženo!"
    if hodnota < 5:
        return "🤏 Jen škrábnutí."
    if hodnota < 15:
        return "👊 Slušný zásah."
    if hodnota < 30:
        return "💥 Tvrdá rána!"
    return "☄️ Zničující úder!"

st.title("🎯 Kalkulačka poškození")

sila = st.slider("Síla útočníka", 1, 30, 12)
hod = st.slider("Hod kostkou", 1, 6, 4)
obrana = st.slider("Obrana cíle", 0, 20, 5)
kriticky = st.checkbox("Kritický zásah (×2)")

vysledek = poskozeni(sila, hod, obrana, kriticky)

st.divider()
st.metric("Poškození", vysledek)
st.success(popis_zasahu(vysledek))

st.divider()

st.subheader("Čtyři různá volání")
priklady = [
    (10, 3, 2, False),
    (10, 3, 2, True),
    (5, 1, 20, False),
    (25, 6, 4, True),
]

for s, h, o, k in priklady:
    v = poskozeni(s, h, o, k)
    st.text(
        f"poskozeni({s:>2}, {h}, {o:>2}, {str(k):<5}) = {v:>3}   {popis_zasahu(v)}"
    )

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 — Knihovna funkcí pro hru (20 min)3. Cvičení na hodinu

Zadání:

Napiš stav_hrdiny(zivoty) vracející text podle počtu životů

Napiš cena_inventare(inventar, cenik) vracející celkovou cenu

Napiš nejsilnejsi(prisery) vracející slovník nejsilnější příšery

Napiš muze_do_veze(inventar, zivoty) vracející True nebo False

Všechny čtyři funkce vyzkoušej s ovládacími prvky

Úroveň	Co má zvládnout
Minimum	Body 1–2
Rozšíření	Body 3–4
Výzva	Bod 5 + přidat docstring ke každé funkci

Očekávaný výsledek: čtyři samostatné funkce, každá dělá jednu věc.

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

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

reseni/reseni3_knihovna.py

import streamlit as st

CENIK = {"meč": 50, "štít": 40, "lektvar": 15, "klíč": 40, "prsten": 300}

PRISERY = [
    {"jmeno": "Skřet", "sila": 8, "zlato": 25},
    {"jmeno": "Trol", "sila": 18, "zlato": 90},
    {"jmeno": "Drak", "sila": 40, "zlato": 500},
]

def stav_hrdiny(zivoty):
    """Vrátí slovní popis stavu podle počtu životů."""
    if zivoty <= 0:
        return "💀 mrtvý"
    if zivoty < 30:
        return "🩸 kriticky zraněný"
    if zivoty < 70:
        return "😰 zraněný"
    return "💪 v pořádku"

def cena_inventare(inventar, cenik):
    """Sečte cenu všech předmětů v inventáři."""
    celkem = 0
    for vec in inventar:
        celkem += cenik.get(vec, 10)
    return celkem

def nejsilnejsi(prisery):
    """Vrátí slovník nejsilnější příšery ze seznamu."""
    nej = prisery[0]
    for p in prisery:
        if p["sila"] > nej["sila"]:
            nej = p
    return nej

def muze_do_veze(inventar, zivoty):
    """Rozhodne, jestli hrdina smí do věže."""
    return "klíč" in inventar and zivoty > 50

st.title("📚 Knihovna funkcí")

zivoty = st.slider("Životy", 0, 100, 65)
inventar = st.multiselect(
    "Inventář", list(CENIK.keys()), default=["meč", "lektvar"]
)

st.divider()

a, b = st.columns(2)
a.metric("Stav hrdiny", stav_hrdiny(zivoty))
b.metric("💰 Cena inventáře", cena_inventare(inventar, CENIK))

nej = nejsilnejsi(PRISERY)
st.error(f"☠️ Nejsilnější příšera: **{nej['jmeno']}** (síla {nej['sila']})")

if muze_do_veze(inventar, zivoty):
    st.success("🏰 Do věže můžeš!")
else:
    st.warning("🔒 Do věže potřebuješ klíč a víc než 50 životů.")

st.divider()
st.caption("Každá funkce dělá právě jednu věc a má docstring.")

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 — Vlastní komponenta karty (20 min)3. Cvičení na hodinu

Zadání:

Napiš funkci karta(jmeno, zivoty, sila, emoji), která vykreslí kartu postavy

Použij v ní st.subheader, st.columns, st.metric a st.progress

Zavolej funkci cyklem pro celou družinu ze seznamu slovníků

Přidej nepovinný parametr max_hp=100 a použij ho v progress baru

Přidej barevný rámeček, jehož barva závisí na počtu životů

Úroveň	Co má zvládnout
Minimum	Body 1–3
Rozšíření	Bod 4
Výzva	Bod 5 s HTML a `unsafe_allow_html=True`

Očekávaný výsledek: tři stejně vypadající karty vygenerované jedním kódem.

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

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

reseni/reseni4_komponenta.py

import streamlit as st

DRUZINA = [
    {"jmeno": "Arkon", "zivoty": 85, "sila": 15, "emoji": "🧙"},
    {"jmeno": "Bela", "zivoty": 40, "sila": 12, "emoji": "🏹"},
    {"jmeno": "Cedrik", "zivoty": 18, "sila": 20, "emoji": "🗡️"},
]

def barva_podle_zivotu(zivoty, max_hp=100):
    """Vrátí barvu podle poměru životů."""
    podil = zivoty / max_hp
    if podil < 0.3:
        return "#c1121f"
    if podil < 0.7:
        return "#e08c00"
    return "#2e933c"

def karta(jmeno, zivoty, sila, emoji="🧙", max_hp=100):
    """Vykreslí jednotnou kartu postavy."""
    barva = barva_podle_zivotu(zivoty, max_hp)

st.markdown(
        f"""
        <div style="border: 3px solid {barva}; border-radius: 12px;
                    padding: 12px; margin-bottom: 8px;">
            <h3 style="margin:0">{emoji} {jmeno}</h3>
        </div>
        """,
        unsafe_allow_html=True,
    )

a, b = st.columns(2)
    a.metric("❤️ Životy", f"{zivoty}/{max_hp}")
    b.metric("💪 Síla", sila)
    st.progress(min(zivoty / max_hp, 1.0))

st.title("🃏 Karty družiny")

max_hp = st.slider("Maximum životů", 50, 200, 100)

st.divider()

for clen in DRUZINA:
    karta(
        clen["jmeno"],
        clen["zivoty"],
        clen["sila"],
        clen["emoji"],
        max_hp,
    )
    st.divider()

st.caption(f"Funkce karta() byla zavolána {len(DRUZINA)}×.")

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: úklid do funkcí (25 min)3. Cvičení na hodinu

Zadání:

Vytáhni vykreslení hrdiny do funkce zobraz_hrdinu(h)

Vytáhni výpravu do funkce vyprava(h, data) vracející text zápisu

Vytáhni nákup do funkce kup(h, zbozi, cena) vracející True/False

Přidej funkci zapis(text), která přidá řádek do deníku

Zkontroluj, že hlavní část programu je krátká a čitelná

Úroveň	Co má zvládnout
Minimum	Body 1–2
Rozšíření	Body 3–4
Výzva	Bod 5 + ke každé funkci docstring

Očekávaný výsledek: stejná hra, ale hlavní kód je poloviční.

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

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

reseni/reseni5_pyquest_funkce.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": "🏰"},
}

PREDMETY = {"lektvar": 15, "štít": 40, "brnění": 120}

def novy_hrdina(jmeno="Arkon"):
    """Vytvoří slovník s novým hrdinou."""
    return {"jmeno": jmeno, "zivoty": 100, "zlato": 100, "inventar": ["meč"]}

def zapis(text):
    """Přidá řádek do deníku."""
    st.session_state.denik.append(text)

def zobraz_hrdinu(h):
    """Vykreslí kartu hrdiny v postranním panelu."""
    st.header(f"🧙 {h['jmeno']}")
    st.metric("❤️ Životy", h["zivoty"])
    st.metric("💰 Zlato", h["zlato"])
    st.progress(min(h["zivoty"] / 100, 1.0))
    if h["inventar"]:
        st.write(f"🎒 {', '.join(h['inventar'])}")
    else:
        st.caption("🎒 prázdno")

def vyprava(h, misto, data):
    """Provede výpravu a vrátí text zápisu do deníku."""
    if h["zivoty"] > data["nebezpeci"]:
        h["zlato"] += data["odmena"]
        h["zivoty"] -= data["nebezpeci"] // 3
        h["inventar"].append(data["korist"])
        return f"✅ {misto}: +{data['odmena']} zlata, našel {data['korist']}"

h["zivoty"] = max(0, h["zivoty"] - data["nebezpeci"] // 2)
    return f"❌ {misto}: útěk se ztrátami"

def kup(h, zbozi, cena):
    """Zkusí koupit zboží. Vrátí True při úspěchu."""
    if h["zlato"] < cena:
        return False
    h["zlato"] -= cena
    h["inventar"].append(zbozi)
    return True

def muze_do_veze(h):
    """Rozhodne, jestli hrdina smí do věže."""
    return "klíč" in h["inventar"]

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

h = st.session_state.hrdina

st.title("⚔️ PyQuest")

with st.sidebar:
    zobraz_hrdinu(h)

st.divider()
    st.subheader("🏪 Obchod")
    zbozi = st.selectbox("Zboží", list(PREDMETY.keys()))
    cena = PREDMETY[zbozi]

if st.button(f"Koupit za {cena}"):
        if kup(h, zbozi, cena):
            zapis(f"🏪 Koupil jsi {zbozi} za {cena}")
        else:
            st.error(f"Chybí ti {cena - h['zlato']} zlata.")
        st.rerun()

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

if h["zivoty"] <= 0:
    st.error("💀 Hrdina padl.")
else:
    misto = st.selectbox("Kam vyrazíš?", list(MISTA.keys()))
    data = MISTA[misto]

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

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

if st.session_state.denik:
    st.divider()
    st.subheader("📜 Deník")
    for z in reversed(st.session_state.denik[-10:]):
        st.text(z)

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

Napiš funkci souboj(hrdina_hp, hrdina_utok, prisera_hp, prisera_utok), která odsimuluje celý souboj cyklem a vrátí tři hodnoty: kdo vyhrál, kolik kol to trvalo a kolik životů zbylo vítězi. Funkce nesmí nic vypisovat — jen počítat a vracet.

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

import streamlit as st

st.set_page_config(page_title="Domácí úkol 10", page_icon="⚔️")
st.title("⚔️ PyQuest — Simulátor souboje")

def souboj(hrdina_hp, hrdina_utok, prisera_hp, prisera_utok):
    """Vrátí vítěze, počet kol a zbývající životy vítěze."""
    kolo = 0
    h = hrdina_hp
    p = prisera_hp

while h > 0 and p > 0 and kolo < 100:
        kolo += 1
        p = max(0, p - hrdina_utok)
        if p <= 0:
            return "hrdina", kolo, h

h = max(0, h - prisera_utok)
        if h <= 0:
            return "příšera", kolo, p

if h > p:
        return "hrdina", kolo, h
    return "příšera", kolo, p

def novy_hrdina():
    return {"jmeno": "Arkon", "zivoty": 100, "zlato": 100, "inventar": ["meč"]}

def zobraz_hrdinu(h):
    st.header(f"🧙 {h['jmeno']}")
    st.metric("❤️ Životy", h["zivoty"])
    st.metric("💰 Zlato", h["zlato"])
    if h["inventar"]:
        st.write(f"🎒 {', '.join(h['inventar'])}")
    else:
        st.caption("🎒 prázdno")

def odmena_po_souboji(hrdina, vitezi):
    if vitezi == "hrdina":
        hrdina["zlato"] += 25
        hrdina["inventar"].append("trofej z boje")

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

h = st.session_state.hrdina

with st.sidebar:
    zobraz_hrdinu(h)
    if st.button("🔄 Nová hra"):
        st.session_state.clear()
        st.rerun()

leva, prava = st.columns(2)
hrdina_utok = leva.slider("⚔️ Útok hrdiny", 1, 40, 15)
prisera_hp = prava.slider("👹 Životy příšery", 10, 200, 90)
prisera_utok = prava.slider("🗡️ Útok příšery", 1, 40, 12)

if h["zivoty"] <= 0:
    st.error("💀 Hrdina padl. Začni novou hru.")
elif st.button("⚔️ Spustit souboj"):
    start_hp = h["zivoty"]
    vitezi, kola, zbylo = souboj(start_hp, hrdina_utok, prisera_hp, prisera_utok)

if vitezi == "hrdina":
        h["zivoty"] = zbylo
        odmena_po_souboji(h, vitezi)
    else:
        h["zivoty"] = 0

st.session_state.denik.append(
        f"Souboj: vítěz {vitezi}, kol {kola}, zbylo {zbylo} HP vítězi"
    )
    st.session_state.posledni_souboj = {
        "vitezi": vitezi,
        "kola": kola,
        "zbylo": zbylo,
        "start_hp": start_hp,
        "hrdina_utok": hrdina_utok,
        "prisera_hp": prisera_hp,
        "prisera_utok": prisera_utok,
    }
    st.rerun()

if "posledni_souboj" in st.session_state:
    s = st.session_state.posledni_souboj
    st.divider()
    a, b, c = st.columns(3)
    a.metric("Vítěz", s["vitezi"])
    b.metric("Počet kol", s["kola"])
    c.metric("Zbylé životy vítěze", s["zbylo"])

st.caption(
        f"souboj({s['start_hp']}, {s['hrdina_utok']}, "
        f"{s['prisera_hp']}, {s['prisera_utok']}) "
        f"→ ({s['vitezi']!r}, {s['kola']}, {s['zbylo']})"
    )

if st.session_state.denik:
    st.divider()
    st.subheader("📜 Deník")
    for z in reversed(st.session_state.denik[-10:]):
        st.text(z)

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 přesný zápis funkce, práci s parametry nebo to, co přesně dělá return. Je v angličtině, ale názvy kapitol i krátké příklady bývají velmi srozumitelné.

Co jsme použili	Oficiální dokumentace	Co tam najdeš
definice funkcí `def`	Function definitions	přesný zápis funkce, parametry a tělo funkce
volání funkce	Calls	jak Python předává argumenty do funkce
`return`	The `return` statement	vracení výsledku z funkce
výchozí hodnoty parametrů	Default Argument Values	jak fungují nepovinné parametry
pojmenované argumenty	Keyword Arguments	zápis jako `kriticky=True`
docstring	Documentation Strings	popis funkce v trojitých uvozovkách
scope proměnných	Python Scopes and Namespaces	proč lokální proměnná neexistuje mimo funkci
`None`	The `None` object	co znamená návratová hodnota `None`

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

Cvičení	Odkaz	Proč se hodí
Robotanik	umimeinformatiku.cz	Podprogramy a jejich volání
Python želva	umimeinformatiku.cz	Vlastní funkce na kreslení
Algoritmické myšlení	umimeinformatiku.cz	Rozklad problému
Programování v Pythonu	umimeinformatiku.cz	Definice funkcí