Lidsky řečeno
Kávovar. Nezajímá tě, jak mele zrna ani kolik stupňů má voda. Nasypeš kávu, zmáčkneš tlačítko a dole vyteče výsledek. Funkce je takové tlačítko v programu: jednou ji zapojíš a pak už jen mačkáš. To, co nasypeš nahoru, jsou argumenty. To, co vyteče dole, je návratová hodnota.
Stejný výpočet na třech místech
Máš e-shop a potřebuješ k cenám bez daně dopočítat cenu s DPH 21 %.
notebook = 20000
print(round(notebook * 1.21, 2)) # 24200.0
mys = 490
print(round(mys * 1.21, 2)) # 592.9
klavesnice = 1290
print(round(klavesnice * 1.21, 2)) # 1560.9Funguje to, ale stejná myšlenka je v kódu třikrát. Až se sazba změní, musíš najít všechna místa. Když jedno přehlédneš, program nespadne. Jen bude tiše počítat špatně, a to je nejhorší druh chyby.
Řešení je dát výpočtu jméno a napsat ho jen jednou.
def cena_s_dph(cena):
return round(cena * 1.21, 2)
print(cena_s_dph(20000))
print(cena_s_dph(490))
print(cena_s_dph(1290))
24200.0 592.9 1560.9
Výsledek je stejný. Změna sazby je teď úprava jednoho řádku a kód navíc říká, co dělá, ne jen jak.
Definice a volání
Funkce má dvě oddělené části. Definice ji vytvoří, volání ji spustí.
def cena_s_dph(cena): <- hlavička: jméno, parametr, dvojtečka
s_dani = cena * 1.21 <- tělo: odsazené o 4 mezery
return round(s_dani, 2) <- co funkce předá zpátky
cena_s_dph(490) <- volání: teprve tady se tělo provedeSamotné def nic nepočítá ani nevypisuje. Jen si zapamatuje postup pod daným jménem. Všimni si, v jakém pořadí se tahle ukázka vypíše.
def pozdrav():
print("Ahoj z funkce!")
print("Funkce existuje, ale ještě neběžela.")
pozdrav()
pozdrav()
Funkce existuje, ale ještě neběžela. Ahoj z funkce! Ahoj z funkce!
Závorky při volání jsou povinné i tehdy, když je v nich prázdno. Znamenají „teď to proveď“.
Python čte soubor shora dolů, takže funkci musíš definovat dřív, než ji zavoláš.
print(dvojnasobek(4))
def dvojnasobek(x):
return x * 2
Hláška name 'dvojnasobek' is not defined říká, že v tu chvíli o takovém jménu Python ještě neví.
Parametr a argument
Dvě slova, která se často pletou:
- Parametr je jméno v hlavičce funkce (
sirka). Je to prázdná kolonka ve formuláři. - Argument je konkrétní hodnota při volání (
4). To, co do kolonky napíšeš.
Parametrů může být víc, oddělují se čárkou.
def plocha_obdelniku(sirka, vyska):
return sirka * vyska
print(plocha_obdelniku(4, 5))
print(plocha_obdelniku(2.5, 10))
20 25.0
Účet se spropitným
Napiš funkci se_spropitnym(castka, procenta), která vrátí částku zvýšenou o dané procento. Pro se_spropitnym(200, 10) vrátí 220. Výsledek funkce vrací, nevypisuje.
def se_spropitnym(castka, procenta):
# doplň
pass
return, nebo print?
Tohle je nejčastější nedorozumění začátečníků, protože obojí na první pohled vypadá stejně. print ukáže hodnotu člověku na obrazovce. return ji předá programu, aby s ní mohl dál pracovat.
def secti_a_vypis(a, b):
print(a + b)
def secti_a_vrat(a, b):
return a + b
prvni = secti_a_vypis(2, 3)
druhy = secti_a_vrat(2, 3)
print("prvni:", prvni)
print("druhy:", druhy)
5 prvni: None druhy: 5
První funkce pětku jen ukázala a nic nevrátila. Do proměnné prvni proto spadlo None, speciální hodnota znamenající „nic“. Vrací ji každá funkce, která nedojde k žádnému return s hodnotou.
S None se nedá počítat, takže chyba se objeví až o kus dál, třeba u secti_a_vypis(2, 3) * 10.
Stejně se chová metoda sort. Seřadí seznam na místě a vrátí None, takže serazeno = cisla.sort() uloží do proměnné jen None. Nový seřazený seznam vrací funkce sorted(cisla).
Co vypíše tento kód? def f(x): x * 2 a potom print(f(3)).
Funkce součin spočítá a hned zahodí, protože chybí return. Volání proto vrátí None a print ho vypíše.
return ukončí funkci
Jakmile Python narazí na return, funkci okamžitě opouští. Co je pod ním, se neprovede. Díky tomu nepotřebuješ dlouhé řetězy elif.
def znamka(body):
if body >= 90:
return 1
if body >= 75:
return 2
if body >= 60:
return 3
if body >= 45:
return 4
return 5
for pocet in [95, 80, 61, 12]:
print(pocet, "bodů, známka", znamka(pocet))
95 bodů, známka 1 80 bodů, známka 2 61 bodů, známka 3 12 bodů, známka 5
return uvnitř cyklu ukončí cyklus i celou funkci. Hodí se na hledání: jakmile máš, co jsi hledal, nemusíš procházet zbytek.
def prvni_zaporne(cisla):
for cislo in cisla:
print("kontroluji", cislo)
if cislo < 0:
return cislo
return None
print("nalezeno:", prvni_zaporne([4, 7, -2, 9, -5]))
print("nalezeno:", prvni_zaporne([1, 2]))
kontroluji 4 kontroluji 7 kontroluji -2 nalezeno: -2 kontroluji 1 kontroluji 2 nalezeno: None
Devítka a pětka z prvního seznamu se vůbec nekontrolovaly. Na konci funkce je return None jen proto, aby bylo vidět, že „nenašel jsem nic“ je zamýšlený výsledek.
První dlouhé slovo
Tahle funkce nalezené slovo jen vypisuje. Oprav ji tak, aby vrátila první slovo, které má aspoň delka znaků. Když takové není, vrátí None.
def prvni_dlouhe(slova, delka):
for slovo in slova:
if len(slovo) >= delka:
print(slovo)
Funkce obsahuje for i in range(5): a v těle cyklu rovnou return i. Co vrátí?
Při prvním průchodu je i rovno 0 a return funkci hned ukončí. Další průchody se nekonají.
Víc výsledků najednou
Funkce vrací vždy jednu hodnotu. Ta ale může být n-tice, a tu si volající rozbalí do několika proměnných.
def rozpeti(cisla):
return min(cisla), max(cisla)
nejmensi, nejvetsi = rozpeti([12, 3, 40, 7])
print(nejmensi, nejvetsi)
vysledek = rozpeti([5, 6])
print(vysledek, type(vysledek))
3 40 (5, 6) <class 'tuple'>
Sekundy na minuty
Napiš funkci na_minuty(sekundy), která vrátí dvě hodnoty: celé minuty a zbylé sekundy. Pro 125 vrátí (2, 5).
def na_minuty(sekundy):
# doplň
pass
Funkce skládané z funkcí
Výsledek jedné funkce může být rovnou argumentem druhé. Velký problém tak rozložíš na malé kousky, které jdou pochopit a vyzkoušet každý zvlášť.
def cena_radku(kusy, cena_za_kus):
return kusy * cena_za_kus
def s_dph(castka):
return round(castka * 1.21, 2)
def radek_uctenky(nazev, kusy, cena_za_kus):
celkem = s_dph(cena_radku(kusy, cena_za_kus))
return f"{nazev}: {celkem} Kč"
print(radek_uctenky("Káva", 2, 55))
print(radek_uctenky("Dort", 1, 89))
Káva: 133.1 Kč Dort: 107.69 Kč
Závorky se čtou zevnitř ven: nejdřív cena_radku, její výsledek jde do s_dph.
Pravidlo „definuj před voláním“ platí pro okamžik spuštění, ne pro pořadí v souboru. Funkce proto smí uvnitř svého těla používat jinou funkci definovanou níž, pokud v době volání už obě existují.
Pod kapotou · def je příkaz, který běží
V Pythonu není def deklarace jako v C nebo Javě. Překladač zkompiluje tělo do code objectu jednou, ale def je běžný příkaz, který za běhu vyrobí nový objekt funkce a přiřadí ho do jména. Proto jde funkci definovat v if, v cyklu nebo uvnitř jiné funkce. Každé provedení dá nový objekt nad stejným kódem.
def tovarna():
def vnitrni():
return 1
return vnitrni
a = tovarna()
b = tovarna()
print(a is b)
print(a.__code__ is b.__code__)
False True
Implicitní návrat není žádná magie. Překladač na konec těla doplní návrat konstanty None, v 3.12 instrukcí RETURN_CONST. Uvidíš ji přes dis.dis(funkce).
Od verze 3.11 volání Python funkce z Python kódu nezabírá další úroveň C zásobníku a rámce se vytvářejí líně (viz „What's New In Python 3.11“, část o rychlosti). Volání pořád něco stojí, ale rozbíjet kvůli tomu čitelný kód má smysl až po změření v profileru.
Pod kapotou · return v produkčním kódu
PEP 8 žádá konzistenci: buď všechny return ve funkci vracejí výraz, nebo žádný. Když některá větev vrací hodnotu, napiš na konci explicitně return None. Ruff to hlídá pravidly RET. Typová kontrola pak funkci vidí jako T | None a donutí volajícího řešit obě možnosti, viz typové anotace.
Pozor na return uvnitř finally. Přebije rozběhnutou výjimku a ta zmizí beze stopy.
def spolkne_chybu():
try:
1 / 0
finally:
return "žádná chyba se nekonala"
print(spolkne_chybu()) # vypíše text, ZeroDivisionError zmizelPython 3.12 to tiše dovolí. PEP 765 proto od verze 3.14 přidává na return, break a continue opouštějící finally varování SyntaxWarning.
return a, b staví n-tici čárka, ne závorky. Když výsledků přibývá, volající si začne plést pořadí. Od tří až čtyř hodnot bývá lepší NamedTuple nebo dataclass, které vracejí pole se jmény.