Python-Dateien lesen – Vollständige Anleitung

Das Lesen von Dateien gehört zu den häufigsten Aufgaben in Python — sei es beim Laden von Konfigurationen, der Verarbeitung von Logs, dem Importieren von CSV-Daten oder dem Lesen von binären Assets. Dieses Kapitel behandelt jede Methode, die Python zum Lesen von Dateiinhalten bereitstellt: vom einfachsten read()-Aufruf bis hin zu speichereffizienter Zeileniterierung, Binärmodus, Kodierungsbehandlung, Dateipositionssteuerung und der modernen pathlib-API.

Eine Datei zum Lesen öffnen

Jede Dateioperation beginnt mit der eingebauten Funktion open(). Um eine Datei im Lesemodus zu öffnen, verwende den Modus-String "r" (der Standard, wenn kein Modus angegeben wird):

file_object = open("notes.txt", "r", encoding="utf-8")

• "r" — zum Lesen öffnen; löst FileNotFoundError aus, wenn die Datei nicht existiert.
• encoding="utf-8" — gibt die Zeichenkodierung für Textdateien immer explizit an, damit dein Code auf Windows, macOS und Linux identisch funktioniert.

Immer einen with-Block verwenden

Der sicherste Weg, eine Datei zu öffnen, ist innerhalb einer with-Anweisung. Python schließt die Datei automatisch, wenn der Block verlassen wird — selbst wenn eine Ausnahme auftritt — was Ressourcenlecks verhindert und sicherstellt, dass alle gepufferten Daten geschrieben werden.

with open("notes.txt", "r", encoding="utf-8") as f:
    contents = f.read()
# File is automatically closed here

open() außerhalb eines with-Blocks aufzurufen und file.close() zu vergessen, ist eine häufige Ursache für "zu viele offene Dateien"-Fehler in lang laufenden Skripten.

Die gesamte Datei mit read() lesen

read() gibt den vollständigen Inhalt der Datei als einzelnen string zurück.

Eine gesamte Datei auf einmal lesen

with open("notes.txt", "r", encoding="utf-8") as f:
    contents = f.read()

print(contents)

Verwende read(), wenn:

• Die Datei klein genug ist, um bequem in den Speicher zu passen.
• Du den vollständigen Text als einen string benötigst (z. B. zum Parsen oder Suchen).

Bei möglicherweise großen Dateien (Logs, Daten-Dumps) sind die nachfolgend beschriebenen zeilenweisen Ansätze zu bevorzugen.

Eine feste Anzahl von Zeichen lesen

Übergib eine ganze Zahl n an read(n), um höchstens n Zeichen ab der aktuellen Position zu lesen. Nachfolgende Aufrufe von read(n) setzen dort fort, wo der letzte Lesevorgang aufgehört hat.

Die ersten 50 Zeichen lesen

with open("notes.txt", "r", encoding="utf-8") as f:
    first_chunk = f.read(50)
    second_chunk = f.read(50)

print(repr(first_chunk))
print(repr(second_chunk))

Dieser blockweise Ansatz ist nützlich, wenn du eine Datei in der Vorschau anzeigen oder in Stücken fester Größe verarbeiten möchtest, ohne alles in den Speicher zu laden.

Eine Zeile nach der anderen mit readline() lesen

readline() liest eine Zeile aus der Datei, einschließlich des abschließenden Zeilenumbruchzeichens \n. Es gibt einen leeren string "" zurück, wenn das Dateiende erreicht ist, was das Schleifen bis EOF erleichtert.

Eine Datei zeilenweise mit readline() lesen

with open("notes.txt", "r", encoding="utf-8") as f:
    line = f.readline()
    while line:
        print(line, end="")   # line already contains '\n'
        line = f.readline()

Das Argument end="" in print() verhindert einen doppelten Zeilenumbruch (einer aus der Dateizeile und einer vom Standard-print).

readline() ist nützlich, wenn du eine Kopfzeile anders verarbeiten musst als den Rest, oder wenn du das Lesen basierend auf einer Bedingung mitten in der Datei abbrechen möchtest.

Über Zeilen iterieren (am pythonischsten)

Direkt über ein Dateiobjekt zu iterieren ist der idiomatischste und speichereffizienteste Weg, eine Textdatei zeilenweise zu verarbeiten. Python liest jeweils eine Zeile, ohne die gesamte Datei in den Speicher zu laden.

Mit einer for-Schleife über Zeilen iterieren

with open("notes.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line, end="")

Dieses Muster ist gegenüber read() + split("\n") und dem Aufruf von readline() in einer while-Schleife vorzuziehen, weil es kürzer ist und alle Sonderfälle (einschließlich Dateien, die nicht mit einem Zeilenumbruch enden) korrekt behandelt.

Ein Muster beim Iterieren suchen

with open("server.log", "r", encoding="utf-8") as f:
    for line in f:
        if "ERROR" in line:
            print(line, end="")

Alle Zeilen mit readlines() in eine Liste lesen

readlines() gibt eine Liste zurück, bei der jedes Element eine Zeile der Datei darstellt (mit dem enthaltenen Zeilenumbruchzeichen). Dies lädt die gesamte Datei in den Speicher.

Alle Zeilen in eine Liste lesen

with open("notes.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()

print(lines[0])        # first line
print(lines[-1])       # last line
print(len(lines))      # total number of lines

Verwende readlines(), wenn du wahlfreien Zugriff auf bestimmte Zeilen per Index benötigst. Für die sequenzielle Verarbeitung von oben nach unten ist das Muster for line in f speichereffizienter.

Zeilenumbruchzeichen entfernen

Zeilen, die von readline(), readlines() und der for-Schleifen-Iteration zurückgegeben werden, enthalten alle das abschließende \n. Verwende .strip() oder .rstrip("\n"), um es zu entfernen:

with open("notes.txt", "r", encoding="utf-8") as f:
    lines = [line.rstrip("\n") for line in f]

print(lines)  # ['Line one', 'Line two', 'Line three']

Die richtige Lesemethode wählen

Dateiposition: tell() und seek()

Jedes geöffnete Dateiobjekt verwaltet einen internen Positionszeiger, der beim Lesen weiterrückt. Zwei Methoden ermöglichen es, ihn zu inspizieren und zu steuern:

• tell() — gibt den aktuellen Byte-Offset vom Dateianfang zurück.
• seek(offset, whence=0) — bewegt den Zeiger. Mit whence=0 (Standard) ist der Offset vom Anfang; whence=1 ist von der aktuellen Position; whence=2 ist vom Ende.

Eine Datei zweimal mit seek(0) lesen

with open("notes.txt", "r", encoding="utf-8") as f:
    first_pass = f.read()
    print(f"Position after first read: {f.tell()}")

    f.seek(0)   # rewind to the beginning
    second_pass = f.read()

print(first_pass == second_pass)  # True

seek() ist besonders nützlich im Modus "r+" (Lesen und Schreiben), wenn du einen Abschnitt einer Datei lesen und dann einen bestimmten Teil im selben open()-Aufruf überschreiben möchtest.

Fehlerbehandlung beim Lesen

Ein gut geschriebenes Skript berücksichtigt immer die Wege, auf denen ein Dateilesen fehlschlagen kann.

Häufige Lesefehler behandeln

try:
    with open("data.txt", "r", encoding="utf-8") as f:
        content = f.read()
except FileNotFoundError:
    print("Error: the file does not exist.")
except PermissionError:
    print("Error: you do not have permission to read this file.")
except UnicodeDecodeError:
    print("Error: the file contains bytes that are not valid UTF-8.")
except OSError as e:
    print(f"OS error: {e}")

Häufige Ausnahmen, denen du begegnen wirst:

Siehe Python Try Except für einen vollständigen Leitfaden zur Ausnahmebehandlung.

Zeichenkodierung

Wenn Python eine Datei im Textmodus öffnet, muss es wissen, wie rohe Bytes in Zeichen umgewandelt werden. Übergib encoding= immer explizit, anstatt dich auf den Plattformstandard zu verlassen, der zwischen Windows (cp1252) und den meisten Unix-Systemen (utf-8) unterschiedlich ist.

Häufige Kodierungswerte:

Kodierungsprobleme erkennen oder ignorieren:

Wenn du dir über die Kodierung einer Datei unsicher bist, kannst du Python anweisen, nicht dekodierbare Bytes durch einen Platzhalter zu ersetzen, anstatt einen Fehler auszulösen:

with open("mystery.txt", "r", encoding="utf-8", errors="replace") as f:
    content = f.read()

Weitere Werte für errors sind "ignore" (fehlerhafte Bytes still überspringen) und "strict" (Standard — löst UnicodeDecodeError aus).

Binärdateien lesen

Öffne eine Datei im Binärmodus, indem du "b" zum Modus-String hinzufügst ("rb"). Der Binärmodus gibt rohe bytes-Objekte statt strings zurück, was für Bilder, Audio, komprimierte Archive, ausführbare Dateien und alle Nicht-Text-Daten korrekt ist.

Eine Binärdatei lesen

with open("photo.jpg", "rb") as f:
    data = f.read()

print(type(data))   # <class 'bytes'>
print(len(data))    # size in bytes

Eine Binärdatei kopieren

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

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

Gib im Binärmodus keine encoding an — Python löst ValueError aus, wenn du es versuchst.

Große Dateien effizient lesen

Das Laden einer mehrere Gigabyte großen Datei mit read() kann den Systemspeicher erschöpfen. Die Lösungen sind:

Zeilenweise Iteration (Textdateien)

with open("huge_log.txt", "r", encoding="utf-8") as f:
    for line in f:
        process(line)   # only one line in memory at a time

Blöcke fester Größe (Binärdateien)

CHUNK_SIZE = 65536  # 64 KB

with open("large_file.bin", "rb") as f:
    while True:
        chunk = f.read(CHUNK_SIZE)
        if not chunk:
            break
        process(chunk)

Beide Muster halten den Speicherverbrauch unabhängig von der Dateigröße konstant.

Dateien mit pathlib lesen

Python 3.4 führte pathlib.Path ein, das eine objektorientierte Schnittstelle für Dateisystempfade bietet. Für einfache einmalige Lese- und Schreibvorgänge sind Path-Objekte prägnanter als open().

Text mit Path.read_text() lesen

from pathlib import Path

content = Path("notes.txt").read_text(encoding="utf-8")
print(content)

Bytes mit Path.read_bytes() lesen

from pathlib import Path

data = Path("photo.jpg").read_bytes()
print(len(data))  # file size in bytes

read_text() und read_bytes() öffnen die Datei, lesen ihren gesamten Inhalt und schließen sie in einem einzigen Aufruf. Verwende sie für kleine Dateien, wenn du nur den Inhalt benötigst. Verwende open() mit einem with-Block, wenn du zeilenweise Iteration, blockweises Lesen, seek() oder andere feinkörnige Steuerung benötigst.

Prüfen, ob eine Datei vor dem Lesen existiert

from pathlib import Path

p = Path("data.txt")
if p.exists() and p.is_file():
    content = p.read_text(encoding="utf-8")
else:
    print("File not found.")

Hinweis: p.exists() kann in Multithread-Code ein veraltetes Ergebnis zurückgeben. In diesen Fällen ist es sicherer, den Lesevorgang zu versuchen und FileNotFoundError abzufangen.

Praktisches Beispiel: Eine einfache Konfigurationsdatei lesen

Viele Skripte lesen eine einfache Textkonfigurationsdatei, die ein key=value-Paar pro Zeile speichert. Hier ist ein vollständiges, funktionsfähiges Beispiel:

Eine key=value-Konfigurationsdatei parsen

from pathlib import Path

def load_config(path):
    config = {}
    with open(path, "r", encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line or line.startswith("#"):
                continue          # skip blank lines and comments
            key, _, value = line.partition("=")
            config[key.strip()] = value.strip()
    return config

# Example config.txt contents:
# host = localhost
# port = 8080
# debug = true

config = load_config("config.txt")
# config == {'host': 'localhost', 'port': '8080', 'debug': 'true'}

str.partition("=") teilt nur am ersten = auf, sodass Werte, die = enthalten (z. B. Base64-strings), korrekt behandelt werden.

Verwandte Kapitel

• Python File Handling — Öffnungsmodi, with-Anweisung, seek(), Binärdateien, pathlib-Übersicht
• Python Write / Create Files — Dateien schreiben, erstellen und anhängen
• 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