Datenaufbereitung mit pandas

Fehlende Daten bedeuten, dass ein Wert unbekannt oder nicht verfügbar ist. pandas speichert an seiner Stelle ein besonderes Kennzeichen. Erkenne das Kennzeichen, bevor du Summen berechnest oder entscheidest, welche Zeilen nutzbar sind.

Die Kennzeichen erkennen

Das Kennzeichen hängt vom Datentyp ab. Gleitkommaspalten verwenden NaN, Datum-Zeit-Spalten NaT und Datentypen mit Fehlwertunterstützung wie "Int64", "boolean" und "string" verwenden pd.NA. pandas 3 erkennt Textspalten als str, mit NaN für fehlenden Text. Auch Pythons None wird als fehlend erkannt. Nutze für die Beispiele import pandas as pd und import numpy as np.

df.isna() erzeugt eine boolesche Tabelle mit denselben Zeilen und Spalten wie df. Ein True markiert eine Lücke; df.notna() markiert vorhandene Werte. Die alternativen Namen isnull() und notnull() erfüllen dieselben Aufgaben. Vergleiche eine Spalte nicht mit np.nan: NaN ist selbst sich selbst nicht gleich, daher übersieht s == np.nan die Lücken.

Zellen und betroffene Zeilen zählen

Betrachte diese Wettermesswerte:

Ein boolesches True zählt als 1, daher ergibt df.isna().sum() 0 fehlende Städte, 2 Temperaturen und 2 Niederschlagsmesswerte. df.isna().mean() ergibt die Anteile 0,0, 0,5 und 0,5. Für den Anteil jeder Spalte dienen alle vier Zeilen als Nenner.

Um betroffene Zeilen zu finden, nutze df.isna().any(axis=1). Der Aufruf gibt False, True, True, True zurück; die Summe ergibt 3. Dagegen ergibt df.isna().sum().sum() 4 fehlende Zellen. Kyiv trägt zwei Zellen, aber nur eine betroffene Zeile bei. Nutze die Kennzahl, die deine Frage beantwortet.

Versteckte Fehlwertcodes erkennen

Ein Messgerät kann einen nicht verfügbaren Messwert als -999, "-" oder "unknown" erfassen. Das sind gewöhnliche Werte, bis du sie umwandelst. Nachdem du die Bedeutung des Codes bestätigt hast, nutze df.replace([-999, "unknown"], np.nan). Beim Laden einer CSV-Datei fügt na_values=[-999, "unknown"] diese Codes zu den erkannten Kennzeichen hinzu. Leere CSV-Felder und häufige Zeichenketten wie "NA", "n/a" und "NULL" werden standardmäßig bereits erkannt.

Ein Niederschlagsmesswert von null kann bedeuten, dass kein Regen gefallen ist. Daher würde das Ersetzen jeder Null echte Beobachtungen zerstören. Außerdem gelten eine im Speicher erstellte leere Zeichenkette "" und eine Zeichenkette aus Leerzeichen für isna() nicht als fehlend. Untersuche den gespeicherten Text ebenso wie die Anzahl der Kennzeichen. Um fehlende Kategorien in eine Häufigkeitstabelle aufzunehmen, nutze value_counts(dropna=False).

Berechnungen und Datentypen prüfen

Für s = pd.Series([4, np.nan, 8]) ist s.mean() gleich 6,0: Der Aufruf nutzt die zwei bekannten Werte. s.count() ist 2, während len(s) gleich 3 ist. Dividierst du s.sum() durch len(s), erhältst du 4,0 und behandelst die Lücke fälschlich als null. Die meisten statistischen Methoden überspringen Lücken standardmäßig; eine Spalte, deren Werte alle fehlen, hat die Summe 0, aber den Mittelwert NaN.

Eine Lücke kann auch die Speicherung ändern. pd.Series([3, None, 5]) wird zu float64 und enthält 3,0, NaN und 5,0. Die Angabe dtype="Int64" behält ganzzahlige Werte bei und setzt <NA> für die Lücke. Das große I kennzeichnet den pandas-Ganzzahldatentyp mit Fehlwertunterstützung.

Wenn du eine Zeile entfernst, entfernst du ihre bekannten Werte zusammen mit ihren Lücken. Füllst du eine Lücke auf, bleibt die Zeile erhalten, aber du führst eine Schätzung ein. Entscheide anhand der Bedeutung der Beobachtung und der Spalten, die die Analyse benötigt.

Steuern, welche Zeilen entfernt werden

df.dropna() entfernt jede Zeile mit einem fehlenden Wert. In der Wettertabelle bleibt nur Lima. Schränke die Entscheidung mit subset ein oder verlange mit thresh eine Mindestanzahl vorhandener Zellen.

axis="columns" entfernt Spalten mit Lücken und behält hier nur city. Bei einer breiten Tabelle kann die standardmäßige Regel für Zeilen einen großen Teil der Daten verwerfen, weil eine Lücke in einer beliebigen Spalte genügt. Vergleiche len(df) vor und nach dem Entfernen.

Das Ergebnis zuweisen

Lerne die Form mit erneuter Zuweisung: df = df.dropna(). Standardmäßig geben Bereinigungsmethoden ein neues Objekt zurück. pandas 3.1 stuft inplace=True unter anderem für die Methoden dropna, drop_duplicates und rename als veraltet ein.

Für eine Spalte schreibe df["temp_c"] = df["temp_c"].fillna(0). Ein verketteter Aufruf wie df["temp_c"].fillna(0, inplace=True) aktualisiert unter Copy-on-Write in pandas 3 nie den übergeordneten DataFrame. Die Zuweisung macht das Ziel ausdrücklich sichtbar.

Mit einem kompatiblen Wert auffüllen

Ein Dictionary mit Werten pro Spalte ermöglicht es, eine gemischte Tabelle mit passenden Werten aufzufüllen: df.fillna({"rain_mm": 0, "city": "Unknown"}). Spalten, die im Dictionary fehlen, behalten ihre Lücken. Ein Skalar wie 0 ist praktisch für eine rein numerische Tabelle, deren Spalten ihn alle annehmen. Text mit einer Zahl aufzufüllen ist nicht kompatibel; pandas 3.1 warnt davor und eine zukünftige Version wird es ablehnen.

Die bekannten Temperaturen sind 18,0 und 31,0. Ihr Mittelwert ist 24,5, daher setzt df["temp_c"].fillna(df["temp_c"].mean()) 24,5 in beide Lücken ein. Ein extremer Wert kann den Mittelwert stark verschieben; ein Median reagiert weniger empfindlich. Halte vor dem Auffüllen mit df["temp_missing"] = df["temp_c"].isna() einen Indikator fest, damit geschätzte und beobachtete Werte unterscheidbar bleiben.

Die Mittelwertimputation verringert die scheinbare Streuung der Spalte. Ein weit entfernter fester Wert kann sie erhöhen. Niederschlagswerte mit 0 aufzufüllen, besagt, dass kein Regen gefallen ist. Das ist bei einem ausgeschalteten Sensor unangemessen.

Benachbarte Messwerte nutzen, wenn die Reihenfolge zählt

ffill() übernimmt den letzten bekannten Wert vorwärts; bfill() übernimmt den nächsten bekannten Wert rückwärts. Für 12,0, NaN, NaN, NaN, 15,0 ergibt das Vorwärtsauffüllen vier Werte von 12,0, gefolgt von 15,0. ffill(limit=1) füllt nur die erste Lücke in dieser Folge. Eine Lücke am Anfang hat keinen vorherigen Wert und bleibt bestehen. Nutze ffill() direkt; fillna(method="ffill") wurde in pandas 3 entfernt.

interpolate() schätzt zwischen benachbarten Positionen. Für 10, NaN, NaN, 16 ergibt lineare Interpolation 10, 12, 14, 16. Sie eignet sich für Messwerte, die sich in einer sinnvollen Reihenfolge stetig ändern. Das Übernehmen oder Interpolieren über nicht zusammengehörige Städte hinweg würde eine Beziehung unterstellen, die zwischen den Zeilen nicht besteht.

Führe nach jeder Operation isna().sum() erneut aus und prüfe die Zeilenanzahl. Ein erfolgreicher Methodenaufruf sagt dir, dass der Code ausgeführt wurde; diese Prüfungen zeigen dir, was sich geändert hat.

Zwei Zeilen können ähnlich aussehen, ohne dass sie dasselbe Ereignis beschreiben. Entscheide vor dem Entfernen von Dubletten, welche Werte einen Datensatz identifizieren. Eine Bestell-ID kann eine Bestellung identifizieren; Kunde und Datum allein können mehrere tatsächliche Käufe bezeichnen.

Die zusätzlichen Kopien markieren

df.duplicated() gibt pro Zeile einen booleschen Wert zurück. Standardmäßig vergleicht die Methode jede Spalte, behält das erste Vorkommen und markiert spätere Kopien mit True. Die Summe des Ergebnisses zählt zusätzliche Kopien, nicht alle Mitglieder wiederholter Gruppen.

Betrachte sechs Bestellzeilen mit den IDs 101, 102, 102, 103, 104, 104. Die beiden Zeilen mit 102 sind identisch. Die beiden Zeilen mit 104 haben unterschiedliche erfasste Gewichte, 0,5 kg und 0,8 kg. Werden alle Spalten verglichen, gibt es eine zusätzliche Kopie: df.duplicated().sum() ist 1. df.drop_duplicates() behält fünf Zeilen, weil die beiden unterschiedlichen Zeilen mit 104 keine exakten Kopien sind.

Die Spalten vergleichen, die die Identität bestimmen

df.duplicated(subset=["order_id"]) vergleicht nur die IDs. Die Methode markiert die zweite 102 und die zweite 104 und ergibt damit zwei zusätzliche Kopien. Die Werte der anderen Spalten beeinflussen diese Entscheidung nicht mehr. Untersuche die widersprüchlichen Gewichte, bevor du entscheidest, welchen Bestelldatensatz du behältst.

df.drop_duplicates(subset="order_id", keep="last") behält bei dieser Reihenfolge die Version mit 0,8 kg für Bestellung 104. Die letzte Zeile zu behalten bedeutet nicht von selbst, den neuesten Datensatz zu behalten. Stelle diese Reihenfolge zuerst her:

latest = df.sort_values("updated").drop_duplicates(
    subset="customer_id", keep="last"
)

Das Sortieren nach updated setzt ältere Datensätze vor neuere. Die Dublettenprüfung vergleicht dann nur customer_id, sodass unterschiedliche Aktualisierungszeitpunkte nicht verhindern, dass zwei Zeilen als Versionen desselben Kunden erkannt werden.

Zeilenwerte von Indexbezeichnungen unterscheiden

Diese Methoden vergleichen Werte und ignorieren Indexbezeichnungen. Identische Zeilen mit den Bezeichnungen 4 und 9 zählen weiterhin als Dubletten. Fehlende Werte an entsprechenden Positionen gelten bei dieser Prüfung als gleich. Um wiederholte Bezeichnungen selbst zu prüfen, nutze df.index.duplicated().

Der exakte Vergleich unterscheidet auch Groß- und Kleinschreibung sowie Leerraumzeichen. Die Werte „ Lisbon“, „lisbon“ und „LISBON “ sind unterschiedlich. Bereinige sie vor der Dublettenprüfung mit .str.strip().str.lower(), wenn diese Schreibweisen dieselbe Stadt bezeichnen. Andernfalls zählt nunique() drei Namen für einen Ort.

Eindeutigkeit dort prüfen, wo die Beziehung sie verlangt

Eine Zuordnungstabelle sollte eine Zeile pro Zuordnungsschlüssel enthalten, wenn jeder Datensatz einen Satz von Angaben erhalten muss. lookup["customer_id"].is_unique prüft diese Anforderung. Wiederholte Kunden-IDs in einer Bestelltabelle sind normal, weil ein Kunde mehrere Bestellungen aufgeben kann.

Wiederholt sich ein Zuordnungsschlüssel, wiederholt ein späterer Verbund jede passende Bestellung für jede passende Zeile der Zuordnungstabelle. Das Entfernen von Dubletten aus den Bestellungen würde echte Käufe verwerfen, ohne die Zuordnungstabelle zu korrigieren. Prüfe den vorgesehenen Schlüssel in der richtigen Tabelle, untersuche widersprüchliche Datensätze und vergleiche die Zeilenanzahl nach dem Entfernen.

Eine Ersetzung ändert passende Werte, eine Zuordnung übersetzt Werte und eine Umbenennung ändert Bezeichnungen. Im Code können diese Aufgaben ähnlich aussehen, sie liefern aber unterschiedliche Ergebnisse, wenn ein Wert in einem Dictionary fehlt.

Exakte Werte ersetzen

s.replace("N/A", np.nan) ändert nur Zellen, die "N/A" entsprechen. Eine Liste kann mehrere alte Werte nennen: s.replace(["-", "?"], np.nan). Ein Dictionary gibt für jeden Wert eine eigene Ersetzung an, etwa s.replace({"M": "male", "F": "female"}). Werte ohne Übereinstimmung bleiben unverändert.

Für eine ganze Tabelle beschränkt ein verschachteltes Dictionary die Änderung auf eine Spalte: df.replace({"status": {0: "open", 1: "closed"}}). So vermeidest du, dass andere Nullen und Einsen an anderer Stelle geändert werden. Weise das zurückgegebene Ergebnis zu, um die Änderung zu behalten.

replace gleicht ganze Zellen ab. Bei „Main St“ und „St“ ändert s.replace("St", "Street") nur „St“. Um Teile einer Zeichenkette zu ändern, nutze s.str.replace("St", "Street", regex=False), das auch „Main Street“ erzeugt.

Mit einer Zuordnung Werte übersetzen

Vergleiche für die Codes „PT“, „JP“ und „KE“ dasselbe Dictionary in zwei Methoden:

Ein an map übergebenes Dictionary legt die möglichen Ausgaben fest. Ein fehlender Schlüssel hat keine Ausgabe und wird zu einem fehlenden Wert. Prüfe anschließend isna().sum(), damit eine unvollständige Zuordnung sichtbar wird.

map akzeptiert auch eine Funktion: s.map(lambda x: x * 1000) wandelt Kilometerwerte in Meter um. Für diese Rechnung ist s * 1000 einfacher und schneller, weil der Ausdruck auf die ganze Spalte wirkt. DataFrame.map wendet eine Funktion Zelle für Zelle an; es ersetzt die entfernte Methode applymap.

Text in Zahlen umwandeln

astype fordert einen Datentyp an, etwa "float64", "Int64" oder "category". Die Methode löst einen Fehler aus, wenn ein Wert nicht umgewandelt werden kann. Für den Text "12", "7.5" und "n/a" erzeugt pd.to_numeric(s, errors="coerce") dagegen 12,0, 7,5 und NaN. Die Typumwandlung mit Fehlerersetzung erhält lesbare Zahlen, verlangt aber, dass du die fehlgeschlagenen Umwandlungen untersuchst.

Die Formatierung kann eine Umwandlung verhindern, selbst wenn die Zahl gültig ist. Entferne für „1,200“ und „950“ zuerst das Tausendertrennzeichen:

cleaned = s.str.replace(",", "", regex=False)
numbers = pd.to_numeric(cleaned, errors="coerce")
failed = s.notna() & numbers.isna()

Hier markiert failed Werte, die vor der Umwandlung vorhanden waren, danach aber fehlten. Der alleinige Vergleich der Anzahl fehlender Werte liefert eine nützliche Gesamtzahl; die Maske zeigt zusätzlich, wo der ursprüngliche Text zur Prüfung steht. Entferne bekannte Einheiten aus Messtexten vor der Umwandlung ebenso gezielt.

Die Bezeichnungen umbenennen

df.rename(columns={"Qty": "quantity"}) ändert eine Spaltenüberschrift und lässt ihre Zellen unverändert. df.rename(columns=str.lower) schreibt alle Überschriften klein. Eine Folge wie df.columns.str.strip().str.lower().str.replace(" ", "_", regex=False) macht aus „Total KG “ den Namen total_kg; weise sie df.columns zu.

Nutze replace oder map für Werte innerhalb einer Spalte. Nutze rename für die Bezeichnungen, anhand derer du diese Werte auswählst.

Manche Analysen benötigen exakte Messwerte, andere Gruppen oder vergleichbare numerische Bereiche. Halte die ursprüngliche Bedeutung klar: Die Klasseneinteilung erzeugt Kategorien, die Skalierung ändert die numerische Skala und die Wertbegrenzung ersetzt extreme Werte.

Werte in Intervalle einteilen

pd.cut(ages, [18, 30, 45, 65]) verwendet die Intervalle (18, 30], (30, 45] und (45, 65]. Die runde Klammer schließt den linken Endpunkt aus; die schließende eckige Klammer schließt den rechten Endpunkt ein. Die Alterswerte 19, 25 und 30 gelangen in das erste Intervall, 41 in das zweite und 64 in das dritte. Der Alterswert 18 wird zu einem fehlenden Wert, weil er auf der ausgeschlossenen linken Grenze liegt.

include_lowest=True nimmt diesen niedrigsten Wert in das erste Intervall auf. right=False erzeugt dagegen links abgeschlossene Intervalle wie [18, 30), sodass 30 in das zweite Intervall gelangt. Werte außerhalb aller Intervalle bleiben fehlend. Teste sowohl die genauen Grenzen als auch typische Werte dazwischen.

Es muss eine Bezeichnung pro Intervall geben, also eine weniger als die Anzahl der Grenzen. Mit labels=["18-30", "31-45", "46-65"] und include_lowest=True ergeben die sechs obigen Alterswerte die Anzahlen 4, 1 und 1. Diese Bezeichnungen beschreiben ganzzahlige Alterswerte; die Intervallgrenzen bestimmen weiterhin die Zuordnung.

Grenzen oder Gruppengrößen wählen

Für 2, 4, 6, 8, 10, 12, 14, 16 ergibt qcut zwei Werte pro Quartilgruppe. Gruppen mit gleicher Besetzungszahl müssen nicht gleich breite Zahlenbereiche abdecken.

Skalieren, ohne Gruppen zu erzeugen

Die Min-Max-Skalierung nutzt (x - x.min()) / (x.max() - x.min()). Für 10, 20, 40 beträgt die Spannweite 30: Die Ergebnisse sind 0, etwa 0,333 und 1. Sowohl das Minimum als auch das Maximum werden benötigt; allein durch das Maximum zu dividieren ist eine andere Operation. Eine konstante Spalte hat die Spannweite null, sodass dieser Ausdruck keine sinnvolle skalierte Streuung liefern kann.

Die Standardisierung nutzt (x - x.mean()) / x.std(). Für 10, 20, 30 ist der Mittelwert 20 und die standardmäßig von pandas berechnete Stichprobenstandardabweichung 10. Subtrahierst du 20 und dividierst durch 10, erhältst du die z-Werte -1, 0 und 1. Ein z-Wert beschreibt den Abstand vom Mittelwert in Einheiten der Standardabweichung, keine Intervallbezeichnung.

Begrenzen und kodieren

pd.Series([5, 12, 250, 8]).clip(upper=100) ergibt 5, 12, 100, 8. Anders als ein Filter behält clip die Zeile und ersetzt die extreme Zahl. Untersuche große Werte vor dem Begrenzen mit describe() oder einem Filter: Auch ein echter großer Messwert ist ein Datenwert.

pd.get_dummies(s) erstellt eine boolesche Indikatorspalte pro Kategorie. Bei Rot, Grün, Rot, Blau ist jede Zeile nur in der Spalte ihrer Farbe True. Nutze dtype=int für Nullen und Einsen. Fehlende Werte ergeben durchweg falsche Indikatorwerte, sofern dummy_na=True keine Spalte für fehlende Werte hinzufügt. Für eine gewöhnliche Kleinste-Quadrate-Regression mit Achsenabschnitt entfernt drop_first=True eine redundante Kategoriespalte; andere Modelle können alle Kategorien behalten. Bei einer Kategorie pro Zeile summiert sich der vollständige Satz von Indikatoren zur Konstanten 1 des Achsenabschnitts und erzeugt eine lineare Abhängigkeit.

Bei Zellen mit mehreren Schlagwörtern teilt s.str.get_dummies(sep="|") einen Wert wie „Action|Comedy“ in separate Indikatoren auf. Auch die Intervalle einer Klasseneinteilung lassen sich an get_dummies übergeben, sodass eine Spalte pro Bereich entsteht.

Ein Mensch erkennt in „ Lisbon“, „lisbon“ und „LISBON “ dieselbe Stadt. pandas sieht drei verschiedene Zeichenketten. Durch das Bereinigen einer Textspalte erhalten spätere Zählungen, Dublettenprüfungen und Verbunde einheitliche Werte zum Vergleichen.

Zeichenkettenmethoden auf eine Series anwenden

Pythons "Lima ".strip() arbeitet mit einer Zeichenkette. Nutze für eine Spalte den .str-Accessor: s.str.strip() entfernt äußere Leerraumzeichen aus jedem nicht fehlenden Wert. s.lower() löst einen AttributeError aus, weil die Series selbst keine Methode lower hat. Nutze s.str.lower().

pandas 3 erkennt Text normalerweise als Datentyp str, der die ältere Standardeinstellung object ersetzt. Der Datentyp str enthält Text und fehlende Werte, wobei NaN für fehlenden Text steht. Zeichenkettenmethoden funktionieren bei beiden Typen. Weise einer str-Spalte Text zu; wandle eine Zahl zuerst in Text um, wenn sie dort als Text hingehört.

Kombiniere passende Bereinigungsoperationen und weise das Ergebnis zu:

df["city"] = df["city"].str.strip().str.lower()

Die drei Schreibweisen von Lissabon werden zu „lisbon“. strip() entfernt äußere Leerraumzeichen, keine Leerzeichen innerhalb eines Namens. upper() schreibt alle Buchstaben groß, während title() jedes Wort am Anfang großschreibt und aus „new york“ „New York“ macht. Wähle für Schlüssel und Zählungen eine einheitliche Form.

Strukturierte Zeichenketten aufteilen

Für „Silva, Ana“ und „Tanaka, Yui“ gibt s.str.split(", ") Listen wie ["Silva", "Ana"] zurück. Füge expand=True hinzu, um separate Spalten zu erzeugen. Hole mit .str[0] oder .str.get(1) einen Teil aus jeder Liste.

Soll nur das erste Trennzeichen einen Wert aufteilen, nutze n=1. Das Aufteilen von „a,b,c“ an Kommas mit n=1 ergibt „a“ und „b,c“. Ohne Begrenzung ergeben sich drei Teile. Gleiche das Trennzeichen exakt ab, einschließlich jedes Leerzeichens, das zum Format gehört.

Suchen und filtern

s.str.contains("lis", case=False) prüft, ob Text irgendwo vorkommt, und ignoriert dabei die Groß- und Kleinschreibung. s.str.startswith("ID") prüft den Anfang; s.str.endswith(".csv") prüft das Ende. Die booleschen Ergebnisse können Zeilen auswählen:

mask = df["city"].str.contains("san", case=False, na=False)
selected = df[mask]

Beim Datentyp str in pandas 3 ergibt fehlender Text in diesen Suchtests False. Die Angabe na=False macht auch bei der Verwendung von Zeichenkettendaten mit Fehlwertunterstützung die beabsichtigte Behandlung deutlich. contains liest standardmäßig ein Regex-Muster; ergänze regex=False für wörtlich zu suchenden Text mit Sonderzeichen.

Teile ersetzen und neue Zeichenketten bilden

s.str.replace("kg", "", regex=False) entfernt „kg“, wo immer es vorkommt. s.replace("kg", "") ändert nur Zellen, die genau „kg“ enthalten. Dieser Unterschied ist bei Werten wie „12 kg“ wichtig.

str.replace behandelt seinen Suchtext standardmäßig wörtlich. Für „3.5 kg“ entfernt .str.replace(".", "", regex=False) den Punkt und ergibt „35 kg“. Mit regex=True steht der Punkt als Muster für fast jedes Zeichen und entfernt in diesem einzeiligen Beispiel alle Zeichen. Nutze diese Änderung niemals, um einen dezimalen Messwert einzulesen.

s.str.len() zählt Zeichen; ein fehlender Wert ergibt NaN und kann das Ergebnis zu einer Gleitkommaspalte machen. s.str[:3] extrahiert die ersten drei Zeichen. Um Spalten zu kombinieren, verbindet df["first"] + " " + df["last"] Ana und Silva zu „Ana Silva“; str.cat ist eine weitere Methode zum Verbinden. Jede Operation gibt ein Ergebnis zurück, speichere es daher in der Spalte, die du verwenden möchtest.

Ein regulärer Ausdruck, auch Regex genannt, beschreibt ein Muster in Text. Er kann eine Mengenangabe erkennen, selbst wenn die Anzahl der Ziffern oder die Abstände variieren. Beginne mit einem kleinen Muster, dessen Teile du erklären kannst.

Die Musterbestandteile lesen

Schreibe Python-Muster als Raw-Strings wie r"\d+", damit Python ihre umgekehrten Schrägstriche beibehält. Ein Punkt passt standardmäßig auf jedes Zeichen außer einem Zeilenumbruch. Maskiere ihn als r"\.", um einen tatsächlichen Punkt zu finden. Für eine einfache Textsuche verhindert regex=False die Interpretation als Muster vollständig.

Festlegen, wie viel Text passen muss

contains findet ein Muster an beliebiger Stelle, match beginnt am Anfang und fullmatch verlangt, dass der gesamte Wert passt. Für „123a“ sind s.str.contains(r"\d+") und s.str.match(r"\d+") erfolgreich, aber s.str.fullmatch(r"\d+") schlägt fehl. Nutze die Prüfung der gesamten Zeichenkette, wenn du einen vollständigen Code prüfst. case=False oder flags=re.IGNORECASE nach import re ermöglicht, wo unterstützt, einen Abgleich ohne Beachtung der Groß- und Kleinschreibung.

Einen Messwert erfassen

Nimm „Rice 5 kg“, „Flour 2kg“, „Salt“ und „Beans 12 kg, 3 kg“. Das Muster r"(\d+)\s*kg" bedeutet eine oder mehrere Ziffern, die als Gruppe erfasst werden, gefolgt von null oder mehr Leerzeichen und dann „kg“.

quantity = s.str.extract(r"(\d+)\s*kg", expand=False)
quantity = pd.to_numeric(quantity)

Die extrahierten Zeichenketten sind „5“, „2“, ein fehlender Wert und „12“. Die Umwandlung ergibt die numerischen Werte 5,0, 2,0, NaN und 12,0. extract nimmt die erste Übereinstimmung jeder Zeile, sodass die zweite Mengenangabe in der Bohnenbeschreibung nicht enthalten ist. Ohne expand=False gibt eine einzelne Gruppe einen DataFrame mit einer Spalte zurück.

Benannte Gruppen beschriften die Ausgabe. s.str.extract(r"(?P<year>\d{4})-(?P<month>\d{2})") findet „2024-03“ in „Report 2024-03 final“ und gibt die Textspalten year und month zurück. Das Muster erkennt die Anordnung der Ziffern; die numerische Umwandlung ist ein separater Schritt.

Alle Übereinstimmungen finden oder nach Muster bereinigen

findall(r"\d+") ergibt pro Zeile eine Liste, darunter ["12", "3"] für den Bohnentext und [] für „Salt“. count(r"\d+") zählt Übereinstimmungen. extractall ergibt eine Zeile pro Übereinstimmung mit einer zusätzlichen Indexebene namens match.

Mit regex=True reduziert s.str.replace(r"\s+", " ", regex=True) Folgen von Leerraumzeichen auf ein Leerzeichen. r"\D" steht für ein Zeichen, das keine Ziffer ist. Entfernst du es, wird aus „+351 912-345-678“ die Zeichenkette „351912345678“. Die Großbuchstabenformen \S und \W verneinen entsprechend die Klassen der Leerraumzeichen und Wortzeichen.

Wiederholungen sind standardmäßig gierig. In "<b>x</b>" reicht r"<.*>" vom ersten öffnenden bis zum letzten schließenden Zeichen. Das Entfernen dieser Übereinstimmung entfernt alles. Das nicht gierige Muster r"<.*?>" erfasst jedes Tag einzeln und lässt „x“ stehen. Prüfe Beispielausgaben, bevor du ein Muster auf eine ganze Spalte anwendest.

Eine Spalte mit wenigen Werten, die sich oft wiederholen, kann den Datentyp category verwenden. Dabei werden die unterschiedlichen Bezeichnungen einmal gespeichert und jede Zeile durch einen kleinen Ganzzahlcode dargestellt. Der sichtbare Wert bleibt die Bezeichnung.

Kategorien und Codes verstehen

Für die Größen M, S, L, M, M ermittelt s.astype("category") die Kategorien L, M, S in alphabetischer Reihenfolge. Die Codes sind 1, 2, 0, 1, 1. Nutze s.cat.categories, um die Bezeichnungen zu prüfen, und s.cat.codes, um die Kennungen zu prüfen. Ein Code von 0 bezeichnet die erste gespeicherte Kategorie; er ist keine gemessene Größe.

Bei wiederholten Bezeichnungen lässt sich viel Speicher sparen. Bis zu 126 Kategorien benötigen die Codes jeweils ein Byte; ab 127 Kategorien benötigen sie zwei Bytes. In einer pandas-3.1-Umgebung mit PyArrow benötigten drei Ländernamen, die sich über 3.000.000 Zeilen wiederholten, etwa 3 MB als kategoriale Daten, etwa 42 MB als str und etwa 165 MB als object. Das verwendete Backend für die Textspeicherung beeinflusst diese Zahlen. Bei einer Spalte mit fast ausschließlich eindeutigen Werten bringt es keinen Vorteil, eine Kategorienliste und einen Code pro Zeile zu speichern.

Eine sinnvolle Reihenfolge festlegen

Die alphabetische Reihenfolge der Größen setzt L vor M und M vor S. Lege die tatsächliche Größenreihenfolge ausdrücklich fest:

size_type = pd.CategoricalDtype(["S", "M", "L"], ordered=True)
sizes = s.astype(size_type)

Nun folgt die Sortierung S, M, L, Vergleiche wie sizes > "S" sind sinnvoll und sizes.max() ist „L“, wenn L vorkommt. Bei ungeordneten Bezeichnungen wie Ländern funktionieren Gleichheitsprüfungen, aber Größer-als-Vergleiche lösen einen TypeError aus. as_ordered() nutzt die vorhandene Kategorienreihenfolge; prüfe sie, bevor du sie als sinnvoll festlegst.

Die erlaubten Bezeichnungen ändern

Du kannst „XL“ keinen kategorialen Daten zuweisen, die nur S, M und L erlauben. Weise zuerst das erweiterte Ergebnis zu, sizes = sizes.cat.add_categories("XL"), und dann den neuen Wert.

Die Umwandlung von Text in eine feste Kategorienliste kann nicht aufgeführte Werte zu fehlenden Werten machen. pandas 3.1 warnt, dass diese verlustbehaftete Umwandlung künftig einen Fehler auslösen wird. Prüfe die Ausgangswerte vor der Umwandlung mit value_counts(), besonders nachdem du Schreibweisen bereinigt hast.

Die .cat-Methoden erfüllen unterschiedliche Zwecke:

• rename_categories({"S": "small"}) ändert eine Bezeichnung und behält ihre zugeordneten Werte.
• remove_categories("L") entfernt eine erlaubte Bezeichnung und macht vorhandene L-Werte zu fehlenden Werten.
• set_categories([...]) ersetzt die ganze Kategorienliste.
• reorder_categories([...], ordered=True) ändert die Reihenfolge, ohne die erlaubten Bezeichnungen zu ändern.
• remove_unused_categories() entfernt Bezeichnungen, denen aktuell keine Werte zugeordnet sind.

value_counts() zeigt jede erlaubte Kategorie an, auch solche mit null Beobachtungen. Bei einem S/M/L-Typ, der nur S und M enthält, erscheint L dennoch mit der Anzahl 0. So wird eine leere Gruppe sichtbar, für die gewöhnliche Textdaten keine Bezeichnung gespeichert haben.

Kategorien für die weitere Verarbeitung nutzbar halten

cut erzeugt kategoriale Intervalle und get_dummies wandelt die Zugehörigkeit zu Kategorien in Indikatorspalten um. Würdest du ungeordnete Ländercodes als Zahlen an ein Modell übergeben, würde dies eine künstliche Reihenfolge und künstliche Abstände unterstellen. Indikatoren vermeiden diese Interpretation.

Das Aneinanderfügen kategorialer Spalten mit unterschiedlichen Kategorienlisten führt normalerweise zum Verlust des kategorialen Datentyps. Stimme zuerst ihre Kategorienlisten aufeinander ab oder nutze pd.concat(..., union_categories=True) in pandas 3.1, wenn die Listen zusammengeführt werden sollen. Prüfe sowohl den Datentyp des Ergebnisses als auch die Kategorienreihenfolge.

Ein Verbund ordnet Zeilen anhand von Schlüsselwerten einander zu und stellt ihre Informationen nebeneinander. Der Schlüssel muss in beiden Tabellen dasselbe bezeichnen, etwa die Kunden-ID einer Bestellung und die Kunden-ID in einer Zuordnungstabelle.

Den Schlüssel angeben und den Verbundtyp wählen

Nutze orders.merge(customers, on="customer_id"). Ohne on verwendet pandas alle Spaltennamen, die in beiden Tabellen vorkommen. Eine andere gemeinsame Spalte wie date könnte dann gültige Kundenzuordnungen verhindern.

Angenommen, Bestellungen haben die Kunden-IDs 10, 20, 20, 30, 50. Die Kundentabelle hat jeweils eine Zeile für 10, 20, 30, 40.

Der innere Verbund ist die Standardeinstellung. Bei einem linken äußeren Verbund fehlen für Kunde 50 die Kundendaten. Ein rechter äußerer Verbund enthält Kunde 40 ohne Bestellung sowie beide Bestellungen für 20. Ein vollständiger äußerer Verbund enthält beide nicht zugeordneten Schlüssel. Ein Kreuzverbund braucht keinen Schlüssel, weil er gezielt jede Zeile mit jeder anderen kombiniert. pandas 3 bietet außerdem left_anti und right_anti für Zeilen ohne passenden Schlüssel auf der anderen Seite.

Prüfen, wie viele Übereinstimmungen eine Zeile haben kann

Zwei linke Zeilen für Schlüssel 20 und drei rechte Zeilen für Schlüssel 20 erzeugen sechs Paare. Der Verbund wählt nicht nur eine rechte Zeile aus. Wenn du im Beispiel eine zweite Kundenzuordnungszeile für 20 hinzufügst, wächst das Ergebnis des inneren Verbunds von vier auf sechs Zeilen.

Gib die beabsichtigte Beziehung mit validate an:

merged = orders.merge(
    customers, on="customer_id", how="left",
    validate="many_to_one"
)

Dies erlaubt viele Bestellungen pro Kunde, verlangt aber eindeutige Kunden-IDs auf der rechten Seite. Ein wiederholter rechter Schlüssel löst einen MergeError aus. one_to_one verlangt Eindeutigkeit auf beiden Seiten; one_to_many verlangt sie auf der linken Seite. many_to_many erlaubt Wiederholungen auf beiden Seiten und prüft die Eindeutigkeit nicht.

Nicht zugeordnete Zeilen untersuchen

Ein vollständiger äußerer Verbund mit indicator=True fügt _merge hinzu. Hier lauten die Anzahlen vier both, ein left_only und ein right_only. Das sind Zeilen, keine unterschiedlichen Schlüssel: Wiederholte Bestellungen können mehrere both-Zeilen für einen Kunden erzeugen.

Um unterschiedliche nicht zugeordnete Schlüssel auf der Bestellseite zu zählen, nutze m.loc[m["_merge"] == "left_only", "customer_id"].nunique(). Das Untersuchen der Zeilen kann fehlende Zuordnungseinträge oder uneinheitlichen Text aufdecken.

Namen und Schlüsselformate steuern

Haben Schlüssel unterschiedliche Namen, nutze left_on="customer_id", right_on="id". Beide Schlüsselspalten bleiben verfügbar. Mehrere Schlüssel lassen sich gemeinsam mit on=["city", "year"] abgleichen; beide müssen übereinstimmen.

Gleichnamige Spalten außerhalb der Schlüsselspalten erhalten _x und _y. Wähle aussagekräftige Suffixe wie suffixes=("_order", "_ship"), damit die Herkunft klar bleibt.

Schlüssel brauchen kompatible Datentypen und gleiche Werte. Die Zahl 1 kann zur Zahl 1,0 passen, aber ganzzahlige und textbasierte Schlüsselspalten können einen Fehler beim Verbinden auslösen. Wandle ihre Formate gezielt um. „ana“ und „Ana “ sind unterschiedliche Texte; vereinheitliche Groß- und Kleinschreibung sowie äußere Leerzeichen vor dem Verbinden, wenn sie dieselbe Person bezeichnen.

Auch fehlende Schlüssel müssen untersucht werden: pandas ordnet fehlende Schlüssel auf einer Seite fehlenden Schlüsseln auf der anderen Seite zu. Enthalten beide Seiten mehrere solche Zeilen, können sich auch diese Übereinstimmungen vervielfachen.

Ein Index kann den Schlüssel enthalten, den du abgleichen möchtest. pandas nutzt diese Bezeichnungen beim Verknüpfen von Tabellen, beim Ergänzen fehlender Werte oder beim Addieren zweier Series. Die Zeilenposition allein entscheidet nicht über die Zuordnung.

Anhand von Indexbezeichnungen verknüpfen

left.join(right) gleicht die beiden Indizes ab und erstellt standardmäßig einen linken äußeren Verbund. Dagegen erstellt merge standardmäßig einen inneren Verbund. Du kannst auch left.merge(right, left_index=True, right_index=True) schreiben, wenn beide Schlüssel im Index liegen.

Angenommen, stations hat die Indexbezeichnungen A, B, C und die Höhen 120, 850, 15 m. Eine Messwerttabelle hat die Stationsindexbezeichnungen A, B, B, D. readings.join(stations) behält vier Zeilen und ergänzt die Höhen 120, 850, 850 und NaN. Beide B-Messwerte erhalten die Höhe von B. Mit how="inner" bleiben nur die drei Messwerte für A und B erhalten.

Wenn die Messwerttabelle Stations-IDs in einer gewöhnlichen Spalte enthält, nutze readings.join(stations, on="station"). Die linke Spalte wird mit dem rechten Index abgeglichen. Die entsprechende Form mit merge lautet readings.merge(stations, left_on="station", right_index=True, how="left").

Die Position des Schlüssels deutlich machen

set_index("station") verschiebt die Stationsspalte in den Index. reset_index() stellt sie als gewöhnliche Spalte wieder her. So kannst du eine Anordnung wählen, bei der sich die Zuordnung leicht prüfen lässt. left.join([t1, t2]) kann mehrere Tabellen mit gemeinsamen Indexbezeichnungen gleichzeitig verknüpfen.

Enthalten beide verknüpften Tabellen eine Spalte außerhalb der Schlüsselspalten wie source, löst join einen ValueError aus, sofern du die Namen nicht unterscheidbar machst. Schreibe in pandas 3.1 suffixes=("_left", "_right"); dies ersetzt die älteren Argumente lsuffix und rsuffix. Die Suffixe erhalten beide Versionen, ohne zu entscheiden, welcher Wert maßgeblich ist.

Lücken aus einer Ersatzquelle ergänzen

a.combine_first(b) behält bekannte Werte in a, füllt dessen Lücken aus b bei übereinstimmenden Bezeichnungen und nimmt Bezeichnungen auf, die nur in b vorkommen.

Das Ergebnis behält 1 und 3, weil die erste Quelle diese Werte bereits kennt. Es nutzt 20, um die Lücke zu füllen, und ergänzt die Bezeichnung d mit 40. Drehst du den Aufruf um, ändert sich, welche Quelle Vorrang hat. Das ist nützlich, wenn eine Hauptdatenquelle Vorrang vor einer Ersatzquelle haben soll, selbst wenn ihre Zeilenreihenfolgen unterschiedlich sind.

Ausrichtung bei Rechenoperationen erkennen

x enthalte a = 5 und b = 7; y enthalte b = 1 und c = 2. x + y ergibt b = 8 und fehlende Ergebnisse bei a und c, weil jeweils ein Operand fehlt. Der Aufruf addiert nicht den ersten Wert von x zum ersten Wert von y.

x.add(y, fill_value=0) setzt für die fehlende Seite null ein und ergibt a = 5, b = 8, c = 2. Nutze diese Regel, wenn ein fehlender Beitrag als null zählen soll. Die Ausrichtung anhand von Indexbezeichnungen ist das gemeinsame Prinzip hinter diesen Operationen, aber ihre Regeln für Werte unterscheiden sich: join fügt Spalten hinzu, combine_first füllt Lücken und Rechenoperationen rechnen mit zugeordneten Werten.

Monatsdateien enthalten meist weitere Zeilen derselben Art von Beobachtung. Die Verkettung fügt diese Teile zu einer Tabelle zusammen. Sie richtet die Bezeichnungen auf der anderen Achse aus; sie sucht nicht nach übereinstimmenden Kunden- oder Bestellschlüsseln.

Zeilen untereinanderfügen und Spalten ausrichten

pd.concat([jan, feb]) fügt Zeilen untereinander, weil axis=0 die Standardeinstellung ist. Angenommen, Januar enthält drei Fahrten mit den Spalten trip und km, während Februar zwei Fahrten mit trip, km und note enthält. Das Ergebnis hat fünf Zeilen und drei Spalten. Die fehlenden note-Zellen für Januar werden zu NaN.

join="outer" ist die Standardeinstellung: Sie behält die Vereinigung der Spaltennamen. join="inner" behält nur gemeinsame Namen, sodass das Ergebnis fünf Zeilen und die zwei Spalten trip und km hat. Es enthält weiterhin alle fünf Beobachtungen; die Einstellung für join steuert die andere Achse.

Die Spaltenreihenfolge in den Teilen bestimmt die Zuordnung nicht. Entscheidend sind die exakten Namen. Verwendet ein Teil km und der andere Km, enthält das Ergebnis zwei teilweise leere Spalten. Benenne die Überschriften vor dem Aneinanderfügen um.

Entscheiden, was die Zeilenbezeichnungen bedeuten sollen

Die ursprünglichen Indizes bleiben standardmäßig erhalten. Bei den Ausgangsindizes 0, 1, 2 und 0, 1 wiederholt das Ergebnis die Bezeichnungen 0 und 1. result.loc[0] wählt zwei Zeilen aus. Nutze ignore_index=True, wenn diese Zahlen keine Bedeutung haben und du neue Bezeichnungen von 0 bis 4 möchtest.

Wenn die Herkunft wichtig ist, nutze eine äußere Indexebene:

result = pd.concat(
    [jan, feb], keys=["jan", "feb"], names=["month", "row"]
)

Nun wählt result.loc["feb"] die zwei Februarzeilen aus. keys hält die Herkunft innerhalb eines MultiIndex fest. In pandas 3 löst die Kombination von keys mit ignore_index=True einen ValueError aus; wähle für diese Operation Herkunftsbezeichnungen oder einen neuen einfachen Index.

Spalten nebeneinanderstellen

pd.concat([x, y], axis=1) richtet Zeilen anhand ihrer Indexbezeichnung aus. Für x mit a = 1, b = 2 und y mit b = 3, c = 4 hat das Ergebnis die Zeilen a, b, c. Die Spalte x fehlt bei c und y fehlt bei a. Mit join="inner" bleibt nur b erhalten.

Speicherung prüfen und Teile effizient sammeln

Eine Spalte, die numerische Werte und Text mischt, kann den Datentyp object erhalten. Entsteht bei gewöhnlichen NumPy-Daten vom Typ int64 eine Lücke, werden sie zu float64; der pandas-Datentyp "Int64" mit Fehlwertunterstützung kann ganze Zahlen mit <NA> behalten. Stimme die Datentypen vor dem Kombinieren aufeinander ab, wenn die Spalte einen festgelegten Typ hat.

DataFrame.append wurde in pandas 2.0 entfernt. Sammle bei vielen Dateien DataFrames in einer Liste und rufe pd.concat nach der Schleife einmal auf. Wird in jedem Durchlauf ein wachsendes Ergebnis neu erstellt, werden die angesammelten Daten wiederholt kopiert und der Vorgang wird langsam.

Prüfe, ob die Länge des Ergebnisses beim Aneinanderfügen von Zeilen der Summe der Eingabelängen entspricht. Untersuche danach Spaltennamen, Anzahl fehlender Werte und Datentypen.

Ein MultiIndex gibt jeder Zeile mehrere Bezeichnungen. Eine Umsatzzeile kann sowohl durch Stadt als auch durch Jahr identifiziert werden, geschrieben als Tupel wie ("Osaka", 2024). Jede Bezeichnung gehört zu einer Ebene und die Reihenfolge dieser Ebenen ist für die Auswahl wichtig.

Den Index erstellen und benennen

df.set_index(["city", "year"]) verschiebt diese Spalten in den Index. pd.MultiIndex.from_product([["Lima", "Osaka"], [2024, 2025]], names=["city", "year"]) bildet jede Kombination der angegebenen Bezeichnungen. Auch das Aneinanderfügen mit keys fügt eine Ebene hinzu.

Für die Beispiele hat sales diese Indexpaarungen und Werte:

Nach dem Festlegen der beiden Indexebenen ist df.index.names gleich ["city", "year"]. rename_axis(["town", "yr"]) ändert die Ebenennamen, ohne ihre Werte zu ändern.

Eine äußere Bezeichnung oder ein vollständiges Tupel auswählen

df.loc["Osaka"] wählt beide Zeilen für Osaka aus. Die ausgewählte Stadtebene fällt weg, sodass 2024 und 2025 als Index bleiben. df.loc[("Lima", 2025), "sales"] wählt eine Zelle aus und gibt 95 zurück.

Eine einzelne an loc übergebene Bezeichnung sucht in der äußersten Ebene. df.loc[2024] sucht daher nach einer Stadt namens 2024 und löst in dieser Tabelle einen KeyError aus. Um ein Jahr über alle Städte hinweg auszuwählen, nutze df.xs(2024, level="year"). Der Aufruf gibt für Osaka 120 und für Lima 80 zurück, wobei die Stadt als verbleibender Index dient.

Für eine allgemeinere Auswahl behält df.loc[pd.IndexSlice[:, 2025], :] alle Städte im Jahr 2025. Der Doppelpunkt an der ersten Position bedeutet alle Bezeichnungen auf dieser Ebene; der letzte Doppelpunkt wählt alle Spalten aus.

Vor Slices über Bereiche sortieren

Die Auswahl anhand exakter Bezeichnungen benötigt keinen insgesamt sortierten Index, aber für einen Slice über einen Bezeichnungsbereich muss passend sortiert sein. Nutze df.sort_index() vor df.loc["Lima":"Osaka"]. Ein unsortierter MultiIndex kann für einen solchen Slice einen UnsortedIndexError auslösen.

sort_index() sortiert alle Ebenen in ihrer aktuellen Reihenfolge, also zuerst Städte und innerhalb jeder Stadt die Jahre. sort_index(level="year") sortiert nach der benannten Ebene. swaplevel("city", "year") setzt das Jahr an die äußere Position; rufe danach sort_index() auf, um die neue Anordnung zu gruppieren und zu sortieren. Das bloße Vertauschen der Ebenenpositionen sortiert die Zeilen nicht.

Bezeichnungen zurück in Spalten verschieben

reset_index() stellt beide Ebenen als Spalten wieder her. reset_index(level="year") stellt nur das Jahr wieder her und belässt die Stadt als Index. Mit diesen Operationen kannst du eine Tabelle für einen Verbund oder zum Speichern vorbereiten, ohne ihre identifizierenden Werte zu verlieren.

Auch Spalten können mehrere Ebenen haben. Eine Umformung mit Umsatz- und Personalwerten kann Spaltenbezeichnungen wie ("sales", 2024) und ("staff", 2025) erzeugen. df["sales"] wählt alle Spalten unter der Umsatzbezeichnung auf der obersten Ebene aus.

Für eine Summe nach Stadt ergibt df.groupby(level="city")["sales"].sum() Lima 175 und Osaka 255. Nutze für diese Zusammenfassung die Gruppierung; das alte Argument sum(level="city") wurde in pandas 2.0 entfernt.

stack und unstack ändern, wo Bezeichnungen stehen. Werte behalten ihre identifizierende Kombination, aber die Tabelle kann Kombinationen sichtbar machen, für die es keine Beobachtung gab.

Spaltenbezeichnungen in den Index stapeln

Angenommen, ein breiter DataFrame hat die Städte Osaka und Lima als Index und die Jahre 2024 und 2025 als Spalten. Osaka hat die Werte 120 und 135; Lima hat 80 und 95. Benenne die Achsen city und year, damit ihre Bedeutung sichtbar bleibt.

long = wide.stack() verschiebt die Jahresbezeichnungen in eine neue innerste Indexebene. Bei diesen einstufigen Spalten ist das Ergebnis eine Series mit vier Werten:

• ("Osaka", 2024) ergibt 120.
• ("Osaka", 2025) ergibt 135.
• ("Lima", 2024) ergibt 80.
• ("Lima", 2025) ergibt 95.

Die Stadtbezeichnungen wiederholen sich, weil jede Stadt nun eine Zeile pro Jahr hat. Beim Stapeln wurden die Werte weder summiert noch zusätzliche Messwerte erzeugt.

Eine Indexebene mit unstack in Spalten verschieben

long.unstack() verschiebt die innerste Indexebene, das Jahr, in Spalten und stellt die breite Anordnung wieder her. long.unstack("city") verschiebt stattdessen die Stadt und erzeugt Jahre als Zeilen und Städte als Spalten. Eine numerische Ebenenposition wie unstack(0) kann dieselbe Ebene auswählen, aber ein Name macht die Absicht leichter lesbar.

Hat die Eingabe hierarchische Spalten, kann beim Stapeln einer Ebene eine andere Ebene als Spalten erhalten bleiben. Für Spalten wie ("sales", 2024) und ("staff", 2024) gibt stack("year") einen DataFrame mit Umsatz- und Personalspalten zurück. Das Stapeln aller Spaltenebenen ergibt eine Series.

Fehlende Kombinationen sichtbar halten

Angenommen, die lange Series enthält nun keinen Eintrag für Lima 2025. Das Umformen mit unstack erzeugt eine rechteckige Tabelle mit Städten und Jahren und führt daher an dieser Stelle NaN ein. Gewöhnliche ganzzahlige Werte werden zu Gleitkommazahlen, wenn diese fehlende Zelle ein Fehlwertkennzeichen für Gleitkommazahlen erfordert.

unstack(fill_value=0) kann eine neu fehlende Kombination mit null füllen. Nutze dies nur, wenn das Fehlen null bedeutet, etwa keine erfassten Verkäufe in einem vollständigen Datensatz von Verkaufsereignissen. Eine fehlende Sensorbeobachtung ist unbekannt und sollte fehlend bleiben.

stack() in pandas 3 behält fehlende Zellen. Das Stapeln der unvollständigen 2 × 2-Tabelle ergibt daher vier Einträge, darunter NaN. Füge .dropna() hinzu, wenn du nur die drei bekannten Werte möchtest. Das Entfernen von Lücken ändert, welche Kombinationen noch dargestellt werden. Prüfe daher die Länge des Ergebnisses.

Doppelte Kombinationen zuerst behandeln

Für unstack wird ein einzelner Wert pro vollständiger Indexkombination benötigt. Zwei Einträge mit der Bezeichnung ("Lima", 2025) beanspruchen dieselbe Ausgabezelle und lösen ValueError: Index contains duplicate entries, cannot reshape aus.

Nutze long.index.duplicated(), um wiederholte vollständige Bezeichnungen zu untersuchen, oder prüfe die entsprechenden Schlüsselspalten vor dem Festlegen des Index. Entscheide, ob die Zeilen versehentliche Kopien oder getrennte Beobachtungen sind, die zusammengefasst werden sollten. Sie zu entfernen oder zu aggregieren ist eine Entscheidung über die Daten; unstack wählt keine Regel für dich.

Im Langformat stehen identifizierende Spalten neben einer Wertespalte. Im Breitformat sind Messwerte auf mehrere Spalten verteilt, etwa eine Spalte pro Jahr. Wähle die Anordnung, die den nächsten Schritt erleichtert: Lange Tabellen eignen sich zum Filtern und Gruppieren, während breite Tabellen direkte Vergleiche nebeneinander ermöglichen.

Eindeutige Paare in Zellen pivotieren

Eine lange Tabelle mit den Spalten city, year und sales wird mit df.pivot(index="city", columns="year", values="sales") breit. Stadtbezeichnungen bilden Zeilen, Jahre bilden Spalten und Umsätze füllen die Zellen. Dies entspricht df.set_index(["city", "year"])["sales"].unstack().

Die Umsätze von Osaka für 2024 und 2025 von 120 und 135 werden zu zwei Zellen in einer Zeile. Die Werte 80 und 95 von Lima bilden die zweite Zeile. Das Vertauschen der Argumente index und columns transponiert diese Anordnung. Lässt du values weg, werden alle verbleibenden Datenspalten pivotiert und es können hierarchische Spalten entstehen, etwa eine Umsatzebene und eine Personalebene über den Jahren.

Entscheiden, ob Wiederholungen Fehler oder Beobachtungen sind

pivot ordnet Werte um und kann sie nicht zusammenfassen. Zwei Zeilen für Lima 2025 würden zwei Werte in einer Ausgabezelle erfordern und lösen daher einen ValueError aus. Zähle wiederholte Paare mit df.duplicated(subset=["city", "year"]).sum().

Sollen getrennte Beobachtungen zusammengefasst werden, nutze pivot_table mit einer gewählten Aggregation. Für die Werte 95 und 105 bei Lima 2025 ergibt der standardmäßige Mittelwert 100,0. Mit aggfunc="sum" ist der Zellwert 200. Sollte jedes Paar einmal vorkommen, behalte pivot bei, damit ein Datenfehler sichtbar wird, statt ihn unbemerkt zusammenzufassen.

Messwertspalten mit melt in Zeilen umformen

Angenommen, eine CSV-Datei liefert die Spalten city, 2023, 2024 und 2025. Die Werte für Osaka sind 110, 120, 135; die für Lima sind 70, 80, 95. Forme die Jahresspalten um:

long = wide.melt(
    id_vars="city", var_name="year", value_name="sales"
)

id_vars bleibt erhalten und wird wiederholt. Jede Messwertspaltenbezeichnung wird zu einem Jahreswert; jede Zelle wird zu einem Umsatzwert. Zwei Zeilen und drei Messwertspalten erzeugen sechs lange Zeilen, darunter eine wie Osaka, „2023“, 110. Auch fehlende Messwertzellen werden zu Zeilen, sofern du sie nicht anschließend entfernst.

Da diese Spaltenbezeichnungen aus CSV-Text stammen, sind die entstehenden Jahreswerte Text. Nutze long["year"] = long["year"].astype(int), bevor du mit ihnen rechnest. Ganzzahlige Eingabespaltenbezeichnungen würden bereits ganzzahlige Jahreswerte ergeben.

Steuern, was umgeformt wird, und die Form wiederherstellen

value_vars=["2024", "2025"] beschränkt das Umformen auf diese Spalten. Wenn du id_vars vergisst, können Städtenamen zusammen mit Messwerten in dieselbe Wertespalte gelangen. Unterscheide Kennungen immer von den Spalten, die Werte enthalten.

Ohne ausdrückliche Namen heißt die Wertespalte value. Die Variablenspalte übernimmt wide.columns.name oder heißt variable, wenn dieser Name leer ist. Ausdrückliche Angaben für var_name und value_name erleichtern die Verwendung des Ergebnisses.

Pivotiere die sechs Zeilen mit index="city", columns="year", values="sales" zurück, um die drei Jahresspalten wiederherzustellen. Nach dem Pivotieren ist die Stadt der Index und die Spaltenachse heißt year. reset_index() stellt die Stadt als Spalte wieder her und rename_axis(columns=None) entfernt den Namen der Spaltenachse. Prüfe sowohl die Form als auch die Bezeichnungen, bevor du die Tabelle verknüpfst oder speicherst.