Úklid kódu — moduly, importy a vlastní knihovna

Cíl hodiny: Umíš rozdělit velký soubor do několika menších, importovat vlastní moduly a ukládat objekty do JSON.

Koncepty: modul, import, from ... import ..., __name__, serializace objektů
Projekt: PyQuest rozdělený do data.py, postavy.py, ulozeni.py, app.py

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

Poznámky pro učiteleMotivace — otevřete jejich vlastní soubor1. Vysvětlení a souvislosti

Nejlepší úvod je ukázat jejich app.py z minulé hodiny:

Kolik má tenhle soubor řádků? Tři sta? Čtyři sta? Zkus najít třídu Drak. Kolikrát jsi musel rolovat?

A teď si představ, že jich tam bude tisíc. Takhle vypadá každý program, který někdo skutečně používá. Proto se kód rozděluje do souborů.

Klíčová věta hodiny:

Dnes nepřidáme ani jednu novou funkci. Program bude po hodině dělat přesně to samé. Ale bude se v něm dát žít.

To je důležité říct nahlas — děti jinak mají pocit, že se nic nestalo. Pojmenujte to: refaktoring = zlepšení struktury bez změny chování.

Blok 1Co je modul1. Vysvětlení a souvislosti

pyquest/
├── app.py          ← spouští se
├── data.py         ← místa, předměty, ceny
├── postavy.py      ← třídy Hrdina, Prisera...
└── ulozeni.py      ← načítání a ukládání

Modul je prostě soubor s Pythonem. Nic víc. Když napíšeš postavy.py, máš modul jménem postavy.

Blok 2Tři způsoby importu1. Vysvětlení a souvislosti

import data                       # 1
st.write(data.MISTA)

from data import MISTA            # 2
st.write(MISTA)

from postavy import Hrdina, Drak  # 3

Zápis	Kdy použít
`import data`	Je vidět, odkud věc pochází. Bezpečné.
`from data import MISTA`	Krátké, když z modulu bereš pár věcí.
`from data import *`	Nikdy. Nevidíš, co se přineslo.

Doporučení: varianta 3 pro třídy a funkce, varianta 1 pro data.

Blok 3Jak Python hledá moduly1. Vysvětlení a souvislosti

Tohle vysvětlete, jinak budou zmatení z chyb:

Když napíšeš import postavy, Python se podívá: 1. do složky, kde je spouštěný soubor, 2. do nainstalovaných balíčků.

Proto musí být postavy.py ve stejné složce jako app.py.

Chyba ModuleNotFoundError: No module named 'postavy' má skoro vždy jednu ze tří příčin: špatná složka, překlep v názvu, nebo koncovka .py v importu.

Blok 4Pozor na kruhový import1. Vysvětlení a souvislosti

# postavy.py
from ulozeni import nacti     # ← ulozeni importuje postavy

# ulozeni.py
from postavy import Hrdina    # ← postavy importuje ulozeni

Dva soubory na sebe čekají navzájem. Python to vzdá a zahlásí chybu. Pravidlo: udělej si směr. Data neví o postavách. Postavy neví o aplikaci. Aplikace ví o všech.

data.py     (neimportuje nic vlastního)
   ↑
postavy.py  (může importovat data)
   ↑
ulozeni.py  (může importovat postavy)
   ↑
app.py      (importuje všechno)

Nakreslete tuhle šipku na tabuli. Řeší to 90 % problémů.

Blok 5Zrádnost: kód v modulu se spustí1. Vysvětlení a souvislosti

Řešení, které uvidíš v každém tutoriálu:

__name__ je proměnná, kterou Python nastaví sám. Když soubor spouštíš, je v ní "__main__". Když ho importuješ, je v ní jméno modulu.

Použití: jednoduché testy modulu na jeho konci.

Blok 6Serializace objektů — to_dict a from_dict1. Vysvětlení a souvislosti

Objekty se do JSON uložit nedají. Podívej se:

json.dumps(hrdina)     # TypeError: Object of type Hrdina is not JSON serializable

JSON umí jen slovníky, seznamy, čísla, texty a True/False/None. Objekt tam prostě nepatří. Musíš mu vysvětlit, jak se má „složit do krabice".

class Hrdina:
    def to_dict(self):
        """Objekt → slovník (do souboru)."""
        return {
            "jmeno": self.jmeno,
            "zivoty": self.zivoty,
            "zlato": self.zlato,
            "typ": type(self).__name__,
        }

    @staticmethod
    def from_dict(d):
        """Slovník → objekt (ze souboru)."""
        h = Hrdina(d["jmeno"])
        h.zivoty = d["zivoty"]
        h.zlato = d["zlato"]
        return h

Analogie: „skládám nábytek do krabice a zase ho složím zpátky". Klíč "typ" je důležitý — bez něj po načtení nepoznáš, jestli to byl bojovník nebo kouzelník.

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

import modul spustí jednou a uloží do sys.modules. Opakovaný import už nic nedělá. Proto Streamlit hot-reload někdy nezachytí změnu v modulu — řešení je restart, případně importlib.reload.
Balíček = složka s __init__.py. Do výuky pro 12–15 let bych to nedával, ploché soubory stačí a __init__.py je od Pythonu 3.3 nepovinný (namespace packages).
Pro C# programátora: modul je zhruba jako soubor s třídou, import je using, ale importuje se soubor, ne namespace. Neexistuje internal/private na úrovni modulu, jen konvence _nazev = „nesahej na to".
Skutečná serializace v produkci: dataclasses.asdict, pydantic, attrs. to_dict/from_dict je ale pedagogicky nejlepší — děti vidí, co se děje.
@staticmethod vs @classmethod: pro from_dict je čistší @classmethod (pracuje s cls), ale @staticmethod je pro děti srozumitelnější.

Poznámky pro učitelePostup refaktoringu na hodině1. Vysvětlení a souvislosti

Nedělejte to najednou. Postupujte v tomto pořadí a po každém kroku spusťte aplikaci:

Vyjmi data (konstanty, slovníky) → data.py, přidej import, spusť.
Vyjmi třídy → postavy.py, přidej import, spusť.
Vyjmi ukládání → ulozeni.py, přidej import, spusť.
V app.py zůstane jen UI.

Po každém kroku spusť aplikaci. Když nefunguje, víš přesně, co jsi rozbil. Když přesuneš všechno najednou a spadne to, hledáš chybu půl hodiny.

Tohle je nejcennější návyk celé hodiny.

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

Chyba	Příčina	Řešení
`ModuleNotFoundError`	Soubor v jiné složce nebo překlep	Stejná složka, přesný název
`import postavy.py`	Koncovka v importu	Bez `.py`
`ImportError: cannot import name`	Kruhový import	Dodržet směr šipky
`NameError` po přesunu	Zapomenutý import v novém modulu	Doplnit `import random` apod.
Změna v modulu se neprojeví	Cache importů	Restartovat aplikaci
`Object is not JSON serializable`	Ukládá se objekt	Použít `to_dict()`
Po načtení je hrdina špatného typu	Chybí klíč `"typ"`	Uložit a přečíst typ

2. Ukázky pro projekci

Blok 8Ukázka 1 — Jeden soubor versus víc souborů2. Ukázky pro projekci

demo/demo1_proc_moduly.py

import streamlit as st

st.title("Proč rozdělovat kód")

st.subheader("❌ Jeden soubor, 400 řádků")

st.code(
    "# app.py\n"
    "import streamlit as st\n"
    "import random, json\n"
    "\n"
    "MISTA = {...}          # ř. 5\n"
    "PREDMETY = {...}       # ř. 40\n"
    "CENY = {...}           # ř. 70\n"
    "\n"
    "class Bojujici: ...    # ř. 95\n"
    "class Hrdina: ...      # ř. 130\n"
    "class Bojovnik: ...    # ř. 180\n"
    "class Prisera: ...     # ř. 210\n"
    "class Drak: ...        # ř. 250\n"
    "\n"
    "def uloz(): ...        # ř. 280\n"
    "def nacti(): ...       # ř. 300\n"
    "\n"
    "st.title(...)          # ř. 320\n"
    "# ... a dalších 80 řádků UI"
)

st.error("Hledáš třídu Drak? Roluj na řádek 250. Každý den. Znovu.")

st.divider()

st.subheader("✅ Čtyři soubory")

a, b = st.columns(2)

with a:
    st.markdown("**data.py** — co je ve hře")
    st.code("MISTA = {...}\nPREDMETY = {...}\nCENY = {...}")

st.markdown("**postavy.py** — kdo ve hře je")
    st.code(
        "import random\n"
        "\n"
        "class Bojujici: ...\n"
        "class Hrdina(Bojujici): ...\n"
        "class Prisera(Bojujici): ..."
    )

with b:
    st.markdown("**ulozeni.py** — jak se hra ukládá")
    st.code(
        "import json\n"
        "from postavy import Hrdina\n"
        "\n"
        "def uloz(h): ...\n"
        "def nacti(): ..."
    )

st.markdown("**app.py** — jak to vypadá")
    st.code(
        "import streamlit as st\n"
        "import data\n"
        "from postavy import Hrdina\n"
        "from ulozeni import uloz, nacti\n"
        "\n"
        "st.title('PyQuest')\n"
        "# jen UI, nic jiného"
    )

st.success("Hledáš třídu Drak? Otevři postavy.py. Hotovo.")

st.divider()

st.subheader("Směr importů — tohle si nakresli")

st.code(
    "data.py      neimportuje nic vlastního\n"
    "   ↑\n"
    "postavy.py   smí importovat data\n"
    "   ↑\n"
    "ulozeni.py   smí importovat postavy\n"
    "   ↑\n"
    "app.py       importuje všechno"
)

st.warning(
    "Šipky nikdy nesmí vést oběma směry. "
    "Když data.py importuje postavy.py a postavy.py importuje data.py, "
    "je to kruhový import a Python spadne."
)

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 9Ukázka 2 — Tři způsoby importu2. Ukázky pro projekci

demo/demo2_zpusoby_importu.py

import math
import random
from datetime import datetime

import streamlit as st

st.title("Tři způsoby importu")

st.subheader("1) import modul")
st.code("import math\nst.write(math.pi)")
st.write("Výsledek:", math.pi)
st.caption("Vidíš, odkud to je. Nejbezpečnější.")

st.divider()

st.subheader("2) from modul import vec")
st.code("from datetime import datetime\nst.write(datetime.now())")
st.write("Výsledek:", datetime.now().strftime("%H:%M:%S"))
st.caption("Krátké. Používej, když bereš pár konkrétních věcí.")

st.divider()

st.subheader("3) from modul import *")
st.code("from math import *      # NEDĚLEJ TO")
st.error(
    "Přinese to do souboru všechno a ty nevíš co. "
    "Když má tvoje funkce stejný název jako něco v modulu, "
    "jedna z nich zmizí a ty nevíš proč."
)

st.divider()

st.subheader("Aliasy — přejmenování při importu")
st.code("import random as nahoda\nnahoda.randint(1, 6)")
st.write("Hod kostkou:", random.randint(1, 6))
st.caption("Používá se u dlouhých názvů: import pandas as pd")

st.divider()

st.subheader("__name__ — spouštím se, nebo mě někdo importuje?")

st.code(
    "# postavy.py\n"
    "class Hrdina: ...\n"
    "\n"
    "if __name__ == '__main__':\n"
    "    # JEN při přímém spuštění souboru\n"
    "    h = Hrdina('Test')\n"
    "    print(h.zivoty)"
)

st.write("V tomto souboru je `__name__` právě:", f"`{__name__}`")

st.info(
    "Streamlit soubor spouští, ale ne jako __main__ — proto tu vidíš jiné jméno. "
    "V běžném Pythonu by tam bylo __main__."
)

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 3 — to_dict a from_dict2. Ukázky pro projekci

demo/demo3_serializace.py

import json

import streamlit as st

st.title("Jak dostat objekt do souboru")

class Hrdina:
    def __init__(self, jmeno, zivoty=100, zlato=50):
        self.jmeno = jmeno
        self.zivoty = zivoty
        self.max_zivoty = zivoty
        self.zlato = zlato
        self.inventar = ["meč"]

def to_dict(self):
        """Objekt → slovník."""
        return {
            "typ": type(self).__name__,
            "jmeno": self.jmeno,
            "zivoty": self.zivoty,
            "max_zivoty": self.max_zivoty,
            "zlato": self.zlato,
            "inventar": self.inventar,
        }

@staticmethod
    def from_dict(d):
        """Slovník → objekt."""
        h = Hrdina(d["jmeno"])
        h.zivoty = d["zivoty"]
        h.max_zivoty = d["max_zivoty"]
        h.zlato = d["zlato"]
        h.inventar = d["inventar"]
        return h

class Bojovnik(Hrdina):
    def __init__(self, jmeno):
        super().__init__(jmeno, zivoty=140, zlato=40)

TRIDY = {"Hrdina": Hrdina, "Bojovnik": Bojovnik}

st.subheader("Proč to nejde přímo")

st.code("json.dumps(hrdina)")

hrdina = Hrdina("Arkon")

try:
    json.dumps(hrdina)
except TypeError as chyba:
    st.error(f"TypeError: {chyba}")

st.info("JSON umí jen slovníky, seznamy, čísla, texty a True/False/None.")

st.divider()

st.subheader("Krok 1: objekt → slovník")

jmeno = st.text_input("Jméno", "Arkon")
zlato = st.slider("Zlato", 0, 500, 120)

h = Hrdina(jmeno)
h.zlato = zlato
h.inventar = ["meč", "lektvar", "klíč"]

slovnik = h.to_dict()
st.json(slovnik)

st.divider()

st.subheader("Krok 2: slovník → text (JSON)")

text = json.dumps(slovnik, ensure_ascii=False, indent=2)
st.code(text, language="json")

st.divider()

st.subheader("Krok 3: text → slovník → objekt")

zpet_slovnik = json.loads(text)
zpet = Hrdina.from_dict(zpet_slovnik)

a, b, c = st.columns(3)
a.metric("Jméno", zpet.jmeno)
b.metric("Zlato", zpet.zlato)
c.metric("Předmětů", len(zpet.inventar))

st.success("Objekt se vrátil přesně takový, jaký byl.")

st.divider()

st.subheader("Proč tam musí být klíč 'typ'")

b1 = Bojovnik("Ragnar")
st.json(b1.to_dict())

st.code(
    "trida = TRIDY[data['typ']]       # najdi správnou třídu\n"
    "objekt = trida(data['jmeno'])    # vytvoř ji"
)

trida = TRIDY[b1.to_dict()["typ"]]
obnoveny = trida("Ragnar")

st.write("Obnovený objekt je typu:", f"`{type(obnoveny).__name__}`")
st.write("Má životů:", obnoveny.max_zivoty)

st.warning(
    "Bez klíče 'typ' bys po načtení dostal obyčejného hrdinu "
    "místo bojovníka a přišel bys o jeho schopnosti."
)

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

Zadání:

Vytvoř soubor data.py a dej do něj slovník MISTA

Přidej do něj i PREDMETY a CENY

V app.py napiš import data

Vypiš místa přes data.MISTA

Přidej do data.py nové místo a ověř, že se v aplikaci objeví

Úroveň	Co má zvládnout
Minimum	Body 1–3
Rozšíření	Bod 4
Výzva	Bod 5 + vyzkoušet i `from data import MISTA`

cviceni/cviceni1_prvni_modul.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: aplikace čte data z jiného souboru.

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

reseni/reseni1_prvni_modul.py

"""Řešení běží jako jeden soubor, aby šlo spustit i samostatně.

Na hodině bude blok DATA v samostatném souboru data.py
a tady bude jen `import data`.
"""

import streamlit as st

# --- obsah souboru data.py -------------------------------------------

MISTA = {
    "les": {
        "nazev": "Temný les",
        "emoji": "🌲",
        "popis": "Mezi stromy něco šustí.",
        "nebezpeci": 2,
    },
    "jeskyne": {
        "nazev": "Jeskyně",
        "emoji": "🕳️",
        "popis": "Ze tmy je cítit síra.",
        "nebezpeci": 4,
    },
    "vesnice": {
        "nazev": "Vesnice",
        "emoji": "🏘️",
        "popis": "Bezpečno. Je tu obchod.",
        "nebezpeci": 0,
    },
    "hory": {
        "nazev": "Mrazivé hory",
        "emoji": "🏔️",
        "popis": "Vítr řeže do tváře.",
        "nebezpeci": 5,
    },
}

PREDMETY = {
    "meč": {"emoji": "⚔️", "sila": 5, "cena": 60},
    "štít": {"emoji": "🛡️", "obrana": 4, "cena": 50},
    "lektvar": {"emoji": "🧪", "leceni": 30, "cena": 25},
    "luk": {"emoji": "🏹", "sila": 4, "cena": 55},
}

CENY = {
    "odpocinek": 15,
    "trenink": 80,
    "mapa": 40,
}

# --- konec data.py ---------------------------------------------------

st.title("📦 První modul")

st.info(
    "Na hodině je horní část v souboru data.py a tady stačí `import data`. "
    "Pak se píše data.MISTA místo MISTA."
)

st.code("import data\n\nfor klic, misto in data.MISTA.items():\n    st.write(misto['nazev'])")

st.divider()

st.subheader("🗺️ Místa")

for klic, misto in MISTA.items():
    with st.container(border=True):
        st.write(f"### {misto['emoji']} {misto['nazev']}")
        st.caption(misto["popis"])
        st.progress(misto["nebezpeci"] / 5, text=f"Nebezpečí {misto['nebezpeci']}/5")

st.divider()

st.subheader("🎒 Předměty")

st.dataframe(
    [
        {"Předmět": f"{v['emoji']} {k}", "Cena": v["cena"]}
        for k, v in PREDMETY.items()
    ],
    use_container_width=True,
)

st.divider()

st.subheader("💰 Ceny služeb")

for sluzba, cena in CENY.items():
    st.write(f"- {sluzba}: **{cena}** zlata")

st.success(
    f"Celkem {len(MISTA)} míst, {len(PREDMETY)} předmětů a {len(CENY)} služeb "
    "— a v app.py není ani jeden řádek dat."
)

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 12Cvičení 2 — Modul s funkcemi (20 min)3. Cvičení na hodinu

Zadání:

Vytvoř nastroje.py s funkcí hod_kostkou(pocet, stran)

Přidej funkci procenta(cast, celek) vracející text jako "75 %"

Přidej funkci zdravi_bar(zivoty, max_zivoty) vracející "█████░░░░░"

Na konec nastroje.py přidej if __name__ == "__main__": s testem

Použij všechny tři funkce v aplikaci

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

cviceni/cviceni2_modul_funkci.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: vlastní mini-knihovna, kterou lze používat kdekoli.

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

reseni/reseni2_modul_funkci.py

"""Blok NÁSTROJE patří na hodině do souboru nastroje.py."""

import random

import streamlit as st

# --- obsah souboru nastroje.py ---------------------------------------

def hod_kostkou(pocet=1, stran=6):
    """Hodí kostkou a vrátí součet."""
    soucet = 0
    for _ in range(pocet):
        soucet += random.randint(1, stran)
    return soucet

def procenta(cast, celek):
    """Vrátí text s procenty, např. '75 %'."""
    if celek == 0:
        return "0 %"
    return f"{round(cast / celek * 100)} %"

def zdravi_bar(zivoty, max_zivoty, delka=10):
    """Textový ukazatel zdraví: █████░░░░░"""
    if max_zivoty == 0:
        return "░" * delka

plnych = round(zivoty / max_zivoty * delka)
    plnych = max(0, min(delka, plnych))
    return "█" * plnych + "░" * (delka - plnych)

def zkrat(text, max_znaku=40):
    """Zkrátí text a přidá tři tečky."""
    if len(text) <= max_znaku:
        return text
    return text[: max_znaku - 3] + "..."

if __name__ == "__main__":
    # Spustí se jen při přímém spuštění: python nastroje.py
    print("Test modulu nastroje.py")
    print("hod_kostkou(2, 6) =", hod_kostkou(2, 6))
    print("procenta(3, 4) =", procenta(3, 4))
    print("zdravi_bar(50, 100) =", zdravi_bar(50, 100))
    print("zkrat('a' * 60) =", zkrat("a" * 60))

# --- konec nastroje.py -----------------------------------------------

st.title("🧰 Modul s funkcemi")

st.code("from nastroje import hod_kostkou, procenta, zdravi_bar, zkrat")

st.divider()

st.subheader("🎲 hod_kostkou")

a, b = st.columns(2)
pocet = a.slider("Počet kostek", 1, 6, 2)
stran = b.selectbox("Kolik stran", [4, 6, 8, 10, 12, 20], index=1)

if st.button("🎲 Hodit"):
    st.metric("Součet", hod_kostkou(pocet, stran))

st.caption(f"Maximum: {pocet * stran}, minimum: {pocet}")

st.divider()

st.subheader("📊 procenta")

x = st.slider("Část", 0, 100, 37)
st.write(f"procenta({x}, 100) →", procenta(x, 100))
st.write(f"procenta({x}, 250) →", procenta(x, 250))

st.divider()

st.subheader("❤️ zdravi_bar")

zivoty = st.slider("Životy", 0, 100, 65)

st.code(zdravi_bar(zivoty, 100))
st.write(f"To je {procenta(zivoty, 100)}")

st.write("**Různé délky:**")
for d in [5, 10, 20]:
    st.text(f"delka={d:<3} {zdravi_bar(zivoty, 100, d)}")

st.divider()

st.subheader("✂️ zkrat")

text = st.text_input(
    "Dlouhý text",
    "Hrdina vstoupil do temného lesa a uslyšel podivné šustění mezi stromy.",
)
st.write("Zkrácený:", zkrat(text, 40))

st.divider()

st.info(
    "Blok `if __name__ == \"__main__\":` se ve Streamlitu nespustí. "
    "Slouží k testu při `python nastroje.py` v terminálu."
)

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í 3 — Třídy do vlastního modulu (20 min)3. Cvičení na hodinu

Zadání:

Vytvoř postavy.py a přesuň do něj třídu Bojujici

Přesuň i Hrdina, Bojovnik, Kouzelnik, Lupic

Přesuň příšery — Prisera, Skret, Vlk, Drak

Nezapomeň na import random uvnitř postavy.py

V aplikaci naimportuj jen to, co potřebuješ

Úroveň	Co má zvládnout
Minimum	Body 1–2
Rozšíření	Body 3–4
Výzva	Bod 5 + slovník `POVOLANI` přímo v `postavy.py`

cviceni/cviceni3_tridy_modul.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: app.py je najednou o dvě stě řádků kratší.

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

reseni/reseni3_tridy_modul.py

"""Blok POSTAVY patří na hodině do souboru postavy.py.

V app.py by pak stačilo:
    from postavy import POVOLANI, BESTIAR
"""

import random

import streamlit as st

# --- obsah souboru postavy.py ----------------------------------------

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 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č"]

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

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

def schopnost(self):
        return "Nejvíc životů"

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

def schopnost(self):
        return "Nejsilnější útok"

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

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

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

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 Drak(Prisera):
    def __init__(self):
        super().__init__("Drak", 180, 28, 600, "🐉")

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

POVOLANI = {"Bojovník": Bojovnik, "Kouzelník": Kouzelnik, "Lupič": Lupic}
BESTIAR = {"Skřet": Skret, "Vlk": Vlk, "Drak": Drak}

# --- konec postavy.py ------------------------------------------------

st.title("🧙 Třídy v modulu")

st.code(
    "# app.py\n"
    "from postavy import POVOLANI, BESTIAR\n"
    "\n"
    "hrdina = POVOLANI['Bojovník']('Arkon')"
)

st.info(
    "Slovníky POVOLANI a BESTIAR jsou také v postavy.py. "
    "Když přidáš novou třídu, stačí ji doplnit tam — app.py se nemění."
)

st.divider()

st.subheader("Povolání")

for nazev, trida in POVOLANI.items():
    h = trida("Ukázka")
    with st.container(border=True):
        st.write(f"### {h.emoji} {nazev}")
        a, b = st.columns(2)
        a.metric("❤️ Životy", h.max_zivoty)
        b.metric("💪 Síla", h.sila)
        st.caption(f"⭐ {h.schopnost()}")

st.divider()

st.subheader("Bestiář")

st.dataframe(
    [
        {
            "Příšera": f"{(t()).emoji} {n}",
            "Životy": t().max_zivoty,
            "Síla": t().sila,
            "Zlato": t().zlato,
        }
        for n, t in BESTIAR.items()
    ],
    use_container_width=True,
)

st.divider()

st.subheader("Rychlý test")

a, b = st.columns(2)
vyber_h = a.selectbox("Hrdina", list(POVOLANI.keys()))
vyber_p = b.selectbox("Příšera", list(BESTIAR.keys()))

if st.button("⚔️ Simulovat 100 soubojů"):
    vyhry = 0
    for _ in range(100):
        h = POVOLANI[vyber_h]("Test")
        p = BESTIAR[vyber_p]()
        while h.je_zivy() and p.je_zivy():
            p.prijmi_poskozeni(h.sila_utoku())
            if p.je_zivy():
                h.prijmi_poskozeni(p.sila_utoku())
        if h.je_zivy():
            vyhry += 1

st.metric("Vyhraných soubojů ze 100", vyhry)
    st.progress(vyhry / 100)

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í 4 — Ukládání objektů (20 min)3. Cvičení na hodinu

Zadání:

Přidej třídě Hrdina metodu to_dict()

Přidej statickou metodu from_dict(d)

Do slovníku ulož i klíč "typ" s názvem třídy

Vytvoř ulozeni.py s funkcemi uloz(hrdina) a nacti()

Otestuj: ulož hrdinu, restartuj aplikaci, načti ho zpět

Úroveň	Co má zvládnout
Minimum	Body 1–2
Rozšíření	Body 3–4
Výzva	Bod 5 + ať `from_dict` vrátí správné povolání podle `"typ"`

cviceni/cviceni4_ukladani_objektu.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: hrdina přežije restart aplikace i s povoláním.

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

reseni/reseni4_ukladani_objektu.py

"""Bloky POSTAVY a ULOŽENÍ patří na hodině do postavy.py a ulozeni.py."""

import json
import os
import random

import streamlit as st

SOUBOR = "hrdina.json"

# --- postavy.py ------------------------------------------------------


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

    def to_dict(self):
        """Objekt → slovník, který umí JSON."""
        return {
            "typ": type(self).__name__,
            "jmeno": self.jmeno,
            "zivoty": self.zivoty,
            "max_zivoty": self.max_zivoty,
            "sila": self.sila,
            "emoji": self.emoji,
            "zlato": self.zlato,
            "inventar": self.inventar,
            "vypravy": self.vypravy,
        }

    @staticmethod
    def from_dict(d):
        """Slovník → objekt SPRÁVNÉ třídy podle klíče 'typ'."""
        trida = TRIDY.get(d.get("typ", "Hrdina"), Hrdina)
        h = trida(d["jmeno"])
        h.zivoty = d["zivoty"]
        h.max_zivoty = d["max_zivoty"]
        h.sila = d["sila"]
        h.emoji = d["emoji"]
        h.zlato = d["zlato"]
        h.inventar = list(d["inventar"])
        h.vypravy = d.get("vypravy", 0)
        return h

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


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

    def schopnost(self):
        return "Nejvíc životů"


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

    def schopnost(self):
        return "Nejsilnější útok"


TRIDY = {"Hrdina": Hrdina, "Bojovnik": Bojovnik, "Kouzelnik": Kouzelnik}

# --- ulozeni.py ------------------------------------------------------


def uloz(hrdina, soubor=SOUBOR):
    """Uloží hrdinu do JSON souboru."""
    with open(soubor, "w", encoding="utf-8") as f:
        json.dump(hrdina.to_dict(), f, ensure_ascii=False, indent=2)


def nacti(soubor=SOUBOR):
    """Načte hrdinu, nebo vrátí None."""
    if not os.path.exists(soubor):
        return None
    try:
        with open(soubor, encoding="utf-8") as f:
            return Hrdina.from_dict(json.load(f))
    except (json.JSONDecodeError, KeyError):
        return None


def smaz(soubor=SOUBOR):
    if os.path.exists(soubor):
        os.remove(soubor)


# --- app.py ----------------------------------------------------------

st.title("💾 Ukládání objektů")

if "h" not in st.session_state:
    nactenty = nacti()
    st.session_state.h = nactenty if nactenty else Bojovnik("Arkon")
    if nactenty:
        st.toast("Hrdina načten ze souboru!")

h = st.session_state.h

st.subheader(f"{h.emoji} {h.jmeno}")
st.caption(f"Typ objektu: `{type(h).__name__}` — {h.schopnost()}")

a, b, c = st.columns(3)
a.metric("❤️ Životy", f"{h.zivoty}/{h.max_zivoty}")
b.metric("💰 Zlato", h.zlato)
c.metric("🗺️ Výprav", h.vypravy)

st.divider()

x, y, z = st.columns(3)

if x.button("🚶 Výprava"):
    h.vypravy += 1
    h.zlato += random.randint(10, 60)
    h.zivoty = max(1, h.zivoty - random.randint(5, 25))
    st.rerun()

if y.button("💾 Uložit"):
    uloz(h)
    st.success(f"Uloženo do {SOUBOR}")

if z.button("🗑️ Smazat uložení"):
    smaz()
    st.session_state.clear()
    st.rerun()

st.divider()

st.subheader("Co se ukládá")
st.json(h.to_dict())

st.divider()

st.subheader("Změna povolání (test klíče 'typ')")

nove = st.selectbox("Nové povolání", list(TRIDY.keys()))

if st.button("🔁 Přehodit povolání"):
    data = h.to_dict()
    data["typ"] = nove
    st.session_state.h = Hrdina.from_dict(data)
    st.rerun()

st.info(
    "Klíč 'typ' rozhoduje, jakou třídu from_dict vytvoří. "
    "Bez něj bys z bojovníka po načtení dostal obyčejného hrdinu."
)

Tenhle kód potřebuje ukládat soubory, což v prohlížeči nejde — spusť ho na počítači příkazem streamlit run.

Blok 15Cvičení 5 — PyQuest: velký úklid (25 min)3. Cvičení na hodinu

Zadání:

Rozděl hru na data.py, postavy.py, ulozeni.py a app.py

Po každém přesunu aplikaci spusť a ověř, že funguje

Dodrž směr importů — data neví o postavách

V app.py nech jen UI, žádné třídy ani data

Přidej do každého modulu docstring, co v něm je

Úroveň	Co má zvládnout
Minimum	Body 1–2
Rozšíření	Body 3–4
Výzva	Bod 5 + přidat `nastroje.py` s pomocnými funkcemi

cviceni/cviceni5_pyquest_uklid.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: stejná hra, čtyři přehledné soubory.

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

reseni/reseni5_pyquest_uklid.py

"""PyQuest po refaktoringu.

Na hodině bude tento soubor rozdělen na:
    data.py     - MISTA, PREDMETY
    postavy.py  - Bojujici, Hrdina, povolání, příšery
    ulozeni.py  - uloz(), nacti()
    app.py      - jen UI (od řádku s 'app.py' níže)

Tady je vše pohromadě, aby šlo řešení spustit jedním souborem.
"""

import json
import os
import random

import streamlit as st

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

SOUBOR = "pyquest_save.json"

# ===================== data.py =======================================

MISTA = {
    "les": {"nazev": "Temný les", "emoji": "🌲", "nebezpeci": 2},
    "jeskyne": {"nazev": "Jeskyně", "emoji": "🕳️", "nebezpeci": 4},
    "hory": {"nazev": "Mrazivé hory", "emoji": "🏔️", "nebezpeci": 5},
}

PREDMETY = {
    "meč": {"emoji": "⚔️", "cena": 60},
    "štít": {"emoji": "🛡️", "cena": 50},
    "lektvar": {"emoji": "🧪", "cena": 25},
}

# ===================== postavy.py ====================================


class Bojujici:
    """Cokoli, co umí bojovat."""

    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=100, sila=10, emoji="🧙"):
        super().__init__(jmeno, zivoty, sila, emoji)
        self.zlato = 50
        self.inventar = ["meč"]
        self.vypravy = 0

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

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

    def to_dict(self):
        return {
            "typ": type(self).__name__,
            "jmeno": self.jmeno,
            "zivoty": self.zivoty,
            "zlato": self.zlato,
            "inventar": self.inventar,
            "vypravy": self.vypravy,
        }

    @staticmethod
    def from_dict(d):
        trida = POVOLANI_PODLE_TRIDY.get(d.get("typ", "Hrdina"), Hrdina)
        h = trida(d["jmeno"])
        h.zivoty = d["zivoty"]
        h.zlato = d["zlato"]
        h.inventar = list(d["inventar"])
        h.vypravy = d.get("vypravy", 0)
        return h


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

    def schopnost(self):
        return "Nejvíc životů"


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

    def schopnost(self):
        return "Nejsilnější útok"


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

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

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


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 Drak(Prisera):
    def __init__(self):
        super().__init__("Drak", 180, 28, 600, "🐉")

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


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

# ===================== ulozeni.py ====================================


def uloz(hrdina, denik, soubor=SOUBOR):
    """Uloží hrdinu i deník."""
    with open(soubor, "w", encoding="utf-8") as f:
        json.dump(
            {"hrdina": hrdina.to_dict(), "denik": denik},
            f,
            ensure_ascii=False,
            indent=2,
        )


def nacti(soubor=SOUBOR):
    """Vrátí (hrdina, denik) nebo (None, [])."""
    if not os.path.exists(soubor):
        return None, []
    try:
        with open(soubor, encoding="utf-8") as f:
            data = json.load(f)
        return Hrdina.from_dict(data["hrdina"]), data.get("denik", [])
    except (json.JSONDecodeError, KeyError):
        return None, []


def smaz(soubor=SOUBOR):
    if os.path.exists(soubor):
        os.remove(soubor)


# ===================== app.py ========================================

st.title("⚔️ PyQuest")

if "hrdina" not in st.session_state:
    ulozeny, denik = nacti()

    if ulozeny:
        st.session_state.hrdina = ulozeny
        st.session_state.denik = denik
        st.rerun()

    st.subheader("Nová hra")
    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"):
        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(f"{type(h).__name__} — {h.schopnost()}")
        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.write("🎒 " + ", ".join(h.inventar))

        if st.button("💾 Uložit hru"):
            uloz(h, st.session_state.denik)
            st.success("Uloženo")

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

    if not h.je_zivy():
        st.error(f"💀 Konec po {h.vypravy} výpravách.")
    else:
        misto_klic = st.selectbox(
            "Kam vyrazit?",
            list(MISTA.keys()),
            format_func=lambda k: f"{MISTA[k]['emoji']} {MISTA[k]['nazev']}",
        )
        misto = MISTA[misto_klic]

        st.progress(
            misto["nebezpeci"] / 5, text=f"Nebezpečí {misto['nebezpeci']}/5"
        )

        if st.button("🚶 Vyrazit"):
            h.vypravy += 1
            p = Drak() if misto["nebezpeci"] >= 5 else 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}. 💀 {misto['emoji']} {p.emoji} {p.jmeno} zvítězil"
                )
            else:
                h.zlato += p.zlato
                st.session_state.denik.append(
                    f"{h.vypravy}. ✅ {misto['emoji']} porazil {p.emoji} "
                    f"{p.jmeno} (+{p.zlato} zlata)"
                )
            st.rerun()

        st.divider()
        st.subheader("🏪 Obchod")

        sloupce = st.columns(len(PREDMETY))
        for sl, (nazev, info) in zip(sloupce, PREDMETY.items()):
            if sl.button(f"{info['emoji']} {nazev}\n{info['cena']} zl", key=nazev):
                if h.zlato >= info["cena"]:
                    h.zlato -= info["cena"]
                    h.inventar.append(nazev)
                    st.rerun()
                else:
                    st.warning("Málo zlata!")

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

Tenhle kód potřebuje ukládat soubory, což v prohlížeči nejde — spusť ho na počítači příkazem streamlit run.

4. Domácí úkol

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

Vytvoř soubor nastroje.py a přesuň do něj alespoň tři pomocné funkce, které používáš v aplikaci. Na jeho konec přidej if __name__ == "__main__": s testem každé funkce. Spusť v terminálu python nastroje.py a přines výpis (nebo screenshot).

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

import streamlit as st

st.set_page_config(page_title="PyQuest — domácí úkol 15", page_icon="🧰")
st.title("🧰 nastroje.py + testy funkcí")

# --- minimální tvar hrdiny jako v PyQuestu (st.session_state.hrdina) ---
class Hrdina:
    def __init__(self, jmeno, zivoty=100, sila=10, emoji="🧙"):
        self.jmeno = jmeno
        self.zivoty = zivoty
        self.max_zivoty = zivoty
        self.sila = sila
        self.emoji = emoji
        self.zlato = 80
        self.inventar = ["meč"]
        self.vypravy = 0

# --- obsah souboru nastroje.py ---
def formatuj_zpravu(hrdina, udalost):
    return f"{hrdina.emoji} {hrdina.jmeno}: {udalost}"

def vypocitej_cenu_nakupu(kosik):
    return sum(cena for _, cena in kosik)

def je_v_batohu(hrdina, vec):
    return vec in hrdina.inventar

def kup_predmet(hrdina, nazev, cena):
    if hrdina.zlato < cena:
        return False, "Nemáš dost zlata."
    hrdina.zlato -= cena
    hrdina.inventar.append(nazev)
    return True, f"Koupeno: {nazev}"

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

h = st.session_state.hrdina

a, b, c = st.columns(3)
a.metric("❤️ Životy", f"{h.zivoty}/{h.max_zivoty}")
b.metric("💰 Zlato", h.zlato)
c.metric("🎒 Předměty", len(h.inventar))

st.subheader("Použití funkcí z nastroje.py v app.py")
st.write(formatuj_zpravu(h, "dorazil do města"))
st.write(f"Je v batohu štít? {je_v_batohu(h, 'štít')}")
st.write(f"Je v batohu klíč? {je_v_batohu(h, 'klíč')}")

obchod = [("štít", 50), ("lektvar", 25), ("mapa", 40)]
st.caption(f"Cena celého nákupu: {vypocitej_cenu_nakupu(obchod)} zl")

sl1, sl2, sl3 = st.columns(3)
if sl1.button("🛡️ Koupit štít (50)"):
    ok, zprava = kup_predmet(h, "štít", 50)
    st.session_state.denik.append(formatuj_zpravu(h, zprava))
    st.rerun()

if sl2.button("🧪 Koupit lektvar (25)"):
    ok, zprava = kup_predmet(h, "lektvar", 25)
    st.session_state.denik.append(formatuj_zpravu(h, zprava))
    st.rerun()

if sl3.button("🔄 Reset ukázky"):
    st.session_state.clear()
    st.rerun()

st.write("🎒 Inventář:", ", ".join(h.inventar))

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

st.divider()
st.subheader("Testy z if __name__ == '__main__'")

vystup_testu = [
    formatuj_zpravu(h, "modul nastroje.py běží"),
    f"vypocitej_cenu_nakupu -> {vypocitej_cenu_nakupu([('jablko', 3), ('chleba', 7)])}",
    f"je_v_batohu(hrdina, 'meč') -> {je_v_batohu(h, 'meč')}",
    f"je_v_batohu(hrdina, 'luk') -> {je_v_batohu(h, 'luk')}",
]
st.code("\\n".join(vystup_testu), language="text")

if __name__ == "__main__":
    test_hrdina = Hrdina("TEST")
    print(formatuj_zpravu(test_hrdina, "modul nastroje.py běží"))
    print("vypocitej_cenu_nakupu:", vypocitej_cenu_nakupu([("jablko", 3), ("chleba", 7)]))
    print("je_v_batohu(test_hrdina, 'meč'):", je_v_batohu(test_hrdina, "meč"))
    print("je_v_batohu(test_hrdina, 'luk'):", je_v_batohu(test_hrdina, "luk"))

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

Oficiální dokumentace se hodí, když si chceš ověřit, jak Python hledá moduly, co přesně dělá import nebo jak funguje __name__ == "__main__". U modulů se vyplatí dívat hlavně na názvy kapitol a krátké příklady.

Co jsme použili	Oficiální dokumentace	Co tam najdeš
moduly	Modules	proč rozdělovat kód do souborů a jak moduly používat
`import`	The import statement	přesný význam různých zápisů importu
balíčky	Packages	jak se větší projekty skládají z více modulů
`__name__ == "__main__"`	`__main__`	kdy se soubor spouští přímo a kdy je jen importovaný
`json`	`json`	ukládání slovníků, čtení JSONu a převod dat

5. Umíme informatiku

Cvičení	Odkaz	Proč se hodí
Programování v Pythonu	umimeinformatiku.cz	Struktura programu
Tabulky	umimeinformatiku.cz	Data odděleně od logiky
Algoritmické myšlení	umimeinformatiku.cz	Rozklad problému
Kódování a modelování	umimeinformatiku.cz	Reprezentace dat