0 dní v řadě · 0 bodů

Funkce · 22 min

Closures

Funkce si umí zapamatovat proměnné z místa, kde vznikla. Naučíš se vyrábět funkce na míru, držet v nich stav a vyhnout se pasti v cyklu.

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

text
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"))
Výstup
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())
Výstup
změněná
Úkol

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

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

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())
Výstup
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"))
Výstup
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())
Výstup
175
Kvíz

Kdy potřebuješ ve vnitřní funkci nonlocal?

Úkol

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

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())
Výstup
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])
Výstup
[0, 1, 2]
[0, 1, 2]
Úkol

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

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))
Výstup
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])))
Výstup
112.0
[56.0, 89.6]
Kvíz

Zavoláš dvakrát a = vytvor_pocitadlo() a b = vytvor_pocitadlo(). Třikrát zavoláš a() a jednou b(). Co vrátí to b()?

Úkol

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"))
Výstup
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))
Výstup
('n',)
('n',)
3
['COPY_FREE_VARS', 'RESUME', 'LOAD_FAST', 'LOAD_DEREF', 'BINARY_OP', 'RETURN_VALUE']
20

COPY_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ň.