0 dní v řadě · 0 bodů

Funkce · 22 min

Funkce jako hodnoty, lambda, sorted, map

Funkci uložíš do proměnné, předáš ji jiné funkci a pomocí sorted, map a lambda seřadíš a přepočítáš data na jeden řádek.

Hloubka
Úkoly
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__)
Výstup
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)
Výstup
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))
Výstup
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í.

Úkol

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ň
Výstup

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))
Výstup
[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.

Kvíz

Máš def dvakrat(x): return x * 2. Co se stane při uprav_vse([1, 2], dvakrat(5))?

Úkol

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]))
Výstup

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)
Výstup
[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))
Výstup
['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))
Výstup
[('čaj', 45), ('káva', 65), ('dort', 95)]
('čaj', 45)
('dort', 95)
Petr

Poslední řá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))
Výstup
['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()))
Výstup

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í.

text
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))
Výstup
[('čaj', 45), ('káva', 65), ('dort', 95)]
[('dort', 95), ('káva', 65), ('čaj', 45)]
5

Poslední 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])))
Výstup
[('Adam', 1), ('Cyril', 1), ('Bára', 2), ('Eva', 2)]
[('Bára', 2), ('Eva', 2), ('Adam', 1), ('Cyril', 1)]
Úkol

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)]))
Výstup

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", ""])))
Výstup
[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)))
Výstup
[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))
Výstup
['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)))
Výstup
[9, 16]
[9, 16]
['1', '2', '3', '4']
Kvíz

Co vypíše druhý print? m = map(len, ["a", "bb"]), potom print(list(m)) a znovu print(list(m)).

Kvíz

Který zápis vrátí slova seřazená od nejdelšího?

Úkol

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))
Výstup
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)
Výstup
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)
Výstup
[('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]))
Výstup
[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š.