Lidsky řečeno
Když odcházíš z domu, zabalíš si batoh. Dům pak klidně může zamknout někdo jiný a ty máš svoje věci pořád s sebou. Closure je funkce s takovým batohem. Vznikne uvnitř jiné funkce, odnese si z ní proměnné, které potřebuje, a používá je i dlouho poté, co ta vnější funkce skončila.
Skoro stejné funkce
Potřebuješ počítat cenu s DPH pro dvě sazby. První nápad vede ke dvěma téměř shodným funkcím.
def s_dph_21(cena):
return round(cena * 1.21, 2)
def s_dph_12(cena):
return round(cena * 1.12, 2)
print(s_dph_21(100))
print(s_dph_12(100))
121.0 112.0
Nabízí se přidat parametr sazba, jenže map nebo key z minulé lekce chtějí funkci s jedním parametrem. Lepší je napsat funkci, která funkce vyrábí. Dostane sazbu a vrátí hotovou kalkulačku pro tuto sazbu.
def s_dph(sazba):
def spocitej(cena):
return round(cena * (1 + sazba / 100), 2)
return spocitej
zakladni = s_dph(21)
snizena = s_dph(12)
print(zakladni(100))
print(snizena(100))
print(list(map(snizena, [50, 80, 200])))
121.0 112.0 [56.0, 89.6, 224.0]
Takové funkci se říká továrna na funkce. Všimni si, že return spocitej je bez závorek. Vrací se funkce samotná, ne její výsledek.
Co je closure
Na ukázce je něco zvláštního. Když se s_dph(21) dokončí, její lokální proměnná sazba by podle všeho, co víš o funkcích, měla zaniknout. Přesto ji spocitej používá později a číslo 21 má k dispozici.
Closure (česky uzávěr) je funkce spolu s proměnnými z okolní funkce, které používá. Python pozná, že vnitřní funkce sazba potřebuje, a udrží ji při životě.
s_dph(21) ──vrátí──► spocitej + batoh { sazba: 21 }
s_dph(12) ──vrátí──► spocitej + batoh { sazba: 12 }Každé zavolání vnější funkce vytvoří nové proměnné, takže každá vyrobená funkce má vlastní batoh. Navzájem se neovlivňují.
def pozdrav_v_jazyce(uvod):
def pozdrav(jmeno):
return f"{uvod}, {jmeno}!"
return pozdrav
cesky = pozdrav_v_jazyce("Ahoj")
anglicky = pozdrav_v_jazyce("Hello")
print(cesky("Evo"))
print(anglicky("Eve"))
print(cesky("Petře"))
Ahoj, Evo! Hello, Eve! Ahoj, Petře!
V batohu ale neleží kopie hodnoty. Leží tam sama proměnná. Když se po vzniku funkce změní, funkce uvidí novou hodnotu. Tohle se za chvíli ukáže jako klíč k nejčastější pasti.
def ukazka():
zprava = "původní"
def precti():
return zprava
zprava = "změněná"
return precti
f = ukazka()
print(f())
změněná
Hlídač rozsahu
Napiš továrnu omezovac(dolni, horni). Vrátí funkci s jedním parametrem, která hodnotu menší než dolni nahradí za dolni, větší než horni za horni a ostatní nechá být.
def omezovac(dolni, horni):
pass # doplň
hlasitost = omezovac(0, 100)
print(hlasitost(140))
Paměť mezi voláními: nonlocal
Closure si může pamatovat i něco, co se mění, třeba počet kliknutí. První pokus ale selže. Přiřazení pocet += 1 udělá z pocet lokální proměnnou vnitřní funkce, přesně podle pravidla z lekce o rozsahu platnosti. A lokální proměnná zatím žádnou hodnotu nemá.
def vytvor_pocitadlo():
pocet = 0
def klik():
pocet += 1
return pocet
return klik
klik = vytvor_pocitadlo()
print(klik())
Slovo nonlocal říká: tohle jméno nepatří mně, patří okolní funkci. Pak přiřazení změní proměnnou v batohu.
def vytvor_pocitadlo():
pocet = 0
def klik():
nonlocal pocet
pocet += 1
return pocet
return klik
prvni = vytvor_pocitadlo()
druhe = vytvor_pocitadlo()
print(prvni(), prvni(), prvni())
print(druhe())
1 2 3 1
Oproti global je tady každé počítadlo samostatné a nikdo zvenku se mu do čísla nedostane. nonlocal je potřeba jen při přiřazení do jména. Když obsah seznamu nebo slovníku jen měníš, jméno se nepřepisuje a stačí ho číst.
def vytvor_kosik():
polozky = []
def pridej(nazev):
polozky.append(nazev)
return len(polozky)
return pridej
pridej = vytvor_kosik()
print(pridej("káva"))
print(pridej("dort"))
1 2
Několik vnitřních funkcí může sdílet tentýž batoh. Vznikne malý objekt se skrytým stavem.
def vytvor_penezenku(zustatek):
def vloz(castka):
nonlocal zustatek
zustatek += castka
def stav():
return zustatek
return vloz, stav
vloz, stav = vytvor_penezenku(100)
vloz(50)
vloz(25)
print(stav())
175
Kdy potřebuješ ve vnitřní funkci nonlocal?
Čtení funguje samo a append jméno nepřepisuje. Teprve přiřazení by bez nonlocal vytvořilo novou lokální proměnnou.
Hlídač útraty
Napiš rozpocet(limit). Vrátí funkci utrat(castka). Když se částka vejde do zbývajícího limitu, odečte ji a vrátí True. Když ne, nic neodečte a vrátí False.
def rozpocet(limit):
pass # doplň
utrat = rozpocet(100)
print(utrat(30), utrat(80), utrat(70))
Past: funkce vytvořené v cyklu
Tohle je nejznámější chyba s closures. Chceš tři funkce, které vrátí 0, 1 a 2. Dostaneš tři stejné.
def vytvor_funkce():
funkce = []
for i in range(3):
funkce.append(lambda: i)
return funkce
for f in vytvor_funkce():
print(f())
2 2 2
Důvod už znáš: v batohu je proměnná, ne její tehdejší hodnota. Všechny tři funkce sdílejí jedno i a volají se až po skončení cyklu, kdy v něm zůstala dvojka. Tomuto chování se říká pozdní vazba. Řešení jsou dvě běžná. Buď pro každý průchod vytvoříš nový batoh přes továrnu, nebo hodnotu uložíš do výchozího parametru, který se vyhodnotí při vzniku funkce.
def vrat_hodnotu(n):
return lambda: n
pres_tovarnu = [vrat_hodnotu(i) for i in range(3)]
pres_vychozi = [lambda i=i: i for i in range(3)]
print([f() for f in pres_tovarnu])
print([f() for f in pres_vychozi])
[0, 1, 2] [0, 1, 2]
Oprav násobiče
Funkce má vrátit pět násobičů: první násobí jedničkou, druhý dvojkou a poslední pětkou. Teď všechny násobí pětkou. Oprav to.
def vytvor_nasobice():
nasobice = []
for n in range(1, 6):
nasobice.append(lambda x: x * n)
return nasobice
print([f(10) for f in vytvor_nasobice()])
K čemu se to hodí
Nejsilnější použití je funkce, která dostane funkci a vrátí vylepšenou funkci. Tahle si pamatuje už spočítané výsledky, takže se drahý výpočet neopakuje.
def s_pameti(funkce):
pamet = {}
def obal(x):
if x not in pamet:
print(f"počítám {x}")
pamet[x] = funkce(x)
return pamet[x]
return obal
def druha_mocnina(x):
return x * x
rychla = s_pameti(druha_mocnina)
print(rychla(4))
print(rychla(4))
print(rychla(5))
počítám 4 16 16 počítám 5 25
Původní funkce se vůbec nezměnila, jen dostala obal s pamětí. Přesně na tomhle stojí dekorátory, které potkáš později.
Pro jednoduché „předvyplnění“ parametrů nemusíš closure psát vůbec. Standardní knihovna má functools.partial.
from functools import partial
def s_dph(cena, sazba):
return round(cena * (1 + sazba / 100), 2)
snizena = partial(s_dph, sazba=12)
print(snizena(100))
print(list(map(snizena, [50, 80])))
112.0 [56.0, 89.6]
Zavoláš dvakrát a = vytvor_pocitadlo() a b = vytvor_pocitadlo(). Třikrát zavoláš a() a jednou b(). Co vrátí to b()?
Každé zavolání továrny vytvoří vlastní proměnnou pocet, takže a a b nic nesdílejí.
Spustit jen jednou
Napiš jen_jednou(funkce). Vrátí novou funkci, která při prvním zavolání spustí funkce se všemi předanými argumenty a výsledek si uloží. Každé další zavolání vrátí uložený výsledek a funkce už nespustí, a to i když vrátila None.
def jen_jednou(funkce):
pass # doplň
def nacti(nazev):
print("načítám", nazev)
return nazev.upper()
f = jen_jednou(nacti)
print(f("a"))
print(f("b"))
Pod kapotou · buňky: jak CPython closure ukládá
Překladač už při kompilaci ví, které lokální proměnné používá vnořená funkce. Takové proměnné neleží přímo v rámci, ale v objektu cell. Vnější funkce i closure drží odkaz na tutéž buňku, proto je vidět každá změna. Jména najdeš v co_cellvars a co_freevars, buňky v __closure__.
import dis
def nasobic(n):
def f(x):
return x * n
return f
trojka = nasobic(3)
print(nasobic.__code__.co_cellvars)
print(trojka.__code__.co_freevars)
print(trojka.__closure__[0].cell_contents)
print([i.opname for i in dis.get_instructions(trojka)])
trojka.__closure__[0].cell_contents = 10
print(trojka(2))
('n',)
('n',)
3
['COPY_FREE_VARS', 'RESUME', 'LOAD_FAST', 'LOAD_DEREF', 'BINARY_OP', 'RETURN_VALUE']
20COPY_FREE_VARS při startu zkopíruje buňky do rámce a LOAD_DEREF čte hodnotu přes buňku. Přístup je tak jen o krok dražší než LOAD_FAST. Rozsahy zavedl PEP 227, klíčové slovo nonlocal PEP 3104. nonlocal se řeší při kompilaci: pokud jméno v žádné okolní funkci není, dostaneš SyntaxError ještě před spuštěním.
Rámec vnější funkce po návratu zaniká a přežívají jen použité buňky. Closure tedy nedrží celé okolí, ale drží celý objekt v zachycené proměnné. Callback v globálním registru, který si z okolí vzal velkou tabulku kvůli jedinému číslu, tuto tabulku nepustí. Vytáhni si to číslo do vlastní proměnné ještě před definicí funkce.
Rekurzivní vnitřní funkce vytvoří cyklus funkce, __closure__, buňka, funkce. Počítání referencí ho neuvolní, musí zasáhnout cyklický garbage collector.
Pod kapotou · pasti a volba mezi closure a třídou
Oprava přes lambda x, n=n: rozšiřuje signaturu, takže volající může n omylem přepsat druhým pozičním argumentem. Čistší je lambda x, *, n=n: nebo functools.partial. Pozdní vazba platí i pro [lambda: i for i in range(3)]. Vkládání comprehensions z PEP 709 tohle chování zachovává.
Tělo třídy není okolní rozsah pro vnořené funkce. Metoda nevidí atribut třídy holým jménem a comprehension v těle třídy nevidí proměnné třídy ve výrazu pro prvek. Ani 3.12 na tom nic nemění.
Closures nejdou standardně serializovat: pickle funkci ukládá jako cestu k ní a modul.nasobic.<locals>.f se importovat nedá. V ProcessPoolExecutor proto skončí chybou Can't pickle local object. Funkce na úrovni modulu zabalená do partial projde.
Praktické měřítko: jedna operace a malý stav znamená closure. Několik operací, potřeba stav prohlížet, testovat nebo serializovat znamená třídu. Třída s __call__ je pak rozumný mezistupeň.