Daten laden und speichern in pandas

Eine CSV-Datei ist reiner Text, der in Datensätze und Felder gegliedert ist. Meist trennen Kommas die Felder und der erste Datensatz liefert häufig die Spaltennamen. Die Datei enthält Zeichen, kein pandas-Schema. Beim Einlesen musst du daher auch entscheiden, wofür diese Zeichen stehen.

Eine kleine Datei laden und untersuchen

Angenommen, eine Datei enthält:

order_id,date,region,units,price
1001,2026-03-02,North,3,4.50
1002,2026-03-02,South,1,12.00
1003,2026-03-03,North,2,7.25

Lies sie ein und untersuche das Ergebnis:

import pandas as pd

df = pd.read_csv("sales.csv")
print(df.head())
print(df.shape)
print(df.dtypes)
df.info()

Die Form ist (3, 5): drei Datenzeilen und fünf Spalten. pandas ermittelt int64 für order_id und units sowie float64 für price. Die Spalte date enthält weiterhin Text. In pandas 3 zeigen automatisch erkannte Textspalten normalerweise str; ältere pandas-Versionen zeigen häufig object.

Jede Prüfung beantwortet eine andere Frage. head() zeigt, ob die Felder zu ihren Bezeichnungen passen. shape deckt fehlende Zeilen oder eine unerwartete zusätzliche Spalte auf. dtypes prüft die Interpretation und info() ergänzt die Anzahl nicht fehlender Werte. Wird eine für Zahlen vorgesehene Spalte als Text geladen, lohnt sich ein Blick auf die Rohwerte: Eine Einheit, ein Platzhalter oder eine andere Dezimalschreibweise kann die Erkennung als numerischer Typ verhindern.

Bezeichnungen den Datensätzen zuordnen

Für eine Datei ohne Kopfzeile, deren erste Zeile 1001,North,3 ist, verwende:

df = pd.read_csv(
    "orders.txt",
    header=None,
    names=["id", "region", "units"]
)

Ohne diese Einstellung verwendet pandas den ersten Datensatz als Kopfzeile. Seine Werte werden zu Spaltennamen und der Datensatz verschwindet aus den Daten. Verwende index_col="order_id", wenn eine vorhandene Spalte die Zeilen bezeichnen soll. Verwende usecols=["region", "units"], um nur diese Spalten einzulesen, oder nrows=1000, um die ersten 1.000 Datenzeilen zu untersuchen, bevor du eine große Datei lädst.

Anführungszeichen vom CSV-Parser verarbeiten lassen

Der Datensatz "Smith, Jane",Boston,10 hat drei Felder. Das Komma innerhalb des Namens in Anführungszeichen gehört zu diesem Namen. Zwei doppelte Anführungszeichen innerhalb eines Feldes in Anführungszeichen stehen für ein einzelnes doppeltes Anführungszeichen als Inhalt: "O'Neil ""Red""" wird zu O'Neil "Red". Ein solches Feld kann sogar einen Zeilenumbruch enthalten, sodass Datensätze und tatsächliche Zeilen nicht immer übereinstimmen.

Der Aufruf line.split(",") zerschneidet den Namen und kann diese Regeln nicht berücksichtigen. read_csv berücksichtigt sie beim Einlesen. pd.read_table verwendet standardmäßig den Tabulator als Trennzeichen; pd.read_fwf verarbeitet Felder, die durch Zeichenpositionen definiert sind.

Die Datei finden, die Python sucht

Ein relativer Pfad wird vom aktuellen Arbeitsverzeichnis des Programms aus aufgelöst. Kann "data/sales.csv" nicht gefunden werden, prüfe das Arbeitsverzeichnis nach from pathlib import Path mit Path.cwd(). An read_csv lassen sich auch ein absoluter Pfad, ein Path-Objekt, eine URL oder eine Textdatei im Arbeitsspeicher wie StringIO übergeben. Prüfe den Speicherort, bevor du Leseoptionen änderst: Eine fehlende Datei und eine falsch eingelesene Datei sind verschiedene Probleme.

Ein Trennzeichen trennt Felder; ein Dezimaltrennzeichen trennt den ganzzahligen Teil einer Zahl von ihrem Nachkommateil. Ein Tausendertrennzeichen gruppiert Ziffern. Diese drei Aufgaben benötigen separate Einstellungen, selbst wenn dasselbe Zeichen in verschiedenen Dateien unterschiedliche Aufgaben erfüllt.

Zeichen vor der Wahl der Optionen untersuchen

Sieh dir einige Rohzeilen in einem Editor an. Die Endung .csv garantiert keine Kommas und .txt verrät den Aufbau nicht. Häufige Einstellungen sind:

Du kannst den Anfang untersuchen, ohne die ganze Datei einzulesen:

with open("products.csv", encoding="utf-8") as f:
    print(f.readline())
    print(f.readline())

Einen regionalen Export durchgehen

Betrachte diesen Text:

product;price;qty
Tea;3,50;1.200
Coffee;12,90;850

Die Semikolons trennen Felder, das Komma ist das Dezimaltrennzeichen und der Punkt gruppiert Tausender. Gib beim Einlesen alle drei Konventionen ausdrücklich an:

df = pd.read_csv(
    "products.csv",
    sep=";",
    decimal=",",
    thousands="."
)

Die Preise werden zu 3,5 und 12,9. Die Mengen werden zu 1200 und 850. Mit dem standardmäßigen Komma als Trennzeichen beschreibt diese Kopfzeile keine drei kommagetrennten Spalten. Selbst nach der Wahl von sep=";" ist die Aufgabe noch nicht erledigt: Die Preise bleiben Text und "1.200" kann zur Dezimalzahl 1,2 werden. Dieses letzte Ergebnis ist eine gültige Zahl mit der falschen Bedeutung. Für einen schwerwiegenden Fehler muss daher keine Ausnahme beim Einlesen auftreten.

Vergleiche einige geladene Werte mit ihrem Quelltext und untersuche describe() auf unplausible Wertebereiche. Eine Menge, die im Tausenderbereich erwartet wird und nahe eins erscheint, deutet auf ein Problem mit der Zahlenschreibweise hin. Das Trennzeichen allein zu ändern, behebt es nicht.

Feldgrenzen von der Zahlengruppierung unterscheiden

In einer kommagetrennten Datei muss eine gruppierte Zahl wie "1,234.50" in Anführungszeichen stehen. Das Komma innerhalb des Feldes gehört zur Zahl. Mit thousands="," kann pandas das Feld in Anführungszeichen als 1234,5 einlesen. Ohne Anführungszeichen erzeugt das Komma auch eine Feldgrenze; thousands kann die verlorene Datensatzstruktur nicht wiederherstellen.

Einen passenden Parser wählen

Der standardmäßige C-Parser verarbeitet übliche Dateiaufbauten schnell. Der Python-Parser unterstützt die Erkennung von Trennzeichen mit sep=None, reguläre Ausdrücke als Trennzeichen und skipfooter. Die Erkennung untersucht eine Stichprobe und kann bei einem unregelmäßigen Bericht falsch liegen. Gib daher ein bekanntes Trennzeichen direkt an.

Ein Trennzeichen mit mehr als einem Zeichen wird im Allgemeinen als regulärer Ausdruck behandelt und benötigt den Python-Parser; r"\s+" ist ein Sonderfall, den auch der C-Parser unterstützt. Der PyArrow-Parser kann mit parallelen Threads einlesen, unterstützt aber andere Optionen. Zum Beispiel wird chunksize mit engine="pyarrow" nicht unterstützt. Wähle den Parser nach den Optionen, die deine Datei benötigt, und prüfe anschließend Struktur und Werte des Ergebnisses.

Die Typinferenz kann nicht wissen, ob 999 ein Messwert oder ein Code für einen unbekannten Wert ist. Sie kann auch nicht wissen, ob führende Nullen eine Bedeutung haben. Nutze die Definitionen der Daten, um Leseoptionen festzulegen, bevor die Typinferenz diese Werte verändert.

Fehlwertkennzeichen dort festlegen, wo sie gelten

pandas erkennt leere Felder und integrierte Kennzeichen wie "NA", "N/A", "n/a", "NULL", "NaN" und "None". Eine Quelle kann zusätzliche Kennzeichen verwenden. Angenommen, score enthält 88, "n/a", "-" und 999, wobei 999 als unbekannt definiert ist:

df = pd.read_csv(
    "scores.csv",
    na_values={"score": ["-", "999"]}
)

Die Spalte mit den Punktzahlen enthält nun 88,0 und drei fehlende Werte. Ohne Deklaration der Kennzeichen kann "-" dazu führen, dass die Spalte Text bleibt; ein nicht deklarierter numerischer Sentinelwert kann in Berechnungen eingehen. Der Mittelwert von 88 und 999 ist 543,5, obwohl die einzige bekannte Punktzahl 88 ist.

Ein Dictionary beschränkt ein Kennzeichen auf seine Spalte. Ein dateiweites na_values=["999"] würde auch einen tatsächlichen Produktcode 999 entfernen. Ist "NA" eine tatsächliche Bezeichnung, schalte mit keep_default_na=False die integrierte Liste der Kennzeichen ab und führe die Kennzeichen, die tatsächlich fehlende Werte bedeuten, ausdrücklich auf. Nimm bei dieser Einstellung "" auf, wenn leere Felder weiterhin als fehlend zählen sollen.

Werte entsprechend ihrer Rolle erhalten

Lies Kennungen als Text ein:

df = pd.read_csv(
    "visits.csv",
    dtype={"site_code": str, "visits": "Int64"}
)

Ein Code wie "00501" muss fünf Zeichen lang bleiben. Als Ganzzahl eingelesen ergibt er 501; wandelst du diese Ganzzahl später in Text um, entsteht "501", nicht der ursprüngliche Code. Verwende einen numerischen Typ für Werte, mit denen du rechnest.

Gewöhnliche NumPy-Ganzzahlspalten können kein NaN enthalten, daher wird eine Zählspalte mit einer Lücke oft zu float64. Das pandas-"Int64" mit Fehlwertunterstützung und großem I behält Ganzzahlwerte und stellt eine Lücke mit <NA> dar. dtype_backend="numpy_nullable" fordert für das gesamte Ergebnis Typen mit Fehlwertunterstützung an. Bei einer kleinen Anzahl wiederholter Bezeichnungen speichert dtype={"region": "category"} die Bezeichnungen als Kategorien und kann den Speicherbedarf senken.

Die Schreibweise von Datumsangaben festlegen

Text, der wie ein Datum aussieht, bleibt Text, bis er als Datum eingelesen wird. Verwende für Datumsangaben mit dem Tag zuerst wie "03/04/2026" und "13/04/2026":

df = pd.read_csv(
    "events.csv",
    parse_dates=["day"],
    date_format="%d/%m/%Y"
)

Diese Werte werden zum 3. beziehungsweise 13. April. Ohne Format kann eine Annahme mit dem Monat zuerst entweder gültige Tage und Monate vertauschen oder die Umwandlung der Spalte scheitern lassen. dayfirst=True gibt eine bevorzugte Reihenfolge an; ein explizites Format legt den erwarteten Aufbau fest. ISO-Datumsangaben wie "2026-04-03" vermeiden Mehrdeutigkeit bei Tag und Monat.

Untersuche nach dem Einlesen dtypes, isna().sum() und die Zeilenanzahl. Prüfe ein Datum, dessen Interpretation sich zwischen den Konventionen unterscheidet. Zeigt eine Spalte weiterhin Text, hat das Einlesen nicht die beabsichtigten Datums- und Zeitwerte erzeugt; eine unerwartet gestiegene Anzahl fehlender Werte kann darauf hinweisen, dass eine tatsächliche Bezeichnung für ein Fehlwertkennzeichen gehalten wurde.

Ein Bericht kann eine Tabelle mit Titeln, Leerzeilen, Kommentaren, Summen und Quellenangaben verbinden. Finde zuerst die Kopfzeile und die Grenzen der Daten. Andernfalls kann eine Lesefunktion einen Titel für Spaltennamen halten oder eine Summe als gewöhnliche Beobachtung einbeziehen.

Nur die Tabelle einlesen

Ein Bericht enthält diese neun tatsächlichen Zeilen:

Monthly sales report
Exported 2026-04-01

region,jan,feb
North,120,135
# test row below
South,98,101
Total,218,236
Source: internal system

Die ersten drei Zeilen stehen vor der Kopfzeile. Die letzten zwei sind keine Beobachtungen. Lies den Bericht so ein:

df = pd.read_csv(
    "report.csv",
    skiprows=3,
    comment="#",
    skipfooter=2,
    engine="python"
)

Das Ergebnis hat zwei Zeilen. Für Januar ergibt sich aus North und South eine Summe von 218. Bliebe die Summenzeile erhalten, kämen weitere 218 hinzu und es würden 436 ausgegeben. Mit den Standardeinstellungen kann stattdessen der Titel mit einem Feld zur Kopfzeile werden und zu einem Lesefehler führen, wenn Datensätze mit drei Feldern folgen.

skiprows=3 zählt die ersten drei tatsächlichen Zeilen einschließlich der Leerzeile. Eine Liste wie skiprows=[0, 2] entfernt bestimmte Zeilenpositionen, gezählt ab null. Leerzeilen werden standardmäßig übersprungen und comment="#" entfernt Kommentartext. skipfooter benötigt den Python-Parser. Passe diese Einstellungen an den tatsächlichen Aufbau an; eine feste Anzahl zu überspringender Zeilen kann falsch werden, wenn ein Exportprogramm eine Titelzeile hinzufügt.

Fehlerhafte Datensätze untersuchen

Ein Datensatz mit zu vielen Feldern kann on_bad_lines="error", die Standardeinstellung, auslösen. "warn" überspringt ihn mit einer Warnung, während "skip" ihn ohne Meldung entfernt. Untersuche den Rohdatensatz, bevor du eine der beiden Optionen wählst. Ein Komma ohne Anführungszeichen innerhalb eines Namens oder ein falsches Trennzeichen kann zusätzliche Felder erzeugen; beim Überspringen geht dann eine gültige Beobachtung verloren, statt die Ursache zu beheben.

Zu wenige Felder verhalten sich anders. Unter id,name,score wird der Datensatz 2,Ben mit einer fehlenden Punktzahl geladen. Dabei muss kein Fehler auftreten. Prüfe sowohl die Anzahl fehlender Werte als auch die Zeilenanzahl und vergleiche beim Ausschließen fehlerhafter Zeilen die behaltenen Datensätze mit der Quelle.

Mehrzeilige Kopfzeilen oder Zeichenpositionen einlesen

Zwei Zeilen mit Spaltenbezeichnungen können einen MultiIndex bilden. Mit den Gruppenbezeichnungen region,sales,sales über ,2025,2026 erzeugt header=[0, 1] Bezeichnungen wie ("sales", "2025"). Eignen sich flache Bezeichnungen besser für die Analyse, überspringe beide Kopfzeilen und gib names=["region", "sales_2025", "sales_2026"] an.

Text mit fester Feldbreite hat kein Trennzeichen. Spaltengrenzen sind Zeichenpositionen:

df = pd.read_fwf(
    "readings.txt",
    colspecs=[(0, 4), (4, 11), (11, 16)]
)

Diese halboffenen Bereiche schließen jeweils den Anfang ein und das Ende aus. Das erste Feld belegt die Positionen 0 bis 3 und das nächste beginnt bei 4. widths=[4, 7, 5] beschreibt denselben Aufbau. Bei regelmäßigen Stichproben ist die automatische Erkennung praktisch; explizite Grenzen verhindern, dass ein kurzer Wert am Anfang eine falsche Breite festlegt.

Eine Datei speichert Bytes, die jeweils einen Wert von 0 bis 255 haben. Eine Zeichenkodierung legt fest, wie Zeichen durch diese Bytes dargestellt werden. Beim Kodieren wird Python-Text in Bytes umgewandelt; beim Dekodieren werden Bytes wieder in Text umgewandelt. Dieselben Bytes können nach unterschiedlichen Dekodierungsregeln für verschiedene Zeichen stehen.

Zeichen und Bytes getrennt zählen

text = "café"
raw = text.encode("utf-8")
print(len(text))  # 4 characters
print(len(raw))   # 5 bytes
print(raw.decode("utf-8"))  # café

Der Akzent bildet hier kein zweites sichtbares Zeichen. Der Buchstabe "é" benötigt in UTF-8 zwei Bytes, sodass vier Zeichen fünf Bytes belegen. Die Anzahl der Bytes und die Anzahl der Zeichen beantworten unterschiedliche Fragen.

ASCII definiert 128 Zeichen, darunter grundlegende englische Buchstaben, Ziffern, Satzzeichen und Steuerzeichen. Ihre Bytewerte stimmen in ASCII, UTF-8, Latin-1 und Windows-1252 überein. Dieser gemeinsame Anfang erklärt, warum eine rein englische Textprobe auch bei einer falschen Kodierungseinstellung korrekt aussehen kann.

Die wichtigsten Kodierungsfamilien erkennen

UTF-8 stellt jedes Unicode-Zeichen dar und ist die übliche Wahl für den Textaustausch. Latin-1 und Windows-1252 stellen einen kleineren Zeichenvorrat dar. Bei vielen Buchstaben mit Akzent stimmen sie überein, unterscheiden sich aber in einem Teil des Bytebereichs: Windows-1252 verwendet Byte 0x80 für "€", während Latin-1 dort ein Steuerzeichen hat. Die beiden Namen stehen nicht austauschbar für dieselbe Zeichenkodierung.

Byte Order Marks richtig einlesen

Eine Byte Order Mark, kurz BOM, ist eine Markierung am Anfang mancher Dateien. UTF-16 kann mit FF FE für die Little-Endian-Reihenfolge oder FE FF für die Big-Endian-Reihenfolge beginnen. encoding="utf-16" wählt die Reihenfolge anhand der BOM. Gib ohne BOM entsprechend der Quelle "utf-16-le" oder "utf-16-be" an.

Eine UTF-8-BOM ist EF BB BF. Pythons open(..., encoding="utf-8-sig") entfernt sie beim Dekodieren. Einfaches "utf-8" in open() behält sie als \ufeff, was unerwartet Teil des ersten Spaltennamens werden kann. Auch der CSV-Parser von pandas verarbeitet eine führende UTF-8-BOM, aber die Wahl von utf-8-sig macht die beabsichtigte Dateikonvention deutlich.

Die Zeichenkodierung ausdrücklich angeben

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

Die Standardeinstellung von open() hängt von der Python-Version und dem UTF-8-Modus ab. Python 3.11 bis 3.14 kann die Zeichenkodierung der Ländereinstellung verwenden; Python 3.15 aktiviert den UTF-8-Modus standardmäßig, wobei er abgeschaltet werden kann. Eine explizite Zeichenkodierung bindet das Skript auf verschiedenen Computern an das tatsächliche Format der Datei. Sie verhindert auch, dass eine Standardeinstellung der Plattform unbemerkt verändert, wie dieselben Bytes gelesen werden.

Eine falsche Zeichenkodierung kann mit einem UnicodeDecodeError deutlich fehlschlagen oder unbemerkt scheinbar lesbaren Unsinn erzeugen, den man Zeichensalat nennt. Beide Probleme entstehen, wenn Bytes nach der falschen Regel interpretiert werden. Bewahre die Originaldatei auf, damit du sie erneut dekodieren kannst.

Einen Fehler anhand der Quelle untersuchen

Eine als Windows-1252 gespeicherte CSV-Datei enthält Städtenamen wie "Zürich" und "Málaga". Beim Einlesen als UTF-8 kann ein Fehler bei Byte 0xfc auftreten, das in Windows-1252 für "ü" verwendet wird. Sobald die Exporteinstellungen der Quelle die Zeichenkodierung bestätigen, lies die Datei so ein:

df = pd.read_csv("cities.csv", encoding="cp1252")
print(df["city"].head())

Untersuche Namen mit Akzenten oder Symbolen. Eine Textprobe, die ausschließlich aus ASCII-Zeichen besteht, kann diese Zeichenkodierungen nicht unterscheiden. Ein bestimmtes, in UTF-8 ungültiges Byte weist auf eine mögliche ältere Zeichenkodierung hin; es bestimmt nicht eindeutig, welche ältere Kodierung die Datei erzeugt hat.

Einen Fehler ohne Fehlermeldung erkennen

Werden Bytes aus UTF-8 als Windows-1252 dekodiert, kann aus "café" "café" und aus "São Paulo" "São Paulo" werden. Die Lesefunktion hat erfolgreich Zeichen erzeugt, aber die falschen. Lies die ursprünglichen Bytes erneut mit UTF-8 ein:

df = pd.read_csv("cities.csv", encoding="utf-8")

Suchen und Ersetzen repariert jeweils ein sichtbares Symptom und kann andere beschädigte Buchstaben übersehen. Außerdem besteht das Risiko, ein tatsächlich vorkommendes Zeichen zu ändern. Die korrekte Dekodierung behebt die Ursache für die ganze Datei.

Anhaltspunkte für die Zeichenkodierung sammeln

Beginne mit der Dokumentation oder den Exporteinstellungen des Anbieters. Untersuche bei Bedarf eine kleine Byteprobe:

with open("cities.csv", "rb") as f:
    sample = f.read(200)
print(sample)

Der Binärmodus erhält die Bytes, ohne sie zu dekodieren. Eine BOM kann einen direkten Hinweis geben. Ein Erkennungsprogramm wie charset-normalizer schätzt eine wahrscheinliche Zeichenkodierung, aber eine kurze Probe kann zu mehreren Möglichkeiten passen. Prüfe das Ergebnis anhand bekannter Namen mit Akzenten und Symbolen.

Latin-1 ordnet jedem Byte ein Zeichen zu und kann daher jede Bytefolge ohne Fehler dekodieren. Dieser Erfolg allein sagt nichts darüber aus, ob die Zeichen richtig sind. Auch Windows-1252 verwendet Ein-Byte-Zeichen, lässt aber einige Bytewerte undefiniert und kann einen Dekodierungsfehler auslösen.

Anhaltspunkte nicht verwerfen

encoding_errors="replace" ersetzt Bytes, die der Decoder nicht lesen kann, durch "�". encoding_errors="ignore" entfernt sie. Diese Optionen können helfen, beschädigte Eingaben zu untersuchen, sie verlieren aber Informationen und ersetzen nicht die Suche nach der richtigen Zeichenkodierung. Ein zu "Zrich" veränderter Name kann einen Abgleich genauso zum Scheitern bringen wie sichtbar entstellter Text.

Für die Ausgabe unterstützt UTF-8 den größten Zeichenumfang. Manche Tabellenkalkulationsprogramme erkennen diese Zeichenkodierung zuverlässiger, wenn eine BOM vorhanden ist:

df.to_csv("cities_export.csv", index=False, encoding="utf-8-sig")

Öffne den Export erneut im empfangenden Programm und untersuche dieselben Werte mit Akzenten. Ziel ist korrekter Text an beiden Enden des Austauschs.

Die Dateigröße auf dem Datenträger entspricht nicht dem benötigten Arbeitsspeicher. pandas erstellt Arrays, Indizes und Textwerte im Arbeitsspeicher, deren Typen den Platzbedarf beeinflussen. Miss den Bedarf mit df.memory_usage(deep=True) oder df.info(memory_usage="deep"), bevor du entscheidest, wie du weitere Daten lädst.

Weniger Daten in den Arbeitsspeicher laden

Lies ausgewählte Spalten mit usecols, untersuche eine erste Stichprobe mit nrows und wähle geeignete Typen mit dtype. Eine Kategorie kann wiederholte Regionsnamen kompakt speichern. float32 benötigt weniger Platz als float64, bietet aber etwa sieben signifikante Stellen. Wähle diesen Typ daher nur, wenn diese Genauigkeit zu den Messwerten passt. Eine kleine Vorschau hilft bei der Typwahl; sie beweist nicht, dass jede spätere Zeile demselben Muster folgt.

Datenblöcke verarbeiten und ein kleines Ergebnis behalten

chunksize ändert den Rückgabewert von einem DataFrame in einen Iterator von DataFrames. Für eine Summe und einen Mittelwert:

total = 0.0
count = 0
with pd.read_csv(
    "measurements.csv",
    usecols=["amount"],
    chunksize=100_000
) as reader:
    for chunk in reader:
        total += chunk["amount"].sum()
        count += chunk["amount"].count()
mean = total / count if count else float("nan")

Die Schleife hält eine laufende Summe und die Anzahl nicht fehlender Werte fest. Jeder Datenblock kann nach der Verwendung freigegeben werden. Sammelst du alle Datenblöcke in einer Liste und fügst sie später zusammen, entsteht erneut der volle Speicherbedarf. Die blockweise Verarbeitung spart nur dann Speicher, wenn sie ein verkleinertes Ergebnis behält oder verarbeitete Teile hinausschreibt.

Eine Datei mit zehn Zeilen ergibt bei chunksize=4 Teile mit 4, 4 und 2 Zeilen. Für Beträge von 1 bis 10 und Regionen, die sich in der Reihenfolge N, S, E wiederholen, addiere die regionalen Teilsummen zu N 22, S 15 und E 18. Zusammen ergeben sie 55.

Die richtigen Größen kombinieren

Summen und Anzahlen werden addiert. Minima werden kombiniert, indem du das kleinste Teilminimum nimmst; bei Maxima nimmst du das größte Teilmaximum. Mittelwerte benötigen Gewichte, weil Datenblöcke unterschiedlich viele gültige Beobachtungen enthalten können.

Für die Werte 1, 2 und 3 in einem Datenblock und 10 in einem anderen sind die Blockmittelwerte 2 und 10. Ihr Mittelwert ist 6; dabei wird der Block mit einem Wert genauso stark gewichtet wie der Block mit drei Werten. Addiere stattdessen die Summen und Anzahlen: Die Summe 16 über vier Beobachtungen ergibt den Mittelwert 4. Die Mediane der Datenblöcke enthalten nicht genug Informationen, um den Gesamtmedian zu rekonstruieren.

Komprimierte Dateien direkt einlesen

read_csv erkennt Kompression normalerweise anhand bekannter Endungen wie .gz, .bz2, .zip, .xz und .zst. Die Datei wird beim Einlesen dekomprimiert:

with pd.read_csv("measurements.csv.gz", chunksize=100_000) as reader:
    for chunk in reader:
        print(len(chunk))

Ein so verwendetes ZIP-Archiv muss genau eine Datendatei enthalten. df.to_csv("out.csv.gz", index=False) schreibt gzip-komprimiertes CSV. Kompression verringert den Platzbedarf auf dem Datenträger und das Übertragungsvolumen; sie verringert nicht den Speicherbedarf der dekodierten Tabelle. Wenn du einen geprüften Datensatz für wiederholte Analysen in Parquet umwandelst, muss außerdem der Text nicht erneut eingelesen werden und die gespeicherten Spaltentypen werden wiederhergestellt.

Eine Excel-Arbeitsmappe kann mehrere Arbeitsblätter, Titel und berechnete Summen enthalten. Zellen haben gespeicherte Werte und Typen sowie eine Anzeigeformatierung. Beim Einlesen eines Arbeitsblatts musst du die Datentabelle finden und verstehen, welche Teile der Arbeitsmappe zu DataFrame-Werten werden.

Arbeitsblatt und Grenzen auswählen

df = pd.read_excel(
    "quarterly.xlsx",
    sheet_name="Q1",
    skiprows=2,
    usecols="A:C",
    nrows=2
)

Angenommen, Zeile 1 ist ein verbundener Titel, Zeile 2 ist leer, Zeile 3 enthält region, date und sales und die Zeilen 4 bis 5 enthalten die Beobachtungen. skiprows=2 macht Zeile 3 zur Kopfzeile; nrows=2 hält vor der Summe in Zeile 6 an. Für North 1200 und South 950 ergeben die beiden Beobachtungen zusammen 2150. Würde eine zwischengespeicherte Summe von 2150 als dritte Beobachtung einbezogen, würde sich dieser Betrag verdoppeln.

Excel zeigt Zeilennummern ab 1 an; pandas-Zeilenpositionen beginnen bei 0. Auch header=2 wählt Excel-Zeile 3 als Kopfzeile. usecols="A,C,E:F" wählt einzelne Spalten und einen Bereich aus. Die Standardeinstellung sheet_name=0 liest das erste Arbeitsblatt; ein Name wählt ein bestimmtes Arbeitsblatt und sheet_name=1 das zweite.

sheet_name=None gibt ein Dictionary zurück, das Arbeitsblattnamen DataFrames zuordnet. Wähle einen Schlüssel oder durchlaufe .items(); das Dictionary selbst ist kein einzelner DataFrame. Für mehrere Lesevorgänge aus einer Arbeitsmappe:

with pd.ExcelFile("quarterly.xlsx") as xf:
    print(xf.sheet_names)
    q1 = pd.read_excel(xf, sheet_name="Q1")

Wissen, was die Zelle tatsächlich speichert

Ein als "15%" angezeigter Prozentwert wird als 0,15 gespeichert. Eine mit fünf Ziffern angezeigte Zahl kann 2139 speichern, obwohl auf dem Bildschirm "02139" steht. Keine Leseoption kann eine Null wiederherstellen, die nur in der Formatierung existiert. Speichere Kennungen in der Arbeitsmappe als Text und übergib beim Einlesen zusätzlich dtype={"zip": str}; andernfalls kann pandas selbst aus Textzellen, die nur Ziffern enthalten, Ganzzahlen ableiten.

Die numerische Genauigkeit von Excel ist auf 15 signifikante Stellen begrenzt. Eine 16-stellige Kennung, die als Zahl eingegeben wurde, kann bereits beschädigt sein, bevor Python sie einliest. Speichere solche Werte als Text. Ein Arbeitsblatt hat höchstens 1.048.576 Zeilen und 16.384 Spalten, ein sehr großer Datensatz benötigt daher ein anderes Format.

Mit Formeln und verbundenen Zellen sorgfältig umgehen

pandas berechnet keine Formeln. Es liest die in der Arbeitsmappe zwischengespeicherten Ergebnisse. Ein Tabellenkalkulationsprogramm kann aktuelle Ergebnisse speichern; eine per Skript erzeugte Datei kann fehlende, als Platzhalter gespeicherte oder veraltete Ergebnisse enthalten. openpyxl berechnet kein Ergebnis und XlsxWriter schreibt normalerweise eine Null als Platzhalter, sofern kein Wert vorgegeben wird. Berechne wichtige Werte in pandas neu oder öffne und speichere die Arbeitsmappe in einem Tabellenkalkulationsprogramm, bevor du dich auf ihre zwischengespeicherten Summen verlässt.

Nur die Zelle oben links in einem verbundenen Zellbereich speichert die Beschriftung. Eine verbundene Länderbeschriftung kann daher in den darunterliegenden Zeilen leere Felder hinterlassen. Bestätigt der Aufbau, dass die Beschriftung für diese Zeilen gilt, überträgt df["country"] = df["country"].ffill() sie nach unten. Prüfe vor dem Auffüllen die Tabellengrenze.

Zum Einlesen wird eine Engine-Bibliothek benötigt. openpyxl verarbeitet .xlsx und .xlsm; xlrd verarbeitet .xls, pyxlsb .xlsb, odf .ods und calamine unterstützt mehrere Tabellenkalkulationsformate. Eine fehlende Engine löst einen ImportError aus, der die benötigte Bibliothek nennt. Farben, Kommentare und andere Gestaltungselemente werden nicht als DataFrame-Daten geladen.

Excel ist nützlich, wenn Personen einen Bericht in einem Tabellenkalkulationsprogramm öffnen und untersuchen sollen. Ein DataFrame kann zu einem Arbeitsblatt werden oder mehrere DataFrames können sich eine Arbeitsmappe teilen. Wähle vor dem Schreiben Zielpfad und Arbeitsblattnamen, damit jede Tabelle an der vorgesehenen Stelle landet.

Eine oder mehrere Tabellen schreiben

weather.to_excel(
    "weather.xlsx",
    sheet_name="Weather",
    index=False
)

index=False hält die standardmäßigen Zeilennummern aus dem Arbeitsblatt heraus. Ohne diese Einstellung erscheinen sie als zusätzliche erste Spalte und können bei einem späteren Einlesen als "Unnamed: 0" zurückkommen. Behalte einen Index nur, wenn er aussagekräftige Bezeichnungen enthält, die in den Bericht gehören.

Ein to_excel-Aufruf mit Pfad schreibt eine Arbeitsmappe an diesen Pfad und ersetzt eine vorhandene Datei. Rufst du die Methode am selben Pfad einmal für Weather und erneut für Counts auf, bleibt möglicherweise nur die zweite Tabelle erhalten. Verwende für beide einen einzigen Writer:

with pd.ExcelWriter("report.xlsx") as writer:
    weather.to_excel(writer, sheet_name="Weather", index=False)
    counts.to_excel(writer, sheet_name="Counts", index=False)

Der Kontextmanager schließt und vervollständigt die Arbeitsmappe am Ende des Blocks. Das Einlesen mit pd.read_excel("report.xlsx", sheet_name=None) liefert ein Dictionary mit beiden Arbeitsblattnamen. Zum Schreiben von .xlsx wird openpyxl oder XlsxWriter benötigt.

Ein Arbeitsblatt in einer vorhandenen Arbeitsmappe aktualisieren

Um ein Arbeitsblatt zu ersetzen und die anderen zu erhalten, verwende einen Writer im Anfügemodus:

with pd.ExcelWriter(
    "report.xlsx",
    mode="a",
    engine="openpyxl",
    if_sheet_exists="replace"
) as writer:
    counts.to_excel(writer, sheet_name="Counts", index=False)

if_sheet_exists steuert eine Namenskollision. "error" bricht ab, "new" erstellt ein weiteres Arbeitsblatt, "replace" ersetzt das betreffende Arbeitsblatt und "overlay" schreibt in dessen vorhandene Zellen. Beim überlagernden Schreiben werden alte Zellen außerhalb der neuen Tabelle nicht geleert, sodass bei einer kürzeren Aktualisierung alte Zeilen zurückbleiben können. Entscheide, ob der Bericht ein vollständiges Ersetzen des Arbeitsblatts oder ein sorgfältig positioniertes überlagerndes Schreiben benötigt.

Die Ausgabe leicht wieder öffnen können

Arbeitsblattnamen sind auf 31 Zeichen begrenzt und dürfen :, \, /, ?, *, [ oder ] nicht enthalten. Ein kurzer Name wie "Q1 Summary" funktioniert; "Q1/Q2" enthält einen verbotenen Schrägstrich. Manche Engines warnen bei einem zu langen Namen, statt abzubrechen. Wähle daher selbst kompatible Namen.

startrow und startcol positionieren eine Tabelle anhand von Offsets, die bei null beginnen. na_rep gibt fehlenden Werten ein sichtbares Kennzeichen. float_format="%.2f" rundet geschriebene Zahlen und autofilter=True ergänzt in pandas 3 Filterschaltflächen in der Kopfzeile. Datums- und Zeitspalten werden als Excel-Datumswerte geschrieben.

Runden bei der Ausgabe verändert die gespeicherten Zahlen, nicht nur ihre Anzeige. Bewahre eine Analysedatei mit voller Genauigkeit separat auf, wenn ein gerundeter Bericht benötigt wird. Öffne die Arbeitsmappe erneut und prüfe die Liste der Arbeitsblätter, die Tabellenmaße und repräsentative Werte. Das Einlesen von Excel ist relativ langsam und ein Roundtrip kann pandas-Datentypen verändern. Verwende daher Parquet für zwischengespeicherte Analysetabellen, wenn der Erhalt der Typen wichtig ist.

JSON speichert verschachtelte Daten als Text. Objekte enthalten Name-Wert-Paare, Arrays enthalten geordnete Werte und Zeichenketten stehen in doppelten Anführungszeichen. Weitere Werte sind Zahlen, true, false und null. Pythons Modul json wandelt diese Syntax in Python-Objekte um, bevor du eine Tabelle erstellst.

Gültiges JSON einlesen und schreiben

import json

text = '{"station":"Oslo","active":true,"temp_c":[3.5,null,4.0]}'
data = json.loads(text)
print(data["active"])   # True
print(data["temp_c"])   # [3.5, None, 4.0]

Objekte werden zu Dictionaries, Arrays zu Listen und null zu None. json.loads liest eine Zeichenkette ein; json.load liest eine geöffnete Datei. Die Schreibfunktionen kehren die Richtung um: json.dumps gibt Text zurück und json.dump schreibt in eine Datei.

with open("station.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

ensure_ascii=False lässt Zeichen wie "ü" lesbar. Die Standardeinstellung kann dasselbe Zeichen als \u00fc schreiben; beide Formen stehen für dieselbe Zeichenkette. Ein ausgegebenes Python-Dictionary ist kein JSON: Einfache Anführungszeichen, True, None und abschließende Kommas sind ungültige JSON-Syntax. Standard-JSON kennt auch kein NaN. Pythons Encoder erlaubt es standardmäßig, aber allow_nan=False lehnt es ab; pandas schreibt fehlende Werte als null.

Den Tabellenaufbau berücksichtigen

Eine JSON-Tabelle benötigt eine Ausrichtung (Orientation), also eine Anordnung von Zeilen, Bezeichnungen und Werten. orient="records" ergibt ein Objekt pro Zeile:

[{"city":"Lyon","temp_c":21.5},{"city":"Osaka","temp_c":null}]

Die standardmäßige DataFrame-Ausrichtung "columns" gruppiert Werte unter Spaltennamen und anschließend unter Zeilenbezeichnungen. "split" speichert Spalten, Index und Daten getrennt. Gib eine Ausrichtung an, die zum empfangenden Programm passt, statt anzunehmen, dass jede JSON-Tabelle dieselbe Form hat.

from io import StringIO
import pandas as pd

df = pd.read_json(
    StringIO('[{"code":"0042","amount":9.5}]'),
    orient="records",
    dtype={"code": str}
)

In pandas 3 ist eine einfache Zeichenkette, die an read_json übergeben wird, ein Pfad. Verpacke daher tatsächlichen JSON-Text in StringIO. Selbst JSON-Zeichenketten, die nur Ziffern enthalten, können als Zahlen erkannt werden; der explizite Datentyp erhält "0042".

JSON Lines für aufeinanderfolgende Datensätze verwenden

JSON Lines enthält ein vollständiges JSON-Objekt pro Zeile, ohne umschließendes Array oder Kommas zwischen den Datensätzen:

{"id":1,"amount":9.5}
{"id":2,"amount":12.0}

Lies das Format mit pd.read_json(path, lines=True) und schreibe es mit df.to_json(path, orient="records", lines=True). Die Leseoptionen chunksize und nrows benötigen lines=True, wodurch einzelne Datensätze nacheinander verfügbar werden.

Setze beim Export von Datumsangaben date_format="iso" für lesbare ISO-Zeitstempel. pandas 3.1 verwendet für die gewöhnliche JSON-Ausgabe von DataFrames weiterhin standardmäßig Millisekunden seit der Epoche, aber diese Standardeinstellung ändert sich. Eine explizite Datumsausgabe verhindert, dass die Lesefunktion erraten muss, wofür eine große Ganzzahl steht.

Verschachteltes JSON kann eine Bestellung, ihren Kunden und mehrere Artikel in einem Objekt beschreiben. Lege vor der Umwandlung in eine flache Tabelle die Zeilengranularität fest: was eine Zeile darstellt. Sie bestimmt, welche Beträge summiert werden können.

Zuerst verschachtelte Objekte in Spalten umwandeln

Betrachte zwei Bestellungen. Bestellung 501 gehört Ana und enthält die Artikel A1 (Menge 2, Preis 3,5) und B7 (Menge 1, Preis 10,0). Bestellung 502 gehört Ben und enthält A1 (Menge 4, Preis 3,5). Die Kundendaten sind verschachtelte Objekte und die Artikel sind Listen.

orders = [
    {"order_id": 501,
     "customer": {"name": "Ana", "country": "PT"},
     "items": [{"sku": "A1", "qty": 2, "price": 3.5},
               {"sku": "B7", "qty": 1, "price": 10.0}]},
    {"order_id": 502,
     "customer": {"name": "Ben", "country": "CA"},
     "items": [{"sku": "A1", "qty": 4, "price": 3.5}]}
]
order_rows = pd.json_normalize(orders)

Dies erzeugt zwei Zeilen und vier Spalten: order_id, items, customer.name und customer.country. Die verschachtelten Kundenfelder werden zu Spalten mit Punkten in den Namen. Die Artikellisten bleiben in Zellen; die Normalisierung wandelt nicht automatisch jede Liste in Zeilen um.

Eine Liste mit übergeordneten Informationen erweitern

items = pd.json_normalize(
    orders,
    record_path="items",
    meta=["order_id", ["customer", "name"]]
)

record_path wählt die Liste, deren Einträge zu Zeilen werden. meta kopiert übergeordnete Werte in jede Zeile; für einen verschachtelten Pfad wird eine Liste von Schlüsseln angegeben. Das Ergebnis hat drei Artikelzeilen: zwei für Anas Bestellung und eine für Bens Bestellung. Der Umsatz ergibt sich aus Menge mal Preis: 7,0, 10,0 und 14,0, zusammen 31,0.

Betragen die Versandkosten auf Bestellungsebene 4,00, werden sie in beiden Artikelzeilen für Bestellung 501 wiederholt. Die Summe dieser wiederholten Kosten ergibt 8,00 für eine Bestellung. Bewahre Beträge auf Bestellungsebene in einer separaten Bestelltabelle auf, wenn du auch eine Artikeltabelle benötigst; behalte order_id, um sie zu verbinden.

Namen und fehlende Felder steuern

sep="_" erzeugt Namen wie customer_name. record_prefix="item_" unterscheidet Artikelfelder von gleichnamigen übergeordneten Feldern. max_level=0 lässt verschachtelte Dictionaries unverändert.

Ein gewöhnliches verschachteltes Feld, das in einem Datensatz fehlt, wird in seiner Ausgabespalte zu einem fehlenden Wert. Ein über meta angefordertes fehlendes Feld löst standardmäßig KeyError aus; errors="ignore" erlaubt fehlende Metadaten und füllt sie mit NaN. Eine fehlende, in record_path benannte Liste muss weiterhin korrigiert werden.

API-Antworten vor dem Umformen auspacken

Eine API kann ein Hüllobjekt mit count, next und results zurückgeben. Übergib data["results"] an pd.json_normalize, um die Datensätze in eine flache Tabelle umzuwandeln. Wird das Hüllobjekt selbst übergeben, wird ein einzelnes umschließendes Objekt normalisiert und seine Ergebnisliste bleibt in einer Zelle. Halte die Paginierungsmetadaten für den Abruf späterer Seiten verfügbar, erstelle die Analysetabelle aber aus der eigentlichen Datensatzliste.

Eine Web-API nimmt eine HTTP-Anfrage an einem Endpunkt entgegen und gibt einen Statuscode, Header und einen Antwortinhalt zurück. Viele APIs verwenden JSON als Antwortinhalt, aber eine erfolgreich eingegangene Antwort bedeutet nicht, dass sie die benötigten Daten oder alle benötigten Datensätze enthält.

Parameter senden und die Antwort prüfen

import requests

resp = requests.get(
    url,
    params={"city": "Lima", "units": "metric"},
    timeout=10
)
resp.raise_for_status()
data = resp.json()
df = pd.json_normalize(data["results"])

Hier ist url der dokumentierte Endpunkt der API. params kodiert die Abfragezeichenkette, sodass Leerzeichen und Sonderzeichen in Werten korrekt verarbeitet werden. Requests hat standardmäßig kein Zeitlimit. Ein einzelner Zeitlimitwert steuert die Wartezeit beim Verbinden und Lesen; er ist keine Frist für das Herunterladen der gesamten Antwort.

Rufe raise_for_status() auf, bevor du den Antwortinhalt verwendest. Die Methode löst bei 4xx- und 5xx-Antworten einen HTTP-Fehler aus. Eine JSON-Fehlermeldung kann erfolgreich eingelesen werden und trotzdem eine fehlgeschlagene Anfrage beschreiben; umgekehrt kann eine 200-Antwort Text enthalten, der kein JSON ist, sodass resp.json() fehlschlägt. Untersuche resp.text, wenn das Antwortformat unerwartet ist.

Zugangsdaten getrennt halten

Verwende die von der API dokumentierte Authentifizierungsmethode. Für ein Bearer-Token lies einen Schlüssel aus einer Umgebungsvariablen und sende ihn in einem Header:

import os

key = os.environ["WEATHER_API_KEY"]
headers = {"Authorization": "Bearer " + key}

Halte Schlüssel aus gespeichertem Code und Notebooks heraus. Wurde ein Schlüssel weitergegeben oder eingecheckt, widerrufe und ersetze ihn. Ein Schlüssel gewährt Zugriff; einen angezeigten Wert später zu verbergen, macht seine Offenlegung nicht rückgängig.

Fortfahren, bis alle Seiten eingelesen sind

Folge dem dokumentierten Verfahren der API für die nächste Seite, unabhängig davon, ob es Seitennummern, Offsets oder eine URL für die nächste Seite verwendet. Sammle die Datensätze jeder Seite und halte bei der angegebenen Endbedingung an. Insgesamt 230 Datensätze mit 100 pro Seite erfordern Seiten mit 100, 100 und 30 Datensätzen. Die erste Seite kann völlig gültig sein, während der Datensatz unvollständig ist.

Vergleiche die gesammelte Anzahl mit einer gemeldeten Gesamtzahl, sofern verfügbar. Beachte Anfrageratenbegrenzungen: 429 bedeutet, vor einer weiteren Anfrage zu warten, und Retry-After kann die Wartezeit angeben. Dieser Header kann Sekunden oder ein HTTP-Datum enthalten. Speichere Rohantworten für eine reproduzierbare Analyse und um zu vermeiden, dieselben Daten bei jeder erneuten Ausführung herunterzuladen.

Andere Webformate für Tabellen erkennen

pd.read_html(url) gibt eine Liste von DataFrames zurück, einen für jede passende HTML-Tabelle. match="Population" beschränkt die Tabellen anhand ihres Textes. Die Funktion benötigt eine Bibliothek zum Einlesen von HTML wie lxml oder BeautifulSoup mit html5lib. pd.read_xml liest wiederholte XML-Elemente als Zeilen ein und verwendet lxml oder parser="etree". Prüfe vor dem automatisierten Auslesen einer Website deren Bedingungen und bevorzuge einen offiziellen Download oder eine API, sofern verfügbar.

Ein CSV-Export sollte die Werte erhalten, die der Empfänger benötigt, und seine Konventionen deutlich machen. Entscheide, ob der Zeilenindex Daten enthält, wie fehlende Werte erscheinen und ob die Ausgabe für eine präzise Analyse oder eine gerundete Anzeige bestimmt ist.

Entscheiden, was zu einer Spalte wird

df.to_csv("weather_processed.csv", index=False)

Standardmäßig wird der Index geschrieben. Bei einer Tabelle mit einem gewöhnlichen nummerierten Index fügt dies ein unbenanntes erstes Feld hinzu; ein späteres read_csv kann es als "Unnamed: 0" anzeigen. index=False lässt diese Zeilennummern weg. Enthält der Index aussagekräftige Bezeichnungen, behalte ihn und lies ihn mit index_col=0 wieder ein.

Fehlende Werte werden normalerweise zu leeren Feldern. na_rep="NA" macht sie sichtbar, aber die empfangende Lesefunktion muss dieses Kennzeichen korrekt interpretieren. In einer Städtetabelle mit Lyon bei 21,5 °C und Osaka bei 18,25 °C sollte ein fehlender Niederschlagswert für Osaka von null Niederschlag unterscheidbar bleiben.

Die Textkonvention des Empfängers berücksichtigen

df.to_csv(
    "weather_export.csv",
    index=False,
    sep=";",
    decimal=",",
    na_rep="NA",
    date_format="%Y-%m-%d",
    encoding="utf-8"
)

Die Optionen für Trennzeichen und Dezimaltrennzeichen erzeugen Werte wie Lyon;21,5;0,0. Die ISO-Datumsausgabe hält Tag und Monat eindeutig. Verwende encoding="utf-8-sig", wenn ein empfangendes Tabellenkalkulationsprogramm eine BOM benötigt, um UTF-8 zu erkennen.

float_format="%.1f" schreibt eine Nachkommastelle. Der Wert 18,25 wird bei dieser Formatierung zu "18.2" und die verworfene Genauigkeit lässt sich aus der CSV-Datei nicht wiederherstellen. Bewahre Analysedaten mit voller Genauigkeit auf; erstelle bei Bedarf einen separaten gerundeten Bericht.

Prüfen, was einen Roundtrip übersteht

CSV speichert Zeichen ohne pandas-Datentypmetadaten. Betrachte vier Spalten: eine Kennung "02139", einen Datums- und Zeitwert, eine geordnete Kategorie A < B < C und Ganzzahlen mit Fehlwertunterstützung und einer Lücke. Ein standardmäßiges Einlesen der CSV-Datei kann die Ganzzahl 2139, Datumstext, einfache Kategoriebezeichnungen ohne ihre Reihenfolge und Gleitkommazahlen für die Anzahlen zurückgeben.

Ein erfolgreich abgeschlossener Lesevorgang hat den ursprünglichen DataFrame daher nicht unbedingt wiederhergestellt. Bewahre die Optionen auf, die zum Rekonstruieren der Daten benötigt werden, einschließlich Textkennungen, Einlesen von Datumsangaben und Fehlwertkennzeichen. Auch die Reihenfolge der Kategorien muss erneut festgelegt werden. Für wiederholte Analysen, bei denen diese Typen wichtig sind, kann Parquet sie direkt erhalten.

Datensätze anfügen und Roheingaben schützen

df.to_csv(
    "daily_results.csv",
    mode="a",
    header=False,
    index=False
)

Dies fügt Zeilen an eine vorhandene Datei an. Halte Spaltenreihenfolge und Konventionen mit dieser Datei konsistent. Mit header=True schreibt ein Anfügevorgang eine weitere Kopfzeile in die Mitte und beim nächsten Einlesen kann sie als Datensatz behandelt werden. Schreibe bei einer neuen Datei die Kopfzeile einmal, bevor du später Zeilen anfügst.

Bewahre erhaltene oder heruntergeladene Dateien unverändert an einem Rohdaten-Speicherort auf. Schreibe abgeleitete Ergebnisse separat unter aussagekräftigen Namen. Prüfe nach dem erneuten Öffnen eines verarbeiteten Exports dessen Zeilenanzahl, Spalten, fehlende Werte und repräsentative Werte einschließlich führender Nullen und Datumsangaben.

Das beste Speicherformat hängt davon ab, wer die Daten als Nächstes liest und was beim Austausch erhalten bleiben muss. Eine an eine andere Person gesendete Tabelle, eine verschachtelte API-Antwort und ein Analysedatensatz mit festgelegten Typen haben unterschiedliche Anforderungen.

Textbasierte und binäre Speicherung vergleichen

Textformate kodieren sichtbare Zeichen. CSV lässt sich leicht untersuchen und wird breit unterstützt; JSON stellt verschachtelte Objekte und Arrays auf natürliche Weise dar. CSV hat kein Spaltentypschema und gewöhnliche JSON-Wertetypen erhalten nicht jeden pandas-Datentyp. Beim erneuten Einlesen müssen sie interpretiert und gegebenenfalls Typen ausdrücklich ausgewählt werden.

Binärformate kodieren Daten so, dass Software sie direkt lesen kann. Formate wie Parquet und Feather speichern ein Schema, das Spalten und Typen beschreibt. Dadurch müssen Typen seltener erneut ermittelt werden. Die Typunterstützung hängt weiterhin vom Format und der Lesefunktion ab: Beliebige Python-Objekte werden nicht allein dadurch portabel, dass die Datei binär ist.

Ein zeilenorientierter Aufbau hält die Felder eines Datensatzes zusammen. Ein spaltenorientierter Aufbau hält Werte derselben Spalte zusammen. Für Analysen werden häufig einige Spalten aus vielen Zeilen benötigt, sodass spaltenorientierte Lesefunktionen nicht benötigte Spalten überspringen können. Ähnliche benachbarte Werte lassen sich außerdem gut komprimieren. Dateigröße und Geschwindigkeit hängen von den Daten ab; ein Kompressionsergebnis für eine Tabelle ist kein festes Verhältnis für alle Tabellen.

Jedem Format eine Aufgabe zuordnen

Parquet ist ein offenes Format, das von pandas, R, Spark und DuckDB verwendet wird. Feather nutzt Arrow IPC und eignet sich für den schnellen Austausch zwischen Python und R oder zwischen lokalen Schritten. to_feather und read_feather ermöglichen diesen Austausch. HDF5 gruppiert mehrere Datensätze in einer Datei; to_hdf von pandas benötigt PyTables.

Die Vertrauensgrenze von pickle verstehen

pickle kann Python-Objekte über gewöhnliche Tabellen hinaus speichern, aber beim Laden kann Code ausgeführt werden. Lade nie eine pickle-Datei aus einer nicht vertrauenswürdigen Quelle. Verwende das Format für eigene kurzlebige Objekte und rechne mit Kompatibilitätsgrenzen, wenn sich Python und Bibliotheken ändern. Beispielsweise unterstützt pandas 3 das Einlesen von pickle-Dateien nicht mehr, die mit pandas-Versionen vor 1.0 erstellt wurden.

Nach dem benötigten Ergebnis entscheiden

Muss ein Empfänger eine kleine Tabelle ohne besondere Werkzeuge untersuchen, ist CSV praktisch. Benötigt er benannte Arbeitsblätter, verwende Excel. Möchtest du Kennungen, Kategorien und Typen mit Fehlwertunterstützung zwischen Analysesitzungen erhalten, wähle Parquet. Müssen mehrere Programme gemeinsam genutzte Datensätze abfragen und aktualisieren, eignet sich eine Datenbank besser, als Kopien einer Datei weiterzugeben. Die Formatwahl richtet sich nach der nächsten Verwendung, nicht nach der Endung der ursprünglichen Eingabe.

Parquet speichert eine Tabelle mit ihren Spaltentypen in einem offenen, spaltenorientierten Format. Das ist nützlich, wenn ein geprüfter DataFrame wiederholt geladen oder an andere Analysewerkzeuge übergeben wird. pandas verwendet für die folgenden Beispiele PyArrow.

Einen Roundtrip mit Datentypen schreiben und prüfen

df.to_parquet("sales.parquet", engine="pyarrow")
restored = pd.read_parquet("sales.parquet", engine="pyarrow")
print(restored.dtypes)

Eine Textkennung "02139", eine Datums- und Zeitspalte, eine geordnete Kategorie und Ganzzahlen mit Fehlwertunterstützung können diesen Roundtrip von pandas über PyArrow zu pandas mit ihren Typen überstehen. Anders als beim Einlesen von CSV muss dabei weder die Rolle der Kennung erraten noch die Kategorienreihenfolge neu erstellt werden. Untersuche Typen und repräsentative Werte, wenn du eine neue Schreib- oder Lesefunktion einführst.

Die Standardeinstellung index=None speichert einen RangeIndex kompakt als Metadatum. Ein anderer Index wird als Spalten geschrieben und beim Einlesen wiederhergestellt. Verwende index=False, wenn der Index nicht benötigt wird. Diese Entscheidung betrifft Zeilenbezeichnungen unabhängig von den gewöhnlichen Tabellenspalten.

Weniger einlesen und Kompression wählen

small = pd.read_parquet(
    "sales.parquet",
    columns=["zip", "amount"]
)

Die Lesefunktion kann nur diese Spalten aus dem Speicher abrufen. Das unterscheidet sich davon, die ganze Tabelle zu laden und anschließend auszuwählen: Dabei ist bereits der Aufwand für das vollständige Einlesen angefallen. Die Spaltenauswahl ist besonders für breite Tabellen nützlich.

Snappy ist der standardmäßige Kompressionscodec. compression="zstd" oder "gzip" ergibt häufig kleinere Dateien bei höherem Schreibaufwand, während compression=None unkomprimierte Daten schreibt. Miss den Kompromiss mit repräsentativen Daten; wiederholte Bezeichnungen und zufällige Messwerte lassen sich unterschiedlich komprimieren. Installiere PyArrow; die alternative Engine fastparquet gilt in pandas 3.1 als veraltet.

Einen Datenbestand in Partitionen organisieren

df.to_parquet(
    "sales_dataset",
    engine="pyarrow",
    partition_cols=["year"],
    index=False
)
recent = pd.read_parquet(
    "sales_dataset",
    filters=[("year", "==", 2026)]
)

Das Ziel ist ein Verzeichnis mit Unterverzeichnissen wie year=2025 und year=2026. Das Einlesen des Verzeichnisses lädt den Datenbestand; ein Filter kann nicht benötigte Partitionen auslassen. Bei diesem Aufbau leitet PyArrow die Werte von year aus Verzeichnisnamen ab und pandas erhält üblicherweise eine kategoriale Partitionsspalte.

Wähle eine Partitionsspalte mit einer kleinen Anzahl nützlicher Werte, nach denen du häufig filterst. Eine eindeutige Datensatzkennung erzeugt Tausende winzige Partitionen und erhöht den Aufwand für Dateien und Verzeichnisse. Ein Jahr oder eine kleine Auswahl an Regionen bietet häufig eine praktischere Aufteilung.

Daten hinzufügen, ohne den Datenbestand zu beschädigen

Eine einzelne Parquet-Datei unterstützt über pandas kein Anfügen von Zeilen wie eine CSV-Datei. Schreibe neue Dateien oder Partitionen in das Verzeichnis des Datenbestands oder lies eine einzelne Datei, kombiniere die Daten und schreibe sie erneut. Dateien desselben Datenbestands benötigen kompatible Schemata. Speichert eine Datei einen Code als Text und eine andere als Ganzzahl, kann das Laden fehlschlagen oder Werte umwandeln. Lege vor dem Schreiben jedes Teils einheitliche Datentypen fest und prüfe, dass eine hinzugefügte Partition keine überlappenden Kopien derselben Datensätze erzeugt.

Eine relationale Datenbank speichert Datensätze in Tabellen mit benannten Spalten. Ein Programm sendet eine SQL-Abfrage über eine Verbindung und erhält ein Ergebnis, das pandas in einen DataFrame umwandeln kann. Die Datenbank kann nur die benötigten Daten auswählen, bevor sie an Python übertragen werden.

Mit einer SQLite-Datei beginnen

import sqlite3
import pandas as pd

con = sqlite3.connect("shop.db")
try:
    df = pd.read_sql_query(
        "SELECT region, amount FROM sales", con
    )
finally:
    con.close()

SQLite läuft ohne separaten Server und speichert eine Datenbank in einer Datei. Beim Verbinden wird die Datei erstellt, falls sie nicht existiert. Ein falsch eingegebener Pfad kann daher eine neue, leere Datenbank statt der gewünschten öffnen. ":memory:" erstellt eine temporäre Datenbank im Arbeitsspeicher. Die obige Abfrage gibt die Spalten region und amount aus einer vorhandenen Tabelle sales zurück; die Spaltennamen des Ergebnisses werden zu DataFrame-Bezeichnungen.

Der with-Block einer SQLite-Verbindung verwaltet eine Transaktion, schließt aber die Verbindung nicht. Rufe nach Abschluss ausdrücklich close() auf. Ein try/finally-Block schließt die Verbindung auch dann, wenn beim Einlesen ein Fehler auftritt.

Eine Engine für eine Serverdatenbank verwenden

SQLAlchemy stellt Engines für Systeme wie PostgreSQL, MySQL und SQL Server bereit, sofern ein passender Treiber installiert ist. Eine Verbindungs-URL bezeichnet Dialekt, Treiber, Server und Datenbank. Bewahre sie in einer Umgebungsvariablen auf:

import os
from sqlalchemy import create_engine

engine = create_engine(os.environ["ANALYSIS_DB_URL"])
try:
    with engine.connect() as conn:
        df = pd.read_sql_query(
            "SELECT region, amount FROM sales", conn
        )
finally:
    engine.dispose()

Der Verbindungskontext gibt die Verbindung an den Pool der Engine zurück. dispose() gibt Ressourcen des Pools frei, wenn die Engine nicht mehr benötigt wird. Verwende für Analysen ein Konto mit reinem Lesezugriff und halte Zugangsdaten aus Notebooks und der Versionsverwaltung heraus. Eine Engine-URL für eine lokale SQLite-Datei kann "sqlite:///shop.db" sein.

Die zur Eingabe passende Lesefunktion wählen

Übergib bei einer einfachen sqlite3-Verbindung eine vollständige Abfrage. pd.read_sql("sales", con) sendet sales als SQL und schlägt fehl; verwende stattdessen pd.read_sql_query("SELECT * FROM sales", con). pandas unterstützt SQLAlchemy-, ADBC- und SQLite-Verbindungen; eine beliebige direkte Treiberverbindung ist kein unterstützter Ersatz, nur weil der Treiber SQL ausführen kann.

Das benötigte Ergebnis übertragen

Eine Abfrage, die ausgewählte Zeilen und Spalten zurückgibt, überträgt weniger Daten, als eine ganze Tabelle einzulesen und den größten Teil in pandas zu verwerfen. Die vorgegebene Abfrage SELECT SUM(amount) AS total FROM sales liefert einen aggregierten Wert mit der Bezeichnung total. Das Einlesen eines Abfrageergebnisses verändert die gespeicherte Tabelle nicht. Prüfe nach dem Laden Zeilenanzahl und Typen wie bei einer Datei; die deklarierten Datenbanktypen und die zurückgegebenen pandas-Typen hängen zusammen, sind aber nicht identisch.

Veränderliche Werte gehören in Abfrageparameter. Die SQL-Anweisung legt die Operation fest; gebundene Parameter liefern die Region, den Schwellenwert oder einen anderen für diese Ausführung verwendeten Wert. So bleibt die Abfragestruktur erhalten, selbst wenn ein Wert ein Anführungszeichen enthält.

Werte mit der Syntax der Verbindung binden

Für SQLite:

query = "SELECT region, amount, sold_on FROM sales WHERE amount > ? ORDER BY amount DESC"
df = pd.read_sql_query(query, con, params=(70,))

Für die Verkaufsbeträge 120,0, 75,5, 60,0 und 210,0 gibt dies 210,0, 120,0 und 75,5 in absteigender Reihenfolge zurück. Das Tupel (70,) hat ein Element; (70) ist nur die Zahl 70. SQLite akzeptiert auch benannte Platzhalter, zum Beispiel WHERE region = :r mit params={"r": "North"}.

Die Regeln für Platzhalter hängen von der Schnittstelle ab. psycopg verwendet %s oder %(name)s. Bei SQLAlchemy verpackst du eine Anweisung in text und verwendest benannte Parameter:

from sqlalchemy import text

query = text("SELECT region, amount FROM sales WHERE amount >= :m")
with engine.connect() as conn:
    df = pd.read_sql_query(query, conn, params={"m": 100})

Übergib Werte über params; verwende keine Python-Formatierung, um sie in die Anweisung einzusetzen.

Verstehen, wovor Parametrisierung schützt

Angenommen, Code erstellt eine Bedingung mit einem f-String und einer Eingabe "x' OR '1'='1". Wird sie innerhalb von Anführungszeichen eingesetzt, ändert sich die Bedingung zu region = 'x' OR '1'='1', was auf jede Zeile zutrifft. Das ist SQL-Injection: Ein Wert ist zu ausführbarer Abfragestruktur geworden.

Ein gebundener Parameter wird als ein Wert verglichen, sodass dieselbe Zeichenkette nur auf eine Region zutrifft, die genau diesen Text als Namen hat. Das Binden verarbeitet auch gewöhnliche Namen mit Apostrophen, ohne Anführungszeichen von Hand maskieren zu müssen. Die Regel gilt für Eingaben aus Dateien ebenso wie für Eingaben aus Benutzerformularen.

Parameter stehen für Werte, nicht für Tabellen- oder Spaltennamen. Ein Parameter anstelle eines Tabellennamens wählt diese Tabelle nicht aus. Benötigt ein Programm eine variable Kennung, wähle sie aus einer festen, vom Code kontrollierten Liste.

Typen im Ergebnis steuern

SQLite speichert Datumsangaben häufig als Text. Weise pandas an, sie als Datum einzulesen:

df = pd.read_sql_query(
    "SELECT sold_on, visits FROM observations", con,
    parse_dates=["sold_on"],
    dtype={"visits": "Int64"}
)

Die Datumsspalte enthält nun Datums- und Zeitwerte und eine Anzahl mit SQL NULL verwendet Ganzzahlen mit Fehlwertunterstützung, statt allein wegen der Lücken zu Gleitkommazahlen zu werden. Untersuche das Ergebnis, um die Umwandlung zu prüfen.

Datenblöcke von der Pufferung durch den Treiber unterscheiden

chunksize=1000 gibt einen Iterator von DataFrames mit jeweils höchstens 1.000 Zeilen zurück. Ein Ergebnis mit vier Zeilen ergibt mit chunksize=3 Teile mit drei und einer Zeile. Halte die Verbindung offen, während du sie verarbeitest. Manche Datenbanktreiber puffern weiterhin das gesamte Ergebnis, bevor pandas Datenblöcke liefert; ein serverseitiger Cursor oder eine Streaming-Konfiguration kann zusätzlich nötig sein, um den Speicherbedarf entlang des gesamten Verbindungswegs zu begrenzen.

to_sql erstellt eine Datenbanktabelle aus einem DataFrame oder schreibt Zeilen in eine vorhandene Tabelle. Die Optionen bestimmen, ob vorhandene Daten erhalten bleiben, ob der Index zu einer Spalte wird und wie eine Gruppe von Schreibvorgängen bestätigt wird.

Das Verhalten bei vorhandener Tabelle wählen

df.to_sql("sales", con, index=False)

Die Standardeinstellung if_exists="fail" bricht ab, wenn sales bereits existiert. Wähle nur dann einen anderen Modus, wenn seine Wirkung zum beabsichtigten Ladevorgang passt:

delete_rows ist in pandas 3 verfügbar. Das Ersetzen einer Tabelle entfernt ihre alte Definition einschließlich Schlüsseln, Indizes und Einschränkungen; auch datenbankspezifische Berechtigungen können betroffen sein. Das Löschen der Zeilen erhält die Definition, entfernt aber trotzdem jeden vorhandenen Datensatz. Verwende es für ein beabsichtigtes vollständiges Neuladen, nicht wenn der DataFrame nur einen neuen Datenblock enthält.

Spalten festlegen und in einer Transaktion schreiben

Standardmäßig wird der DataFrame-Index als Spalte geschrieben. Ein unbenannter Index wird zu index; ein benannter Index behält seinen Namen. index_label gibt ihm einen expliziten Namen und index=False schließt ihn aus. Ist eine Kennung bereits eine gewöhnliche Spalte, fügt das Schreiben standardmäßiger Zeilennummern meist keine nützlichen Informationen hinzu.

Mit SQLAlchemy kann dtype Datenbanktypen wählen:

from sqlalchemy import types

with engine.begin() as conn:
    df.to_sql(
        "sales", conn,
        if_exists="append",
        index=False,
        dtype={"sold_on": types.Date()},
        chunksize=1000
    )

engine.begin() bestätigt die Transaktion beim erfolgreichen Verlassen und rollt sie bei einer Ausnahme zurück. Bei einer vorhandenen Tabelle bestimmt weiterhin das gespeicherte Schema, welche Werte eingefügt werden können; dtype ist kein Befehl, um ihre Spalten neu zu gestalten. Transaktionszusicherungen hängen auch davon ab, ob die Datenbank die verwendeten Operationen unterstützt. Das Anfügen innerhalb einer SQLAlchemy-Transaktion hält den Einfügevorgang des Beispiels zusammen.

chunksize gruppiert Zeilen in Blöcke. method="multi" setzt mehrere Zeilen in eine INSERT-Anweisung, wo dies unterstützt wird. Das kann die Leistung abhängig von Datenbank und Blockgröße verbessern oder verschlechtern, miss sie daher mit repräsentativen Daten.

Zuwachs prüfen, nicht nur den Abschluss

check = pd.read_sql_query("SELECT COUNT(*) AS n FROM sales", con)
print(check["n"].iloc[0])

Vergleiche bei einer neuen oder vollständig neu geladenen Tabelle die Anzahl mit len(df). Vergleiche beim Anfügen den Zuwachs: Eine Tabelle mit vier Zeilen, die zwei Zeilen erhält, sollte sechs enthalten. Die von to_sql zurückgegebene Zeilenanzahl beruht auf der Meldung des Treibers; prüfe die gespeicherten Daten direkt.

Führst du einen Anfügevorgang zweimal aus, werden die Datensätze wiederholt, sofern die Datenbank keine Dubletten ablehnt oder das Programm nur neue Datensätze auswählt. Entscheide vor einer erneuten Ausführung, ob die Operation ein vollständiges Neuladen oder das Anfügen neuer Datensätze ist. Eine Transaktion verhindert einen unvollständigen Ladevorgang bei einem Fehler; sie macht wiederholte erfolgreiche Anfügevorgänge nicht eindeutig.