7. hodina – Procvičování a debugging
Čtení chybových hlášek, hledání chyb debuggerem ve VS Code a procvičení látky z předchozích hodin.
Výklad a cvičení
Výklad si můžeš přečíst přímo na webu. Příklady procházej po pořadí a kód si zkoušej ve VS Code.
Čtení chybových hlášek, hledání chyb debuggerem ve VS Code a procvičení látky z předchozích hodin.
Výklad si můžeš přečíst přímo na webu. Příklady procházej po pořadí a kód si zkoušej ve VS Code.
Procházej příklady postupně, pak si vyzkoušej cvičení. Kód z bloků si můžeš zkopírovat do Python souboru ve VS Code a spustit. Příklady na jedné stránce na sebe mohou navazovat.
V lekci 1 jsme u první chybové hlášky slíbili, že se jim budeme věnovat později. Teď je to později.
Spusť soubor. Spadne – to je schválně.
jmeno = "Anna"
vek = "30"
print(f"Jméno: {jmeno}")
rok_narozeni = 2026 - vek
print(f"Rok narození: {rok_narozeni}")
V terminálu se objeví tohle:
Jméno: Anna Traceback (most recent call last):
File "01_hlaska_je_napoveda.py", line 14, in <module>
rok_narozeni = 2026 - vek
~~~~~^~~~~
TypeError: unsupported operand type(s) for -: 'int' and 'str'
(U tebe bude před názvem souboru ještě celá cesta k němu. Se starší verzí Pythonu vypadají vlnovky pod kódem trochu jinak, nebo tam nejsou vůbec – poslední řádek je ale stejný.)
Čte se to odspodu.
Poslední řádek je ten důležitý – druh chyby a co se stalo: TypeError Python dostal jiný typ hodnoty, než čekal. unsupported mínus mezi int a str nefunguje.
Nad ním je vypsaný řádek s kódem a vlnovky ukazují na místo, kde to prasklo. Úplně nahoře je soubor a číslo řádku.

V lekci 1 stačilo vědět, že hláška říká soubor, řádek a druh chyby. Teď ten poslední řádek přečteme celý. Číslo řádku tě pošle na správné místo, poslední řádek řekne, co tam hledat.
Tady je vek text "30", ne číslo 30. Oprav řádek 10 na vek = 30 a spusť znovu.
Zpět na téma: Když to spadne · Další: Když se nespustí vůbec nic
Spusť soubor. Nevypsalo se ani "Začínám" – přestože je to první řádek programu.
print("Začínám")
cena = 100
print(f"Cena: {cena} Kč)
print("Hotovo")
Hláška:
File "02_nespustilo_se_vubec.py", line 10
print(f"Cena: {cena} Kč)
^
SyntaxError: unterminated f-string literal (detected at line 10)
Za Kč chybí uzavírací uvozovka. Python text začal číst a nenašel, kde končí.
Zajímavější je, co se nevypsalo. "Začínám" je na řádku 7, je napsané správně, a přesto se neobjevilo.
Některé chyby totiž Python najde ještě předtím, než program spustí. Nejdřív si přečte celý soubor, a když mu jeden řádek nedává smysl, nespustí vůbec nic. Takové chyby jsou dvě: SyntaxError (špatně napsaný řádek) a IndentationError (špatné odsazení).
Všimni si, že VS Code ten řádek podtrhl červeně, ještě než jsi soubor spustila. Pozná to ze stejného důvodu.
Chyby za běhu jsou ten druhý druh – jako TypeError z minulého souboru. Tam se "Jméno: Anna" vypsalo a teprve pak to spadlo. Program doběhl až k chybnému řádku, takže všechno nad ním se opravdu stalo.
Proto se u každého spadlého programu vyplatí mrknout, jestli se vypsalo vůbec něco. Když ne, je chyba v zápisu.
Doplň uvozovku za Kč a spusť znovu.
Zpět na téma: Když to spadne · Další: Když to spadne ve funkci
Spusť soubor. První průměr se spočítá, druhý shodí program.
def prumer(soucet, pocet):
return soucet / pocet
def vypis_prumer(nazev, soucet, pocet):
vysledek = prumer(soucet, pocet)
print(f"{nazev}: {vysledek:.1f}")
vypis_prumer("Leden", 120, 4)
vypis_prumer("Únor", 0, 0)
Hláška má tentokrát tři patra:
Leden: 30.0 Traceback (most recent call last):
File "03_spadlo_to_ve_funkci.py", line 16, in <module>
vypis_prumer("Únor", 0, 0)
~~~~~~~~~~~~^^^^^^^^^^^^^^
File "03_spadlo_to_ve_funkci.py", line 11, in vypis_prumer
vysledek = prumer(soucet, pocet)
File "03_spadlo_to_ve_funkci.py", line 7, in prumer
return soucet / pocet
~~~~~~~^~~~~~~
ZeroDivisionError: division by zero
Odspodu: dělení nulou se stalo na řádku 7, uvnitř funkce prumer. O patro výš je vidět, kdo prumer zavolal – funkce vypis_prumer z řádku 11. A nahoře řádek 16, odkud to celé začalo.
"most recent call last" znamená, že nejspodnější patro je to poslední a nejhlubší.
Spadlo to na řádku 7, ale chyba tam není. Dělení dvou čísel je napsané správně a pro leden fungovalo. Problém vznikl na řádku 16: tam někdo poslal jako počet nulu. Nejvrchnější patro ukazuje, odkud se funkce zavolala – a tam bývá i chyba.
Změň řádek 16 na vypis_prumer("Únor", 90, 3) a spusť znovu.
Zpět na téma: Když to spadne · Další: Hláška ukazuje, kde to Python poznal
Spusť soubor. Spadne – a tentokrát na řádku, kde je všechno napsané správně.
jablka = 5
hruksy = 3
cena_jablka = 12
cena_hrusky = 15
print("Počítám nákup...")
za_jablka = jablka * cena_jablka
za_hrusky = hrusky * cena_hrusky
print(f"Celkem: {za_jablka + za_hrusky} Kč")
Hláška:
Počítám nákup... Traceback (most recent call last):
File "04_chyba_je_jinde.py", line 15, in <module>
za_hrusky = hrusky * cena_hrusky
^^^^^^
NameError: name 'hrusky' is not defined. Did you mean: 'hruksy'?
Řádek 15 je napsaný správně. Chyba je na řádku 8: proměnná se tam omylem jmenuje hruksy. Python o ní ví, ale pod tímhle jménem, takže na řádku 15 žádné hrusky nenajde.
V minulém souboru ti hláška ukázala celou cestu – tři patra, odkud kam. Tady ukáže jediný bod: místo, kde to Python poznal. Odtud musíš hledat sama.
Pomůže konec hlášky: "Did you mean: 'hruksy'?" Python našel podobné jméno a nabízí ho. U překlepů trefí skoro vždycky, takže tahle část stojí za přečtení.
NameError znamená skoro vždycky jedno ze dvou:
překlep ve jméně proměnné (jako tady),
nebo proměnná ještě neexistuje, protože řádek, kde vzniká, je až pod tím, kde ji používáš.
Oprav řádek 8 na hrusky = 3 a spusť znovu.
Zpět na téma: Když to spadne · Další: Cvičení: Když to spadne
Každé cvičení má vlastní soubor ve složce lekce07-procvicovani-a-debugging/01_kdyz_to_spadne/cviceni/. Otevři ho ve VS Code, doplň kód pod zadání a soubor spusť (Run). Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.
Soubor: cviceni/01_cislo_nebo_text.py
Spusť soubor (Run), přečti hlášku a chybu oprav.
Program se má zeptat na cenu a počet kusů a vypsat, kolik to dělá dohromady.
cena = input("Cena za kus: ")
pocet = input("Počet kusů: ")
print(f"Celkem: {cena * pocet} Kč")
Opravený program. Pod ním je, jak se ta chyba našla.
cena = int(input("Cena za kus: "))
pocet = int(input("Počet kusů: "))
print(f"Celkem: {cena * pocet} Kč")
TypeError: can't multiply sequence by non-int of type 'str'
input vrací text, i když naťukáš číslici. Dva texty se násobit nedají. int() z textu udělá číslo.
"sequence" v hlášce znamená text – pro Python je to posloupnost znaků, jak víš z lekce 3.
Soubor: cviceni/02_deleni_nulou.py
Spusť soubor (Run), přečti hlášku a chybu oprav.
Program má spočítat průměr známek.
znamky = "13245"
soucet = 0
pocet = 0
for znak in znamky:
soucet = soucet + int(znak)
print(f"Průměr známek: {soucet / pocet:.1f}")
Opravený program. Pod ním je, jak se ta chyba našla.
znamky = "13245"
soucet = 0
pocet = 0
for znak in znamky:
soucet = soucet + int(znak)
pocet = pocet + 1
print(f"Průměr známek: {soucet / pocet:.1f}")
ZeroDivisionError: division by zero
Nulou dělit nejde. Hláška tedy říká, že pocet byl v tu chvíli nula.
Proměnná pocet se založila na začátku a pak už se o ni nikdo nestaral. V cyklu chybělo zvyšování – soucet se zvětšoval, pocet zůstal na nule.
Soubor: cviceni/03_mimo_rozsah.py
Spusť soubor (Run), přečti hlášku a chybu oprav.
Program má vypsat každou číslici PINu na vlastní řádek a pod tím jejich součet.
Všimni si, kolik řádků se vypsalo, než to spadlo.
def cislice_na(pin, pozice):
return int(pin[pozice])
pin = "4821"
soucet = 0
for i in range(len(pin) + 1):
cislice = cislice_na(pin, i)
soucet = soucet + cislice
print(f"{i + 1}. číslice: {cislice}")
print(f"Součet: {soucet}")
Opravený program. Pod ním je, jak se ta chyba našla.
def cislice_na(pin, pozice):
return int(pin[pozice])
pin = "4821"
soucet = 0
for i in range(len(pin)):
cislice = cislice_na(pin, i)
soucet = soucet + cislice
print(f"{i + 1}. číslice: {cislice}")
print(f"Součet: {soucet}")
IndexError: string index out of range
Čtyři řádky se vypsaly a teprve pátý průchod spadl. Na prvních čtyřech číslicích tedy program fungoval.
Hláška má dvě patra. Spodní ukazuje na řádek v cislice_na, kde se do PINu sahá. Vrchní ukazuje na řádek v cyklu, odkud se funkce zavolala – a tam je i chyba.
"4821" má čtyři znaky s indexy 0, 1, 2, 3. range(len(pin) + 1) ale dojde až k pětce, takže poslední průchod sahá na index 4. Správně je range(len(pin)).
Soubor: cviceni/04_prectu_bez_spusteni.py
Tenhle soubor nespouštěj. Jsou v něm tři hlášky z cizích programů. U každé napiš do komentáře, na kterém řádku to spadlo, jaký je to druh chyby a co se nejspíš stalo.
Samotný kód těch programů nevidíš. To je schválně – z hlášky se dá poznat dost.
File "dochazka.py", line 5
print(pocet)
IndentationError: unexpected indent
Tvoje odpověď:
Traceback (most recent call last):
File "uctenka.py", line 9, in <module>
print(s_poplatkem("12,50"))
~~~~~~~~~~~^^^^^^^^^
File "uctenka.py", line 6, in s_poplatkem
return na_cislo(castka) + 100
~~~~~~~~^^^^^^^^
File "uctenka.py", line 2, in na_cislo
return int(text)
ValueError: invalid literal for int() with base 10: '12,50'
Tvoje odpověď:
200 Traceback (most recent call last):
File "prumer.py", line 6, in <module>
print(vysledek + 50)
~~~~~~~~~^~~~
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
Tvoje odpověď:
Hláška 1 Řádek 5 v souboru dochazka.py, IndentationError. Řádek print(pocet) je odsazený víc, než má být.
Hlášce chybí "Traceback (most recent call last)". To je známka chyby, kterou Python najde ještě před spuštěním – nevypsalo se tedy vůbec nic.
Hláška 2 Spadlo to na řádku 2 v souboru uctenka.py, ValueError. int() dostal text "12,50" a z toho číslo udělat neumí: desetinná čísla se v Pythonu píšou s tečkou, ne s čárkou.
Chyba ale vznikla výš. Patra vedou od řádku 9, kde někdo poslal "12,50" do funkce s_poplatkem, přes řádek 6 až do na_cislo. Opravit se to má na řádku 9.
Hláška 3 Řádek 6 v souboru prumer.py, TypeError. V proměnné vysledek je None, tedy "nic", a k ničemu se padesátka přičíst nedá.
Nad hláškou se vypsalo 200, takže funkce svoje číslo spočítala – jen ho vypsala printem místo toho, aby ho vrátila returnem. Bez returnu vrací funkce None, jak víš z lekce 5.
Procházej příklady postupně, pak si vyzkoušej cvičení. Kód z bloků si můžeš zkopírovat do Python souboru ve VS Code a spustit. Příklady na jedné stránce na sebe mohou navazovat.
Spusť soubor a zadej 2 a 3. Nespadne. Je výsledek správně?
prvni = input("První číslo: ")
druhe = input("Druhé číslo: ")
print(f"Součet: {prvni + druhe}")
Žádná chybová hláška se neobjevila. Program udělal přesně to, co jsme napsali – jen jsme napsali něco jiného, než jsme mysleli.
Celá minulá složka stála na tom, že hláška je nápověda. Tady žádná není. Zbývá podívat se dovnitř: co je v proměnných doopravdy?
print(prvni) # 2
print(type(prvni)) # <class 'str'>
type() je vestavěná funkce jako len(). Řekne, jakého typu hodnota je. Tady str, tedy text.
input vrací text pokaždé, i když naťukáš číslici. A plus mezi dvěma texty je spojí, jak víš z lekce 6.
prvni = int(prvni)
druhe = int(druhe)
print(f"Součet: {prvni + druhe}") # Součet: 5
Printem se dá nakouknout do každého programu. Má to ale dvě nevýhody. Musíš dopředu uhodnout, kterou proměnnou chceš vidět – a když uhodneš špatně, přidáváš další print a spouštíš znovu. A po opravě ty printy zase mažeš.
U čtyř řádků to nevadí. U programu, kde se chyba schovává mezi několika funkcemi, je to zdlouhavé.
VS Code umí program zastavit uprostřed běhu a ukázat všechny proměnné naráz, bez psaní a bez mazání. O tom je zbytek téhle složky.
Kámen, nůžky, papír možná znáš z bonusu ve čtvrté lekci. Tahle verze navíc uklidí, co uživatelka napíše, a o výsledku rozhodují vlastní funkce.
Spusť ho a napiš kamen.
from random import randrange
def uklid_vstupu(text):
return text.strip().title()
def tah_pocitace():
cislo = randrange(1, 4)
if cislo == 1:
return "kamen"
elif cislo == 2:
return "nuzky"
else:
return "papir"
def je_platny(tah):
return tah == "kamen" or tah == "nuzky" or tah == "papir"
def kdo_vyhral(tvuj, pocitacuv):
if tvuj == pocitacuv:
return "remiza"
vyhrala_kamenem = tvuj == "kamen" and pocitacuv == "papir"
vyhrala_nuzkami = tvuj == "nuzky" and pocitacuv == "papir"
vyhrala_papirem = tvuj == "papir" and pocitacuv == "kamen"
if vyhrala_kamenem or vyhrala_nuzkami or vyhrala_papirem:
return "vyhra"
else:
return "prohra"
tvuj_tah = uklid_vstupu(input("Tvůj tah (kamen/nuzky/papir): "))
if not je_platny(tvuj_tah):
print("Takový tah neznám.")
else:
pocitacuv_tah = tah_pocitace()
print(f"Ty hraješ: {tvuj_tah}")
print(f"Počítač hrál: {pocitacuv_tah}")
vysledek = kdo_vyhral(tvuj_tah, pocitacuv_tah)
if vysledek == "vyhra":
print("Vyhrála jsi!")
elif vysledek == "remiza":
print("Remíza.")
else:
print("Prohrála jsi.")
Napsala jsi kamen a program odpověděl "Takový tah neznám." Přitom kamen mezi tahy patří.
Rozhoduje o tom funkce je_platny na řádku 27. Ta vypadá v pořádku – porovnává vstup se všemi třemi tahy. Zajímavější je, co do ní vlastně přišlo.
Klikni do šedého pruhu vlevo od čísla řádku 28. Objeví se červená tečka – to je breakpoint. Může být i uvnitř funkce: program se na něm zastaví pokaždé, když se funkce zavolá.

Nespouštěj soubor tlačítkem Run. Vedle něj je šipka dolů. Klikni na ni a vyber "Python Debugger: Debug Python File". Jde to i klávesou F5.

Při prvním spuštění se tě VS Code může zeptat, co vlastně má spustit. Nabídne seznam a v něm vyber "Python File". Příště už se neptá.
Když v nabídce není nic s Pythonem, chybí rozšíření Python z první lekce. Doinstaluj ho a zkus to znovu.
Napiš do terminálu kamen. Program se zastaví na řádku 28, ten zežloutne a vlevo se otevře panel Variables.

V panelu je:
tah = 'Kamen'
Velké K. Napsala jsi malé písmeno a do funkce přišlo velké, takže se tah nerovná ani jednomu ze tří. Všimni si uvozovek – panel ukazuje hodnotu přesně tak, jak ji Python má.
Vstup se uklízí na řádku 14 a je tam title(), která změní první písmeno na velké. Patří tam lower(). Oprav to a spusť znovu.
Nahoře uprostřed, nad kódem, se objevil pruh se šesti tlačítky. Zleva:
Continue (modrá šipka s čárkou) – program běží dál až k dalšímu breakpointu. Když už žádný nepřijde, doběhne.
Step Over (oblouk s tečkou) – provede jeden řádek a zastaví se na dalším. Volání funkce provede celé najednou.
Step Into (šipka dolů do tečky) – když se na řádku volá funkce, vejde do ní a zastaví se na jejím prvním řádku.
Step Out (šipka nahoru od tečky) – dokončí funkci, ve které zrovna jsi, a zastaví se tam, odkud se volala.
Restart (zelená kolečková šipka) – spustí program znovu od začátku.
Stop (červený čtvereček) – program ukončí.

Teď už hra běží. Zahraj několikrát za sebou kamen a dívej se na výsledky. Dřív nebo později uvidíš tohle:
Ty hraješ: kamen Počítač hrál: nuzky Prohrála jsi.
Jenže kámen tupí nůžky. Tohle kolo jsi vyhrála.
Rozhoduje funkce kdo_vyhral. Dej breakpoint na řádek 34, spusť program přes Python Debugger a zahraj kamen.
Když počítač zahraje taky kamen, je to remíza. Funkce skončí už na řádku 33, k breakpointu se nedostane a program doběhne. Spusť ho znovu. Chyba, která se projeví jen někdy, se hledá opakováním.
Když počítač zahraje nuzky, program se zastaví na řádku 34. Mačkej Step Over a po každém zmáčknutí se podívej do panelu, co přibylo:
tvuj = 'kamen' sedí, to jsi napsala
pocitacuv = 'nuzky' sedí, to padlo počítači
vyhrala_kamenem = False nesedí
vyhrala_nuzkami = False
vyhrala_papirem = False
Kámen proti nůžkám je výhra, takže vyhrala_kamenem má být True. Přečti si řádek 34: ptá se, jestli počítač hrál papir. Kámen ale poráží nůžky, ne papír.
Oprav na řádku 34 "papir" na "nuzky" a zahraj si znovu.
Nech si breakpoint na řádku 34 a přidej ještě jeden na řádek 28. Po spuštění se program zastaví nejdřív na osmadvacítce, a když zmáčkneš Continue, skočí na čtyřiatřicítku.
Když je breakpoint uvnitř cyklu, zabere v každém průchodu znovu. Continue tě tam posune vždycky o jedno kolo dál.
Breakpoint zrušíš dalším kliknutím na červenou tečku.
Zpět na téma: Debugger · Další: Opravená hra a pojmenované tahy
Tohle je hra z minulého souboru s opravenými chybami. Porovnej si ji se svojí verzí – a všimni si tří řádků nahoře, které tam dřív nebyly.
from random import randrange
KAMEN = "kamen"
NUZKY = "nuzky"
PAPIR = "papir"
def uklid_vstupu(text):
return text.strip().lower()
def tah_pocitace():
cislo = randrange(1, 4)
if cislo == 1:
return KAMEN
elif cislo == 2:
return NUZKY
else:
return PAPIR
def je_platny(tah):
return tah == KAMEN or tah == NUZKY or tah == PAPIR
def kdo_vyhral(tvuj, pocitacuv):
if tvuj == pocitacuv:
return "remiza"
vyhrala_kamenem = tvuj == KAMEN and pocitacuv == NUZKY
vyhrala_nuzkami = tvuj == NUZKY and pocitacuv == PAPIR
vyhrala_papirem = tvuj == PAPIR and pocitacuv == KAMEN
if vyhrala_kamenem or vyhrala_nuzkami or vyhrala_papirem:
return "vyhra"
else:
return "prohra"
tvuj_tah = uklid_vstupu(input("Tvůj tah (kamen/nuzky/papir): "))
if not je_platny(tvuj_tah):
print("Takový tah neznám.")
else:
pocitacuv_tah = tah_pocitace()
print(f"Ty hraješ: {tvuj_tah}")
print(f"Počítač hrál: {pocitacuv_tah}")
vysledek = kdo_vyhral(tvuj_tah, pocitacuv_tah)
if vysledek == "vyhra":
print("Vyhrála jsi!")
elif vysledek == "remiza":
print("Remíza.")
else:
print("Prohrála jsi.")
Opravené jsou dvě věci: na řádku 16 je lower() místo title() a na řádku 36 nůžky místo papíru.
Třetí změna je nahoře, na řádcích 10 až 12. Tahy se dřív psaly jako text v uvozovkách pokaždé znovu – dohromady dvanáctkrát. Teď jsou uložené v proměnných a všude jinde se používá jméno.
Velká písmena jsou zvyk. Říkají, že tahle hodnota se v programu už nemění. Takové proměnné se říká konstanta.
Zkus si do nějakého porovnání schválně napsat NUZKI a spustit to:
NameError: name 'NUZKI' is not defined. Did you mean: 'NUZKY'?
Python překlep našel sám a rovnou poradil. Ve jméně proměnné si ho všimne, protože žádná taková proměnná neexistuje.
A teď totéž s uvozovkami. Napiš do porovnání "nuzki" a spusť to. Žádná hláška. Program poběží dál a jen bude mlčky odpovídat špatně – a to je přesně ten druh chyby, který jsi v minulém souboru hledala debuggerem.
Stejný překlep, úplně jiné hledání. S konstantou ho najde Python za tebe.
Naše původní chyba by prošla dál i s konstantami. Na řádku 36 bylo PAPIR tam, kde patří NUZKY – a obě ty proměnné existují, takže by si Python nestěžoval.
Konstanty hlídají překlepy, ne špatně vybrané hodnoty.
Stejným způsobem by se daly pojmenovat i výsledky "vyhra", "remiza" a "prohra", které se v programu opakují taky.
Každé cvičení má vlastní soubor ve složce lekce07-procvicovani-a-debugging/02_debugger/cviceni/. Otevři ho ve VS Code, doplň kód pod zadání a soubor spusť (Run). Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.
Soubor: cviceni/01_znamky.py
Spusť soubor (Run). Dvě ze tří vysvědčení jsou špatně. Najdi debuggerem obě chyby a oprav je.
Program vypíše vysvědčení: spočítá průměr ze tří testů, přeloží ho na slovní známku a připíše, jestli student prospěl.
Stupnice: 90 bodů a víc výborně 75 a víc chvalitebně 60 a víc dobře 45 a víc dostatečně míň než 45 nedostatečně
Neprospěl ten, kdo má nedostatečně.
def prumer(test1, test2, test3):
return (test1 + test2 + test3) / 3
def slovni_znamka(body):
if body > 90:
return "výborně"
elif body >= 75:
return "chvalitebně"
elif body >= 60:
return "dobře"
elif body >= 45:
return "dostatečně"
else:
return "nedostatečně"
def prospel(znamka):
if znamka == "nedostatečně":
return "neprospěl"
else:
return "prospěl"
def vysvedceni(jmeno, test1, test2, test3):
body = prumer(test1, test2, test3)
znamka = slovni_znamka(body)
return f"{jmeno}: {body:.1f} bodů, {znamka}, {prospel(body)}"
print(vysvedceni("Jana", 40, 35, 45))
print(vysvedceni("Petr", 95, 88, 91))
print(vysvedceni("Klára", 88, 91, 91))
Opravený program. Pod ním jsou obě chyby popořadě.
def prumer(test1, test2, test3):
return (test1 + test2 + test3) / 3
def slovni_znamka(body):
if body >= 90:
return "výborně"
elif body >= 75:
return "chvalitebně"
elif body >= 60:
return "dobře"
elif body >= 45:
return "dostatečně"
else:
return "nedostatečně"
def prospel(znamka):
if znamka == "nedostatečně":
return "neprospěl"
else:
return "prospěl"
def vysvedceni(jmeno, test1, test2, test3):
body = prumer(test1, test2, test3)
znamka = slovni_znamka(body)
return f"{jmeno}: {body:.1f} bodů, {znamka}, {prospel(znamka)}"
print(vysvedceni("Jana", 40, 35, 45))
print(vysvedceni("Petr", 95, 88, 91))
print(vysvedceni("Klára", 88, 91, 91))
Chyba 1 – Jana
"nedostatečně, prospěl" si odporuje. Body a známka spolu přitom sedí: 40 bodů je míň než 45, takže prumer i slovni_znamka počítají správně. Zbývá prospel.
Dej breakpoint na první řádek funkce prospel a spusť program přes Python Debugger. V panelu Variables je:
znamka = 40.0
Parametr se jmenuje znamka, ale je v něm číslo. Porovnání 40.0 == "nedostatečně" nikdy neplatí, takže funkce pokaždé vrátí "prospěl".
Sama funkce je v pořádku. Chyba je na řádku, odkud se volá: ve vysvedceni dostane body místo znamka.
Chyba 2 – Klára
Klára má přesně 90 bodů a podle stupnice to je výborně. Program ale vypsal chvalitebně.
Dej breakpoint dovnitř slovni_znamka a pak zmáčkni Step Over přes první if: v panelu je body = 90.0 a žlutý řádek přeskočí rovnou na elif. Podmínka body > 90 pro devadesátku neplatí.
Ve stupnici stojí "90 a víc", takže tam patří >=. Zbylé tři podmínky ho mají správně, vypadlo jen z té první.
U Petra přitom vycházelo všechno správně. Program, který dá dobrý výsledek pro jeden vstup, tím ještě není ověřený.
Soubor: cviceni/02_hadej_cislo.py
Spusť soubor (Run) a zahraj si pár her. Chyby jsou dvě a ta druhá se ukáže jen někdy. Najdi je debuggerem a oprav. Druhou nejsnáz uvidíš, až opravíš tu první: pak se schválně trefuj až pátým tipem – z nápověd už budeš vědět, kde číslo je.
Hádání čísla znáš ze čtvrté lekce. Počítač si vylosuje číslo od 1 do 20 a ty hádáš. Po každém tipu napíše "Moc velké." nebo "Moc malé.". Když se trefíš, napíše "Trefa!". Když se netrefíš ani pátým tipem, prozradí číslo.
from random import randrange
def vylosuj_cislo():
return randrange(1, 21)
def zeptej_se_na_tip():
return int(input("Hádej číslo od 1 do 20: "))
def je_trefa(tip, hledane):
return tip == hledane
def napoveda(tip, hledane):
if tip > hledane:
return "Moc velké."
else:
return "Moc malé."
pokusy = 0
while True:
hledane_cislo = vylosuj_cislo()
tip = zeptej_se_na_tip()
pokusy = pokusy + 1
if pokusy == 5:
print(f"Došly ti pokusy. Hledané číslo bylo {hledane_cislo}.")
break
if je_trefa(tip, hledane_cislo):
print("Trefa!")
break
print(napoveda(tip, hledane_cislo))
Opravený program. Pod ním jsou obě chyby popořadě.
from random import randrange
def vylosuj_cislo():
return randrange(1, 21)
def zeptej_se_na_tip():
return int(input("Hádej číslo od 1 do 20: "))
def je_trefa(tip, hledane):
return tip == hledane
def napoveda(tip, hledane):
if tip > hledane:
return "Moc velké."
else:
return "Moc malé."
hledane_cislo = vylosuj_cislo()
pokusy = 0
while True:
tip = zeptej_se_na_tip()
pokusy = pokusy + 1
if je_trefa(tip, hledane_cislo):
print("Trefa!")
break
if pokusy == 5:
print(f"Došly ti pokusy. Hledané číslo bylo {hledane_cislo}.")
break
print(napoveda(tip, hledane_cislo))
Chyba 1 – číslo se pořád mění
Nápovědy si odporovaly – třeba na 10 program napsal "Moc velké." a o kolo později na 9 "Moc malé.".
S breakpointem na řádku s print(napoveda(...)) a Continue po každém tipu je v panelu Variables vidět, že hledane_cislo je v každém kole jiné.
Losování bylo uvnitř cyklu, takže proběhlo v každém kole znovu. Patří před cyklus – číslo se vylosuje jednou na celou hru.
Chyba 2 – trefa pátým tipem
Ukáže se, jen když se trefíš právě pátým tipem. Program pak napíše "Došly ti pokusy." a jako hledané prozradí přesně to číslo, které jsi zadala.
Breakpoint na řádku if pokusy == 5 zabere v každém kole. Mačkej Continue, dokud se netrefíš pátým tipem. V panelu je pak třeba:
tip = 13
hledane_cislo = 13
pokusy = 5
Step Over skočí do větve, kde došly pokusy, a program skončí dřív, než se dostane ke kontrole trefy. Podmínky se zkouší odshora, takže kontrola trefy musí být první.
Soubor: cviceni/03_kontrola_hesla.py
Spusť soubor (Run) třikrát a zadej postupně hesla ze seznamu níž. Chyby jsou dvě. Najdi je debuggerem a oprav.
Kontrolu hesla znáš z bonusu v šesté lekci. Heslo projde, když má aspoň osm znaků, aspoň jednu číslici a aspoň jedno velké písmeno.
Pyladies2026 – má projít
2026Pyladies – má projít
pyladies2026 – nemá projít, chybí v něm velké písmeno
heslo = input("Zadej heslo: ")
dost_dlouhe = len(heslo) >= 8
ma_velke = heslo != heslo.upper()
ma_cislici = False
for znak in heslo:
if znak.isdigit():
ma_cislici = True
else:
ma_cislici = False
print(f"Aspoň osm znaků: {dost_dlouhe}")
print(f"Obsahuje číslici: {ma_cislici}")
print(f"Velké písmeno: {ma_velke}")
if dost_dlouhe and ma_cislici and ma_velke:
print("Heslo přijato.")
else:
print("Heslo nevyhovuje.")
Opravený program. Pod ním jsou obě chyby popořadě.
heslo = input("Zadej heslo: ")
dost_dlouhe = len(heslo) >= 8
ma_velke = heslo != heslo.lower()
ma_cislici = False
for znak in heslo:
if znak.isdigit():
ma_cislici = True
break
print(f"Aspoň osm znaků: {dost_dlouhe}")
print(f"Obsahuje číslici: {ma_cislici}")
print(f"Velké písmeno: {ma_velke}")
if dost_dlouhe and ma_cislici and ma_velke:
print("Heslo přijato.")
else:
print("Heslo nevyhovuje.")
Chyba 1 – 2026Pyladies
Program napsal "Obsahuje číslici: False", přestože heslo začíná čtyřmi číslicemi.
Breakpoint uvnitř cyklu a Continue po každém znaku: ma_cislici je u znaků '2', '0', '2' a '6' True a u 'P' spadne zpátky na False. Každý znak přepsal, co zjistil ten před ním, takže rozhodoval jen poslední znak. Pyladies2026 končí číslicí, proto prošlo.
Větev else tam nepatří. Jakmile se číslice najde, ma_cislici má zůstat True. Break cyklus rovnou ukončí, dál už se hledat nemusí.
Chyba 2 – pyladies2026
Heslo bez velkého písmena prošlo. Po řádku s ma_velke je v panelu:
heslo = 'pyladies2026'
ma_velke = True
upper() udělá z hesla 'PYLADIES2026'. To se od hesla liší, kdykoli je v něm aspoň jedno malé písmeno – program se tak ptal na malá písmena. Na velké se zeptá lower(): heslo se od své malé verze liší, jen když v něm nějaké velké písmeno je.
Soubor: cviceni/04_sleva_na_vstupenky.py
Spusť soubor (Run). Výsledek je špatný. Najdi chybu debuggerem.
Program spočítá cenu vstupenky podle věku: do 6 let zdarma, do 18 let poloviční, do 65 let plná cena, od 65 let sleva 30 %.
Zkontroluj podle pravidel výš, jestli vypsaná cena sedí.
vek = 10
plna_cena = 250
if vek < 65:
cena = plna_cena
elif vek < 6:
cena = 0
elif vek < 18:
cena = plna_cena / 2
else:
cena = plna_cena * 0.70
print(f"Vstupenka pro {vek} let: {cena:.0f} Kč")
Opravený program. Pod ním je, jak se ta chyba našla.
vek = 10
plna_cena = 250
if vek < 6:
cena = 0
elif vek < 18:
cena = plna_cena / 2
elif vek < 65:
cena = plna_cena
else:
cena = plna_cena * 0.70
print(f"Vstupenka pro {vek} let: {cena:.0f} Kč")
Breakpoint na první if a pak Step Over. Žlutý řádek skočil rovnou do větve cena = plna_cena a odtud až na print.
Desetileté dítě je míň než 65, takže projde hned první podmínkou. Větve v if/elif se zkouší odshora a jakmile jedna platí, zbytek se přeskočí. Do větví pro děti se program nedostal nikdy.
Podmínky proto musí jít od nejužší po nejširší.
Soubor: cviceni/05_rozpocitat_mince.py
Spusť soubor (Run). Výsledek je špatný. Najdi chybu debuggerem.
Program rozpočítá částku na mince: nejdřív bere dvacetikoruny, ze zbytku pětikoruny a co zůstane, jsou koruny.
Na výpisu je jedno číslo, které takhle vyjít nemůže.
zbyva = 87
dvacetikoruny = 0
petikoruny = 0
while zbyva >= 20:
dvacetikoruny = dvacetikoruny + 1
zbyva = zbyva - 20
while zbyva >= 5:
petikoruny = petikoruny + 1
zbyva = zbyva - 20
print(f"Dvacetikoruny: {dvacetikoruny}")
print(f"Pětikoruny: {petikoruny}")
print(f"Koruny: {zbyva}")
Opravený program. Pod ním je, jak se ta chyba našla.
zbyva = 87
dvacetikoruny = 0
petikoruny = 0
while zbyva >= 20:
dvacetikoruny = dvacetikoruny + 1
zbyva = zbyva - 20
while zbyva >= 5:
petikoruny = petikoruny + 1
zbyva = zbyva - 5
print(f"Dvacetikoruny: {dvacetikoruny}")
print(f"Pětikoruny: {petikoruny}")
print(f"Koruny: {zbyva}")
Výpis končil na "Koruny: -13". Zbývat nemůže míň než nic, takže bylo jasné, že se někde odečítá moc.
Breakpoint na první řádek druhého cyklu a pohled do panelu:
zbyva = 7, dvacetikoruny = 4 po prvním cyklu, sedí
První cyklus je tedy v pořádku. Pak Step Over přes dva řádky druhého cyklu: petikoruny vyskočí na 1, což sedí, a zbyva spadne ze sedmi na -13.
Ze zbytku se odečetlo dvacet místo pěti. Druhý cyklus vznikl zkopírováním prvního a v kopii zůstalo staré číslo.
Soubor: cviceni/06_prevod_na_minuty.py
Spusť soubor (Run). Výsledek je špatný. Najdi chybu debuggerem.
Program sečte délku tří tréninků zadaných ve tvaru "h:mm".
def na_minuty(cas):
hodiny = int(cas[0])
minuty = int(cas[2:3])
return hodiny * 60 + minuty
pondeli = na_minuty("2:45")
streda = na_minuty("1:30")
patek = na_minuty("2:20")
celkem = pondeli + streda + patek
print(f"Pondělí: {pondeli} min")
print(f"Středa: {streda} min")
print(f"Pátek: {patek} min")
print(f"Celkem: {celkem} min")
Opravený program. Pod ním je, jak se ta chyba našla.
def na_minuty(cas):
hodiny = int(cas[0])
minuty = int(cas[2:])
return hodiny * 60 + minuty
pondeli = na_minuty("2:45")
streda = na_minuty("1:30")
patek = na_minuty("2:20")
celkem = pondeli + streda + patek
print(f"Pondělí: {pondeli} min")
print(f"Středa: {streda} min")
print(f"Pátek: {patek} min")
print(f"Celkem: {celkem} min")
Breakpoint na první řádek na_minuty a pak Step Over po řádcích. V panelu Variables:
cas = '2:45'
hodiny = 2 sedí
minuty = 4 nesedí, má to být 45
Výřez cas[2:3] bere od indexu 2 do indexu 3 a konec se nepočítá – vyjde z něj jediný znak "4". Správně je cas[2:], tedy od indexu 2 až do konce textu.
Soubor: cviceni/07_soucet_cislic.py
Spusť soubor (Run). Výsledek je špatný. Najdi chybu debuggerem.
Program má sečíst číslice v PINu a vypsat jedno číslo – konečný součet. Teď vypisuje čtyři řádky.
pin = "4821"
soucet = 0
for znak in pin:
soucet = soucet + int(znak)
print(f"Součet číslic: {soucet}")
Opravený program. Pod ním je, jak se ta chyba našla.
pin = "4821"
soucet = 0
for znak in pin:
soucet = soucet + int(znak)
print(f"Součet číslic: {soucet}")
Dej breakpoint na řádek s printem a mačkej Continue. Program se na něm zastavil čtyřikrát – jednou za každou číslici PINu. Breakpoint uvnitř cyklu zabere v každém průchodu, takže čtyři zastavení znamenají, že ten řádek je uvnitř cyklu.
A tam nepatří. Print byl odsazený stejně jako řádek nad ním, takže patřil do těla cyklu.
Odsazení rozhoduje o tom, co je uvnitř cyklu a co až za ním. Python v tom chybu nevidí – obě varianty dávají smysl, jen každá dělá něco jiného.
Soubor: cviceni/08_staci_to.py
Spusť soubor (Run). Výsledek je špatný. Najdi chybu debuggerem.
Program se zeptá, kolik máš korun a kolik stojí vstupenka, a řekne, jestli ti to stačí.
Zadej 1000 a 250.
castka = input("Kolik korun máš? ")
cena = input("Kolik stojí vstupenka? ")
if castka > cena:
print("Stačí.")
else:
print("Nestačí.")
Opravený program. Pod ním je, jak se ta chyba našla.
castka = int(input("Kolik korun máš? "))
cena = int(input("Kolik stojí vstupenka? "))
if castka > cena:
print("Stačí.")
else:
print("Nestačí.")
Dej breakpoint na řádek s podmínkou. V panelu Variables je:
castka = '1000'
cena = '250'
Obě čísla sedí, ale jsou v uvozovkách – a to znamená text. Ve výpisu by tohle vidět nebylo, print uvozovky neukazuje.
input vrací text. Texty se porovnávají znak po znaku od začátku: "1000" začíná jedničkou, "250" dvojkou, a jednička je dřív. Proto "1000" > "250" neplatí.
S int() se porovnávají čísla a program odpoví správně.
Bonusy jsou pro rychlíky – když máš hotová cvičení a zbývá čas. Každý bonus má vlastní soubor ve složce lekce07-procvicovani-a-debugging/02_debugger/cviceni_bonusy/. Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.
Soubor: cviceni_bonusy/01_nekonecny_cyklus.py
Tenhle program se zacyklí. Než ho spustíš, přečti si, jak ho zastavíš: červeným čtverečkem Stop nahoře, nebo kliknutím do terminálu a Ctrl+C.
Program má odpočítat od sta k nule po pěti a vypsat, kolik kroků to trvalo. Místo toho běží pořád dokola.
Spusť ho přes Python Debugger a nech ho chvíli běžet. Pak zmáčkni v pruhu nahoře Pause – dvě svislé čárky na místě, kde byl Continue. Program se zastaví tam, kde zrovna je, a v panelu Variables uvidíš, proč se nehne z místa.
Pak chybu oprav.
cislo = 100
kroku = 0
while cislo != 0:
kroku = kroku + 1
print(f"Hotovo za {kroku} kroků.")
Opravený program. Pod ním je, jak se ta chyba našla.
cislo = 100
kroku = 0
while cislo != 0:
cislo = cislo - 5
kroku = kroku + 1
print(f"Hotovo za {kroku} kroků.")
Po zmáčknutí Pause se program zastavil uvnitř cyklu a v panelu Variables bylo:
cislo = 100 pořád stejné
kroku = 2847193 obrovské číslo (u tebe vyjde jiné,
záleží, jak dlouho jsi nechala program běžet)
Tohle je typický obrázek zacykleného programu. Něco se počítá donekonečna a podmínka cyklu se nemá o co opřít.
V cyklu chyběl řádek, který cislo zmenšuje. Dokud zůstává na stovce, podmínka cislo != 0 platí pořád.
U každého while stojí za to se zeptat: mění se v cyklu to, na co se podmínka ptá?
Soubor: cviceni_bonusy/02_oprav_a_rozsir.py
Nejdřív chybu najdi a oprav, pak program rozšiř.
Program počítá, kolik je ve větě samohlásek a kolik souhlásek. Mezery se nepočítají.
Samohlásky a souhlásky dohromady musí dát počet písmen ve větě. Zkontroluj, jestli to tak vychází.
Najdi a oprav chybu.
Pak přidej výpis, kolik procent ze všech písmen jsou samohlásky, zaokrouhleno na jedno desetinné místo.
veta = "Python je jazyk pro lidi a stroje"
samohlasky = "aeiouy"
pocet_samohlasek = 0
pocet_souhlasek = 0
for znak in veta.lower():
if znak == " ":
continue
if znak in samohlasky:
pocet_samohlasek = pocet_samohlasek + 1
pocet_souhlasek = pocet_souhlasek + 1
print(f"Samohlásek: {pocet_samohlasek}")
print(f"Souhlásek: {pocet_souhlasek}")
veta = "Python je jazyk pro lidi a stroje"
samohlasky = "aeiouy"
pocet_samohlasek = 0
pocet_souhlasek = 0
for znak in veta.lower():
if znak == " ":
continue
if znak in samohlasky:
pocet_samohlasek = pocet_samohlasek + 1
else:
pocet_souhlasek = pocet_souhlasek + 1
pocet_pismen = pocet_samohlasek + pocet_souhlasek
podil = pocet_samohlasek / pocet_pismen * 100
print(f"Samohlásek: {pocet_samohlasek}")
print(f"Souhlásek: {pocet_souhlasek}")
print(f"Samohlásky tvoří {podil:.1f} % písmen.")
Souhlásek vycházelo 27, což je počet všech písmen ve větě. To samo napovídá, že se počítadlo souhlásek zvyšuje pokaždé, i u samohlásky.
Chybělo else. Bez něj jsou ty dva ify nezávislé: první se ptá na samohlásku, druhý se nezeptá na nic a přičte vždycky.
Soubor: cviceni_bonusy/03_rezervace.py
Jsou tu tři chyby a každá je jiného druhu. Jednu ti ukáže chybová hláška, druhou poznáš z výsledku a na tu třetí se hodí debugger. Oprav je po jedné a po každé opravě program spusť.
Program spočítá rezervaci kurzu.
kurz stojí 2 400 Kč za osobu
od tří osob je sleva 10 % z celkové ceny
každá členka klubu má navíc slevu 200 Kč
záloha je třetina výsledné ceny zaokrouhlená na celé koruny
Počítá se pro čtyři osoby, z toho dvě členky. Obě vypsaná čísla si zkontroluj podle pravidel výš – u zálohy stačí podělit celkovou cenu třemi.
def zaloha_z(castka):
return round(castka / 3)
osoby = 4
clenky = 2
cena_osoby = 2400
celkem = osoby * cena_osoba
zaloha = zaloha_z(celkem)
if osoby >= 3:
celkem = celkem * 0.9
celkem = celkem - 200
print(f"Osob: {osoby}, z toho členek: {clenky}")
print(f"Celkem: {celkem:.0f} Kč")
print(f"Záloha: {zaloha} Kč")
Opravený program. Pod ním jsou všechny tři chyby popořadě.
def zaloha_z(castka):
return round(castka / 3)
osoby = 4
clenky = 2
cena_osoby = 2400
celkem = osoby * cena_osoby
if osoby >= 3:
celkem = celkem * 0.9
celkem = celkem - clenky * 200
zaloha = zaloha_z(celkem)
print(f"Osob: {osoby}, z toho členek: {clenky}")
print(f"Celkem: {celkem:.0f} Kč")
print(f"Záloha: {zaloha} Kč")
Po opravě program doběhne a vypíše celkem 8 440 Kč a zálohu 3 200 Kč. Obojí je špatně.
Po opravě sedí celkem 8 240 Kč. Záloha je pořád 3 200.
Breakpoint na řádek s voláním a pohled do panelu Variables: celkem je v tu chvíli 9 600, protože slevy se počítají až pod tím řádkem. Záloha se tedy počítala z ceny před slevami.
Funkce byla celou dobu správně. Špatně bylo místo, odkud se volala.