0 dní v řadě · 0 bodů

Python pod kapotou · 24 min

Context managery

Pochopíš, co dělá with, napíšeš vlastní context manager třídou i generátorem a zajistíš úklid, i když se program pokazí.

Hloubka
Úkoly
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())
Výstup
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š za as.
  • __exit__ se zavolá na konci, ať blok skončí jakkoli: normálně, výjimkou, přes return nebo break.

__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")
Výstup
vstup
uvnitř: hodnota z __enter__
výstup, chyba: None
---
vstup
uvnitř, teď to spadne
výstup, chyba: ValueError('ups')
výjimka prošla ven
Kvíz

Co dostane proměnná x v with Spravce() as x:?

Úkol

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

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

Úkol

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

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")
Výstup
[start] import
[ok] import, zpráv: 1
[start] export
[chyba] export: disk je plný
pokračuju náhradním plánem
Úkol

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

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)
Výstup
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())
Výstup
{'mléko': 1}
TOHLE NEJDE NA OBRAZOVKU

Dá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.

Kvíz

Jak dopadne výjimka, když __exit__ nemá žádný return?

Pod kapotou · co přesně with znamená

Sémantiku definuje PEP 343. Zjednodušeně:

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