Python Academy · Lektion

Das enter- und exit-Protokoll

Erstellen Sie Kontextmanager mit dem Dunder-Protokoll.

Lektion 2 von 413 Schritte

Das __enter__- und __exit__-Protokoll ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Das Context-Manager-Protokoll

Jedes Objekt, das __enter__ und __exit__ definiert, ist ein Context Manager und kann mit with verwendet werden.

class Managed:
    def __enter__(self):
        print("entering")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("exiting")
        return False

with Managed() as m:
    print("inside")

Rückgabewert von enter

__enter__ wird am Anfang des with-Blocks aufgerufen. Sein Rückgabewert wird an die Variable nach as gebunden.

class Resource:
    def __enter__(self):
        self.value = 42
        return self  # bound to 'r'

    def __exit__(self, *args):
        self.value = None
        return False

with Resource() as r:
    print(r.value)  # 42

Argumente von exit

__exit__(exc_type, exc_val, exc_tb) erhält Informationen zur Ausnahme, wenn ein Fehler aufgetreten ist. Wenn keine Ausnahme aufgetreten ist, sind alle drei Werte None.

class Safe:
    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type is ValueError:
            print(f"Suppressed ValueError: {exc_val}")
            return True   # suppress the exception
        return False      # re-raise anything else

with Safe():
    raise ValueError("oops")  # suppressed

Ausnahmen unterdrücken

Geben Sie aus __exit__ den Wert True zurück, um die Ausnahme zu unterdrücken. Geben Sie False (oder nichts) zurück, damit sie weitergegeben wird.

class Ignore:
    def __enter__(self): return self
    def __exit__(self, *args): return True  # swallow all exceptions

with Ignore():
    1 / 0

print("continues here")

Beispiel für eine Datenbankverbindung

Ein klassischer Anwendungsfall: Beim Eintritt eine Verbindung herstellen und beim Verlassen ein Commit oder Rollback ausführen und die Verbindung schließen.

class DBConn:
    def __enter__(self):
        self.conn = connect_db()
        return self.conn

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type:
            self.conn.rollback()
        else:
            self.conn.commit()
        self.conn.close()
        return False

Ein Timer-Context-Manager

Messen Sie die verstrichene Zeit, indem Sie in __enter__ den Startzeitpunkt speichern und in __exit__ die Differenz berechnen.

import time

class Timer:
    def __enter__(self):
        self.start = time.perf_counter()
        return self

    def __exit__(self, *args):
        self.elapsed = time.perf_counter() - self.start
        print(f"Elapsed: {self.elapsed:.3f}s")
        return False

with Timer():
    sum(range(1_000_000))

Context Manager verschachteln

Mehrere Context Manager können in einer einzigen with-Zeile kombiniert werden.

with open("in.txt") as src, open("out.txt", "w") as dst:
    dst.write(src.read())

Wiederverwendbare vs. einmalige Manager

Context Manager, deren __enter__ bei jedem Aufruf eine neue Ressource bereitstellt, sind wiederverwendbar. Manager, deren interner Zustand erschöpft wird (wie bei einer Sperre, die nur einmal gehalten werden kann), sind möglicherweise nicht wiederverwendbar.

class Reusable:
    def __enter__(self):
        return []
    def __exit__(self, *a):
        return False

for _ in range(3):
    with Reusable() as lst:
        lst.append(1)
        print(lst)  # [1] each time

aenter und aexit (asynchron)

Für asynchrone Context Manager definieren Sie die Coroutinen __aenter__ und __aexit__ und verwenden async with.

class AsyncDB:
    async def __aenter__(self):
        self.conn = await connect()
        return self.conn

    async def __aexit__(self, *args):
        await self.conn.close()

# async with AsyncDB() as conn:
#     ...

Dateiobjekte umschließen

Python-Dateiobjekte implementieren das Context-Manager-Protokoll bereits – rufen Sie f.close() niemals manuell auf.

with open("data.txt", "r") as f:
    data = f.read()
# file is closed here automatically
print(f.closed)  # True

Eine Sperre implementieren

Thread-Sperren sind Context Manager: __enter__ erwirbt die Sperre, __exit__ gibt sie frei.

import threading

lock = threading.Lock()

def update_shared():
    with lock:
        # critical section
        pass

Kurzer Test

Was muss __exit__ zurückgeben, um eine Ausnahme zu unterdrücken?

Beantworte es in der interaktiven Lektion

Zusammenfassung

Implementieren Sie __enter__ und __exit__, um Kontextmanager zu erstellen. Geben Sie die Ressource aus __enter__ zurück und behandeln Sie in __exit__ die Bereinigung und das Unterdrücken von Ausnahmen.

Kostenlos starten

Lerne Python mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 76
Lektionen: 320

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Das enter- und exit-Protokoll“ kostenlos?

Ja — der vollständige Text von „Das __enter__- und __exit__-Protokoll“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Das enter- und exit-Protokoll“?

Erstellen Sie Kontextmanager mit dem Dunder-Protokoll. Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Das enter- und exit-Protokoll“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Python Academy