0 dní v řadě · 0 bodů

Funkce · 18 min

Parametry a výchozí hodnoty

Poziční a pojmenované argumenty, výchozí hodnoty a past s prázdným seznamem, která potrápí i zkušené programátory.

Hloubka
Úkoly
Lidsky řečeno

V kavárně řekneš jen „kávu“ a dostaneš tu běžnou, střední a bez cukru. To jsou výchozí hodnoty. Když chceš jinou, řekneš „velkou“ a zbytek zůstane. A protože barista ví, co znamená „velkou“, nezáleží na tom, jestli to řekneš před cukrem, nebo po něm. To jsou pojmenované argumenty.

Na pořadí záleží, dokud nepoužiješ jména

Argumenty se normálně přiřazují podle pořadí: první hodnota do prvního parametru, druhá do druhého. Takovým argumentům se říká poziční.

def rezervace(jmeno, osob, terasa):
    if terasa:
        misto = "terasa"
    else:
        misto = "uvnitř"
    return f"{jmeno}, {osob} os., {misto}"

print(rezervace("Anna", 4, True))
print(rezervace(4, "Anna", True))
Výstup
Anna, 4 os., terasa
4, Anna os., terasa

Druhý řádek je nesmysl, ale Python nemá jak to poznat. Číslo a text prostě uložil do parametrů v daném pořadí. A co vlastně znamená to True? Z volání to nikdo nevyčte, aniž by šel hledat definici.

Argument můžeš předat i pojmenovaně, zápisem jmeno=hodnota. Pořadí pak nehraje roli a volání se čte samo.

def rezervace(jmeno, osob, terasa):
    if terasa:
        misto = "terasa"
    else:
        misto = "uvnitř"
    return f"{jmeno}, {osob} os., {misto}"

print(rezervace(osob=4, terasa=True, jmeno="Anna"))
print(rezervace("Petr", osob=2, terasa=False))
Výstup
Anna, 4 os., terasa
Petr, 2 os., uvnitř

Tohle už znáš: print("a", "b", sep="-") je přesně pojmenovaný argument.

Když kombinuješ oba způsoby, poziční jdou první. Opačně to Python odmítne, ještě než cokoli spustí.

Každý parametr musí dostat právě jednu hodnotu. Python ohlídá chybějící i přebývající argumenty a jeho hlášky jsou přesné.

Volání funkce def f(a, b)Hláška
f(1)f() missing 1 required positional argument: 'b'
f(1, 2, 3)f() takes 2 positional arguments but 3 were given
f(1, a=2)f() got multiple values for argument 'a'
f(1, c=2)f() got an unexpected keyword argument 'c'
f(a=1, 2)positional argument follows keyword argument
Kvíz

Máš def f(a, b, c). Které volání je platné?

Výchozí hodnoty

Parametr s = v hlavičce je nepovinný. Když ho volající vynechá, použije se uvedená hodnota. Funkce tak zvládne běžný případ krátce a neobvyklý na požádání.

def konecna_cena(zaklad, sleva=0, doprava=99):
    return zaklad * (100 - sleva) / 100 + doprava

print(konecna_cena(1000))
print(konecna_cena(1000, 10))
print(konecna_cena(1000, doprava=0))
print(konecna_cena(1000, 10, 0))
Výstup
1099.0
999.0
1000.0
900.0

Třetí řádek je hlavní důvod, proč se pojmenované argumenty vyplatí: přeskočíš sleva a nastavíš jen doprava.

Stejně fungují vestavěné funkce. round(3.14159) a round(3.14159, 2) je jedna funkce s nepovinným druhým parametrem.

Parametry s výchozí hodnotou musí v hlavičce stát až za povinnými. Jinak by nešlo určit, ke kterému parametru patří poziční argument. Zápis def pozvanka(cas="18:00", jmeno): skončí hláškou parameter without a default follows parameter with a default.

Úkol

Cena jízdy

Napiš funkci cena_jizdy(km, sazba=18, nastupni=50). Vrátí nastupni + km * sazba.

def cena_jizdy(km):
    return km * 18
Výstup

Past: výchozí seznam

Tahle funkce má přidat věc do košíku. Když košík nedostane, má začít s prázdným. Vypadá to nevinně.

def pridej(vec, kosik=[]):
    kosik.append(vec)
    return kosik

print(pridej("chleba"))
print(pridej("mléko"))
print(pridej("máslo"))
Výstup
['chleba']
['chleba', 'mléko']
['chleba', 'mléko', 'máslo']

Každý zákazník měl začít s prázdným košíkem, a přesto se věci hromadí. Příčina: výchozí hodnota se vyrobí jednou, ve chvíli provedení def, a ne při každém volání. Všechna volání proto sdílejí tentýž seznam.

Moment vyhodnocení jde vidět přímo.

def vyrob_vychozi():
    print("Vyrábím výchozí hodnotu")
    return 10

def f(x=vyrob_vychozi()):
    return x

print("Definice je hotová")
print(f())
print(f())
Výstup
Vyrábím výchozí hodnotu
Definice je hotová
10
10

U čísel a textů to nevadí, protože je nejde změnit na místě. Problém dělají měnitelné hodnoty: seznam, slovník, množina. Správný vzor je výchozí None a nový objekt vyrobený až uvnitř funkce.

def pridej(vec, kosik=None):
    if kosik is None:
        kosik = []
    kosik.append(vec)
    return kosik

print(pridej("chleba"))
print(pridej("mléko"))

muj = ["sýr"]
print(pridej("víno", muj))
Výstup
['chleba']
['mléko']
['sýr', 'víno']
Úkol

Deník bez paměti

Funkce zapis má stejnou chybu jako košík. Oprav ji: bez druhého argumentu začne pokaždé s novým prázdným seznamem. Když seznam dostane, přidá záznam přímo do něj a ten samý seznam vrátí.

def zapis(udalost, denik=[]):
    denik.append(udalost)
    return denik
Výstup
Kvíz

Proč je def f(x, seznam=[]) nebezpečné?

Co funkce udělá s tím, co dostane

Parametr je nové jméno pro tentýž objekt, který předal volající. Nic se nekopíruje. Z lekce o referencích a kopiích už víš, co z toho plyne: změna objektu je vidět venku, přiřazení nového objektu do parametru ne.

def zmen_obsah(ceny):
    ceny.append(999)

def prirad_nove(ceny):
    ceny = [0, 0, 0]

moje = [100, 200]
zmen_obsah(moje)
print(moje)

prirad_nove(moje)
print(moje)
Výstup
[100, 200, 999]
[100, 200, 999]

Funkce, která potichu mění svůj vstup, umí překvapit. Když to není její výslovný účel, ať vrátí nový seznam a původní nechá být.

def se_slevou(ceny, procenta=10):
    return [round(cena * (100 - procenta) / 100, 2) for cena in ceny]

puvodni = [100, 250, 80]
nove = se_slevou(puvodni, 20)

print(puvodni)
print(nove)
Výstup
[100, 250, 80]
[80.0, 200.0, 64.0]

Python to dělá stejně: sorted(seznam) vrací nový seznam a seznam.sort() mění původní a vrací None. Jméno i návratová hodnota napovídají, co čekat.

Úkol

Zdražení bez vedlejších účinků

Funkce zdraz teď přepisuje seznam volajícího. Uprav ji, aby vrátila nový seznam s cenami zvýšenými o procenta (výchozí 10) a původní nechala beze změny. Výsledky zaokrouhli na 2 desetinná místa.

def zdraz(ceny, procenta=10):
    for i in range(len(ceny)):
        ceny[i] = round(ceny[i] * (100 + procenta) / 100, 2)
    return ceny
Výstup
Pod kapotou · kde výchozí hodnoty bydlí

Výchozí hodnoty leží na objektu funkce, poziční v n-tici __defaults__, keyword-only ve slovníku __kwdefaults__. Sdílený stav se dá přímo prohlédnout.

def pridej(vec, kosik=[]):
    kosik.append(vec)
    return kosik

pridej("a")
pridej("b")
print(pridej.__defaults__)
Výstup
(['a', 'b'],)

Stejná past nemá jen podobu seznamu. def log(zprava, cas=datetime.now()) zamrzne na čase importu a def f(cfg=nacti_konfiguraci()) sáhne na disk při importu modulu, ještě než proběhne nastavení prostředí. V testech se to projeví závislostí na pořadí, ve vláknech sdíleným stavem. Ruff (převzato z flake8-bugbear) hlásí B006 pro měnitelné výchozí hodnoty a B008 pro volání funkce v nich. dataclasses seznam jako výchozí hodnotu odmítnou s ValueError a chtějí field(default_factory=list).

Pod kapotou · když je None platná hodnota

Někdy potřebuješ rozlišit „nezadáno“ od „zadáno None“, například u PATCH požadavku, kde None znamená vymazat pole. Pomůže vlastní sentinel, objekt, který nikdo jiný nemá.

_CHYBI = object()

def nastav(hodnota=_CHYBI):
    if hodnota is _CHYBI:
        return "nezadáno, nechávám původní"
    return f"nastavuji na {hodnota!r}"

print(nastav())
print(nastav(None))
print(nastav(0))
Výstup
nezadáno, nechávám původní
nastavuji na None
nastavuji na 0

Pro typovou kontrolu je lepší výčet s jedním členem. PEP 484 ho doporučuje právě proto, že ho kontrolory umějí zúžit přes is, zatímco object() ne.

Předávání argumentů v Pythonu není ani „by value“, ani „by reference“ ve smyslu C++. Dokumentace mluví o předávání hodnotou, kde hodnota je vždy reference na objekt, často se používá název call by sharing. Rebinding parametru proto volajícího nezasáhne, mutace ano.