Dateien in Python schreiben und erstellen

Das Schreiben von Dateien ist eine der grundlegendsten I/O-Operationen in Python. Ob Sie Programmausgaben speichern, Konfigurationen persistieren, Daten in CSV exportieren oder Ereignisse protokollieren – Sie benötigen eine zuverlässige Methode zum Erstellen und Aktualisieren von Dateien. Dieses Kapitel behandelt alle Ansätze, die Python bietet: write(), writelines(), Anhängemodus, Binärschreibvorgänge, Zeilenumbrüche, Zeichenkodierung, die moderne pathlib-API sowie Muster für sicheres Schreiben ohne Datenverlust.

Eine Datei zum Schreiben öffnen

Jede Datei-Schreiboperation beginnt mit der eingebauten Funktion open(). Das zweite Argument — der Modus — bestimmt, was passiert, wenn Sie die Datei öffnen:

Das Wichtigste, das Sie sich beim "w"-Modus merken sollten: Er löscht die gesamte Datei stillschweigend, bevor er schreibt. Wenn Sie einer bestehenden Datei lediglich Inhalt hinzufügen möchten, verwenden Sie stattdessen den "a"-Modus (Anhängen).

Geben Sie beim Schreiben von Textdateien immer den Parameter encoding an, damit sich Ihr Code auf Windows, macOS und Linux identisch verhält:

file = open("output.txt", "w", encoding="utf-8")

Immer einen with-Block verwenden

Wenn Sie open() ohne einen with-Block aufrufen, müssen Sie file.close() selbst aufrufen. Vergessen Sie, eine Datei zu schließen, kann es dazu führen, dass gepufferte Daten nie auf die Festplatte geschrieben werden, dass in lang laufenden Skripten Fehler wegen zu vieler offener Dateien auftreten, und dass Dateien auf manchen Betriebssystemen beschädigt werden.

Die with-Anweisung (ein Kontextmanager) löst all diese Probleme. Python schließt die Datei automatisch, wenn der Block verlassen wird — auch wenn innerhalb des Blocks eine Ausnahme ausgelöst wird.

with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Hello, World!\n")
# File is closed and flushed here — guaranteed

Alle Beispiele in diesem Kapitel verwenden die with-Anweisung. Vermeiden Sie das manuelle open() / close()-Muster.

Text mit write() schreiben

file.write(string) schreibt den angegebenen string in die Datei und gibt die Anzahl der geschriebenen Zeichen zurück. Es wird nicht automatisch ein Zeilenumbruch hinzugefügt — Sie müssen \n selbst einfügen.

Eine einzelne Zeile in eine neue Datei schreiben

with open("greeting.txt", "w", encoding="utf-8") as f:
    chars_written = f.write("Hello, World!\n")
    print(chars_written)   # 14

Mehrere Zeilen durch wiederholten Aufruf von write() schreiben

with open("poem.txt", "w", encoding="utf-8") as f:
    f.write("Roses are red,\n")
    f.write("Violets are blue,\n")
    f.write("Python is great,\n")
    f.write("And so are you.\n")

Jeder Aufruf von write() hängt an der aktuellen Position an die Datei an. Die Datei wird neu geschrieben (alle vorherigen Inhalte sind verschwunden), da der "w"-Modus verwendet wurde.

Mehrere Zeilen mit writelines() schreiben

file.writelines(iterable) akzeptiert ein beliebiges Iterable aus Strings — eine Liste, einen Generator oder ein Tupel — und schreibt jedes Element der Reihe nach. Wie write() fügt es keine Zeilenumbrüche zwischen den Elementen ein.

Eine Liste von Zeilen schreiben

lines = [
    "First line\n",
    "Second line\n",
    "Third line\n",
]

with open("lines.txt", "w", encoding="utf-8") as f:
    f.writelines(lines)

Wenn Ihre Quelldaten noch kein \n enthalten, fügen Sie es vor dem Schreiben hinzu:

data = ["Alice", "Bob", "Charlie"]

with open("names.txt", "w", encoding="utf-8") as f:
    f.writelines(name + "\n" for name in data)

Der Generatorausdruck name + "\n" for name in data ist speichereffizient: Python erzeugt jeden string bei Bedarf, anstatt zuerst die gesamte Liste im Speicher aufzubauen.

write() vs. writelines() — Wann was verwenden

Eine Datei erstellen, die noch nicht existieren darf

Verwenden Sie den Modus "x" (exklusives Erstellen), wenn Sie möchten, dass Python eine neue Datei erstellt und scheitert, wenn die Datei bereits existiert. Damit verhindern Sie das versehentliche Überschreiben wichtiger Daten.

try:
    with open("config.txt", "x", encoding="utf-8") as f:
        f.write("host=localhost\n")
        f.write("port=8080\n")
except FileExistsError:
    print("config.txt already exists — not overwriting.")

Dieses Muster ist nützlich zum Erzeugen eindeutiger Ausgabedateien (Logs, Exporte, Snapshots), bei denen eine Kollision bedeutet, dass etwas schiefgelaufen ist.

An eine bestehende Datei anhängen

Wenn Sie eine Datei mit dem Modus "a" öffnen, wird der Schreibzeiger ans Ende der Datei verschoben. Neuer Inhalt wird nach dem vorhandenen Inhalt hinzugefügt; es wird nichts gelöscht.

Einen Log-Eintrag an eine bestehende Datei anhängen

import datetime

with open("app.log", "a", encoding="utf-8") as f:
    timestamp = datetime.datetime.now().isoformat()
    f.write(f"[{timestamp}] Server started\n")

Wenn app.log noch nicht existiert, erstellt Python sie. Wenn sie bereits existiert, wird die neue Zeile am Ende hinzugefügt. Mehrfaches Ausführen des Skripts baut ein wachsendes Log auf.

Schreiben vs. Anhängen — Den richtigen Modus wählen

• Verwenden Sie "w", wenn Sie den Dateiinhalt vollständig ersetzen möchten (einen frischen Bericht erstellen, eine neue Konfiguration speichern).
• Verwenden Sie "a", wenn Sie dem vorhandenen Inhalt etwas hinzufügen möchten (Protokollierung, Ergebnisse über mehrere Durchläufe hinweg ansammeln).

Zeilenumbrüche und Zeilenenden

Pythons Textmodus ("w", "a", "r") übersetzt beim Schreiben den universellen Zeilenumbruch \n in das plattformeigene Zeilenende:

• Windows: \n → \r\n (CRLF)
• macOS / Linux: \n bleibt \n (LF)

Dies ist normalerweise das richtige Verhalten — auf Windows geschriebene Dateien öffnen sich korrekt im Notepad.

Wenn Sie ein bestimmtes Zeilenende erzwingen müssen, unabhängig von der Plattform — zum Beispiel beim Erzeugen von Dateien, die von einem bestimmten System gelesen werden müssen — übergeben Sie den Parameter newline:

# Force Unix-style LF on all platforms (e.g. for Linux-target files)
with open("unix_file.txt", "w", encoding="utf-8", newline="\n") as f:
    f.write("line one\n")
    f.write("line two\n")

# Preserve line endings exactly as given (no translation at all)
with open("raw.txt", "w", encoding="utf-8", newline="") as f:
    f.write("line one\r\n")
    f.write("line two\n")

Zeichenkodierung

Geben Sie beim Schreiben von Textdateien immer encoding= an. Wenn Sie sich auf den Plattformstandard verlassen, riskieren Sie, Dateien zu erstellen, die auf anderen Systemen nicht gelesen werden können.

Empfohlene Kodierungen für häufige Szenarien:

Eine Datei mit UTF-8-Kodierung schreiben

with open("international.txt", "w", encoding="utf-8") as f:
    f.write("English: Hello\n")
    f.write("Japanese: こんにちは\n")
    f.write("Arabic: مرحبا\n")

Binärdateien schreiben

Öffnen Sie eine Datei mit dem Modus "wb" (Write Binary), um rohe Bytes statt Strings zu schreiben. Der Binärmodus ist für Bilder, Audio, komprimierte Archive, ausführbare Dateien und alle Nicht-Text-Daten erforderlich. Geben Sie im Binärmodus kein encoding an.

Bytes in eine Binärdatei schreiben

data = bytes([0x89, 0x50, 0x4E, 0x47])  # PNG magic bytes

with open("header.bin", "wb") as f:
    f.write(data)
    print(f.write(b"\r\n\x1a\n"))   # 4

Eine Binärdatei kopieren

with open("photo.jpg", "rb") as src:
    content = src.read()

with open("photo_backup.jpg", "wb") as dst:
    dst.write(content)

Lesen und schreiben Sie bei großen Binärdateien in Blöcken, um zu vermeiden, dass die gesamte Datei in den Speicher geladen wird:

CHUNK = 65536  # 64 KB

with open("large.bin", "rb") as src, open("large_copy.bin", "wb") as dst:
    while True:
        chunk = src.read(CHUNK)
        if not chunk:
            break
        dst.write(chunk)

Fehler beim Schreiben behandeln

Ein produktionsreifes Skript antizipiert stets die Wege, auf denen ein Datei-Schreibvorgang fehlschlagen kann.

Häufige Schreibfehler behandeln

try:
    with open("/etc/protected.txt", "w", encoding="utf-8") as f:
        f.write("data\n")
except PermissionError:
    print("Error: you do not have write permission for this file.")
except FileNotFoundError:
    print("Error: one or more directories in the path do not exist.")
except IsADirectoryError:
    print("Error: the path points to a directory, not a file.")
except OSError as e:
    print(f"OS error: {e}")

Häufige Ausnahmen, denen Sie begegnen werden:

Siehe Python Try Except für eine vollständige Anleitung zur Ausnahmebehandlung.

Dateien sicher schreiben (Atomic Write Pattern)

Ein einfaches open("file.txt", "w") ist für kritische Daten nicht sicher: Wenn Ihr Skript abstürzt oder mitten beim Schreiben unterbrochen wird, bleibt die Datei in einem teilweise geschriebenen, beschädigten Zustand. Die Standardlösung ist ein atomarer Schreibvorgang: Schreiben Sie zuerst in eine temporäre Datei und benennen Sie sie dann über das Ziel um.

import os
import tempfile

def write_file_safely(path, content, encoding="utf-8"):
    """Write content to path atomically using a temp file + rename."""
    dir_name = os.path.dirname(os.path.abspath(path)) or "."
    # Write to a temp file in the same directory (same filesystem = atomic rename)
    fd, tmp_path = tempfile.mkstemp(dir=dir_name)
    try:
        with os.fdopen(fd, "w", encoding=encoding) as f:
            f.write(content)
        os.replace(tmp_path, path)   # atomic on POSIX; best-effort on Windows
    except Exception:
        os.unlink(tmp_path)          # clean up if something went wrong
        raise

write_file_safely("important.txt", "critical data\n")

os.replace() (Python 3.3+) ersetzt das Ziel auf POSIX-Systemen atomar: Leser sehen entweder die alte oder die neue Datei, niemals einen partiellen Schreibvorgang.

Dateien mit pathlib schreiben

pathlib.Path (eingeführt in Python 3.4) bietet eine prägnante, objektorientierte API. Für einfache einmalige Schreibvorgänge sind Path.write_text() und Path.write_bytes() lesbarer als open().

Path.write_text()

from pathlib import Path

Path("output.txt").write_text("Hello from pathlib!\n", encoding="utf-8")

write_text() öffnet die Datei im "w"-Modus, schreibt den string und schließt die Datei — alles in einem Aufruf. Die Datei wird dabei immer überschrieben. Es gibt kein Äquivalent zum Anhängen; verwenden Sie für das Anhängen open() mit dem Modus "a".

Path.write_bytes()

from pathlib import Path

Path("data.bin").write_bytes(b"\x00\x01\x02\x03")

Pfade mit pathlib erstellen

pathlib erleichtert auch das sichere Erstellen von Pfaden ohne Stringverkettung:

from pathlib import Path

output_dir = Path("results")
output_dir.mkdir(exist_ok=True)          # create the directory if needed

report_path = output_dir / "report.txt"
report_path.write_text("Run complete.\n", encoding="utf-8")

print(report_path)         # results/report.txt
print(report_path.exists())  # True

Der /-Operator auf Path-Objekten verbindet Pfadsegmente — kein Bedarf für os.path.join().

Praktisches Beispiel: Einen CSV-Bericht schreiben

Das folgende vollständige Beispiel schreibt eine Liste von Datensätzen in eine CSV-Datei, ausschließlich mit eingebauten Werkzeugen (ohne das csv-Modul), und demonstriert dabei mehrere Konzepte aus diesem Kapitel.

from pathlib import Path
import datetime

def write_csv_report(path, headers, rows):
    """Write a simple CSV file with a header row."""
    with open(path, "w", encoding="utf-8", newline="") as f:
        f.write(",".join(headers) + "\n")
        for row in rows:
            f.write(",".join(str(v) for v in row) + "\n")

records = [
    ("Alice", 30, "Engineering"),
    ("Bob", 25, "Marketing"),
    ("Charlie", 35, "Finance"),
]

output = Path("staff_report.txt")
write_csv_report(output, ["Name", "Age", "Department"], records)

print(output.read_text(encoding="utf-8"))

Erwartete Ausgabe:

Name,Age,Department
Alice,30,Engineering
Bob,25,Marketing
Charlie,35,Finance

Beachten Sie, dass newline="" an open() übergeben wird, damit Python Zeilenenden innerhalb von CSV-Zeilen nicht doppelt übersetzt — dies entspricht der Empfehlung in der Dokumentation des Python-csv-Moduls.

Für alles Komplexere (Anführungszeichen, Dialekte, Unicode-Randfälle) verwenden Sie stattdessen das eingebaute Python CSV-Modul.

Kurzreferenz

Verwandte Kapitel

• Python File Handling — Öffnungsmodi, open()-Parameter und die with-Anweisung
• Python Read Files — read(), readline(), readlines(), Zeileniteration und seek()
• Python Delete Files — Dateien und Verzeichnisse sicher löschen
• Python Try Except — Ausnahmen in Python behandeln
• Python CSV — CSV-Dateien mit dem csv-Modul lesen und schreiben
• Python JSON — Daten in JSON-Dateien serialisieren