Lidsky řečeno
Jméno funkce funguje jako kontakt v telefonu. Máma není máma, je to štítek, za kterým je uložené číslo. To číslo můžeš uložit pod druhým jménem nebo ho poslat kamarádovi, a nikomu přitom nezazvoní. Zvoní to až po stisku tlačítka Volat. V Pythonu jsou tím tlačítkem závorky.
Jméno bez závorek
Doteď se funkce hlavně volaly. Teď si všimni rozdílu mezi pozdrav() a pozdrav. Se závorkami se funkce spustí a dostaneš její výsledek. Bez závorek dostaneš funkci samotnou, jako věc, se kterou se dá dál pracovat.
def pozdrav():
return "Ahoj!"
print(pozdrav())
print(type(pozdrav))
print(pozdrav.__name__)
Ahoj! <class 'function'> pozdrav
Funkce je v Pythonu hodnota stejně jako číslo nebo text. Můžeš ji přiřadit do další proměnné. Nevznikne tím kopie, jen druhý štítek na tutéž věc.
def pozdrav():
return "Ahoj!"
rekni_neco = pozdrav
print(rekni_neco())
print(rekni_neco.__name__)
print(rekni_neco is pozdrav)
Ahoj! pozdrav True
Když je funkce hodnota, smí být i v seznamu nebo ve slovníku. To je praktické. E-shop počítá dopravu pro každý způsob jinak a místo dlouhého if, elif, elif si výpočty uloží do slovníku podle názvu.
def posta(kg):
return 89 + 10 * kg
def vydejna(kg):
return 69 if kg <= 5 else 119
def osobne(kg):
return 0
DOPRAVA = {"pošta": posta, "výdejna": vydejna, "osobně": osobne}
vybrano = "výdejna"
vypocet = DOPRAVA[vybrano]
print(vypocet(3))
print(DOPRAVA["pošta"](3))
for nazev, funkce in DOPRAVA.items():
print(nazev, funkce(8))
69 119 pošta 169 výdejna 119 osobně 0
Zápis DOPRAVA["pošta"](3) vypadá divoce, ale čte se zleva: vezmi ze slovníku funkci a hned ji zavolej s číslem 3. Nový způsob dopravy pak znamená jednu funkci a jeden řádek ve slovníku. Zbytek programu se nemění.
Kalkulačka ze slovníku
Doplň slovník OPERACE, aby znaky "+", "-" a "*" ukazovaly na připravené funkce. Potom napiš spocitej(a, znak, b), která vybere funkci podle znaku a vrátí výsledek. Pro neznámý znak vrátí None.
def secti(a, b):
return a + b
def odecti(a, b):
return a - b
def vynasob(a, b):
return a * b
OPERACE = {} # doplň
def spocitej(a, znak, b):
pass # doplň
Funkce jako parametr
Když funkci můžeš uložit, můžeš ji i předat jiné funkci. Ta pak neřeší, co přesně se má udělat, jen kdy a s čím. Tahle funkce prochází seznam a konkrétní úpravu dostane zvenku.
def uprav_vse(polozky, uprava):
vysledek = []
for polozka in polozky:
vysledek.append(uprava(polozka))
return vysledek
def se_slevou(cena):
return cena * 0.9
print(uprav_vse([100, 250], se_slevou))
print(uprav_vse(["káva", "dort"], len))
print(uprav_vse(["káva", "dort"], str.upper))
[90.0, 225.0] [4, 4] ['KÁVA', 'DORT']
Jedna smyčka teď slouží třem různým účelům. Funguje s tvojí funkcí, s vestavěným len i s metodou str.upper. Funkci předané tímto způsobem se říká callback: ty ji dodáš a někdo jiný ji zavolá, až bude potřeba.
Máš def dvakrat(x): return x * 2. Co se stane při uprav_vse([1, 2], dvakrat(5))?
Závorky funkci spustí hned. Do uprava tak přijde výsledek 10 a Python u uprava(polozka) ohlásí, že číslo není možné volat. Správně je předat dvakrat bez závorek.
Výrobní linka
Napiš retez(hodnota, kroky). V kroky je seznam funkcí. Na hodnotu použij první funkci, na její výsledek druhou a tak dál. Vrať konečný výsledek. Prázdný seznam hodnotu nezmění.
def retez(hodnota, kroky):
pass # doplň
print(retez(" ahoj ", [str.strip, str.upper, len]))
sorted a parametr key
sorted vrátí nový seřazený seznam a původní nechá být. Čísla řadí podle velikosti, texty podle znaků. Parametr reverse=True pořadí otočí.
ceny = [120, 45, 300, 80]
print(sorted(ceny))
print(sorted(ceny, reverse=True))
print(ceny)
[45, 80, 120, 300] [300, 120, 80, 45] [120, 45, 300, 80]
Často ale chceš řadit podle něčeho jiného, než je hodnota sama. K tomu slouží parametr key. Předáš mu funkci, Python ji zavolá na každý prvek a řadí podle toho, co vrátí. Prvky samotné se nezmění.
ovoce = ["kiwi", "ananas", "fík", "hruška"]
print(sorted(ovoce))
print(sorted(ovoce, key=len))
['ananas', 'fík', 'hruška', 'kiwi'] ['fík', 'kiwi', 'ananas', 'hruška']
U seznamu dvojic si napíšeš malou funkci, která vybere, podle čeho se řadí. Totéž key umějí min a max.
produkty = [("káva", 65), ("čaj", 45), ("dort", 95)]
def cena(produkt):
return produkt[1]
print(sorted(produkty, key=cena))
print(min(produkty, key=cena))
print(max(produkty, key=cena))
hlasy = {"Anna": 12, "Petr": 30, "Eva": 21}
print(max(hlasy, key=hlasy.get))
[('čaj', 45), ('káva', 65), ('dort', 95)]
('čaj', 45)
('dort', 95)
PetrPoslední řádek stojí za pozornost. Procházení slovníku dává klíče a hlasy.get je funkce, která ke klíči vrátí hodnotu. Výsledkem je jméno s nejvíc hlasy.
Texty mají jeden háček. Python je řadí podle čísel znaků v Unicode, takže velká písmena jsou před malými a česká písmena s háčkem až za z.
jmena = ["Zita", "adam", "Čeněk", "Bára"]
print(sorted(jmena))
print(sorted(jmena, key=str.lower))
['Bára', 'Zita', 'adam', 'Čeněk'] ['adam', 'Bára', 'Zita', 'Čeněk']
key=str.lower srovná velikost písmen, ale Čeněk zůstává na konci. Správné české řazení probírá blok pro zkušené níž.
slova = ["pes", "kočka"]
print(sorted(slova, key=len()))
lambda: funkce na jedno použití
Psát def cena(...) kvůli jedinému řazení je trochu zbytečné. lambda je krátký zápis funkce přímo na místě, kde ji potřebuješ. Nemá jméno a obsahuje jediný výraz, jehož hodnota se automaticky vrátí.
lambda produkt: produkt[1]
^^^^^^^ ^^^^^^^^^^
parametr co se vrátí (bez slova return)produkty = [("káva", 65), ("čaj", 45), ("dort", 95)]
print(sorted(produkty, key=lambda p: p[1]))
print(sorted(produkty, key=lambda p: p[1], reverse=True))
secti = lambda a, b: a + b
print(secti(2, 3))
[('čaj', 45), ('káva', 65), ('dort', 95)]
[('dort', 95), ('káva', 65), ('čaj', 45)]
5Poslední ukázka funguje, ale nedělej to. Když chceš funkci pojmenovat, napiš def. Lambda se hodí tam, kde je krátká a kde ji hned někomu předáváš.
Řadit můžeš i podle několika hledisek. Funkce vrátí n-tici, Python porovná první položky a při shodě přejde na další. Mínus u čísla otočí směr jen pro tuhle položku.
zaci = [("Eva", 2), ("Adam", 1), ("Bára", 2), ("Cyril", 1)]
# nejlepší známka první, při shodě podle abecedy
print(sorted(zaci, key=lambda z: (z[1], z[0])))
# nejhorší známka první, při shodě podle abecedy
print(sorted(zaci, key=lambda z: (-z[1], z[0])))
[('Adam', 1), ('Cyril', 1), ('Bára', 2), ('Eva', 2)]
[('Bára', 2), ('Eva', 2), ('Adam', 1), ('Cyril', 1)]Největší objednávky nahoře
Napiš serad_objednavky(objednavky). Dostane seznam dvojic (jmeno, castka) a vrátí nový seznam seřazený od nejvyšší částky. Při stejné částce jdou jména podle abecedy. Původní seznam se nesmí změnit.
def serad_objednavky(objednavky):
pass # doplň
print(serad_objednavky([("Petr", 100), ("Anna", 300), ("Eva", 100)]))
map a filter
map(funkce, data) použije funkci na každý prvek. filter(funkce, data) nechá jen prvky, u kterých funkce vrátí pravdivou hodnotu. Obě jsou líné: nespočítají nic předem a výsledek vydávají postupně, až když si o něj někdo řekne. Proto je obvykle obalíš do list.
vstup = "12 7 30"
cisla = list(map(int, vstup.split()))
print(cisla)
print(sum(map(len, ["káva", "čaj"])))
suda = list(filter(lambda x: x % 2 == 0, cisla))
print(suda)
print(list(filter(None, ["a", "", "b", ""])))
[12, 7, 30] 7 [12, 30] ['a', 'b']
filter(None, ...) je zkratka pro „nech jen pravdivé hodnoty“, tady neprázdné texty. map umí vzít i víc seznamů naráz a skončí s tím nejkratším.
kusy = [2, 1, 3]
ceny = [65, 95, 45]
print(list(map(lambda k, c: k * c, kusy, ceny)))
[130, 95, 135]
Líný výsledek se dá projít jen jednou. Potom je prázdný, a to bez jakéhokoli varování.
velka = map(str.upper, ["a", "b"])
print(list(velka))
print(list(velka))
['A', 'B'] []
Totéž umí comprehension, kterou už znáš, a často je čitelnější. Rozumné pravidlo: máš hotovou pojmenovanou funkci, klidně použij map. Pokud by to znamenalo psát lambdu, napiš comprehension.
cisla = [1, 2, 3, 4]
print(list(map(lambda x: x * x, filter(lambda x: x > 2, cisla))))
print([x * x for x in cisla if x > 2])
print(list(map(str, cisla)))
[9, 16] [9, 16] ['1', '2', '3', '4']
Co vypíše druhý print? m = map(len, ["a", "bb"]), potom print(list(m)) a znovu print(list(m)).
Výsledek map je jednorázový. První list ho vyčerpal, takže při druhém průchodu už nic nezbývá. Když ho potřebuješ víckrát, ulož si hotový seznam.
Který zápis vrátí slova seřazená od nejdelšího?
Funkci nejde obrátit mínusem, proto ji obalí lambda. Ekvivalentní je sorted(slova, key=len, reverse=True). Metoda sort vrací None.
Drahé zboží na ceduli
Napiš drahe_nazvy(produkty, limit). V produkty jsou dvojice (nazev, cena). Vrať seznam názvů produktů s cenou aspoň limit, velkými písmeny a seřazený podle abecedy. Můžeš použít filter a map, nebo comprehension.
def drahe_nazvy(produkty, limit):
pass # doplň
print(drahe_nazvy([("mleko", 25), ("kava", 180), ("dort", 95)], 90))
Pod kapotou · co sorted skutečně dělá
list.sort a sorted používají Timsort, od CPythonu 3.11 s pravidlem slučování powersort. Na částečně seřazených datech se blíží O(n), nejhůř je O(n log n). Klíč se počítá přesně jednou na prvek a uloží se vedle něj, takže drahý key nezaplatíš n log n krát.
volani = 0
def klic(x):
global volani
volani += 1
return -x
sorted(range(1000), key=klic)
print(volani)
1000
Řazení je stabilní: prvky se stejným klíčem si drží původní pořadí, a to i s reverse=True. Díky tomu můžeš řadit v několika průchodech od nejméně důležitého hlediska. To se hodí tam, kde mínus nejde použít, třeba sestupně podle textu a vzestupně podle čísla.
from operator import itemgetter
radky = [("b", 2), ("a", 2), ("c", 1), ("a", 1)]
radky.sort(key=itemgetter(1))
radky.sort(key=itemgetter(0), reverse=True)
print(radky)
[('c', 1), ('b', 2), ('a', 1), ('a', 2)]operator.itemgetter a attrgetter jsou psané v C, bývají rychlejší než lambda a umějí víc polí naráz: itemgetter(1, 0).
Porovnává se jen operátorem <. Z toho plyne nepříjemná produkční past: NaN není menší ani větší než nic, takže rozbije předpoklady algoritmu. Nevznikne chyba, jen tiše špatné pořadí.
nan = float("nan")
print(sorted([3.0, nan, 1.0, 2.0]))
[3.0, nan, 1.0, 2.0]
Před řazením dat z vnějšku proto NaN odfiltruj nebo ho přesuň klíčem, například key=lambda x: (x != x, x). Stejný trik řeší None, které by jinak skončilo TypeError: key=lambda x: (x is None, x). Dvě None se operátorem < neporovnají ani tady, protože porovnání n-tic přeskakuje položky, které jsou tentýž objekt nebo si jsou rovné.
České řazení (ch za h, č za c) vyžaduje kolaci. Standardní cesta je locale.setlocale a key=locale.strxfrm, ale nastavení je globální pro proces a závisí na tom, jaké locale má systém nainstalované. V kontejnerech často žádné české není. Spolehlivější je PyICU, nebo řazení přenechat databázi.
Pod kapotou · lambda, map a výkon
Lambda vytvoří úplně stejný objekt jako def, liší se jen __name__ == "<lambda>". To se projeví ve výpisech chyb a v profileru, kde jsou všechny lambdy stejné. Standardní pickle je navíc neumí uložit, takže je nepředáš do ProcessPoolExecutor. PEP 8 přiřazení lambdy do jména výslovně nedoporučuje.
O rychlosti rozhoduje hlavně to, kolik se volá Pythonu. map s funkcí v C (int, len, str.upper) je velmi rychlý. map s lambdou platí za volání na každý prvek, zatímco comprehension má výraz přímo v těle a od 3.12 se navíc vkládá do okolní funkce (PEP 709). Čísla si změř přes timeit na svých datech.
Lenost má vedlejší efekt: chyba z mapované funkce nastane až při čtení, klidně daleko od řádku s map. A map přes více vstupů tiše skončí s nejkratším. Když je rozdílná délka chyba, ve 3.12 napiš zip(a, b, strict=True).
Vázaná metoda jako hlasy.get se vytváří při každém přístupu, takže hlasy.get is hlasy.get je False, ale == platí. Při odhlašování callbacků porovnávej přes ==, jinak registraci nenajdeš.