0 dní v řadě · 0 bodů

Funkce · 20 min

Rozsah platnosti a pravidlo LEGB

Kde proměnná platí, jak Python hledá jména, proč padá UnboundLocalError a proč se global většinou nevyplatí.

Hloubka
Úkoly
Lidsky řečeno

Hledáš nůžky. Nejdřív se podíváš na svůj stůl. Pak do kanceláře, ve které sedíš. Potom do společného skladu firmy. A když nejsou ani tam, zbývá základní vybavení, které má budova odjakživa. Jakmile je najdeš, hledat přestaneš. Python hledá jména úplně stejně. A to, co si položíš na svůj stůl, kolegové nevidí.

Co vznikne ve funkci, zůstane ve funkci

Proměnná vytvořená uvnitř funkce je lokální. Existuje jen během volání a zvenčí není vidět. Totéž platí pro parametry.

def spocitej(cena):
    dan = cena * 0.21
    return cena + dan

print(spocitej(100))
print(dan)
Výstup
121.0

Díky tomu můžou dvě funkce používat stejné jméno, třeba vysledek, a nijak si nepřekážejí. Nemusíš znát vnitřek každé funkce, abys ji mohl bezpečně volat. Každé volání navíc začíná s čistým stolem: lokální proměnné si mezi voláními nic nepamatují.

Číst smíš, přiřadit ne

Proměnná vytvořená mimo všechny funkce je globální, platí v celém souboru. Funkce ji může přečíst. Dívá se na ni až v okamžiku volání, takže vidí aktuální hodnotu, ne tu z doby definice.

sazba = 21

def s_dani(cena):
    return cena * (100 + sazba) / 100

print(s_dani(1000))

sazba = 12
print(s_dani(1000))
Výstup
1210.0
1120.0

Jakmile ale jménu uvnitř funkce něco přiřadíš, vznikne nová lokální proměnná. Ta globální zůstane nedotčená, jen je pro tuto funkci zakrytá.

zprava = "venku"

def f():
    zprava = "uvnitř"
    print("ve funkci:", zprava)

f()
print("mimo funkci:", zprava)
Výstup
ve funkci: uvnitř
mimo funkci: venku
Kvíz

Co vypíše tento kód? x = 1, potom def f(): x = 2, potom f() a print(x).

Nejzáludnější chyba: UnboundLocalError

Tohle vypadá, že by fungovat mělo. Přečteš globální zustatek, odečteš, hotovo.

zustatek = 1000

def vyber(castka):
    zustatek = zustatek - castka
    return zustatek

print(vyber(200))
Výstup

Hláška cannot access local variable 'zustatek' where it is not associated with a value překvapí každého. Python totiž o druhu proměnné rozhoduje pro celou funkci předem, ještě před jejím spuštěním. Vidí v těle přiřazení do zustatek, takže je to lokální proměnná od prvního do posledního řádku. Pravá strana pak čte lokální proměnnou, která ještě nemá hodnotu.

zustatek -= castka dopadne stejně, protože je to taky přiřazení. Pořadí řádků nepomůže: kdyby funkce jméno nejdřív vypsala a přiřadila mu až pod tím, spadne už na tom výpisu.

global a lepší cesta

Klíčové slovo global říká: „tohle jméno ve funkci znamená globální proměnnou“. Chyba zmizí, ale platí se za to. Z volání zapocitej() není vidět, co se mění. Výsledek závisí na tom, co a v jakém pořadí proběhlo předtím, a funkce nejde vyzkoušet samostatně. Skoro vždy je lepší předat stav parametrem a nový stav vrátit. Obě cesty vedle sebe:

pocet = 0

def zapocitej():
    global pocet
    pocet += 1

zapocitej()
zapocitej()
print("přes global:", pocet)

def dalsi(stav):
    return stav + 1

stav = 0
stav = dalsi(stav)
stav = dalsi(stav)
print("přes parametr:", stav)
Výstup
přes global: 2
přes parametr: 2

U druhé verze je všechno, co funkce potřebuje, vidět v jejím volání. Globální proměnné mají dobré místo pro konstanty, které se nemění. Píšou se velkými písmeny, třeba SAZBA_DPH = 21.

Pozor na rozdíl mezi přiřazením a změnou objektu. kosik.append(vec) nic nepřiřazuje, takže ve funkci projde i bez global. Skrytá závislost tam ale zůstává.

Úkol

Pokladna bez globálu

Funkce vyber padá na UnboundLocalError. Přepiš ji bez global: přijme dva parametry, zustatek a castka, a vrátí nový zůstatek. Pod ní pak spočítej dva výběry, 200 a 300, a výsledek ulož do proměnné konecny.

zustatek = 1000

def vyber(castka):
    zustatek = zustatek - castka
    return zustatek
Výstup

LEGB: pořadí hledání

Když Python narazí na jméno, prochází čtyři úrovně a bere první shodu.

text
B  Built-in    vestavěná jména: print, len, sum ...
^
G  Global      nejvyšší úroveň souboru
^
E  Enclosing   funkce, ve které je ta naše vnořená
^
L  Local       aktuální funkce            <- začíná se tady

Novinka je úroveň E. Funkci můžeš definovat uvnitř jiné funkce a vnitřní pak vidí proměnné té vnější. V téhle ukázce pochází každé jméno z jiné úrovně.

sazba = 21                                  # G

def vypocet():
    mena = "Kč"                             # E pro vnitrni
    def vnitrni(cena):
        s_dani = cena * (100 + sazba) / 100 # cena, s_dani: L, sazba: G
        return f"{round(s_dani)} {mena}"    # round: B, mena: E
    return vnitrni(1000)

print(vypocet())
Výstup
1210 Kč

Když je stejné jméno na víc úrovních, vyhrává to nejbližší. Proto lokální proměnná zakryje stejně pojmenovanou globální.

Pro přiřazení do proměnné vnější funkce slouží nonlocal. Je to obdoba global o úroveň níž a naplno ho využiješ v lekci o closures.

def hra():
    skore = 0
    def pridej(body):
        nonlocal skore
        skore += body
    pridej(3)
    pridej(4)
    return skore

print(hra())
Výstup
7

Poslední úroveň skrývá častou nehodu. Vestavěná jména nejsou chráněná, takže je snadno zastíníš vlastní proměnnou. Vestavěná funkce je pak nedostupná.

sum = 0
for cislo in [1, 2, 3]:
    sum += cislo
print(sum)

print(sum([4, 5]))
Výstup
6

Typičtí viníci jsou list, dict, str, id, max, min, sum, input, type. Když se ti to stane v interaktivní konzoli, del sum vlastní jméno odstraní a vestavěná funkce je zase vidět.

Úkol

Vrať vestavěné funkce

Funkce má vrátit součet a průměr, ale padá. Oprav ji, aby shrnuti([1, 2, 3]) vrátilo (6, 2.0).

def shrnuti(cisla):
    sum = sum(cisla)
    len = len(cisla)
    return sum, sum / len
Výstup
Úkol

Vnitřní počítadlo

Vnitřní funkce zapocti má zvyšovat proměnnou pocet z vnější funkce, ale padá. Oprav to, aby spocitej_kladne vrátila počet kladných čísel.

def spocitej_kladne(cisla):
    pocet = 0
    def zapocti():
        pocet += 1
    for cislo in cisla:
        if cislo > 0:
            zapocti()
    return pocet
Výstup
Kvíz

V jakém pořadí Python hledá jméno?

Co nový rozsah nevytváří

Nový rozsah vzniká u funkce, ne u každého odsazeného bloku. Proměnné z if a for po skončení bloku dál existují. Comprehension je výjimka: její proměnná zůstává uvnitř, takže poslední řádek ukázky skončí chybou.

if True:
    zprava = "z ifu"

for i in range(3):
    posledni = i * 10

print(zprava)
print(i, posledni)

ctverce = [n * n for n in range(3)]
print(ctverce)
print(n)
Výstup
z ifu
2 20
[0, 1, 4]
Kvíz

Co vypíše for i in range(3): pass a pod tím print(i)?

Pod kapotou · rozsah se určuje při překladu

Překladač projde tělo funkce a každé jméno zařadí jednou provždy. Výsledek je vidět přímo na code objectu.

sazba = 21

def vnejsi():
    mena = "Kč"
    def vnitrni(cena):
        s_dani = cena * sazba
        return mena, len(str(s_dani))
    return vnitrni

kod = vnejsi().__code__
print("lokální:", kod.co_varnames)
print("volné:  ", kod.co_freevars)
print("ostatní:", kod.co_names)
print("buňky ve vnější:", vnejsi.__code__.co_cellvars)
Výstup
lokální: ('cena', 's_dani')
volné:   ('mena',)
ostatní: ('sazba', 'len', 'str')
buňky ve vnější: ('mena',)

Z toho plyne i použitá instrukce. Lokální jména čte LOAD_FAST podle indexu v rámci, kde slovník vůbec není. Tam, kde překladač nemůže vyloučit nepřiřazenou proměnnou, stojí v 3.12 LOAD_FAST_CHECK, a odtud pochází UnboundLocalError. Volné proměnné jdou přes buňky a LOAD_DEREF. Globální a vestavěná jména řeší LOAD_GLOBAL, který hledá v globals a potom v builtins a adaptivní interpret (PEP 659) ho specializuje s inline cache. Staré doporučení kopírovat globály do lokálních proměnných kvůli rychlosti proto dnes obvykle nestojí za horší čitelnost, dokud to neukáže profiler.

Pod kapotou · okrajové případy

Třída není obklopující rozsah pro funkce ani comprehension ve svém těle. Ani inlinování comprehension z PEP 709 (3.12) tohle pravidlo nezměnilo. Výjimkou je jen nejvnější iterovaná hodnota, ta se vyhodnotí přímo v těle třídy.

python
class Konfigurace:
    zaklad = 10
    hodnoty = [zaklad * i for i in range(3)]
# NameError: name 'zaklad' is not defined
  • global znamená „modul“, ne „celý program“. from nastaveni import LIMIT zkopíruje vazbu v okamžiku importu, takže pozdější nastaveni.LIMIT = 5 tvůj modul neuvidí. Odtud pravidlo pro mock.patch: nahrazuj jméno tam, kde se používá.
  • pocet += 1 na globálu není atomické. Skládá se z načtení, sečtení a uložení, takže mezi vlákny může přijít o přírůstky. Víc pracovních procesů serveru má navíc každý vlastní kopii modulu.
  • except Chyba as e jméno e na konci bloku smaže, aby traceback nedržel rámec v paměti. Čtení po bloku dá NameError, ve funkci UnboundLocalError.
  • Operátor mrož := v comprehension přiřazuje do obklopujícího rozsahu (PEP 572), jde tedy o záměrnou díru v izolaci.
  • locals() ve funkci v 3.12 vrací slovník, jehož úpravy skutečné proměnné nemění. PEP 667 chování od 3.13 zpřesnil.

Vyzkoušej si: Pravidlo LEGB

Vyber, ve kterých oborech jméno existuje, a podívej se, který z nich Python použije.