Lidsky řečeno
Na recepci si půjčíš klíč od zasedačky. Ať schůzka dopadne jakkoli, i kdyby všichni utekli kvůli požárnímu poplachu, klíč se musí vrátit. Představ si recepční, která tě při odchodu z místnosti vždy spolehlivě zastaví a klíč si vezme. Přesně to dělá with: něco ti půjčí a zaručí, že se to vrátí.
Úklid, na který nejde zapomenout
Spousta věcí v programu má začátek a konec: otevřít a zavřít soubor, zamknout a odemknout, spustit a potvrdit transakci. Konec se snadno zapomene, a hlavně ho přeskočí chyba. Spolehlivá verze s try/finally je ale ukecaná. with zapíše totéž na dva řádky.
soubor = open("poznamka.txt", "w", encoding="utf-8")
try:
soubor.write("ručně\n")
finally:
soubor.close()
with open("poznamka.txt", "a", encoding="utf-8") as soubor:
soubor.write("přes with\n")
print("uvnitř zavřený?", soubor.closed)
print("venku zavřený?", soubor.closed)
with open("poznamka.txt", encoding="utf-8") as soubor:
print(soubor.read())
uvnitř zavřený? False venku zavřený? True ručně přes with
Objektu, který se s with umí domluvit, se říká context manager (správce kontextu). Soubor je jen nejznámější příklad.
Co dělá with
Protokol má dvě metody:
__enter__se zavolá na začátku. Co vrátí, to dostaneš zaas.__exit__se zavolá na konci, ať blok skončí jakkoli: normálně, výjimkou, přesreturnnebobreak.
__exit__ dostává tři údaje o chybě: typ výjimky, samotnou výjimku a traceback. Když chyba nenastala, jsou všechny tři None.
class Hlidac:
def __enter__(self):
print("vstup")
return "hodnota z __enter__"
def __exit__(self, typ, chyba, traceback):
print("výstup, chyba:", repr(chyba))
return False
with Hlidac() as h:
print("uvnitř:", h)
print("---")
try:
with Hlidac():
print("uvnitř, teď to spadne")
raise ValueError("ups")
print("sem se nedojde")
except ValueError:
print("výjimka prošla ven")
vstup
uvnitř: hodnota z __enter__
výstup, chyba: None
---
vstup
uvnitř, teď to spadne
výstup, chyba: ValueError('ups')
výjimka prošla venCo dostane proměnná x v with Spravce() as x:?
Často je to tentýž objekt, protože __enter__ vrací self, jako u souboru. Není to ale pravidlo: zámek z modulu threading vrací True a vlastní správce může vrátit cokoli.
Všechno, nebo nic
Napiš třídu Transakce(data), kde data je slovník. V bloku with Transakce(ucet) as d: se slovník upravuje přímo (d je tentýž slovník). Když blok skončí výjimkou, slovník se vrátí do původního stavu a výjimka pokračuje ven. Bez výjimky změny zůstanou.
class Transakce:
def __init__(self, data):
self.data = data
def __enter__(self):
return self.data
def __exit__(self, typ, chyba, traceback):
return False
Polknout, nebo pustit dál
Návratová hodnota __exit__ rozhoduje o osudu výjimky. Pravdivá hodnota znamená „vyřízeno, zahoď ji“, nepravdivá (i prosté None) ji pustí dál. Skoro vždy chceš to druhé. Tichá ztráta chyby je jedna z nejdražších věcí, které můžeš v kódu udělat.
class Ignoruj:
def __init__(self, typ_chyby):
self.typ_chyby = typ_chyby
def __enter__(self):
return self
def __exit__(self, typ, chyba, traceback):
return typ is not None and issubclass(typ, self.typ_chyby)
with Ignoruj(KeyError):
print({}["chybi"])
print("tohle se neprovede")
print("program běží dál")
program běží dál
Blok po výjimce nepokračuje. Přeskočí se zbytek a program jede až za with. Přesně tohle hotově umí contextlib.suppress(KeyError).
Počítadlo tolerovaných chyb
Napiš třídu Tolerance(*typy). V with potlačí výjimky uvedených typů (i jejich potomků) a jejich počet si ukládá do atributu pocet, který začíná na 0. Jeden objekt jde použít opakovaně. Jiné výjimky projdou ven a nepočítají se. __enter__ vrací objekt samotný.
class Tolerance:
def __init__(self, *typy):
self.typy = typy
self.pocet = 0
def __enter__(self):
return self
def __exit__(self, typ, chyba, traceback):
return False
Kratší cesta: @contextmanager
Psát třídu kvůli dvěma krokům se nevyplatí. Dekorátor contextlib.contextmanager udělá context manager z generátoru. Co je před yield, je vstup. Co je za ním, je výstup. Hodnota z yield jde za as. Výjimka z bloku se objeví přímo na řádku s yield, takže ji chytíš obyčejným try.
from contextlib import contextmanager
@contextmanager
def krok(nazev):
print(f"[start] {nazev}")
zpravy = []
try:
yield zpravy
except Exception as chyba:
print(f"[chyba] {nazev}: {chyba}")
raise
else:
print(f"[ok] {nazev}, zpráv: {len(zpravy)}")
with krok("import") as z:
z.append("načteno 10 řádků")
try:
with krok("export"):
raise OSError("disk je plný")
except OSError:
print("pokračuju náhradním plánem")
[start] import [ok] import, zpráv: 1 [start] export [chyba] export: disk je plný pokračuju náhradním plánem
Dočasné nastavení
Napiš context manager docasne(slovnik, klic, hodnota). V bloku platí slovnik[klic] == hodnota. Po skončení, i po výjimce, se vrátí původní stav: stará hodnota, nebo když klíč předtím neexistoval, klíč zmizí. Pozor, původní hodnota může být i None.
from contextlib import contextmanager
@contextmanager
def docasne(slovnik, klic, hodnota):
slovnik[klic] = hodnota
yield
Víc správců a hotové pomůcky
V jednom with může být správců několik. Pro delší seznam použij závorky. Otevírají se popořadě a zavírají pozpátku, stejně jako vnořené bloky. Když selže otevření druhého, první se korektně zavře.
class Zdroj:
def __init__(self, nazev, rozbity=False):
self.nazev = nazev
self.rozbity = rozbity
def __enter__(self):
if self.rozbity:
raise OSError(f"{self.nazev} nejde otevřít")
print("otevírám", self.nazev)
return self
def __exit__(self, *info):
print("zavírám", self.nazev)
with (
Zdroj("A") as a,
Zdroj("B") as b,
):
print("pracuju s", a.nazev, "a", b.nazev)
print("---")
try:
with Zdroj("C"), Zdroj("D", rozbity=True):
print("sem se nedojde")
except OSError as chyba:
print("chyba:", chyba)
otevírám A otevírám B pracuju s A a B zavírám B zavírám A --- otevírám C zavírám C chyba: D nejde otevřít
Modul contextlib má pár hotových nástrojů, které ušetří psaní: suppress potlačí vyjmenované výjimky a redirect_stdout přesměruje výpis.
import contextlib
import io
kosik = {"mléko": 1}
with contextlib.suppress(KeyError):
del kosik["chleba"]
print(kosik)
zachyceno = io.StringIO()
with contextlib.redirect_stdout(zachyceno):
print("tohle nejde na obrazovku")
print(zachyceno.getvalue().upper().strip())
{'mléko': 1}
TOHLE NEJDE NA OBRAZOVKUDále se hodí closing (zavolá na konci .close() u objektu, který with neumí), nullcontext (správce, který nic nedělá, když je with jen volitelný) a chdir (dočasná změna pracovní složky, od 3.11). with umí i zámky z modulu threading nebo tempfile.TemporaryDirectory.
Jak dopadne výjimka, když __exit__ nemá žádný return?
Funkce bez return vrací None. Výjimku potlačí jen pravdivá návratová hodnota.
Pod kapotou · co přesně with znamená
Sémantiku definuje PEP 343. Zjednodušeně:
spravce = VYRAZ
vstup = type(spravce).__enter__
vystup = type(spravce).__exit__
hodnota = vstup(spravce)
try:
CIL = hodnota
TELO
except BaseException as e:
if not vystup(spravce, type(e), e, e.__traceback__):
raise
else:
vystup(spravce, None, None, None)Z toho plyne několik věcí. Metody se hledají na typu, ne na instanci, takže obj.__enter__ = ... nestačí a od 3.11 dostaneš TypeError. Výjimka v __enter__ znamená, že __exit__ neproběhne, proto __enter__ získávající víc zdrojů musí po částečném selhání uklidit sám. Chytá se i BaseException, takže __exit__ vidí také KeyboardInterrupt a SystemExit. Výjimka z __exit__ nahradí tu původní, ta přežije jen v __context__.
class Vadny:
def __enter__(self):
return self
def __exit__(self, *info):
raise RuntimeError("úklid selhal")
try:
with Vadny():
raise ValueError("původní chyba")
except Exception as chyba:
print(type(chyba).__name__, "|", chyba)
print("původní:", repr(chyba.__context__))
class NaInstanci:
pass
objekt = NaInstanci()
objekt.__enter__ = lambda: None
objekt.__exit__ = lambda *a: None
try:
with objekt:
pass
except TypeError as chyba:
print("TypeError:", chyba)
RuntimeError | úklid selhal
původní: ValueError('původní chyba')
TypeError: 'NaInstanci' object does not support the context manager protocolŽádný finally ani __exit__ nepřežije os._exit(), SIGKILL nebo výpadek proudu. Co musí přežít pád procesu, patří do transakce na úrovni databáze nebo souborového systému. Asynchronní obdoba je async with s __aenter__ a __aexit__, viz lekce asyncio.
Pod kapotou · jednorázové, opakovatelné, reentrantní
Dokumentace contextlib rozlišuje tři druhy správců. Jednorázový jde použít jednou: soubor nebo objekt z @contextmanager, protože generátor nejde přetočit. Opakovatelný jde použít znovu, ale ne zanořeně do sebe, typicky threading.Lock, který by se sám se sebou zablokoval. Reentrantní zvládne i zanoření: RLock, suppress, redirect_stdout.
Objekt z @contextmanager je zároveň dekorátor (ContextDecorator). V té roli si pro každé volání vyrobí nový generátor, takže jednorázovost nevadí.
from contextlib import contextmanager
@contextmanager
def krok():
print("start")
yield
print("konec")
jeden = krok()
with jeden:
pass
try:
with jeden:
pass
except Exception as chyba:
print("druhý vstup selhal:", type(chyba).__name__)
@krok()
def uloha():
print("práce")
uloha()
uloha()
start konec druhý vstup selhal: AttributeError start práce konec start práce konec
Druhý vstup končí nepříliš výmluvným AttributeError, protože první __enter__ si smazal uložené argumenty funkce. Interně __enter__ volá next(gen) a __exit__ buď znovu next, nebo gen.throw(výjimka). Když generátor udělá druhý yield, dostaneš RuntimeError: generator didn't stop.
Pozor na správce s globálním účinkem. redirect_stdout mění sys.stdout a chdir pracovní složku celého procesu, takže ve vláknech nebo na asynchronním serveru ovlivní cizí kód. Klasická past je i sqlite3: with spojeni: řídí transakci, potvrdí ji, nebo vrátí zpět, ale spojení nezavře.
import sqlite3
from contextlib import closing
with closing(sqlite3.connect(":memory:")) as db:
db.execute("CREATE TABLE ucet (zustatek INTEGER)")
with db:
db.execute("INSERT INTO ucet VALUES (100)")
try:
with db:
db.execute("UPDATE ucet SET zustatek = 0")
raise ValueError("platba selhala")
except ValueError:
pass
print(db.execute("SELECT zustatek FROM ucet").fetchone())
(100,)