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)
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))
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)
ve funkci: uvnitř mimo funkci: venku
Co vypíše tento kód? x = 1, potom def f(): x = 2, potom f() a print(x).
Přiřazení ve funkci vytvořilo lokální x, které zaniklo s koncem volání. Globální x se nezměnilo.
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))
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)
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á.
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
LEGB: pořadí hledání
Když Python narazí na jméno, prochází čtyři úrovně a bere první shodu.
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 tadyNovinka 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())
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())
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]))
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.
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
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 jakém pořadí Python hledá jméno?
Od nejbližšího k nejvzdálenějšímu, proto LEGB. Díky tomu smí lokální proměnná zakrýt globální a globální zase vestavěnou.
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)
z ifu 2 20 [0, 1, 4]
Co vypíše for i in range(3): pass a pod tím print(i)?
Cyklus nemá vlastní rozsah, takže i zůstává. Má poslední přiřazenou hodnotu a range(3) končí dvojkou.
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)
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.
class Konfigurace:
zaklad = 10
hodnoty = [zaklad * i for i in range(3)]
# NameError: name 'zaklad' is not definedglobalznamená „modul“, ne „celý program“.from nastaveni import LIMITzkopíruje vazbu v okamžiku importu, takže pozdějšínastaveni.LIMIT = 5tvůj modul neuvidí. Odtud pravidlo promock.patch: nahrazuj jméno tam, kde se používá.pocet += 1na 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 ejménoena konci bloku smaže, aby traceback nedržel rámec v paměti. Čtení po bloku dáNameError, ve funkciUnboundLocalError.- 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.