🧲 Wie man print() in Python „abfängt”: stdout ohne externe Bibliotheken abfangen

In Python kann man das, was über print() auf dem Bildschirm ausgegeben wird, abfangen.
Dies ist nützlich für Tests, Debugging, Logging oder um „laute” Ausgaben zu unterdrücken.
Ich zeige, wie man dies elegant macht — nur mit der Standardbibliothek und wenigen Codezeilen.

---

🧩 Verständnis von Context Managern in Python

Was ist ein Context Manager?

Ein Context Manager verwaltet Ressourcen sicher und organisiert.
Er definiert das Verhalten bei Initialisierung und Aufräumen rund um einen Codeblock.

Beispiel: Arbeiten mit Dateien

with open("file.txt", "w") as f:
    f.write("Hallo, Welt!")

✅ Automatisches Aufräumen: Die Datei wird geschlossen, selbst wenn eine Ausnahme auftritt.

---

Warum Context Manager nützlich sind

• Automatisches Aufräumen – Ressourcen werden automatisch freigegeben
• Sicherheit bei Fehlern – Aufräumen erfolgt auch bei Ausnahmen
• Code-Lesbarkeit – Setup/Teardown-Logik an einer Stelle
• Wiederverwendbarkeit – geeignet für Dateien, Locks, Netzwerkverbindungen oder stdout

---

Nutzung von @contextmanager aus contextlib

Der Dekorator @contextmanager erlaubt das Erstellen von Context Managern mittels Generatoren:

from contextlib import contextmanager

@contextmanager
def my_context():
    print("Wir betreten den Kontext")
    resource = "eine Ressource"
    try:
        yield resource
    finally:
        print("Wir verlassen den Kontext")

with my_context() as res:
    print("Innerhalb des Kontexts:", res)

Ausgabe:

Wir betreten den Kontext
Innerhalb des Kontexts: eine Ressource
Wir verlassen den Kontext

💡 Erklärung:

• Code vor yield → wird beim Eintritt ausgeführt
• Wert aus yield → verfügbar als as res
• Code nach yield → wird beim Verlassen ausgeführt, auch bei Ausnahme

Ideal für temporäre Änderungen des globalen Zustands, z.B. beim Abfangen von stdout.

---

⚡ Zusammenfassung: Context Manager für stdout/stderr

Aufgabe / Szenario	Empfohlener Context Manager
Nur print abfangen	capture_stdout
Nur Fehler / Ausnahmen abfangen	capture_stderr
stdout und stderr gleichzeitig abfangen	capture_output
Abfangen und gleichzeitig anzeigen	capture_stdout_tee / capture_output_tee

---

📦 stdout abfangen

from contextlib import contextmanager
import sys, io

@contextmanager
def capture_stdout():
    old_stdout = sys.stdout
    sys.stdout = buffer = io.StringIO()
    try:
        yield buffer
    finally:
        sys.stdout = old_stdout

Beispiel:

with capture_stdout() as out:
    print("Diese Ausgabe wurde abgefangen")

print("Abgefangen:", out.getvalue())

---

🔧 stderr oder beide Streams abfangen

stderr abfangen

@contextmanager
def capture_stderr():
    old_stderr = sys.stderr
    sys.stderr = buffer = io.StringIO()
    try:
        yield buffer
    finally:
        sys.stderr = old_stderr

stdout + stderr abfangen

@contextmanager
def capture_output():
    old_stdout = sys.stdout
    old_stderr = sys.stderr
    sys.stdout = sys.stderr = buffer = io.StringIO()
    try:
        yield buffer
    finally:
        sys.stdout = old_stdout
        sys.stderr = old_stderr

---

🔀 Tee-Modus: Abfangen und Anzeigen

class Tee(io.StringIO):
    def __init__(self, original):
        super().__init__()
        self.original = original

    def write(self, text):
        self.original.write(text)
        super().write(text)

    def flush(self):
        self.original.flush()

Context Manager:

@contextmanager
def capture_stdout_tee():
    old_stdout = sys.stdout
    sys.stdout = tee = Tee(old_stdout)
    try:
        yield tee
    finally:
        sys.stdout = old_stdout

@contextmanager
def capture_output_tee():
    old_stdout = sys.stdout
    old_stderr = sys.stderr
    sys.stdout = sys.stderr = tee = Tee(old_stdout)
    try:
        yield tee
    finally:
        sys.stdout = old_stdout
        sys.stderr = old_stderr

Beispiel:

with capture_stdout_tee() as out:
    print("Sichtbar und abgefangen")

print("Inhalt Tee:", out.getvalue())

---

📦 Vollständige Datei: stdout_capture.py

"""
Tool zum Abfangen von stdout und stderr mit Context Managern.
Unterstützt:
- stdout abfangen
- stderr abfangen
- kombinierte Abfangung
- Tee-Modus
"""

import sys, io
from contextlib import contextmanager

@contextmanager
def capture_stdout():
    old_stdout = sys.stdout
    sys.stdout = buffer = io.StringIO()
    try: yield buffer
    finally: sys.stdout = old_stdout

@contextmanager
def capture_stderr():
    old_stderr = sys.stderr
    sys.stderr = buffer = io.StringIO()
    try: yield buffer
    finally: sys.stderr = old_stderr

@contextmanager
def capture_output():
    old_stdout = sys.stdout
    old_stderr = sys.stderr
    sys.stdout = sys.stderr = buffer = io.StringIO()
    try: yield buffer
    finally:
        sys.stdout = old_stdout
        sys.stderr = old_stderr

class Tee(io.StringIO):
    def __init__(self, original):
        super().__init__()
        self.original = original
    def write(self, text):
        self.original.write(text)
        super().write(text)
    def flush(self):
        self.original.flush()

@contextmanager
def capture_stdout_tee():
    old_stdout = sys.stdout
    sys.stdout = tee = Tee(old_stdout)
    try: yield tee
    finally: sys.stdout = old_stdout

@contextmanager
def capture_output_tee():
    old_stdout = sys.stdout
    old_stderr = sys.stderr
    sys.stdout = sys.stderr = tee = Tee(old_stdout)
    try: yield tee
    finally:
        sys.stdout = old_stdout
        sys.stderr = old_stderr

---

✅ Anwendungsbeispiele

from stdout_capture import capture_stdout, capture_output, capture_stdout_tee

def test_func():
    print("Hallo aus der Funktion")

# stdout abfangen
with capture_stdout() as out:
    test_func()
print("stdout abgefangen:", out.getvalue())

# stdout + stderr abfangen
try:
    with capture_output() as out:
        print("Etwas")
        raise Exception("Ups!")
except Exception:
    pass
print("Abgefangene Ausgabe:", out.getvalue())

# Abfangen und gleichzeitig anzeigen
with capture_stdout_tee() as out:
    print("Sichtbar UND abgefangen")
print("Tee-Inhalt:", out.getvalue())

---

⚠️ Praktische Tipps und Hinweise

1️⃣ Sehr große Ausgabe

• io.StringIO kann bei großen Datenmengen viel Speicher verbrauchen
• Verwenden Sie eine temporäre Datei:

import sys, tempfile

with tempfile.TemporaryFile(mode='w+') as tmp:
    old_stdout = sys.stdout
    sys.stdout = tmp
    try:
        print("Viele Daten...")
        tmp.seek(0)
        captured = tmp.read()
    finally:
        sys.stdout = old_stdout

2️⃣ Ausgabe von Subprozessen

• capture_stdout() erfasst keine Ausgabe von externen Prozessen
• Verwenden Sie subprocess.PIPE:

import subprocess
result = subprocess.run(["ls", "-la"], capture_output=True, text=True)
print(result.stdout)

3️⃣ Threadsicherheit

• sys.stdout und sys.stderr sind global → vermeiden Sie gleichzeitiges Abfangen in mehreren Threads

4️⃣ Wann Tee verwenden

• Debugging von Funktionen mit Logging
• Interaktive CLI-Tools
• Integrationstests mit Terminalausgabe

5️⃣ Streams wiederherstellen

• Immer sys.stdout/sys.stderr in finally zurücksetzen

6️⃣ Zu tiefe Verschachtelung vermeiden

• Mehrfaches Abfangen kann Ausgaben mischen. Verwenden Sie einen Kontext pro Szenario

7️⃣ Best Practices in Tests

• Unit Tests → capture_stdout() oder capture_output()
• Manuelles Debugging → Tee-Modus
• Überprüfen Sie den Inhalt des Puffers, nicht Nebeneffekte