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"))
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.
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
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"))
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á"))
Tržby: černá
Co vrátí f([1, 2]), když platí def f(*a): return a?
Předal jsi jeden argument, a to seznam. N-tice má tedy jeden prvek. Aby se seznam rozložil, musel bys volat f(*[1, 2]).
Hvězdička při volání: rozbalení
Stejný znak funguje i obráceně. V definici hodnoty sbírá, ve volání je rozbaluje.
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=" / ")
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="-")
[info] Hotovo [info]-a-b-c
Volba sep se týká všeho, co print dostal, tedy i předpony [info].
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)
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
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))
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))
7
Celé pořadí v hlavičce vypadá takhle. Žádnou část nemusíš použít, ale pořadí je pevné.
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ý parametr | def f(a) |
| nepovinnou volbu | def f(a, b=1) |
| libovolně mnoho hodnot | def f(*hodnoty) |
| přepínač, který musí být čitelný | def f(a, *, prepsat=False) |
| volnost přejmenovat parametr | def f(a, /) |
| poslat všechno dál | def f(*args, **kwargs) |
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)
Máš def f(a, *, b). Které volání projde?
b stojí za hvězdičkou, takže je povinné a jde předat jen jménem. f(1, 2) má o poziční argument víc, f(1) ho vynechává úplně.
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)
{'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}))
('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))
{'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í.