5. hodina – Vlastní funkce
Definice vlastních funkcí pomocí def, parametry a výchozí hodnoty, návratová hodnota return a lokální proměnné.
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.
Zpět na přehled materiálů
Definice funkce
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.
Zpět na přehled hodiny
Proč vlastní funkce
Spusť soubor a sleduj, co se vypíše.
Funkce používáš od první lekce. Dřív jsme jim říkali vestavěné funkce –
Python je má připravené a napsal je někdo jiný:
print("Ahoj") vypíše text
input("Jméno: ") počká na odpověď
len("Ahoj") spočítá znaky
round(3.14159, 2) zaokrouhlí
randrange(1, 7) hodí kostkou
Pokaždé je to stejné: napíšeš jméno funkce, do závorek pošleš hodnoty,
se kterými má pracovat, a ona odvede svoji práci. Kdo ji napsal a co
je uvnitř, řešit nemusíš.
Na všechno ale hotová funkce být nemůže – co budeš zrovna potřebovat,
dopředu nikdo netuší. Od téhle lekce si funkce píšeš sama – třeba
takovou, která zkontroluje, jestli je heslo dost dlouhé.
Nejdřív se podíváme, jak taková kontrola vypadá bez ní.
Heslo bereme jako dost dlouhé, když má aspoň 8 znaků:
moje_heslo = "kolo"
if len(moje_heslo) < 8:
print(moje_heslo, "– moc krátké")
else:
print(moje_heslo, "– dost dlouhé")
moje_heslo = "pyladies2026"
if len(moje_heslo) < 8:
print(moje_heslo, "– moc krátké")
else:
print(moje_heslo, "– dost dlouhé")
moje_heslo = "abc"
if len(moje_heslo) < 8:
print(moje_heslo, "– moc krátké")
else:
print(moje_heslo, "– dost dlouhé")
Stejné čtyři řádky třikrát. Až se hranice změní z 8 na 10,
musíme to opravit na třech místech a na žádné zapomenout.
Kontrolu si proto pojmenujeme a napíšeme jenom jednou:
def zkontroluj_heslo(heslo):
if len(heslo) < 8:
print(heslo, "– moc krátké")
else:
print(heslo, "– dost dlouhé")
Samotné def ještě nic nevypíše. Funkce se spustí, až když ji zavoláme:
zkontroluj_heslo("kolo")
zkontroluj_heslo("pyladies2026")
zkontroluj_heslo("abc")
Na pořadí výpisů je ten rozdíl vidět. Python si při čtení definice funkci
jenom zapamatuje a dovnitř se zatím nepodívá:
print("před definicí")
def pozdrav():
print("uvnitř funkce")
print("po definici")
pozdrav()
print("po zavolání")
Takhle se definice čte:
def = klíčové slovo (definuju funkci)
zkontroluj_heslo = jméno, které si volíš sama
(heslo) = parametr, se kterým funkce pracuje
: = dvojtečka na konci řádku
odsazení = odsazené řádky jsou tělo funkce

Zpět na téma: Definice funkce · Další: Parametry
Zdrojový Python soubor
Parametry
Spusť soubor a sleduj, co se vypíše.
V minulém souboru byla hranice 8 napevno v těle funkce. Když si ji
chceme vybrat až při volání, přidáme druhý parametr:
def zkontroluj_heslo(heslo, min_delka):
if len(heslo) < min_delka:
print(heslo, "– moc krátké")
else:
print(heslo, "– dost dlouhé")
zkontroluj_heslo("pyladies", 8)
zkontroluj_heslo("pyladies", 20)
Parametry jsou jména v definici: heslo, min_delka.
Argumenty jsou hodnoty, které pošleš při volání: "pyladies", 8.
Parametr si pojmenuješ, jak chceš – platí pro něj stejná pravidla jako
pro proměnné. Vyplatí se jméno, ze kterého je poznat, co se do funkce
posílá: min_delka napoví víc než x.
Záleží na pořadí. Tenhle řádek skončí chybou TypeError, protože
do heslo se dostane číslo 8 a do min_delka text "pyladies":
zkontroluj_heslo(8, "pyladies")
Parametrů může být kolik potřebuješ. Jenom je odděl čárkou:
def vypis_ucastnici(jmeno, mesto, vek):
print(jmeno, "z", mesto, "-", vek, "let")
vypis_ucastnici("Anna", "Prahy", 30)
vypis_ucastnici("Petra", "Brna", 25)
Zpět na téma: Definice funkce · Další: Funkce bez parametru
Zdrojový Python soubor
Funkce bez parametru
Spusť soubor víckrát – pokaždé to dopadne jinak.
Někdy funkce nic zvenku nepotřebuje. Závorky pak zůstanou prázdné –
v definici i při volání.
from random import randrange
def hod_minci():
if randrange(1, 3) == 1:
print("Panna")
else:
print("Orel")
hod_minci()
hod_minci()
hod_minci()
Zpět na téma: Definice funkce · Další: Výchozí hodnota parametru
Zdrojový Python soubor
Výchozí hodnota parametru
Spusť soubor a sleduj, co se vypíše.
round(3.14159, 2) zaokrouhlí na dvě desetinná místa, round(3.14159)
na celé číslo. Druhý parametr se dá vynechat, protože má připravenou
výchozí hodnotu. Ve vlastní funkci se zapisuje rovnítkem v definici:
def zkontroluj_heslo(heslo, min_delka=8):
if len(heslo) < min_delka:
print(heslo, "– moc krátké")
else:
print(heslo, "– dost dlouhé")
zkontroluj_heslo("pyladies") # min_delka zůstane 8
zkontroluj_heslo("pyladies", 20) # 20 přebije výchozí hodnotu
Hodí se to tam, kde skoro vždycky platí jedna hodnota a jenom občas
potřebuješ jinou:
def pozdrav(jmeno, osloveni="Ahoj"):
print(osloveni + ",", jmeno)
pozdrav("Anno")
pozdrav("Anno", "Dobrý den")
Parametry s výchozí hodnotou patří až za ty bez ní.
Tahle definice by skončila chybou SyntaxError:
def zkontroluj_heslo(min_delka=8, heslo):
Zpět na téma: Definice funkce · Další: Popis funkce
Zdrojový Python soubor
Popis funkce
Spusť soubor a sleduj, co se vypíše.
Funkci, kterou napíšeš dneska, budeš za měsíc číst znovu. A funkci od
někoho jiného čteš bez toho, že bys viděla, jak ji psal. Proto se hned
na první řádek těla píše popis, čemu se říká docstring:
def zkontroluj_heslo(heslo, min_delka=8):
"""Vypíše, jestli je heslo dost dlouhé.
heslo text, který se kontroluje
min_delka nejmenší povolená délka, celé číslo větší než nula
"""
if len(heslo) < min_delka:
print(heslo, "– moc krátké")
else:
print(heslo, "– dost dlouhé")
zkontroluj_heslo("kolo")
zkontroluj_heslo("pyladies2026")
Tři uvozovky na začátku a na konci dovolí text na víc řádků. Mezi ně
patří jedna věta o tom, co funkce dělá, a pak co čeká od každého
parametru – včetně toho, jaké hodnoty mají smysl.
Python popis nijak nehlídá. Když do min_delka pošleš nulu, funkce se
nezlobí a projde cokoli:
zkontroluj_heslo("kolo", 0)
Popis je vzkaz pro člověka. Python ho ale umí najít a ukázat:
help(zkontroluj_heslo)
Ve VS Code se ten stejný text objeví sám, když na jméno funkce najedeš
myší nebo když za ni napíšeš levou závorku.
Zpět na téma: Definice funkce · Další: Cvičení: Definice funkce
Zdrojový Python soubor
Cvičení: Definice funkce
Každé cvičení má vlastní soubor ve složce lekce05-vlastni-funkce/01_definice_funkce/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.
Cvičení 1
Soubor: cviceni/01_oddelovac.py
Napiš funkci oddelovac(), která vypíše řádek z 30 hvězdiček.
Zavolej ji třikrát.
Zobrazit řešeníSkrýt řešení
def oddelovac():
print("*" * 30)
oddelovac()
oddelovac()
oddelovac()
Cvičení 2
Soubor: cviceni/02_ramecek.py
Napiš funkci ramecek, která má na vstupu řetězec. Vypíše řádek
hvězdiček, pod něj ten text a pod něj další řádek hvězdiček.
Zavolej ji pro dva různé texty.
Můžeš v ní použít oddelovac() z prvního úkolu – zkopíruj si jeho
definici sem nahoru, soubory se navzájem nevidí.
Zobrazit řešeníSkrýt řešení
def oddelovac():
print("*" * 30)
def ramecek(text):
oddelovac()
print(text)
oddelovac()
ramecek("Vítej v kurzu!")
ramecek("Dneska nás čekají funkce.")
Cvičení 3
Soubor: cviceni/03_ohodnot_znamku.py
Napiš funkci ohodnot_znamku, která má na vstupu celé číslo a vypíše:
1 → "Výborně", 2 → "Chvalitebně", 3 → "Dobře",
cokoliv jiného → "Ještě zabereme".
Zavolej ji v cyklu for pro známky 1 až 5.
Zobrazit řešeníSkrýt řešení
def ohodnot_znamku(znamka):
if znamka == 1:
print("Výborně")
elif znamka == 2:
print("Chvalitebně")
elif znamka == 3:
print("Dobře")
else:
print("Ještě zabereme")
for znamka in range(1, 6):
ohodnot_znamku(znamka)
Cvičení 4
Soubor: cviceni/04_odpocet.py
Napiš funkci odpocet(od), která odpočítá od zadaného čísla
dolů k 1 a nakonec vypíše "Teď!".
Zavolej ji pro 3 a pro 5.
Krok v range jde nastavit i tak, aby se počítalo dolů.
Zobrazit řešeníSkrýt řešení
Napiš funkci odpocet(od), která odpočítá od zadaného čísla
dolů k 1 a nakonec vypíše "Teď!".
Zavolej ji pro 3 a pro 5.
Počet opakování známe, jakmile funkci zavoláme -> for.
range(od, 0, -1) začne na od a jde po jedné dolů. Druhé číslo se
do range nepočítá, takže poslední vypsané je 1.
def odpocet(od):
for cislo in range(od, 0, -1):
print(cislo)
print("Teď!")
odpocet(3)
odpocet(5)
Cvičení 5
Soubor: cviceni/05_oddelovac_na_prani.py
Předělej oddělovač z prvního úkolu tak, aby šlo při volání vybrat
znak a délku řádku. Když se nevybere nic, ať vypíše 30 hvězdiček
jako dřív.
Funkce musí zvládnout všechna tři volání:
oddelovac()
oddelovac("=")
oddelovac("-", 10)
Zobrazit řešeníSkrýt řešení
Oba parametry mají výchozí hodnotu, takže se dá vynechat
jeden i oba.
def oddelovac(znak="*", delka=30):
print(znak * delka)
oddelovac()
oddelovac("=")
oddelovac("-", 10)
Zpět na téma: Definice funkce · Další: Bonusová cvičení: Definice funkce
Zdrojové soubory na GitHubu
Bonusová cvičení: Definice funkce
Bonusy jsou pro rychlíky – když máš hotová cvičení a zbývá čas. Každý bonus má vlastní soubor ve složce lekce05-vlastni-funkce/01_definice_funkce/cviceni_bonusy/. Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.
Bonus 1
Soubor: cviceni_bonusy/01_obdelnik.py
Napiš funkci obdelnik(sirka, vyska), která z hvězdiček vypíše
obdélník zadané velikosti. obdelnik(5, 3) vypíše tři řádky
po pěti hvězdičkách.
Zobrazit řešeníSkrýt řešení
def obdelnik(sirka, vyska):
for radek in range(vyska):
print("*" * sirka)
obdelnik(5, 3)
Bonus 2
Soubor: cviceni_bonusy/02_radek_uctenky.py
Napiš funkci ucet(cena, pocet), která vypíše řádek účtenky:
kolik kusů, cena za kus a celková cena.
Například ucet(25, 4) vypíše: 4 x 25 Kč = 100 Kč
Zobrazit řešeníSkrýt řešení
def ucet(cena, pocet):
print(pocet, "x", cena, "Kč =", cena * pocet, "Kč")
ucet(25, 4)
ucet(199, 2)
Bonus 3
Soubor: cviceni_bonusy/03_pozdrav_bez_parametru.py
Napiš funkci zeptej_se_a_pozdrav(), která se uživatele zeptá
na jméno a pozdraví ho. Zavolej ji dvakrát.
Zobrazit řešeníSkrýt řešení
def zeptej_se_a_pozdrav():
jmeno = input("Jak se jmenuješ? ")
print("Ahoj,", jmeno)
zeptej_se_a_pozdrav()
zeptej_se_a_pozdrav()
Zpět na téma: Definice funkce
Zdrojové soubory na GitHubu
Návratová hodnota
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.
Zpět na přehled hodiny
Návratová hodnota – return
Spusť soubor a sleduj, co se vypíše.
Funkce z minulé složky uměla jenom vypsat, jak na tom heslo je:
def zkontroluj_heslo(heslo):
if len(heslo) < 8:
print(heslo, "– moc krátké")
else:
print(heslo, "– dost dlouhé")
zkontroluj_heslo("kolo")
Výsledek se ale jenom vypíše a tím to končí. Program s ním dál nic
neudělá – kdybychom chtěli krátké heslo odmítnout a dlouhé pustit dál,
musí nám funkce tu informaci předat zpátky. Od toho je return:
def je_heslo_dost_dlouhe(heslo):
if len(heslo) >= 8:
return True
else:
return False
Funkce teď vrací True nebo False – hodnoty, které už znáš z podmínek.
Porovnání len(heslo) >= 8 vyrobí True nebo False samo o sobě, takže se
ta funkce dá napsat i takhle krátce:
def je_heslo_dost_dlouhe(heslo):
return len(heslo) >= 8
Obě verze dělají to samé. Delší se čte snadněji, kratší potkáš v cizím
kódu. Druhá definice tu první přepsala, takže dál v souboru pracujeme
s kratší verzí.
Výsledek si můžeme uložit do proměnné:
vysledek = je_heslo_dost_dlouhe("kolo")
print("kolo:", vysledek)
vysledek = je_heslo_dost_dlouhe("pyladies2026")
print("pyladies2026:", vysledek)
A hlavně se podle výsledku můžeme rozhodnout:
heslo = input("Zvol si heslo: ")
if je_heslo_dost_dlouhe(heslo):
print("Heslo přijato.")
else:
print("Moc krátké, zkus delší.")
Volání funkce se chová jako hodnota, kterou funkce vrátila.
Klidně ho můžeš rovnou dosadit do výpočtu:
def cena_s_dph(cena):
return cena * 1.21
print("Celkem:", cena_s_dph(100) + cena_s_dph(250), "Kč")
Zpět na téma: Návratová hodnota · Další: return vs. print
Zdrojový Python soubor
return vs. print
Spusť soubor a sleduj, co se vypíše.
Tyhle dvě funkce vypadají na první pohled skoro stejně:
def vypis_dph(cena):
print(cena * 1.21)
def spocitej_dph(cena):
return cena * 1.21
Když je zavoláš, obě ukážou to samé číslo:
vypis_dph(100)
print(spocitej_dph(100))
Rozdíl je vidět, až když si výsledek zkusíš uložit:
vysledek_vypisu = vypis_dph(100)
vysledek_vypoctu = spocitej_dph(100)
print("z vypis_dph:", vysledek_vypisu)
print("ze spocitej_dph:", vysledek_vypoctu)
Proměnná vysledek_vypisu je None. Funkce vypis_dph číslo vypsala,
ale ven nic nepředala – a když funkce nemá return, vrací Python
právě None (tedy „nic"). S None se dál počítat nedá:
print(vysledek_vypisu + 50) # TypeError
Proto se funkce většinou píšou tak, že spočítají a vrátí, a vypisování
nechají na tom, kdo je volá. Funkce, která výsledek vypíše, umí jednu
jedinou věc a navždycky. Funkce, která ho vrátí, ho podá dál a volající
si vybere, co s ním:
print("Cena s DPH:", spocitej_dph(100), "Kč")
print("Dohromady:", spocitej_dph(100) + spocitej_dph(250), "Kč")
Vybrat si může i to, že výsledek pošle do další funkce. Děláš to celou
dobu – print(spocitej_dph(100)) je přesně ono. Tady ho pošleme funkci
round, kterou znáš z vestavěných funkcí:
print(round(spocitej_dph(99.9), 2))
Nebo se podle výsledku rozhodne:
if spocitej_dph(1000) > 1000:
print("Tohle už je na dražší objednávku.")
Vypsat výsledek hned se zdá jednodušší. print ale píše do terminálu
a terminál je jen jedno z míst, kde výsledek může skončit – jinde to
bude webová stránka, okno aplikace nebo soubor. Funkce, která spočítá
a vrátí, poslouží všude.
Zpět na téma: Návratová hodnota · Další: return funkci ukončí
Zdrojový Python soubor
return funkci ukončí
Spusť soubor a sleduj, co se vypíše.
Jakmile Python narazí na return, funkci opustí. Řádky pod ním
se už neprovedou:
def pozdrav_a_vrat(jmeno):
print("Zdravím,", jmeno)
return "hotovo"
print("Tenhle řádek se nikdy nevypíše.")
print(pozdrav_a_vrat("Anno"))
return jde napsat i bez hodnoty. Pak funkci jenom ukončí. Hodí se, když
se zbytek práce nemá dělat vůbec:
def pozdrav(jmeno):
if jmeno == "":
print("Nevím, koho zdravit.")
return
print("Ahoj,", jmeno)
print("Vítej v kurzu!")
pozdrav("Anno")
Takový return žádnou hodnotu nepředá, takže funkce vrátí None – stejně
jako funkce, která return nemá vůbec.
print(pozdrav(""))
Funkce může mít returnů víc. Použije se ten, ke kterému program dojde
jako k prvnímu – takhle si funkce vybírá z několika odpovědí:
def ohodnot_znamku(znamka):
if znamka == 1:
return "Výborně"
elif znamka == 2:
return "Chvalitebně"
elif znamka == 3:
return "Dobře"
else:
return "Ještě zabereme"
for znamka in range(1, 6):
print(znamka, "->", ohodnot_znamku(znamka))
Tuhle funkci jsi psala i v minulé složce, tam ale hodnocení rovnou
vypisovala. Teď ho vrací, takže si volající může vybrat, co s ním –
vypsat ho, uložit, nebo poslat do další funkce.
hodnoceni = ohodnot_znamku(1)
print("Na vysvědčení bude:", hodnoceni)
Zpět na téma: Návratová hodnota · Další: Cvičení: Návratová hodnota
Zdrojový Python soubor
Cvičení: Návratová hodnota
Každé cvičení má vlastní soubor ve složce lekce05-vlastni-funkce/02_navratova_hodnota/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.
Cvičení 1
Soubor: cviceni/01_cena_po_sleve.py
Napiš funkci cena_po_sleve(cena, sleva), která vrátí cenu
sníženou o slevu v procentech. cena_po_sleve(200, 25) vrátí 150.0.
Vypiš cenu 200 Kč se slevou 25 % a cenu 1200 Kč se slevou 10 %.
Zobrazit řešeníSkrýt řešení
def cena_po_sleve(cena, sleva):
return cena - cena * sleva / 100
print("200 Kč se slevou 25 %:", cena_po_sleve(200, 25))
print("1200 Kč se slevou 10 %:", cena_po_sleve(1200, 10))
Cvičení 2
Soubor: cviceni/02_je_plnoleta.py
Napiš funkci je_plnoleta(vek), která vrátí True, nebo False.
Zeptej se uživatele na věk a podle výsledku vypiš
"Můžeš dál." nebo "Ještě ne.".
Zobrazit řešeníSkrýt řešení
def je_plnoleta(vek):
return vek >= 18
Porovnání vek >= 18 vyrobí True nebo False samo. Delší zápis, který
dělá to samé a čte se snadněji:
def je_plnoleta(vek):
if vek >= 18:
return True
else:
return False
vek = int(input("Kolik ti je let? "))
if je_plnoleta(vek):
print("Můžeš dál.")
else:
print("Ještě ne.")
Cvičení 3
Soubor: cviceni/03_vetsi_z_dvou.py
Napiš funkci vetsi(a, b), která vrátí větší z obou čísel.
Funkci max nepoužívej.
Zobrazit řešeníSkrýt řešení
def vetsi(a, b):
if a > b:
return a
else:
return b
print(vetsi(3, 8))
print(vetsi(10, 2))
Cvičení 4
Soubor: cviceni/04_prumer_tri_cisel.py
Napiš funkci prumer(a, b, c), která vrátí průměr tří čísel
zaokrouhlený na jedno desetinné místo.
Zobrazit řešeníSkrýt řešení
def prumer(a, b, c):
return round((a + b + c) / 3, 1)
print(prumer(1, 2, 4))
Cvičení 5
Soubor: cviceni/05_hodnoceni_testu.py
Napiš funkci hodnoceni(body), která vrátí "prošla" pro 50 a víc bodů
a "neprošla" pro méně. Pak se v cyklu while ptej na body tak dlouho,
dokud uživatel nezadá -1, a u každého zadání vypiš hodnocení.
Zobrazit řešeníSkrýt řešení
def hodnoceni(body):
if body >= 50:
return "prošla"
else:
return "neprošla"
body = int(input("Zadej body (-1 = konec): "))
while body != -1:
print(body, "bodů:", hodnoceni(body))
body = int(input("Zadej body (-1 = konec): "))
Cvičení 6
Soubor: cviceni/06_vraci_nebo_vypisuje.py
Oprav kód a soubor spusť (Run).
V téhle funkci je chyba. Spusť soubor, přečti si hlášku a funkci
oprav. Zbytek programu nech tak, jak je.
def obvod_ctverce(strana):
print(strana * 4)
celkem = obvod_ctverce(3) + obvod_ctverce(5)
print("Dohromady:", celkem)
Zobrazit řešeníSkrýt řešení
print hodnotu jen ukáže na obrazovce a funkce pak vrací None.
Sčítat None nejde, proto TypeError. S return se dá s výsledkem
dál počítat.
def obvod_ctverce(strana):
return strana * 4
celkem = obvod_ctverce(3) + obvod_ctverce(5)
print("Dohromady:", celkem)
Zpět na téma: Návratová hodnota · Další: Bonusová cvičení: Návratová hodnota
Zdrojové soubory na GitHubu
Bonusová cvičení: Návratová hodnota
Bonusy jsou pro rychlíky – když máš hotová cvičení a zbývá čas. Každý bonus má vlastní soubor ve složce lekce05-vlastni-funkce/02_navratova_hodnota/cviceni_bonusy/. Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.
Bonus 1
Soubor: cviceni_bonusy/01_kontrola_pinu.py
Napiš funkci zkontroluj_pin(spravny_pin), která dá uživateli
tři pokusy zadat PIN. Když se trefí, vrátí True, jinak False.
Po zavolání vypiš "Odemčeno." nebo "Karta zablokována.".
Zobrazit řešeníSkrýt řešení
def zkontroluj_pin(spravny_pin):
pokusy = 0
while pokusy < 3:
zadany = input("Zadej PIN: ")
pokusy = pokusy + 1
if zadany == spravny_pin:
return True
print("Špatný PIN.")
return False
if zkontroluj_pin("1234"):
print("Odemčeno.")
else:
print("Karta zablokována.")
Bonus 2
Soubor: cviceni_bonusy/02_dotaz_na_heslo.py
Napiš funkci zeptej_se_na_heslo(), která se ptá tak dlouho,
dokud uživatel nezadá heslo aspoň o 8 znacích, a to heslo vrátí.
Uvnitř použij funkci je_heslo_dost_dlouhe z výkladu –
zkopíruj si její definici sem nahoru, soubory se navzájem nevidí.
Zobrazit řešeníSkrýt řešení
def je_heslo_dost_dlouhe(heslo):
return len(heslo) >= 8
def zeptej_se_na_heslo():
heslo = input("Zvol si heslo: ")
while not je_heslo_dost_dlouhe(heslo):
print("Moc krátké, aspoň 8 znaků.")
heslo = input("Zvol si heslo: ")
return heslo
nove_heslo = zeptej_se_na_heslo()
print("Heslo nastaveno:", nove_heslo)
Bonus 3
Soubor: cviceni_bonusy/03_pocet_pismen.py
Napiš funkci spocitej_pismeno(slovo, pismeno), která vrátí,
kolikrát se písmeno ve slově objeví.
spocitej_pismeno("kolotoč", "o") vrátí 3.
Nechej si zadat slovo i písmeno od uživatele a výsledek vypiš.
Zobrazit řešeníSkrýt řešení
def spocitej_pismeno(slovo, pismeno):
pocet = 0
for znak in slovo:
if znak == pismeno:
pocet = pocet + 1
return pocet
slovo = input("Zadej slovo: ")
pismeno = input("Které písmeno mám počítat? ")
print("Počet:", spocitej_pismeno(slovo, pismeno))
Bonus 4
Soubor: cviceni_bonusy/04_cena_jizdenky.py
Napiš funkci cena_jizdenky, která má na vstupu věk cestujícího
a základní cenu jízdenky, a vrátí cenu, kterou cestující zaplatí:
děti do 10 let včetně zdarma
mládež do 18 let včetně polovina
senioři od 65 let včetně třetina
ostatní plná cena
Vyzkoušej ji pro několik věků a ceny vypiš.
Zobrazit řešeníSkrýt řešení
Podmínky se zkouší odshora. Jakmile jedna platí, funkce se vrátí
a na další už nedojde – proto stačí u mládeže napsat vek <= 18.
Desetileté a mladší totiž zachytil už první if.
def cena_jizdenky(vek, cena):
if vek <= 10:
return 0
elif vek <= 18:
return cena / 2
elif vek >= 65:
return cena / 3
else:
return cena
print("8 let:", cena_jizdenky(8, 30))
print("10 let:", cena_jizdenky(10, 30))
print("15 let:", cena_jizdenky(15, 30))
print("40 let:", cena_jizdenky(40, 30))
print("70 let:", cena_jizdenky(70, 30))
Zpět na téma: Návratová hodnota
Zdrojové soubory na GitHubu
Funkce dohromady
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.
Zpět na přehled hodiny
Funkce volá funkci
Spusť soubor a zkus se zaregistrovat.
V těle funkce můžeš volat další funkce – klidně i ty svoje.
Poskládáme dohromady tři, které už z téhle lekce znáš.
def ramecek(text):
print("*" * 30)
print(text)
print("*" * 30)
def je_heslo_dost_dlouhe(heslo):
return len(heslo) >= 8
def zaregistruj(jmeno, heslo):
if je_heslo_dost_dlouhe(heslo):
ramecek("Vítej, " + jmeno)
else:
print("Heslo je moc krátké, zkus jiné.")
zaregistruj("Anna", "kolo")
zaregistruj("Petra", "pyladies2026")
Každá funkce má na starosti jednu věc: ramecek vypisuje,
je_heslo_dost_dlouhe rozhoduje a zaregistruj obojí řídí.
Až budeš chtít jiný rámeček, opravíš ho na jednom místě
a změní se všude, kde se volá.
jmeno = input("Jméno: ")
heslo = input("Heslo: ")
zaregistruj(jmeno, heslo)
Zpět na téma: Funkce dohromady · Další: Proměnné uvnitř funkce
Zdrojový Python soubor
Proměnné uvnitř funkce
Spusť soubor. Na konci schválně spadne – tu chybu si přečti.
Proměnná, která vznikne uvnitř funkce, patří jenom té funkci.
Venku o ní Python neví.
def cena_s_dph(cena):
print("Uvnitř funkce je cena:", cena)
dan = cena * 0.21
return cena + dan
Parametr je na tom stejně. Tady je proměnná cena i venku,
a přesto si funkce žije se svou vlastní:
cena = 500
print("Výsledek:", cena_s_dph(100))
print("Venku je cena:", cena)
Kdyby to tak nebylo, každá funkce by nám přepisovala proměnné
v celém programu a nikdo by se v tom nevyznal.
Druhým směrem to ale funguje. Funkce vidí proměnné, které vznikly venku:
jmeno = "Jana"
def predstav_se():
print("Ahoj, já jsem", jmeno)
predstav_se()
Vypadá to pohodlně. Takovou funkci ale nejde přenést jinam, protože mimo
tenhle program žádné jmeno není. A z prvního řádku její definice není
poznat, s čím vlastně pracuje. Když si to, co potřebuje, vezme jako
parametr, je to vidět hned:
def predstav_se(jmeno):
print("Ahoj, já jsem", jmeno)
predstav_se("Jana")
predstav_se("Petra")
A teď ta chyba. Proměnná dan vznikla uvnitř funkce cena_s_dph,
takže tenhle řádek skončí hláškou NameError: name 'dan' is not defined
print(dan)
Zpět na téma: Funkce dohromady · Další: Cvičení: Funkce dohromady
Zdrojový Python soubor
Cvičení: Funkce dohromady
Každé cvičení má vlastní soubor ve složce lekce05-vlastni-funkce/03_funkce_dohromady/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.
Cvičení 1
Soubor: cviceni/01_nadpis.py
Napiš funkci nadpis(text), která vypíše text a pod něj čáru
z pomlček dlouhou přesně jako ten text.
Vyzkoušej ji na dvou různě dlouhých nadpisech.
Zobrazit řešeníSkrýt řešení
def nadpis(text):
print(text)
print("-" * len(text))
nadpis("Lekce 5")
nadpis("Vlastní funkce a návratové hodnoty")
Cvičení 2
Soubor: cviceni/02_sude_nebo_liche.py
Napiš dvě funkce:
je_sude(cislo) vrátí True, nebo False,
popis(cislo) vrátí text "4 je sudé" nebo "7 je liché" a uvnitř
se na je_sude zeptá.
Pak v cyklu for vypiš popis čísel od 1 do 6.
Zobrazit řešeníSkrýt řešení
def je_sude(cislo):
return cislo % 2 == 0
def popis(cislo):
if je_sude(cislo):
return str(cislo) + " je sudé"
else:
return str(cislo) + " je liché"
for cislo in range(1, 7):
print(popis(cislo))
Cvičení 3
Soubor: cviceni/03_soucet_do_n.py
Napiš funkci soucet_do(n), která vrátí součet čísel od 1 do n.
soucet_do(5) vrátí 15.
Zobrazit řešeníSkrýt řešení
def soucet_do(n):
soucet = 0
for cislo in range(1, n + 1):
soucet = soucet + cislo
return soucet
print("Součet do 5:", soucet_do(5))
Cvičení 4
Soubor: cviceni/04_zeptej_se_na_slovo.py
Napiš funkci zeptej_se_na_slovo(), která se ptá tak dlouho,
dokud uživatel nezadá slovo aspoň o třech písmenech, a slovo vrátí.
Zavolej ji a výsledek pošli do funkce nadpis, která je připravená níž.
def nadpis(text):
print(text)
print("-" * len(text))
Zobrazit řešeníSkrýt řešení
def nadpis(text):
print(text)
print("-" * len(text))
def zeptej_se_na_slovo():
slovo = input("Zadej slovo (aspoň 3 písmena): ")
while len(slovo) < 3:
print("Moc krátké.")
slovo = input("Zadej slovo (aspoň 3 písmena): ")
return slovo
nadpis(zeptej_se_na_slovo())
Cvičení 5
Soubor: cviceni/05_nabidka_programu.py
Napiš program, který pořád dokola nabízí tři možnosti a zeptá se,
co má udělat:
1 - hodit kostkou
2 - pozdravit
3 - konec
Volba 1 hodí kostkou a vypíše, co padlo. Volba 2 se zeptá na jméno
a pozdraví ho. Volba 3 program ukončí. Po volbě 1 a 2 se nabídka
objeví znovu. Na cokoli jiného program odpoví, že volbu nezná.
Použij cyklus while True.
Zobrazení nabídky i obě akce napiš jako vlastní funkce.
Zobrazit řešeníSkrýt řešení
from random import randrange
def zobraz_menu():
print("1 - hodit kostkou")
print("2 - pozdravit")
print("3 - konec")
def hod_kostkou():
print("Padlo:", randrange(1, 7))
def pozdrav(jmeno):
print("Ahoj,", jmeno)
while True:
zobraz_menu()
volba = input("Co chceš dělat? ")
if volba == "1":
hod_kostkou()
elif volba == "2":
jmeno = input("Koho pozdravit? ")
pozdrav(jmeno)
elif volba == "3":
break
else:
print("Takovou volbu neznám.")
print("Nashledanou!")
Zpět na téma: Funkce dohromady · Další: Bonusová cvičení: Funkce dohromady
Zdrojové soubory na GitHubu
Bonusová cvičení: Funkce dohromady
Bonusy jsou pro rychlíky – když máš hotová cvičení a zbývá čas. Každý bonus má vlastní soubor ve složce lekce05-vlastni-funkce/03_funkce_dohromady/cviceni_bonusy/. Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.
Bonus 1
Soubor: cviceni_bonusy/01_maly_kviz.py
Malý kvíz. Napiš funkci otazka(text, spravna_odpoved), která
otázku položí, odpověď načte a vrátí True, když je správná.
Polož tři otázky, počítej správné odpovědi a nakonec vypiš skóre.
Zobrazit řešeníSkrýt řešení
def otazka(text, spravna_odpoved):
odpoved = input(text)
return odpoved == spravna_odpoved
body = 0
if otazka("Hlavní město Česka? ", "Praha"):
body = body + 1
if otazka("Kolik je 7 * 8? ", "56"):
body = body + 1
if otazka("Jak se jmenuje cyklus, co běží dokud platí podmínka? ", "while"):
body = body + 1
print("Skóre:", body, "ze 3")
Bonus 2
Soubor: cviceni_bonusy/02_nejvetsi_ze_tri.py
Napiš funkci nejvetsi_ze_tri(a, b, c), která vrátí největší
ze tří čísel. Uvnitř použij funkci vetsi(a, b) z minulé složky –
zkopíruj si její definici sem nahoru, soubory se navzájem nevidí.
Zobrazit řešeníSkrýt řešení
def vetsi(a, b):
if a > b:
return a
else:
return b
def nejvetsi_ze_tri(a, b, c):
return vetsi(vetsi(a, b), c)
print(nejvetsi_ze_tri(3, 9, 5))
Bonus 3
Soubor: cviceni_bonusy/03_hadani_cisla_z_funkci.py
Hra na hádání čísla, celá poskládaná z funkcí – losování,
načtení tipu i vyhodnocení ať má každé svoji.
Hlavní cyklus while pak jenom tyhle funkce volá.
Zobrazit řešeníSkrýt řešení
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()
while True:
tip = zeptej_se_na_tip()
if je_trefa(tip, hledane_cislo):
print("Trefa!")
break
print(napoveda(tip, hledane_cislo))
Zpět na téma: Funkce dohromady
Zdrojové soubory na GitHubu