0Pricing
AI Agents · Lektion

Sichere Dateioperationen mit Fehlerbehandlung

Dateiexistenz und Berechtigungen prüfen und IO-Fehler angemessen behandeln.

Sichere Dateioperationen mit Fehlerbehandlung ist eine kostenlose AI Agents-Lektion auf CoddyKit. Dies ist Lektion 4 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 AI Agents-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Warum sichere Dateioperationen wichtig sind

Dateioperationen in Agenten können auf viele Arten fehlschlagen: Die Datei existiert nicht, dem Agenten fehlen die erforderlichen Berechtigungen, der Pfad verweist auf ein Verzeichnis oder der Speicherplatz geht während des Schreibens aus. Ein Agent, der bei einem Dateifehler abstürzt, hinterlässt unvollständige Ausgaben und einen beschädigten Zustand. Defensive Programmierung mit geeigneten Prüfungen und einer guten Fehlerbehandlung macht Agenten robust.

from pathlib import Path

# Unsafe: crashes with FileNotFoundError
# content = Path('missing.txt').read_text()

# Safe: check first
path = Path('config.json')
if path.exists():
    content = path.read_text(encoding='utf-8')
    print('Loaded config')
else:
    print(f'Config not found at {path.resolve()}')
    content = '{}'  # use default

Path.exists() und Path.is_file()

Prüfen Sie vor dem Lesen einer Datei, ob sie existiert und tatsächlich eine reguläre Datei ist (kein Verzeichnis, kein symbolischer Link auf ein Verzeichnis und keine spezielle Datei). Path.exists() gibt für jedes Dateisystemobjekt True zurück; Path.is_file() gibt True nur für reguläre Dateien zurück.

from pathlib import Path

path = Path('data/report.csv')

# Chain of checks
if not path.exists():
    print(f'Not found: {path}')
elif not path.is_file():
    print(f'Not a regular file: {path} (is_dir={path.is_dir()})')
elif path.stat().st_size == 0:
    print(f'File is empty: {path}')
else:
    # Safe to read
    import csv
    with open(path, 'r', encoding='utf-8', newline='') as f:
        reader = csv.DictReader(f)
        rows = list(reader)
    print(f'Read {len(rows)} rows')

os.access() — Berechtigungen prüfen

os.access(path, mode) prüft, ob der aktuelle Prozess über die angegebene Berechtigung für eine Datei verfügt. Verwenden Sie os.R_OK zum Lesen, os.W_OK zum Schreiben und os.X_OK zum Ausführen. Das ist nützlich, bevor Sie Vorgänge ausführen, die bestimmte Berechtigungen erfordern.

import os
from pathlib import Path

def check_file_access(path):
    p = Path(path)

    checks = {
        'exists': p.exists(),
        'is_file': p.is_file(),
        'readable': os.access(p, os.R_OK),
        'writable': os.access(p, os.W_OK),
    }

    for check, result in checks.items():
        status = 'OK' if result else 'FAIL'
        print(f'  {check}: {status}')

    return all(checks.values())

if check_file_access('data/input.json'):
    print('File is accessible')
else:
    print('Access problem — check path and permissions')

FileNotFoundError abfangen

FileNotFoundError (eine Unterklasse von OSError) wird ausgelöst, wenn Sie versuchen, eine nicht vorhandene Datei zu öffnen. Fangen Sie ihn explizit ab und geben Sie eine hilfreiche Fehlermeldung aus, die den erwarteten Pfad enthält, damit der Benutzer oder Betreiber genau weiß, was fehlt.

import json
from pathlib import Path

def load_agent_config(config_path='agent_config.json'):
    path = Path(config_path)
    try:
        with open(path, 'r', encoding='utf-8') as f:
            return json.load(f)
    except FileNotFoundError:
        print(f'Config file not found: {path.resolve()}')
        print('Create agent_config.json with your settings')
        print('Example: {"model": "gpt-4o", "max_retries": 3}')
        return {}  # return empty config as default
    except json.JSONDecodeError as e:
        print(f'Invalid JSON in {path}: {e}')
        return {}

# --- demo ---
config = load_agent_config('does_not_exist_config.json')
print(f'Config used: {config}')

PermissionError abfangen

PermissionError wird ausgelöst, wenn dem Prozess die Berechtigung zum Lesen oder Schreiben einer Datei fehlt. Das kann bei Systemdateien, Dateien eines anderen Benutzers oder Dateien mit restriktiven Berechtigungen vorkommen. Fangen Sie diesen Fehler immer getrennt von FileNotFoundError ab – sie erfordern unterschiedliche Reaktionen.

from pathlib import Path

def read_file_safely(path):
    try:
        return Path(path).read_text(encoding='utf-8')
    except FileNotFoundError:
        print(f'File not found: {path}')
        return None
    except PermissionError:
        import os
        print(f'Permission denied: {path}')
        print(f'File permissions: {oct(Path(path).stat().st_mode)}')
        print(f'Current user: {os.getlogin()}')
        print('Try: chmod +r ' + str(path))
        return None
    except IsADirectoryError:
        print(f'Path is a directory, not a file: {path}')
        return None

# --- demo ---
import os
print(read_file_safely('does_not_exist.txt'))

os.makedirs('a_directory', exist_ok=True)
print(read_file_safely('a_directory'))

IsADirectoryError abfangen

IsADirectoryError wird ausgelöst, wenn Sie versuchen, ein Verzeichnis wie eine Datei zu öffnen. Das kann passieren, wenn ein Agent einen Pfad falsch zusammensetzt – zum Beispiel, wenn ein Dateiname angehängt wird, der bereits als Verzeichnis existiert. Fangen Sie den Fehler immer ab, um eine aussagekräftige Fehlerausgabe zu ermöglichen.

from pathlib import Path

def safe_write(output_path, content):
    path = Path(output_path)

    # Check the path is not an existing directory
    if path.is_dir():
        raise IsADirectoryError(
            f'Cannot write file: {path} is a directory. '
            f'Use a filename like {path}/output.txt instead.'
        )

    # Ensure parent directory exists
    path.parent.mkdir(parents=True, exist_ok=True)

    try:
        path.write_text(content, encoding='utf-8')
        print(f'Written: {path} ({len(content)} chars)')
    except IsADirectoryError as e:
        print(f'Path error: {e}')
    except PermissionError:
        print(f'Cannot write to {path} — permission denied')

# --- demo ---
import os
safe_write('demo_output/report.txt', 'Agent finished the task.')

os.makedirs('already_a_dir', exist_ok=True)
try:
    safe_write('already_a_dir', 'this will fail')
except IsADirectoryError as e:
    print(f'Rejected: {e}')

Atomare Schreibvorgänge mit tempfile

Das direkte Schreiben in eine Datei ist gefährlich – wenn der Agent während des Schreibvorgangs abstürzt, bleibt die Datei teilweise geschrieben und beschädigt zurück. Die Lösung ist ein atomarer Schreibvorgang: Schreiben Sie zunächst in eine temporäre Datei und benennen Sie sie anschließend in den endgültigen Pfad um. Das Umbenennen ist auf POSIX-Systemen atomar – die endgültige Datei ist entweder die alte oder die neue Version, niemals eine teilweise geschriebene.

import tempfile
import os
import json
from pathlib import Path

def atomic_write_json(file_path, data):
    path = Path(file_path)
    path.parent.mkdir(parents=True, exist_ok=True)

    # Write to temp file in same directory
    tmp_fd, tmp_path = tempfile.mkstemp(
        dir=path.parent,
        prefix='.tmp_',
        suffix='.json'
    )
    try:
        with os.fdopen(tmp_fd, 'w', encoding='utf-8') as f:
            json.dump(data, f, indent=2, ensure_ascii=False)
        # Atomic rename: replaces final file in one operation
        os.replace(tmp_path, path)
        print(f'Atomically wrote: {path}')
    except Exception as e:
        os.unlink(tmp_path)  # clean up temp file on error
        raise

# --- demo ---
atomic_write_json('demo_state/state.json', {'step': 3, 'status': 'running'})
print('File contents:', Path('demo_state/state.json').read_text(encoding='utf-8'))

Dateisperren für nebenläufige Agenten

Wenn mehrere Agent-Instanzen parallel ausgeführt werden und in dieselbe Datei schreiben, können Race Conditions die Daten beschädigen. Verwenden Sie Dateisperren mit dem Modul fcntl (Linux/macOS) oder die plattformübergreifende Bibliothek filelock, um gleichzeitige Schreibvorgänge zu verhindern.

from filelock import FileLock, Timeout
import json
from pathlib import Path

COUNTER_FILE = Path('shared_counter.json')
LOCK_FILE = Path('shared_counter.json.lock')

def increment_counter():
    lock = FileLock(str(LOCK_FILE), timeout=10)
    try:
        with lock:
            # Only one process can be here at a time
            if COUNTER_FILE.exists():
                data = json.loads(COUNTER_FILE.read_text())
            else:
                data = {'count': 0}

            data['count'] += 1
            COUNTER_FILE.write_text(
                json.dumps(data, indent=2)
            )
            return data['count']
    except Timeout:
        print('Could not acquire lock within 10 seconds')
        return None

Sicheres Löschen mit Existenzprüfungen

Das Löschen einer nicht vorhandenen Datei löst FileNotFoundError aus. Das Löschen eines Verzeichnisses mit Path.unlink() löst IsADirectoryError aus. Verwenden Sie Path.unlink(missing_ok=True) (Python 3.8 oder höher) oder prüfen Sie zuerst, ob die Datei existiert, um sie sicher zu löschen.

from pathlib import Path
import shutil

# Safe file deletion (Python 3.8+)
Path('temp_output.json').unlink(missing_ok=True)

# Safe directory deletion
def safe_remove(path):
    p = Path(path)
    if not p.exists():
        print(f'Already gone: {p}')
        return
    if p.is_file():
        p.unlink()
        print(f'Deleted file: {p}')
    elif p.is_dir():
        shutil.rmtree(p)
        print(f'Deleted directory: {p}')
    else:
        print(f'Unknown file type: {p}')

# Clean up temporary workspace
safe_remove('/tmp/agent_workspace/run_001')

Prüfen des Speicherplatzes vor dem Schreiben

Agenten, die große Dateien schreiben (KI-Ausgaben, Datensätze, Protokolle), sollten zuerst den verfügbaren Speicherplatz prüfen. shutil.disk_usage(path) gibt die Gesamtzahl, die belegte und die freie Anzahl an Bytes zurück. Prüfen Sie vor dem Start eines langen Schreibvorgangs, ob der freie Speicherplatz die erwartete Ausgabegröße übersteigt.

import shutil
from pathlib import Path

def check_disk_space(output_dir, required_bytes):
    path = Path(output_dir)
    path.mkdir(parents=True, exist_ok=True)

    usage = shutil.disk_usage(path)
    free_gb = usage.free / (1024 ** 3)
    required_gb = required_bytes / (1024 ** 3)

    print(f'Disk free: {free_gb:.2f} GB')
    print(f'Required:  {required_gb:.2f} GB')

    if usage.free < required_bytes * 1.1:  # 10% safety margin
        raise IOError(
            f'Insufficient disk space: '
            f'{free_gb:.2f} GB free, '
            f'{required_gb:.2f} GB required'
        )
    return True

# Before writing a 500 MB dataset
check_disk_space('/tmp/output', 500 * 1024 * 1024)

Sicherung vor dem Überschreiben

Wenn ein Agent eine vorhandene Datei aktualisiert, ist es sinnvoll, eine Sicherung der vorherigen Version aufzubewahren. So können Sie einen Rollback durchführen, falls der neue Inhalt falsch ist. Verwenden Sie einen Dateinamen mit Zeitstempel für die Sicherung und begrenzen Sie die Anzahl der Sicherungen, damit der Speicherplatz nicht vollständig belegt wird.

import shutil
import datetime
from pathlib import Path

def write_with_backup(file_path, content, max_backups=5):
    path = Path(file_path)
    backup_dir = path.parent / '.backups'
    backup_dir.mkdir(exist_ok=True)

    # Backup existing file
    if path.exists():
        timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
        backup = backup_dir / f'{path.name}.{timestamp}'
        shutil.copy2(path, backup)
        print(f'Backed up to: {backup}')

    # Write new content
    path.write_text(content, encoding='utf-8')

    # Prune old backups
    backups = sorted(backup_dir.glob(f'{path.name}.*'))
    for old in backups[:-max_backups]:
        old.unlink()
        print(f'Pruned old backup: {old.name}')

# --- demo ---
write_with_backup('demo_notes.txt', 'version 1')
write_with_backup('demo_notes.txt', 'version 2')
print('Backups:', [p.name for p in sorted(Path('.backups').glob('demo_notes.txt.*'))])

Schnelltest: Atomare Schreibvorgänge

Testen Sie Ihr Verständnis sicherer Muster zum Schreiben von Dateien.

Zusammenfassung: Sichere Dateioperationen

Ihre Agenten können Dateien nun defensiv verarbeiten:

  • Vor dem Zugriff prüfen: Path.exists() + Path.is_file() + os.access(path, os.R_OK)
  • FileNotFoundError, PermissionError und IsADirectoryError mit klaren Meldungen abfangen
  • Atomare Schreibvorgänge (tempfile + os.replace) verwenden, um bei einem Absturz teilweise geschriebene oder beschädigte Dateien zu verhindern
  • Dateisperren (filelock library) verwenden, wenn mehrere Agenten in dieselbe Datei schreiben
  • missing_ok=True für sicheres Löschen ohne FileNotFoundError verwenden
  • Vor großen Schreibvorgängen den Speicherplatz prüfen und wichtige Dateien vor dem Überschreiben sichern

Häufig gestellte Fragen

Ist die Lektion „Sichere Dateioperationen mit Fehlerbehandlung“ kostenlos?

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

Was lerne ich in „Sichere Dateioperationen mit Fehlerbehandlung“?

Dateiexistenz und Berechtigungen prüfen und IO-Fehler angemessen behandeln. Du übst AI Agents 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 AI Agents zu starten?

Keine Vorkenntnisse erforderlich. AI Agents 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 4 von 4.

Wie lange dauert die Lektion „Sichere Dateioperationen mit Fehlerbehandlung“?

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 AI Agents-Lektion Code schreiben und ausführen?

Ja. Jede AI Agents-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

  1. Dateien im Agentenkontext lesen und schreiben
  2. Verzeichnisdurchlauf und Dateisuche
  3. Dateiformate verarbeiten: CSV, JSON und TXT
  4. Sichere Dateioperationen mit Fehlerbehandlung
← Zurück zu AI Agents