← Zpět na hodinu

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

Definice funkce – názorné vysvětlení


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