0 dní v řadě · 0 bodů

Funkce · 20 min

**kwargs, *args a pravidla volání

Funkce pro libovolný počet argumentů, rozbalování hvězdičkou a parametry, které lze předat jen jménem nebo jen pozicí.

Hloubka
Úkoly
Lidsky řečeno

Pozvánka na oslavu: „Přijďte, a kdo chce, ať vezme kohokoli dalšího.“ Předem nevíš, kolik lidí dorazí, tak u dveří stojí někdo se seznamem a všechny zapíše. Přesně to dělá hvězdička v hlavičce funkce. Posbírá všechno, co přijde navíc, a dá ti to jako jeden celek.

Libovolný počet argumentů

Chceš sečíst ceny na účtence. Někdy jsou dvě, někdy dvacet. Psát funkci pro každý počet nejde. Hvězdička před jménem parametru řekne: „sem seber všechny zbylé poziční argumenty“. Běžné parametry můžou stát před ní a naplní se první.

def uctenka(zakaznik, *ceny):
    print("ceny:", ceny)
    celkem = 0
    for cena in ceny:
        celkem += cena
    return f"{zakaznik} platí {celkem} Kč"

print(uctenka("Eva", 120, 45))
print(uctenka("Adam", 30, 30, 30, 10))
print(uctenka("Iva"))
Výstup
ceny: (120, 45)
Eva platí 165 Kč
ceny: (30, 30, 30, 10)
Adam platí 100 Kč
ceny: ()
Iva platí 0 Kč

Uvnitř je ceny obyčejná n-tice. Když nepřijde nic, je prázdná. print funguje stejně, proto mu můžeš dát kolik hodnot chceš.

Jméno args je jen zvyk. Rozhoduje hvězdička. V obecném kódu se píše *args, ale když to jde, zvol jméno, které něco říká, třeba *ceny.

Úkol

Průměr čehokoli

Napiš funkci prumer, která přijme libovolný počet čísel jako samostatné argumenty a vrátí jejich průměr. Bez argumentů vrátí 0.

def prumer():
    # doplň parametr i tělo
    pass
Výstup

Libovolné pojmenované argumenty

Dvě hvězdičky sbírají pojmenované argumenty, které nepatří žádnému parametru. Dostaneš je jako slovník, v pořadí, v jakém je volající napsal. Hodí se to tam, kde předem neznáš všechny volby. Třeba při skládání HTML značky, která může mít libovolné atributy.

def odkaz(text, **atributy):
    print("atributy:", atributy)
    casti = ""
    for nazev, hodnota in atributy.items():
        casti += f' {nazev}="{hodnota}"'
    return f"<a{casti}>{text}</a>"

print(odkaz("Domů", href="/"))
print(odkaz("Ceník", href="/cenik/", title="Naše ceny"))
print(odkaz("Nikam"))
Výstup
atributy: {'href': '/'}
<a href="/">Domů</a>
atributy: {'href': '/cenik/', 'title': 'Naše ceny'}
<a href="/cenik/" title="Naše ceny">Ceník</a>
atributy: {}
<a>Nikam</a>
def graf(titulek, **volby):
    barva = volby.get("barva", "černá")
    return f"{titulek}: {barva}"

print(graf("Tržby", barav="červená"))
Výstup
Tržby: černá
Kvíz

Co vrátí f([1, 2]), když platí def f(*a): return a?

Hvězdička při volání: rozbalení

Stejný znak funguje i obráceně. V definici hodnoty sbírá, ve volání je rozbaluje.

text
def f(*a):      sbírá:      f(1, 2, 3)      ->  a = (1, 2, 3)
f(*seznam):     rozbaluje:  f(*[1, 2, 3])   ==  f(1, 2, 3)
f(**slovnik):   rozbaluje:  f(**{"x": 1})   ==  f(x=1)
def vzdalenost(x, y):
    return abs(x) + abs(y)

bod = (3, -4)
print(vzdalenost(*bod))

souradnice = {"y": 2, "x": 5}
print(vzdalenost(**souradnice))

mesice = ["leden", "únor", "březen"]
print(*mesice, sep=" / ")
Výstup
7
7
leden / únor / březen

Spojením obou směrů vznikne obal: funkce, která něco přidá a všechno ostatní pošle beze změny dál. Tady oznam umí všechno co print, aniž bychom vypisovali jeho parametry.

def oznam(*hodnoty, **volby):
    print("[info]", *hodnoty, **volby)

oznam("Hotovo")
oznam("a", "b", "c", sep="-")
Výstup
[info] Hotovo
[info]-a-b-c

Volba sep se týká všeho, co print dostal, tedy i předpony [info].

Úkol

Rozbal a zavolej

Máš hotovou funkci a data. Jediným voláním funkce obdelnik ulož do proměnné popis výsledek s rozměry z rozmery a volbami ze volby. Výsledek má být 4 x 5 m.

def obdelnik(sirka, vyska, jednotka="cm"):
    return f"{sirka} x {vyska} {jednotka}"

rozmery = (4, 5)
volby = {"jednotka": "m"}

popis = obdelnik(rozmery, volby)
Výstup
Úkol

Skladatel adres

Napiš adresa(zaklad, *casti, **parametry). Části připoj za základ přes /. Pojmenované argumenty přidej na konec jako ?klic=hodnota&klic2=hodnota2. Bez nich otazník nepiš.

adresa("https://x.cz", "clanky", "12", strana=2, jazyk="cs") vrátí https://x.cz/clanky/12?strana=2&jazyk=cs.

def adresa(zaklad):
    return zaklad
Výstup

Jen jménem, jen pozicí

Vzpomeň si na záhadné True z minulé lekce. Volání zaloha("fotky", True, False) nikdo nepřečte. Samotná hvězdička v hlavičce říká: všechno za mnou se musí předat jménem.

def zaloha(soubor, *, komprimovat=False, prepsat=False):
    return f"{soubor}: komprimovat={komprimovat}, prepsat={prepsat}"

print(zaloha("fotky", prepsat=True))
print(zaloha("fotky", True, False))
Výstup
fotky: komprimovat=False, prepsat=True

Totéž platí pro parametry za *args. Proto u print musíš psát sep=: všechno ostatní by spadlo mezi vypisované hodnoty.

Lomítko je opak: všechno před ním se musí předat pozicí. Jména takových parametrů pak nejsou součástí veřejného rozhraní a autor je může kdykoli přejmenovat. Stejně se chová třeba len.

def rozdil(a, b, /):
    return abs(a - b)

print(rozdil(3, 10))
print(rozdil(a=3, b=10))
Výstup
7

Celé pořadí v hlavičce vypadá takhle. Žádnou část nemusíš použít, ale pořadí je pevné.

text
def f(a, b, /, c, d=0, *args, e, g=0, **kwargs):
      -------  ------  -----  ------  --------
         |       |       |      |        |
         |       |       |      |        +-- zbylé pojmenované (slovník)
         |       |       |      +----------- jen jménem
         |       |       +------------------ zbylé poziční (n-tice)
         |       +-------------------------- pozicí i jménem
         +---------------------------------- jen pozicí
ChcešPoužij
běžný parametrdef f(a)
nepovinnou volbudef f(a, b=1)
libovolně mnoho hodnotdef f(*hodnoty)
přepínač, který musí být čitelnýdef f(a, *, prepsat=False)
volnost přejmenovat parametrdef f(a, /)
poslat všechno dáldef f(*args, **kwargs)
Úkol

Kurz jen jménem

Uprav hlavičku prevod tak, aby kurz i mista šly předat jen jménem, zatímco castka zůstane normální. Volání prevod(100, 25.5) pak musí skončit chybou TypeError.

def prevod(castka, kurz, mista=2):
    return round(castka * kurz, mista)
Výstup
Kvíz

Máš def f(a, *, b). Které volání projde?

Pod kapotou · jak se argumenty párují

Při volání CPython nejdřív rozdá poziční argumenty do pozičních slotů, přebytek dá do *args (nebo vyhodí TypeError). Pak projde pojmenované: najde shodu podle jména mezi parametry, které jdou předat jménem, jinak je uloží do **kwargs. Nakonec doplní výchozí hodnoty a ohlásí, co chybí. Celý postup si vyzkoušíš bez volání přes inspect.signature(...).bind, což se hodí v dekorátorech a validátorech.

import inspect

def f(a, /, b, *c, d, **e):
    pass

svazano = inspect.signature(f).bind(1, 2, 3, 4, d=5, x=6)
print(svazano.arguments)
Výstup
{'a': 1, 'b': 2, 'c': (3, 4), 'd': 5, 'e': {'x': 6}}

Související návrhy: PEP 3102 (keyword-only), PEP 570 (positional-only), PEP 448 (rozbalení ve volání a literálech), PEP 468 (**kwargs drží pořadí) a PEP 692 (typování **kwargs přes Unpack[TypedDict], od 3.12). Pro obaly, které mají zachovat signaturu, slouží ParamSpec z PEP 612.

Pod kapotou · méně známé chování

Parametr před / uvolní své jméno, takže stejné jméno může přijít v **kwargs. Bez lomítka by tohle volání skončilo chybou got multiple values. Klíče navíc nemusí být platné identifikátory, jen řetězce, což řeší atributy jako class nebo data-id.

def tag(nazev, /, **atributy):
    return nazev, atributy

print(tag("a", nazev="odkaz"))
print(tag("div", **{"class": "box", "data-id": 7}))
Výstup
('a', {'nazev': 'odkaz'})
('div', {'class': 'box', 'data-id': 7})

Slučování slovníků a slučování argumentů se liší. V literálu {**a, **b} vyhraje poslední hodnota, ve volání je duplicitní klíč chyba.

def f(**kw):
    return kw

zaklad = {"timeout": 5}
uprava = {"timeout": 30}

print({**zaklad, **uprava})
print(f(**zaklad, **uprava))
Výstup
{'timeout': 30}

Ve funkci je **kw vždy nový slovník, takže jeho úprava volajícího neovlivní. To ale platí jen pro horní úroveň: vnořené seznamy zůstávají sdílené. V produkci skládej URL přes urllib.parse.urlencode, které řeší escapování. Ruční spojování z našeho úkolu je jen cvičení.