Einstieg in pandas

Eine Series hält eine Folge von Werten zusammen mit Bezeichnungen fest. Diese Bezeichnungen geben den Werten Bedeutung: Eine Niederschlagsmessung gehört zu einem Tag und eine Bevölkerungszahl zu einer Stadt. Importiere pandas und NumPy unter ihren üblichen Kurznamen.

import pandas as pd
import numpy as np
rain = pd.Series([4.5, 3.0, 6.2],
                 index=["Mon", "Tue", "Wed"], name="rain_mm")

Werte und Bezeichnungen auslesen

Die Werte sind 4.5, 3.0 und 6.2; der Index lautet Mon, Tue und Wed. Ohne index= vergibt pandas die Bezeichnungen 0, 1 und 2. Ein Dictionary liefert beides zugleich: pd.Series({"Lima": 10, "Oslo": 5, "Pune": 7}) übernimmt die Bezeichnungen von den Schlüsseln in deren Reihenfolge im Dictionary.

Attribute beschreiben die Series ohne Klammern: rain.index enthält die Bezeichnungen, rain.dtype ist float64, rain.name ist "rain_mm" und rain.size ist 3. Verwende rain.to_numpy(), wenn ein NumPy-Array benötigt wird. Das ältere .values gibt je nach Datentyp unterschiedliche Arten von Arrays zurück; bei Textdaten kann es ein pandas-Array liefern.

Ein Datentyp gibt pandas an, welche Art von Werten gespeichert wird. Häufige Typen sind int64 für ganze Zahlen, float64 für Dezimalzahlen, bool für True/False, str für Text und datetime64 für Datums- und Zeitangaben. pandas 3 ermittelt für Text den Typ str; ältere Beispiele zeigen oft object.

Mit der ganzen Series arbeiten

Für s = pd.Series([10, 20, 30], index=["a", "b", "c"]) erzeugt s * 2 die Werte 20, 40 und 60. s > 15 erzeugt False, True und True. Beide behalten die Bezeichnungen bei. Diese Operationen sind vektorisiert: Ein Ausdruck bearbeitet die ganze Series ohne Python-Schleife.

Schlage eine Bezeichnung mit s["b"] nach; das ergibt 20. Schlage eine Position mit s.iloc[0] nach; das ergibt 10. Der Ausdruck "b" in s prüft den Index; 20 in s ist False. Auch eine Ganzzahl in eckigen Klammern ist eine Bezeichnung: Beim Index [2, 0, 1] meint s[0] die Bezeichnung 0 und nicht den ersten Eintrag. Bei Textbezeichnungen löst s[0] in pandas 3 einen KeyError aus.

Bezeichnungen bei der Arithmetik zuordnen

a = pd.Series([1, 2, 3], index=["x", "y", "z"])
b = pd.Series([10, 20, 30], index=["y", "z", "w"])
a + b

Die gemeinsame Bezeichnung y verbindet 2 und 10 zu 12.0; z verbindet 3 und 20 zu 23.0. Die Bezeichnungen w und x kommen nur in einer Eingabe vor und erhalten daher NaN. Das Ergebnis enthält alle vier Bezeichnungen. Eine Addition nach der sichtbaren Zeilenposition würde fälschlich 11, 22 und 33 ergeben.

Verwende a.add(b, fill_value=0), wenn ein fehlender Wert als null zählen soll. Die Ergebnisse sind w 30.0, x 1.0, y 12.0 und z 23.0. Verwandte Methoden sind sub, mul und div.

Fehlende Werte erkennen

Ein fehlender Gleitkomma- oder str-Wert verwendet NaN; ein fehlender Datums- und Zeitwert verwendet NaT; eine fehlende Ganzzahl mit Fehlwertunterstützung verwendet <NA>. pd.Series([1, None, 3]) wird zu float64 und zeigt 1.0, NaN und 3.0 an, weil das gewöhnliche int64 kein NaN aufnehmen kann.

Ein DataFrame ist eine zweidimensionale Tabelle. Jede Zeile erfasst eine Beobachtung, etwa eine Bestellung; jede Spalte enthält eine Variable, etwa eine Menge. Spalten können unterschiedliche Datentypen haben, teilen sich aber denselben Zeilenindex.

Eine Tabelle aus Python-Daten erstellen

df = pd.DataFrame({
    "product": ["Notebook", "Desk lamp", "Pen set", "Mug"],
    "quantity": [3, 1, 2, 4],
    "unit_price": [2.50, 18.00, 4.75, 6.00]
})

Jeder Dictionary-Schlüssel wird zu einem Spaltennamen; jede Liste liefert die Werte dieser Spalte. Die Listen müssen gleich lang sein, damit jede Zeile in jeder Spalte einen Platz hat. Hier lauten die Indexbezeichnungen 0 bis 3. Unterschiedlich lange Listen lösen einen ValueError aus.

Eine Liste von Dictionaries liefert dagegen ein Dictionary pro Zeile. pd.DataFrame([{"a": 1, "b": 2}, {"a": 3, "c": 4}]) erstellt die Spalten a, b und c. Das fehlende b in der zweiten Zeile und das fehlende c in der ersten werden zu NaN, sodass diese Spalten float64 verwenden. Auch ein zweidimensionales NumPy-Array kann Werte liefern; columns=[...] benennt dabei die Spalten.

Die Dimensionen der Tabelle auslesen

df.shape ist (4, 3): vier Zeilen und drei Spalten, in dieser Reihenfolge. len(df) ist 4, während df.size gleich 12 ist, weil es Zellen zählt. df.index enthält Zeilenbezeichnungen, df.columns enthält Spaltenbezeichnungen und df.dtypes gibt einen Datentyp pro Spalte aus. Dies sind Attribute: df.shape() versucht, ein Tupel aufzurufen, und löst einen TypeError aus. df.T vertauscht Zeilen und Spalten.

Eine Series oder eine Tabelle erhalten

Die innere Liste fordert eine Sammlung von Spalten an. Ohne sie übergibt df["product", "unit_price"] einen einzelnen Tupelschlüssel, der keinem der gewöhnlichen Spaltennamen entspricht, und löst einen KeyError aus.

Eckige Klammern funktionieren auch, wenn Namen Leerzeichen enthalten oder mit Methoden kollidieren. Die Punktschreibweise wie df.quantity funktioniert nur bei geeigneten Namen. Eine Spalte namens size benötigt df["size"], weil df.size die Zellenanzahl der Tabelle bezeichnet. Erstelle Spalten ebenfalls mit eckigen Klammern: df["total"] = 5 fügt eine Spalte hinzu, df.total = 5 hingegen nicht.

Eine Achse wählen

Für numbers = pd.DataFrame({"a": [1, 2], "b": [3, 4]}) addiert numbers.sum() entlang der Zeilen und ergibt a 3 und b 7. Dies ist axis=0, auch "index" genannt. numbers.sum(axis=1) addiert über jede Zeile hinweg und ergibt 4 und 6; diese Achse heißt auch "columns". Benenne zuerst das benötigte Ergebnis: eine Summe pro Spalte oder eine Summe pro Zeile.

Die Auswahl einer Zeile erzeugt eine Series, deren Bezeichnungen die Spaltennamen sind. Diese Series benötigt einen Datentyp, der jede Zelle der Zeile aufnehmen kann. Eine Zeile mit Ganz- und Gleitkommazahlen wird zu float64; eine Zeile mit Text und Zahlen wird zu object. Die ursprünglichen Spalten behalten ihre jeweiligen Datentypen.

Zeilenbezeichnungen können eine Bedeutung tragen, etwa eine Bestellnummer, oder einfach die aktuellen Zeilen bezeichnen. Ein nützlicher Index macht Abfragen und spätere Ergebnisse leichter interpretierbar. Das Ändern von Bezeichnungen gibt eine neue Tabelle zurück; behalte das Ergebnis daher durch eine Zuweisung.

Eine ID in den Index verschieben

orders = pd.DataFrame({
    "order_id": [1001, 1002, 1003],
    "product": ["Notebook", "Desk lamp", "Pen set"],
    "unit_price": [2.50, 18.00, 4.75]
})
orders_by_id = orders.set_index("order_id")

Die ursprüngliche Tabelle hat einen standardmäßigen RangeIndex: 0, 1 und 2. Die neue Tabelle hat die Bezeichnungen 1001, 1002 und 1003. order_id wurde aus den Spalten in den Index verschoben. orders_by_id.loc[1002] identifiziert nun die Zeile mit Desk lamp anhand ihrer ID.

Der Aufruf orders.set_index("order_id") ohne Speichern des Ergebnisses lässt orders unverändert. Eine erneute Zuweisung wie orders = orders.set_index("order_id") behält die neue Struktur. In pandas 3.1 ist inplace= für diese Methoden zum Ändern von Bezeichnungen und für das Sortieren veraltet; verwende eine Zuweisung.

Bezeichnungen zurück in eine Spalte verschieben

orders_by_id.reset_index() stellt order_id als gewöhnliche Spalte wieder her und erstellt einen neuen RangeIndex. Ein unbenannter Index wird zu einer Spalte namens index. So bleibt die alte Zeilenidentität erhalten.

reset_index(drop=True) verwirft die alten Bezeichnungen. Bei einem Index [10, 20, 30] behält das einfache reset_index() diese Zahlen in einer Spalte index; reset_index(drop=True) verwirft sie und verwendet 0, 1 und 2. Entscheide nach dem Filtern oder Sortieren, ob die alten Bezeichnungen nützlich sind, bevor du sie verwirfst. Die Neunummerierung des Index ändert weder die Datenwerte noch macht sie eine Sortierung rückgängig.

Bezeichnungen umbenennen oder entfernen

renamed = orders.rename(columns={"unit_price": "price"})
short = orders.drop(columns=["product"])
remaining = orders.drop(index=[0, 1])

rename ordnet alten Bezeichnungen neue zu und behält nicht aufgeführte Namen bei. Standardmäßig wird ein falsch geschriebener alter Name ignoriert. Untersuche daher .columns, wenn eine Umbenennung nichts bewirkt zu haben scheint. Um jeden Spaltennamen zu ersetzen, weise orders.columns eine vollständige Liste zu; ihre Länge muss der Spaltenanzahl entsprechen.

drop(columns=...) entfernt Spalten; drop(index=...) entfernt Zeilen anhand ihrer Bezeichnung. Eine fehlende Bezeichnung löst einen KeyError aus. Nach dem Sortieren ist die Bezeichnung 0 möglicherweise nicht mehr die erste Zeile: Ihr Entfernen löscht weiterhin die Zeile mit der Bezeichnung 0.

Wähle eine Liste aus, um die Spaltenreihenfolge festzulegen: orders = orders[["order_id", "unit_price", "product"]]. Spalten, die in dieser Liste fehlen, werden aus dem Ergebnis entfernt.

Prüfen, ob eine ID wirklich eine Zeile identifiziert

Indexbezeichnungen können mehrfach vorkommen. Prüfe orders_by_id.index.is_unique, bevor du sie als eindeutige IDs behandelst. Kommt die Bezeichnung 1002 zweimal vor, gibt .loc[1002] beide Zeilen als DataFrame zurück. Bei eindeutigen Bezeichnungen gibt dieselbe Abfrage mit einer einzelnen Bezeichnung eine Series zurück.

Ein aussagekräftiger Index verbessert auch Zusammenfassungen. In einer Wettertabelle mit Tagen als Index gibt weather["temp_c"].idxmax() einen Tag wie "Thu" aus; bei einem Standardindex gibt es eine Zeilennummer aus.

Eine CSV-Datei speichert eine Tabelle als Text: Datensätze stehen in Zeilen und ein Trennzeichen trennt die Felder. Die erste Zeile enthält oft Spaltennamen. Um die Datei richtig zu laden, musst du sowohl ihren Aufbau als auch die Bedeutung ihrer Werte erkennen.

Die Bestelltabelle laden

orders = pd.read_csv("orders.csv")

Ein relativer Pfad wird vom aktuellen Arbeitsverzeichnis von Python aus aufgelöst. Ein falscher Speicherort löst einen FileNotFoundError aus. Auch ein absoluter Pfad oder eine URL kann an read_csv übergeben werden.

Die Beispiele verwenden diese Datei. Die letzte Zeile hat ein leeres Mengenfeld.

order_id,date,product,category,quantity,unit_price
1001,2026-03-02,Notebook,Stationery,3,2.50
1002,2026-03-02,Desk lamp,Home,1,18.00
1003,2026-03-03,Pen set,Stationery,2,4.75
1004,2026-03-04,Mug,Home,4,6.00
1005,2026-03-04,Backpack,Bags,1,35.00
1006,2026-03-05,Notebook,Stationery,,2.50

Mit den Standardeinstellungen hat das Ergebnis die Form (6, 6) und die Indexbezeichnungen 0 bis 5. pandas ermittelt die Datentypen: order_id ist int64, unit_price ist float64, und auch quantity wird zu float64, weil das leere Feld zu NaN wird. Die anderen Spalten einschließlich date sind str. Eine wie ein Datum aussehende Zeichenkette bleibt Text, bis sie umgewandelt wird.

Den Aufbau der Datei berücksichtigen

Verwende für eine Datei mit den Zeilen a;b, 1,5;2 und 3,0;4 den Aufruf pd.read_csv("file.csv", sep=";", decimal=","). Spalte a enthält dann 1.5 und 3.0. Das Standardtrennzeichen Komma erzeugt eine Spalte namens a;b: ein Hinweis darauf, das Trennzeichen zu prüfen.

index_col="order_id" macht diese Spalte beim Laden zum Zeilenindex. thousands="," liest ein Feld wie "1,200" als 1200 ein; in einer kommagetrennten Datei muss das Feld durch CSV-Anführungszeichen maskiert werden, damit sein internes Komma nicht als weiteres Trennzeichen gilt.

Bei der Typinferenz die Bedeutung erhalten

Codes wie "001" sind Kennungen und keine Mengen. dtype={"id": str} erhält ihre führenden Nullen. Wandelt pandas sie zuerst in 1 um, kann eine Rückumwandlung dieser Zahl in Text nicht wiederherstellen, wie viele Nullen die Datei enthielt.

Leere Felder und gängige Kennzeichen wie NA, N/A, NULL, NaN und None gelten standardmäßig als fehlend. Ergänze ein besonderes Kennzeichen der Datei mit na_values=["-"]. Dies sind Regeln für das Laden. Prüfe daher die Konventionen der Datei, wenn ein Code wie ein Fehlwertkennzeichen aussieht.

Verwende parse_dates=["date"], um die Beispieldaten als Datums- und Zeitwerte einzulesen. In pandas 3 verwenden diese Daten eine Auflösung in Mikrosekunden, datetime64[us]. UTF-8 ist die Standardzeichenkodierung. Ein UnicodeDecodeError ist ein Anlass, die Kodierung der Datei zu prüfen und die passende Option anzugeben, etwa encoding="latin-1".

Ein erfolgreicher Lesevorgang bedeutet, dass pandas die Datei einlesen konnte. Er belegt nicht, dass Spalten, Datentypen und fehlende Werte zu dem passen, was die Tabelle darstellen soll. Untersuche den neuen DataFrame, bevor du damit rechnest.

Sichtbare Zeilen und Dimensionen prüfen

orders.head(3)
orders.tail()
orders.shape
orders.columns.tolist()

head() zeigt standardmäßig fünf Zeilen; head(3) zeigt drei. tail() prüft das Ende, an dem ein Export andere Datensätze enthalten kann. sample(3, random_state=0) liefert eine reproduzierbare Zufallsstichprobe aus drei Zeilen. In einem Notebook wird der letzte Ausdruck einer Zelle automatisch angezeigt; verwende andernorts print.

Die Bestelldatei sollte sechs Zeilen und sechs Spalten enthalten. Eine Vorschau sollte benannte Spalten und die erste Bestellung als Daten zeigen. Erscheint der erste Datensatz unter den Spaltennamen, fehlt der Datei wahrscheinlich eine Kopfzeile und sie benötigt header=None. Steht alles in einer einzigen breiten Spalte, prüfe sep.

Spaltennamen müssen genau übereinstimmen, einschließlich Groß- und Kleinschreibung und Leerzeichen. orders["Product"] schlägt fehl, wenn der Name product lautet. Durch die Untersuchung der Liste lassen sich angehängte Leerzeichen leichter erkennen. orders.columns = orders.columns.str.strip() entfernt Leerzeichen an den Enden der Kopfzeilennamen.

Den Aufbau mit info auslesen

orders.info() gibt den Indexbereich, den Namen jeder Spalte, die Anzahl vorhandener Werte, den Datentyp und den Speicherbedarf aus. Im Beispiel mit sechs Zeilen hat quantity fünf nicht fehlende Werte; die anderen Spalten haben jeweils sechs. Die Datentypen umfassen zwei Gleitkommaspalten, eine Ganzzahlspalte und drei str-Spalten. orders.dtypes liefert eine kompakte Typenliste.

Eine numerisch aussehende Spalte mit dem Datentyp str solltest du untersuchen: Ein Eintrag wie "unknown", eine Einheit wie "12 kg" oder ein nicht berücksichtigtes Tausendertrennzeichen kann die Erkennung als numerischer Typ verhindern. Auch Datumsangaben bleiben Text, sofern sie nicht umgewandelt werden. Entscheide anhand der Bedeutung der Spalte über den benötigten Typ, nicht allein anhand ihres Aussehens in einer Vorschau.

Lücken und wiederholte Werte zählen

orders.isna().sum()
orders.isna().any(axis=1).sum()
orders.nunique()

isna() erstellt eine boolesche Tabelle: True markiert eine fehlende Zelle. Die Summe entlang jeder Spalte zählt diese Zellen. Quantity hat einen fehlenden Wert und jede andere Spalte null. Um betroffene Zeilen zu zählen, prüft .any(axis=1) zunächst, ob jede Zeile irgendeine Lücke hat; anschließend zählt .sum() diese Zeilen. Würdest du stattdessen alle Spaltenanzahlen addieren, könnte eine Zeile mehrfach gezählt werden.

nunique() zählt unterschiedliche vorhandene Werte: Die Bestellungen haben sechs IDs, vier Daten, fünf Produkte, drei Kategorien, vier Mengen und fünf Preise. Vergleiche die Anzahl der IDs mit der Zeilenanzahl, um die Eindeutigkeit zu prüfen, und berücksichtige dabei auch die Anzahl fehlender IDs. orders.duplicated(subset="product") markiert die zweite Notebook-Zeile mit der Bezeichnung 5 als Wiederholung. Ein wiederholtes Produkt ist hier zulässig; eine wiederholte Bestell-ID müsste untersucht werden.

Einen schnellen numerischen Überblick auslesen

orders.describe() gibt Anzahl, arithmetisches Mittel, Standardabweichung, Minimum, Quartile und Maximum für numerische Spalten aus. Die Anzahl von quantity ist fünf, sodass ihr arithmetisches Mittel fünf erfasste Mengen zusammenfasst. Prüfe neben den Datentypen auch plausible Wertebereiche und Einheiten: Eine Spalte kann numerisch sein und dennoch einen Eingabefehler enthalten. Halte bei der Prüfung neu geladener Daten die festgestellte Zeilenanzahl, Spaltenanzahl, die Datentypen, die Anzahlen fehlender Werte und die ID-Prüfung zusammen fest.

Der Datentyp einer Spalte bestimmt, welche Operationen sinnvoll sind. Eine Textspalte mit "12" speichert weiterhin Text; ihr arithmetisches Mittel lässt sich nicht wie bei einer numerischen Spalte berechnen. Wandle bewusst um und weise das Ergebnis der Tabelle wieder zu.

Strikte Umwandlung oder Typumwandlung mit Fehlerersetzung wählen

astype wandelt eine Series in einen angegebenen Typ um, etwa int, float, str oder "Int64". Die Umwandlung schlägt fehl, wenn ein Wert im gewünschten Typ nicht dargestellt werden kann.

raw = pd.Series(["12", "7", "n/a", "3.5"])
numeric = pd.to_numeric(raw, errors="coerce")

raw.astype(float) löst bei "n/a" einen ValueError aus. Mit errors="coerce" lauten die Ausgabewerte 12.0, 7.0, NaN und 3.5. Der nicht umwandelbare Eintrag wird zu einem fehlenden Wert, statt die Umwandlung zu stoppen. Vergleiche raw.isna().sum() mit numeric.isna().sum(): Aus null fehlenden Werten wurde einer, womit ein zu prüfender Wert sichtbar wird.

Die Fehlerersetzung ist eine Umwandlungsregel und kein Beleg dafür, dass jede neue Lücke harmlos ist. Nutze die Anzahlen vor und nach der Umwandlung, um Verluste zu finden. Speichere die Umwandlung in einer neuen Variablen oder Spalte, wenn der Rohtext nützlich ist, um einen nicht umgewandelten Wert zurückzuverfolgen.

Fehlende ganze Zahlen erhalten

Die Bestellspalte quantity enthält ganze Zahlen und ein NaN, daher ist sie float64. Das einfache astype(int) schlägt fehl, weil NaN keine gewöhnliche Ganzzahldarstellung hat.

orders["quantity"] = orders["quantity"].astype("Int64")

Das große I ist entscheidend: Int64 mit Fehlwertunterstützung behält die Lücke als <NA>, während es die bekannten Werte als ganze Zahlen speichert. Diese Wahl passt zu Anzahlen mit fehlenden Einträgen. Sie macht eine tatsächlich gebrochene Mengenangabe nicht zu einer gültigen ganzzahligen Anzahl.

Auch Tausendertrennzeichen in Text müssen behandelt werden. pd.Series(["1,200", "950"]).str.replace(",", "").astype(int) ergibt 1200 und 950. Verwendet die Datei selbst diese Konvention, kann thousands="," sie beim Einlesen berücksichtigen.

Datumstext umwandeln

orders["date"] = pd.to_datetime(orders["date"])
orders["date"].dt.day_name()

Die Umwandlung ermöglicht .dt.year, .dt.month, .dt.day und .dt.day_name(). Für die sechs Bestelldaten lauten die Tagesnamen Monday, Monday, Tuesday, Wednesday, Wednesday und Thursday. Der alleinige Aufruf von pd.to_datetime(orders["date"]) erzeugt eine umgewandelte Series, lässt die ursprüngliche Spalte aber als Text bestehen. Erst die Zuweisung behält das Ergebnis.

Wiederholte Kategorien speichern

orders["category"].astype("category") speichert wiederholte Bezeichnungen über eine Menge erlaubter Kategorien. Bei großen Tabellen spart dies meist Speicher. Weise das Ergebnis zu, um es zu behalten, genau wie bei anderen Umwandlungen.

Der kategoriale Datentyp verändert einige Operationen. Seine Kategorien sind standardmäßig ungeordnet, daher lösen min() und max() einen TypeError aus. value_counts() einer kategorialen Spalte führt auch bekannte Kategorien auf, die in einer gefilterten Auswahl fehlen, und gibt für sie die Anzahl null an. Der kategoriale Datentyp ist für wiederholte Bezeichnungen nützlich, verändert aber neben der Speicherung auch das Verhalten.

Mit Bezeichnungen kannst du eine Zeile oder Spalte anhand ihrer Bedeutung auswählen. Bei loc identifiziert eine Bestellnummer eine Zeile auch dann, wenn die Tabelle sortiert wurde. Die Auswahl besteht aus einem Zeilenteil, gefolgt von einem Spaltenteil: df.loc[rows, columns].

Von einem aussagekräftigen Index ausgehen

Die Bestelldatei hat sechs Zeilen mit den IDs 1001 bis 1006. Erstelle orders_by_id = orders.set_index("order_id"). Die Spalten lauten der Reihe nach date, product, category, quantity und unit_price. Die Zeilenbezeichnungen sind Bestellnummern, nicht die Positionen 0 bis 5.

orders_by_id.loc[1003]
orders_by_id.loc[1004, "product"]

Der erste Ausdruck gibt Bestellung 1003 als Series zurück: date "2026-03-03", product "Pen set", category "Stationery", quantity 2.0 und Preis 4.75. Die Series trägt den Namen 1003. Der zweite Ausdruck gibt eine Zelle zurück: "Mug".

Eine fehlende Bezeichnung löst einen KeyError aus. orders_by_id.loc[0] schlägt fehl: Eine erste Zeile an Position 0 erzeugt keine Bezeichnung 0.

Mehrere Bezeichnungen auswählen

orders_by_id.loc[[1001, 1005], ["product", "unit_price"]]

Listen wählen Bezeichnungen in der angeforderten Reihenfolge aus. Dies ergibt zwei Zeilen und zwei Spalten: Notebook zu 2.5, dann Backpack zu 35.0. Eine Liste erhält ein tabellenförmiges Ergebnis, auch wenn sie nur eine Bezeichnung enthält: .loc[[1003]] ist ein DataFrame mit einer Zeile.

Ein Doppelpunkt allein bedeutet alle Bezeichnungen entlang dieser Achse. Lässt du die Spaltenauswahl weg, werden ebenfalls alle Spalten angefordert.

Beide Endpunkte eines bezeichnungsbasierten Slice einschließen

orders_by_id.loc[1002:1004, "product":"quantity"]

Bei diesem geordneten Index sind die Zeilen 1002, 1003 und 1004. Der Spalten-Slice schließt product, category und quantity ein. Sowohl die Endbezeichnung der Zeilen als auch die der Spalten ist enthalten, sodass die Form (3, 3) ist. Würdest du hier Pythons übliche Regel anwenden, nach der der Endpunkt ausgeschlossen ist, würdest du eine vorgesehene Zeile und Spalte auslassen.

Bezeichnungen bleiben beim Sortieren erhalten

Ein Standardindex kann den Unterschied zwischen Bezeichnung und Position verbergen. Angenommen, das Sortieren von Punktzahlen ergibt die Zeilenbezeichnungen 3, 0, 2, 1, 4. .loc[0] wählt weiterhin die Bezeichnung 0 aus, nun die zweite angezeigte Zeile. .iloc[0] wählt die oberste angezeigte Zeile mit der Bezeichnung 3. Beim Sortieren wird eine Zeile zusammen mit ihrer Bezeichnung verschoben; der Index wird nicht stillschweigend neu nummeriert.

Eine Bedingung mit der Spaltenauswahl verbinden

Die Zeilenauswahl kann eine boolesche Series sein:

orders.loc[orders["unit_price"] > 5, ["product", "unit_price"]]

Dies behält Desk lamp zu 18.0, Mug zu 6.0 und Backpack zu 35.0 und gibt nur die beiden angeforderten Spalten zurück. Die Maske bestimmt, welche Zeilen die Bedingung erfüllen; die Spaltenliste bestimmt, was angezeigt wird. Dieselbe Form mit zwei Achsen kann Zellen für eine Aktualisierung auswählen, indem die Auswahl auf der linken Seite einer Zuweisung steht.

Verwende iloc, wenn es darauf ankommt, an welcher Stelle eine Zeile oder Spalte steht: die ersten drei Zeilen, die letzte Spalte oder eine bestimmte angezeigte Zelle. Die Auswahl erfolgt über ganzzahlige Positionen, unabhängig von den Indexbezeichnungen.

Bei null anfangen zu zählen

orders.iloc[0] wählt die erste Zeile und orders.iloc[-1] die letzte aus. Eine negative Position zählt vom Ende rückwärts. Zwei Positionen wählen eine Zelle aus: orders.iloc[2, 2] ist "Pen set" in der ursprünglichen Bestelltabelle, in der product an Spaltenposition 2 steht.

Die Tabelle orders_by_id mit geändertem Index hat die Spalten date, product, category, quantity und unit_price. Durch das Verschieben von order_id in den Index haben sich die Spaltenpositionen geändert, sodass product nun an Position 1 steht. Positionsbasierter Code hängt von diesem Aufbau ab.

Vor dem Endpunkt eines Slice aufhören

orders_by_id.iloc[1:3, 0:2]

Ausgewählt werden die Zeilenpositionen 1 und 2 mit den Bestellungen 1002 und 1003. Die Spaltenpositionen sind 0 und 1, also date und product. Position 3 und Spalte 2 sind ausgeschlossen; die Form ist damit (2, 2). Eine ausgelassene Anfangsposition steht für den Beginn des Bereichs, eine ausgelassene Endposition für sein Ende.

Listen fordern bestimmte Positionen an, auch eine Mischung aus positiven und negativen. orders.iloc[[0, -1], [2, 5]] wählt product und unit_price für die erste und letzte Bestellung aus. Beide sind zufällig Notebook zu 2.5.

Die Form des Ergebnisses vorhersagen

Ein Skalar wählt ein Element entlang einer Achse aus und entfernt diese Dimension. Ein Slice oder eine Liste erhält die Achse, auch wenn nur ein Element ausgewählt wird. Das ist wichtig, wenn die nächste Operation eine Tabelle statt einer Series erwartet.

Das Ende einer Tabelle berücksichtigen

Die Bestelltabelle mit sechs Zeilen hat die gültigen nicht negativen Zeilenpositionen 0 bis 5. orders.iloc[10] löst einen IndexError aus. Ein Slice kann über die Tabelle hinausreichen: orders.iloc[4:100] gibt einfach die letzten zwei Zeilen zurück. Eine einzelne nicht vorhandene Position ist eine ungültige Anforderung eines Elements, während ein Slice einen Bereich beschreibt, der auf die verfügbaren Zeilen begrenzt wird.

Bewusst zwischen Bezeichnungen und Positionen wählen

Für eine einzelne Zelle verwendet at Bezeichnungen und iat Positionen. orders.at[2, "product"] und orders.iat[2, 2] ergeben beide "Pen set", bevor die Zeilen neu angeordnet werden.

Wähle loc, wenn du eine ID oder die Bedeutung einer Spalte kennst. Wähle iloc, wenn die Position selbst wichtig ist. Um die ersten Zeilen mit einem Spaltennamen zu kombinieren, gibt orders.columns.get_loc("quantity") dessen Position 4 zurück, sodass du orders.iloc[0:3, 4] verwenden kannst.

Einfache eckige Klammern können ihre Rolle wechseln: orders["product"] wählt eine Spalte aus, aber orders[2:4] wählt die Zeilenpositionen 2 und 3 als Slice aus. Mit ausdrücklich angegebenem loc und iloc ist diese Wahl leichter zu erkennen.

Beim Filtern wählst du Beobachtungen aus, die eine Frage beantworten, etwa welche Bestellungen zu Home gehören und pro Artikel mehr als 10 kosten. Erstelle zuerst eine boolesche Maske, eine Series mit einem True oder False pro Zeile. Verwende sie dann, um die passenden Zeilen auszuwählen.

Eine Maske erstellen und anwenden

is_stationery = orders["category"] == "Stationery"
stationery = orders[is_stationery]

Die Maske lautet True, False, True, False, False und True. Die Auswahl behält die Bezeichnungen 0, 2 und 5, die den Bestellungen 1001, 1003 und 1006 entsprechen. Das Filtern erhält diese Bezeichnungen und nummeriert sie nicht neu. reset_index(drop=True) erzeugt bei Bedarf fortlaufende Bezeichnungen.

Zu den Vergleichsoperatoren gehören ==, !=, <, <=, > und >=. Textvergleiche müssen genau übereinstimmen: "home" unterscheidet sich von "Home", und auch Leerzeichen können eine Übereinstimmung verhindern.

Bedingungen zeilenweise verknüpfen

is_home = orders["category"] == "Home"
is_expensive = orders["unit_price"] > 10
orders[is_home & is_expensive]

Nur die Desk lamp erfüllt die Bedingung: Ihre Kategorie ist Home und ihr Preis beträgt 18.0. Der Mug gehört zu Home, kostet aber 6.0. Backpack kostet 35.0, gehört aber zu Bags.

Wenn du Vergleiche direkt schreibst, setze jeden in Klammern:

orders[(orders["category"] == "Home") &
       (orders["unit_price"] > 10)]

Verwende & für und, | für oder und ~ für nicht. Die Klammern halten jeden Vergleich zusammen, bevor pandas die Masken verknüpft. Ohne sie kann Python aufgrund seiner Vorrangregeln versuchen, eine Zeichenkette und eine Series mit & zu verknüpfen, und einen TypeError auslösen.

Pythons and, or und not erwarten einen einzelnen Wahrheitswert und keine Spalte von Wahrheitswerten. Ihre Verwendung auf Masken löst einen ValueError wegen eines mehrdeutigen Wahrheitswerts aus. Ein einfaches if orders["quantity"] > 1: hat dasselbe Problem. Verwende .any(), um zu fragen, ob irgendeine Zeile zutrifft, oder .all(), um zu fragen, ob jede Zeile zutrifft.

Treffer und Anteile zählen

is_stationery.sum() ist 3, weil True als 1 und False als 0 zählt. is_stationery.mean() ist 0.5, der Anteil der sechs Bestellungen, die zutreffen. Multipliziere mit 100, um diesen Anteil als 50 % auszudrücken.

Fehlende Werte ausdrücklich behandeln

Bei der ursprünglichen float64-Spalte quantity ergeben Vergleiche mit NaN False, außer !=, das True ergibt. quantity >= 1 behält fünf Zeilen; quantity < 1 behält keine. Die leere Mengenangabe ist in keiner der beiden Auswahlen enthalten. Dennoch schließt quantity != 3 diese Zeile mit leerem Wert ein. Ungleich bedeutet also nicht bekannt und verschieden.

Nach der Umwandlung in Int64 mit Fehlwertunterstützung ergibt ein Vergleich mit <NA> den Wert <NA>, und beim Filtern werden diese Zeilen ausgelassen. Verwende isna() oder notna(), wenn es um Lücken geht.

Um neben Zeilen auch Spalten auszuwählen, verwende orders.loc[is_home, "product"]. Der Aufruf gibt Desk lamp und Mug zurück. Eine benannte Maske kann wiederverwendet werden, um dieselben Zeilen zu untersuchen, zu zählen und zu aktualisieren.

Manche Filter haben vertraute Formen: Zugehörigkeit zu einer Liste, ein numerisches Intervall, ein fehlender Wert oder ein Textfragment. Hilfsmethoden drücken diese Tests direkt aus und erzeugen weiterhin Masken, die sich mit anderen Bedingungen verknüpfen lassen.

Zugehörigkeit und Wertebereiche prüfen

orders[orders["category"].isin(["Home", "Bags"])]
orders[orders["unit_price"].between(4.75, 18)]

isin trifft auf jeden aufgeführten Wert zu. Die erste Auswahl enthält die Bestellungen 1002, 1004 und 1005. ~orders["category"].isin(["Home"]) kehrt die Zugehörigkeit um und behält Zeilen mit Stationery und Bags. Ein Python-Ausdruck mit in erzeugt diese zeilenweise Zugehörigkeitsmaske nicht.

between schließt standardmäßig beide Endpunkte ein. Die zweite Auswahl enthält Desk lamp zu 18.0, Pen set zu 4.75 und Mug zu 6.0. Verwende inclusive="neither", um beide Endpunkte auszuschließen, "left", um nur den unteren Endpunkt einzuschließen, oder "right", um nur den oberen Endpunkt einzuschließen. Wähle die Regel für die Endpunkte passend zur gestellten Frage.

Fehlende und vorhandene Einträge finden

orders[orders["quantity"].isna()] behält Bestellung 1006. notna() bewirkt das Gegenteil und behält erfasste Mengen. Prüfe nicht auf Gleichheit mit np.nan: NaN ist selbst zu sich selbst ungleich, sodass quantity == np.nan die Zeile mit fehlendem Wert nicht findet.

Innerhalb von Text suchen

orders[orders["product"].str.contains("note", case=False, na=False)]

str.contains prüft, ob jeder Textwert eine Übereinstimmung enthält. Ohne Berücksichtigung der Groß- und Kleinschreibung werden beide Notebook-Zeilen gefunden. na=False lässt fehlenden Text als Nichtübereinstimmung zählen. Die Suche behandelt ihr Muster standardmäßig als regulären Ausdruck; bei einem wörtlichen Textfragment mit Satzzeichen verhindert regex=False, dass diese Satzzeichen als Muster interpretiert werden. str.startswith und str.endswith prüfen Anfang und Ende.

Einen Filter als Abfrage schreiben

orders.query("quantity >= 2 and unit_price < 5")

Dies behält die Bestellungen 1001 und 1003. Innerhalb einer query-Zeichenkette stehen Spaltennamen für Spalten und and, or und not sind erlaubt. Die Zeichenkette ist ein pandas-Abfrageausdruck; ihre Syntax entspricht nicht der direkten Verknüpfung von Series in gewöhnlichem Python.

Eine Python-Variable benötigt @:

limit = 5
orders.query("unit_price > @limit")

Das Ergebnis enthält Desk lamp, Mug und Backpack. Ein Spaltenname mit Leerzeichen benötigt innerhalb der Abfrage Graviszeichen, wie in orders.query("`unit price` > 5").

Dieselbe Frage lässt sich als Maske, Hilfsmethodenaufruf oder Abfrage schreiben. Bevorzuge die Form, die die Regel klar erkennen lässt. Für ein Intervall stellt between die Schranken und die Regel für ihren Einschluss zusammen dar. Für eine Menge erlaubter Bezeichnungen vermeidet isin wiederholte Gleichheitstests. Verhält sich ein Filter unerwartet, untersuche die Maske und die genauen Spaltenwerte, bevor du die Bedingung änderst.

Eine Aktualisierung muss auf die Tabelle zielen, die du ändern möchtest. In pandas 3 verhält sich eine Auswahl unter Copy-on-Write wie ein separates Objekt. Eine Änderung am ausgewählten Objekt ändert daher seine Ursprungstabelle nicht.

Das gesamte Ziel in eine loc-Zuweisung setzen

sale = orders.copy()
is_home = sale["category"] == "Home"
sale.loc[is_home, "unit_price"] *= 0.9

Die Maske wählt zwei Home-Zeilen aus. Die Spaltenauswahl zielt auf deren Preise. Die Multiplikation mit 0,9 behält 90 % jedes Preises bei und senkt 18,00 auf 16,20 und 6,00 auf 5,40. Andere Zeilen bleiben unverändert. Die ausgeschriebene Form liest rechts dieselbe Auswahl aus und weist links ihre multiplizierten Werte zu.

Hier ist sale eine separate Tabelle für eine Preisänderung, sodass orders für den Vergleich verfügbar bleibt. Um die ursprüngliche Tabelle zu aktualisieren, setze orders.loc[...] selbst auf die linke Seite der Zuweisung.

Verkettete Zuweisung vermeiden

orders[orders["category"] == "Home"]["unit_price"] = 0

Dies verwendet zwei Indizierungsschritte. Der erste erzeugt ein ausgewähltes Objekt; der zweite weist diesem Objekt einen Wert zu. In pandas 3 aktualisiert dies niemals orders, und eine ChainedAssignmentError-Warnung weist auf das Problem hin. Dasselbe Problem betrifft orders["unit_price"][1] = 0.

Verwende orders.loc[orders["category"] == "Home", "unit_price"] = 0, wenn die ursprüngliche Tabelle geändert werden soll. Tabelle, passende Zeilen und Spalte werden alle in einer Zuweisung angegeben.

Ausgewählte Tabellen verstehen

Nach home = orders[orders["category"] == "Home"] ändert eine Änderung an home["unit_price"] nur home. Spätere Änderungen an orders ändern ebenfalls nicht home. Die Objekte können sich intern Speicher teilen, bis ein Schreibvorgang nötig wird, aber ihre sichtbaren Werte verhalten sich unabhängig voneinander.

Ältere pandas-Beispiele zeigen möglicherweise eine SettingWithCopyWarning und verwenden nach einer Auswahl .copy(), um unsichere Aktualisierungen zu vermeiden. pandas 3 hat diese Warnung entfernt und sorgt einheitlich dafür, dass sich Auswahlen unabhängig verhalten. Ein ausdrückliches .copy() ist weiterhin nützlich, um die Absicht deutlich zu machen, aber eine Auswahl verhält sich bei Aktualisierungen bereits unabhängig.

Werte auf der rechten Seite dem Ziel zuordnen

Ein Skalar füllt alle ausgewählten Zellen. Eine Liste benötigt genau einen Wert pro ausgewählter Zeile und füllt sie in der Reihenfolge der Auswahl. Eine Series wird anhand der Indexbezeichnung ausgerichtet:

new_prices = pd.Series([16.2, 5.4], index=[1, 3])
sale.loc[is_home, "unit_price"] = new_prices

Die Home-Zeilen haben die Bezeichnungen 1 und 3 und erhalten daher 16.2 und 5.4. Würde eine ausgewählte Bezeichnung in der Series fehlen, wäre der zugewiesene Wert NaN; Zeilen außerhalb der Auswahl blieben unverändert. Gleiche Längen allein stellen keine Zuordnung der Series zu den Zeilen sicher.

Untersuche sale.loc[is_home, "unit_price"] nach der Änderung und vergleiche es mit orders.loc[is_home, "unit_price"]. Das .sum() der Maske ist 2 und gibt damit die erwartete Anzahl der für diesen Rabatt ausgewählten Zeilen an.

Neue Spalten machen aus erfassten Daten Größen, die du analysieren kannst. Eine Berechnung zwischen Spalten erfolgt zeilenweise, während der Index jedes Ergebnis seiner Beobachtung zugeordnet hält.

Umsatz berechnen

orders["revenue"] = orders["quantity"] * orders["unit_price"]

Die sechs Umsätze sind 7.5, 18.0, 9.5, 24.0, 35.0 und NaN. In der ersten Zeile ergeben drei Artikel zu je 2,50 den Wert 7,50. Die letzte Zeile hat eine unbekannte Menge, daher ist auch ihr Umsatz unbekannt. Die Zuweisung an einen neuen Namen fügt rechts eine Spalte hinzu; die Zuweisung an einen vorhandenen Namen überschreibt diese Spalte.

Spaltenarithmetik ist vektorisiert. Sie drückt eine Regel für die ganze Spalte aus und vermeidet eine Python-Schleife über Zeilen. Bei großen Tabellen ist dies deutlich schneller als for oder iterrows, und der Ausdruck macht den Zusammenhang zwischen den Eingaben deutlich.

Die erfassten Werte für eine Summe verwenden

orders["revenue"].sum() überspringt NaN und ergibt 94.0, die Summe der fünf bekannten Umsätze. .mean() ergibt 18.8, weil der Nenner fünf erfasste Umsätze umfasst. Würdest du 94.0 durch alle sechs Zeilen dividieren, würdest du den fehlenden Umsatz stillschweigend so behandeln, als hätte er eine bekannte Null beigetragen.

Um prozentuale Anteile zu berechnen:

orders["share_pct"] = (
    orders["revenue"] / orders["revenue"].sum() * 100
).round(1)

Die Anteile sind 8.0, 19.1, 10.1, 25.5, 37.2 und NaN. Dies sind Anteile an der bekannten Summe. Der fehlende Eintrag bleibt bei der Arithmetik fehlend.

Mit assign eine Tabelle zurückgeben

assign gibt einen neuen DataFrame mit hinzugefügten oder ersetzten Spalten zurück und lässt seine Eingabe unverändert. Es lässt sich gut in einer Kette verwenden:

with_tax = orders.assign(
    tax=lambda d: (d["revenue"] * 0.2).round(2)
)

Der Lambda-Ausdruck liest die Tabelle an dieser Stelle der Kette. Er liefert die Steuerwerte 1.5, 3.6, 1.9, 4.8, 7.0 und NaN. In pandas 3 ist pd.col("revenue") * 0.2 eine weitere Möglichkeit, in assign auf eine Spalte zu verweisen.

Bei Dezimalrechnungen können winzige binäre Gleitkommafehler sichtbar werden: 9,5 mal 0,2 kann als 1.9000000000000001 gespeichert werden. .round(2) liefert einen nützlichen Wert für die Darstellung. Vermeide exakte Gleichheitstests bei berechneten Dezimalzahlen, wenn kleine Darstellungsfehler möglich sind.

Wissen, wie Zuweisungen Zeilen zuordnen

orders["home_price"] = orders.loc[
    orders["category"] == "Home", "unit_price"
]

Die zugewiesene Series hat die Bezeichnungen 1 und 3. Diese Zeilen erhalten 18.0 und 6.0; jede andere Zeile erhält NaN. Die Zuweisung einer Series ordnet anhand der Bezeichnungen zu, auch wenn ihre Länge von der der Tabelle abweicht. Eine einfache Liste hat keine Bezeichnungen und muss genau einen Wert pro Zeile enthalten. Ein Skalar wie in orders["currency"] = "EUR" füllt jede Zeile.

Werte aus Text oder Datumsangaben ableiten

Auch die Accessoren .str und .dt bieten vektorisierte Spaltenoperationen. orders["product"].str.upper() liefert Namen in Großbuchstaben und .str.len() die Längen 8, 9, 7, 3, 8 und 8. Weise solche Ergebnisse einer neuen Spalte zu, wenn sowohl die ursprünglichen als auch die abgeleiteten Werte nützlich sind.

Eine Spalte zu transformieren kann bedeuten, eine numerische Regel anzuwenden, eine Bezeichnung zuzuweisen oder vorhandene Bezeichnungen zu übersetzen. Wähle eine Methode, deren Verhalten zur Regel passt, besonders für Werte, die die Regel nicht nennt.

Eine Bedingung in Bezeichnungen umwandeln

orders["price_band"] = np.where(
    orders["unit_price"] >= 5, "high", "low"
)

np.where wählt sein zweites Argument, wenn die Bedingung True ist, und sein drittes, wenn sie False ist. Für die Preise 2,50; 18,00; 4,75; 6,00; 35,00 und 2,50 lauten die Bezeichnungen low, high, low, high, high und low. Das >= schließt einen Preis ein, der genau 5 beträgt.

Alle Werte zuordnen oder einzelne ändern

codes = {"Stationery": "ST", "Home": "HM", "Bags": "BG"}
orders["category_code"] = orders["category"].map(codes)

map mit einem Dictionary ergibt ST, HM, ST, HM, BG und ST. Ein Wert, der im Dictionary fehlt, wird zu NaN. Steht dort nur {"Stationery": "ST"}, werden sowohl Home als auch Bags zu fehlenden Werten. Verwende eine vollständige Zuordnung, wenn jede Kategorie einen zugeordneten Code benötigt.

replace ändert aufgeführte Werte und lässt nicht aufgeführte unverändert. orders["category"].replace({"Bags": "Luggage"}) behält Stationery und Home bei und benennt Bags um.

Eine eigene Funktion anwenden

Eine Series kann jeden Wert über map oder apply an eine Funktion übergeben. orders["product"].apply(len) gibt die Länge jedes Produktnamens zurück. Übergib len selbst; len() würde die Funktion sofort ohne Wert aufrufen.

Ein Lambda-Ausdruck kann eine kurze Regel für Werte ausdrücken: orders["unit_price"].apply(lambda p: "budget" if p < 5 else "standard"). Dies gibt budget, standard, budget, standard, standard und budget zurück.

Für Logik, die mehrere Zellen einer Zeile benötigt, akzeptiert apply auf einem DataFrame axis=1:

orders.apply(
    lambda r: r["quantity"] * r["unit_price"], axis=1
)

Die Funktion liest Menge und Preis jeder Zeile. Für diese Berechnung ist die direkte Spaltenmultiplikation klarer und bei einer großen Tabelle deutlich schneller. Verwende vektorisierte Ausdrücke oder np.where, wenn sie die Berechnung ausdrücken können; behalte zeilenweise Funktionen für Logik vor, die sie benötigt.

Integrierte numerische Transformationen verwenden

round(n) rundet auf n Nachkommastellen, abs() gibt absolute Werte zurück und clip(lower=..., upper=...) begrenzt Werte an Schranken. orders["unit_price"].clip(upper=20) ändert 35.0 in 20.0 und lässt die anderen fünf Preise unverändert. Die teure Zeile wird nicht entfernt.

Diese Transformationen geben neue Werte zurück. Weise sie einer neuen Spalte zu, um die Eingabe für eine Prüfung zu erhalten, oder überschreibe das Original, wenn dies beabsichtigt ist. Untersuche einige transformierte Zeilen oder führe value_counts() aus, um zu prüfen, ob neue Bezeichnungen und ihre Anzahlen zur Regel passen.

Das Sortieren ändert die Reihenfolge, in der Beobachtungen erscheinen. Es hält die Werte jeder Zeile zusammen und nimmt die Zeilenbezeichnung mit. Entscheide, was Vorrang hat und wie gleiche Werte geordnet werden sollen, bevor du die obersten oder untersten Zeilen auswählst.

Nach einer Spalte sortieren

scores = pd.DataFrame({
    "name": ["Ana", "Ben", "Chen", "Dara", "Eli"],
    "points": [88, 92, 88, 75, 92]
})
ordered = scores.sort_values("points")

Standardmäßig steht der kleinste Wert zuerst. Die 75 von Dara steht am Anfang, gefolgt von den beiden Werten 88 und dann den beiden Werten 92. Zeilenbezeichnungen bewegen sich mit den Datensätzen. Bei gleichen Werten garantiert der standardmäßige Sortieralgorithmus nicht die ursprüngliche Reihenfolge; die angezeigten Bezeichnungen können 3, 0, 2, 1, 4 lauten, aber du darfst nicht davon ausgehen, dass Zeilen mit gleichen Werten diese Reihenfolge behalten.

Verwende ascending=False, damit der größte Wert zuerst steht. sort_values gibt eine Tabelle zurück und lässt scores unverändert, sofern das Ergebnis nicht zugewiesen wird.

Die Behandlung gleicher Werte festlegen

scores.sort_values(
    ["points", "name"], ascending=[False, True]
)

Der erste Schlüssel hat Vorrang. Die Punktzahlen nehmen ab; bei gleichen Punktzahlen steigen die Namen auf. Die Reihenfolge lautet Ben, Eli, Ana, Chen und Dara. Eine Sortierung zuerst nach Namen würde eine andere Frage beantworten, weil die Namen dann der primäre Schlüssel wären.

Sollen bei einer Sortierung nach einer Spalte gleiche Werte ihre Eingabereihenfolge behalten, verwende scores.sort_values("points", kind="stable"). Die stabile Sortierung erhält die bisherige Reihenfolge solcher Zeilen. Ein zweiter Schlüssel gibt gleichen Werten dagegen eine eigene ausdrückliche Sortierregel.

Fehlende Werte und Text platzieren

Fehlende Werte stehen standardmäßig sowohl bei aufsteigender als auch bei absteigender Sortierung zuletzt. pd.Series([3.0, np.nan, 1.0]).sort_values() ergibt 1.0, 3.0 und dann NaN. na_position="first" verschiebt den fehlenden Eintrag an den Anfang; das bloße Umkehren der Sortierrichtung bewirkt dies nicht.

Die Textsortierung folgt den Zeichencodes. "Zebra" steht vor "apple", weil Groß- und Kleinbuchstaben unterschiedliche Bereiche belegen. Einheitlich geschriebene Namen wie Bags, Home und Stationery stehen in der erwarteten alphabetischen Reihenfolge.

Bezeichnungen sortieren oder neu nummerieren

sort_index() ordnet die Zeilenbezeichnungen und nicht die Datenwerte. Nach dem Sortieren nach Punkten kann es die ursprüngliche Reihenfolge der Standardbezeichnungen wiederherstellen. sort_index(ascending=False) kehrt die Reihenfolge der Bezeichnungen um. reset_index(drop=True) dagegen behält die aktuelle Zeilenreihenfolge bei und ersetzt ihre Bezeichnungen durch 0, 1, 2 und so weiter.

Die größten oder kleinsten Zeilen auswählen

scores.nlargest(2, "points") gibt Ben und Eli zurück, beide mit 92. nsmallest wählt stattdessen niedrige Werte. Fällt die Auswahlgrenze in eine Rangbindung, entscheide, ob alle Zeilen mit gleichem Wert behalten werden sollen. scores.nlargest(1, "points", keep="all") gibt beide Werte 92 zurück, obwohl n gleich 1 ist. Die angeforderte Anzahl ist dann eine Auswahlgrenze und keine Zusage über die endgültige Zeilenanzahl.

Ein Rang hält fest, wo ein Wert in der sortierten Reihenfolge hingehört, ohne seine Zeile zu verschieben. Das ist nützlich, wenn jede Beobachtung neben ihren ursprünglichen Daten eine Platznummer benötigt. Rangbindungen brauchen eine Regel, weil mehrere Werte denselben Teil dieser Reihenfolge belegen können.

Die Richtung wählen

scores["points"].rank() vergibt Ränge vom kleinsten zum größten Wert. Verwende ascending=False für eine Ergebnistabelle, in der hohe Punktzahlen die besten Ränge erhalten sollen. Die Methode für Rangbindungen entscheidet dann, welche Platznummer jede Gruppe gleicher Werte erhält.

Die Beispielpunktzahlen in Zeilenreihenfolge sind Ana 88, Ben 92, Chen 88, Dara 75 und Eli 92. In absteigender Reihenfolge belegen die Werte 92 die Plätze 1 und 2, die Werte 88 die Plätze 3 und 4 und 75 den Platz 5. Die Standardeinstellung method="average" weist jedem gleichen Wert das arithmetische Mittel der belegten Plätze zu. Die zurückgegebenen Werte in der ursprünglichen Zeilenreihenfolge lauten 3,5; 1,5; 3,5; 5,0 und 1,5.

Eine Methode für Rangbindungen wählen

Bei min bedeuten zwei Gewinner auf Rang 1, dass die nächste Punktzahl auf Rang 3 beginnt. Bei dense beginnt die nächste andere Punktzahl auf Rang 2. first löst eine Rangbindung auch dann auf, wenn die Punktzahlen selbst keinen Grund bieten, eine Person zu bevorzugen; es folgt der Eingabereihenfolge.

Rangergebnisse sind Gleitkommazahlen und erlauben damit Werte wie 1,5. Wenn eine gewählte Methode für Rangbindungen ganzzahlige Ränge ergibt und keiner fehlt, wandelt .astype(int) sie für die Darstellung in Ganzzahlen um. Ein gewöhnlicher Ganzzahldatentyp kann keinen fehlenden Rang aufnehmen.

Ränge als Anteile ausdrücken

Bei der standardmäßigen Mittelwertmethode und nicht fehlenden Werten dividiert rank(pct=True) jeden Rang durch die Anzahl der eingestuften Werte. Die aufsteigende Einstufung der fünf Beispielpunktzahlen ergibt 2,5; 4,5; 2,5; 1,0 und 4,5. Die Division durch fünf ergibt 0,5; 0,9; 0,5; 0,2 und 0,9.

Die höchsten Werte mit Rangbindung erhalten 0,9 und nicht 1, weil ihr mittlerer Rang 4,5 ist. Ein relativer Rang beschreibt den Rang im Verhältnis zu den eingestuften Werten; er ist kein Prozentsatz der Punktzahl selbst.

Fehlende Ränge behandeln und Ergebnisse speichern

Fehlende Werte behalten standardmäßig NaN als Rang. Bei den Umsätzen 7,5; 18,0; 9,5; 24,0; 35,0 und NaN lauten die absteigenden Ränge 5, 3, 4, 2, 1 und NaN. na_option="bottom" setzt den fehlenden Eintrag hinter die erfassten Werte und gibt ihm Rang 6.

scores["place"] = scores["points"].rank(
    method="min", ascending=False
)

Die Zeilen bleiben Ana, Ben, Chen, Dara und Eli. Die neue Spalte place enthält 3, 1, 3, 5 und 1. Sortiere separat, wenn die Anzeige die Gewinner zuerst zeigen soll.

Ein deskriptiver Kennwert verdichtet viele Beobachtungen zu einer nützlichen Größe. Wähle einen Kennwert, der zur Frage passt, und lies die Anzahl nicht fehlender Werte ab, damit du weißt, auf wie vielen Daten er beruht.

Lagemaße und Streuung berechnen

weather = pd.DataFrame({
    "temp_c": [14.0, 17.5, 16.0, 21.0, 19.5, 12.5, 15.0],
    "rain_mm": [0.0, 2.4, 0.0, 0.0, 5.1, 12.3, 0.8]
}, index=["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"])

Für weather["temp_c"] ist sum() gleich 115.5, mean() gleich 16.5 und median() gleich 16.0. Das Minimum ist 12.5 und das Maximum 21.0, was eine Spannweite von 8,5 °C ergibt. idxmax() gibt die Bezeichnung "Thu" zurück, während idxmin() "Sat" zurückgibt: Sie identifizieren Beobachtungen, statt die Extremwerte selbst zurückzugeben.

std() und var() messen die Streuung. pandas verwendet standardmäßig den Nenner für Stichproben, ddof=1, und dividiert die quadrierten Abweichungen durch eine um eins kleinere Anzahl als die Anzahl der Werte. Hier beträgt die Standardabweichung etwa 3,028 °C und die Varianz etwa 9,167 Quadratgrad Celsius. std(ddof=0) verwendet die Anzahl selbst und ergibt etwa 2,803 °C. NumPys np.std verwendet standardmäßig ddof=0; gleiche daher die Einstellung an, bevor du Ergebnisse vergleichst.

Quartile und describe auslesen

quantile(0.25) liefert das untere Quartil 14.5; quantile(0.5) liefert den Median 16.0; quantile(0.75) liefert das obere Quartil 18.5. Die standardmäßige Interpolation kann einen Wert zwischen erfassten Messwerten zurückgeben.

weather.describe() stellt Anzahl, arithmetisches Mittel, Standardabweichung, Minimum, die drei Quartile und Maximum für numerische Spalten zusammen. Der Regen hat ein arithmetisches Mittel von etwa 2,94 mm und einen Median von 0,8 mm. Der Messwert von 12,3 mm zieht das arithmetische Mittel nach oben; der Median beschreibt einen typischen Tag in dieser Woche mit rechtsschief verteiltem Niederschlag besser.

Fehlende Werte und Datentypen berücksichtigen

Für pd.Series([1, np.nan, 3]) ist .mean() gleich 2.0, weil fehlende Werte standardmäßig übersprungen werden. .count() ist 2, während .size gleich 3 ist. Mit skipna=False ist das arithmetische Mittel NaN. Verwende nicht die Zeilenanzahl als Nenner für das standardmäßige arithmetische Mittel, wenn einige Einträge fehlen.

Textzusammenfassungen sind anders. orders["category"].describe() ergibt count 6, unique 3, top Stationery und freq 3. Die Mittelwertberechnung für die Bestelltabelle mit gemischten Daten einschließlich Text löst einen TypeError aus; verwende orders.mean(numeric_only=True) oder wähle mit select_dtypes("number") numerische Spalten aus.

Entlang einer Achse zusammenfassen

Standardmäßig reduzieren DataFrame-Kennwerte entlang der Zeilen auf ein Ergebnis pro Spalte. axis=1 liefert stattdessen ein Ergebnis pro Zeile; wähle Größen aus, deren Einheiten sich sinnvoll kombinieren lassen.

orders[["quantity", "unit_price"]].agg(["mean", "max"])

agg berechnet mehrere benannte Kennwerte gemeinsam. Quantity hat ein arithmetisches Mittel von 2.2 und ein Maximum von 4.0; unit_price hat ein arithmetisches Mittel von etwa 11.46 und ein Maximum von 35.0. weather["rain_mm"].cumsum() ergibt die kumulativen Summen 0.0, 2.4, 2.4, 2.4, 7.5, 19.8 und 20.6 mm und behält ein Ergebnis pro Tag bei.

Häufigkeiten beschreiben, wie oft Werte vorkommen; Korrelationen beschreiben, wie zwei numerische Variablen gemeinsam variieren. Beide Zusammenfassungen müssen interpretiert werden: Was wird gezählt, was fehlt und welchen Zusammenhang misst der Kennwert?

Kategorien zählen oder unterschiedliche Werte aufführen

orders["category"].value_counts() ergibt Stationery 3, Home 2 und Bags 1, nach Häufigkeit geordnet. Die zurückgegebene Series heißt count. Fehlende Einträge werden standardmäßig ausgeschlossen; dropna=False zählt sie separat mit.

orders["category"].value_counts(normalize=True)

Die normierte Series heißt proportion: Stationery ist 0.5, Home etwa 0.333 und Bags etwa 0.167. Die Multiplikation mit 100 ergibt Prozentangaben. Bei der standardmäßigen Regel für fehlende Werte beschreiben diese Anteile die vorhandenen Werte.

unique() behält die Reihenfolge des ersten Auftretens bei: Stationery, Home, Bags. mode() gibt eine Series zurück, weil mehrere Werte dieselbe höchste Häufigkeit haben können. Die Methode fordert nicht einen einzelnen willkürlich gewählten Gewinner an.

Bedingungen lassen sich direkt zählen. (weather["rain_mm"] > 0).sum() zählt vier Regentage. Das zugehörige .mean() ist etwa 0.571, sodass es an etwa 57 % der sieben Tage regnete.

Einen geradlinigen Zusammenhang messen

weather["temp_c"].corr(weather["rain_mm"]) ergibt eine Pearson-Korrelation von etwa −0,397. Das negative Vorzeichen besagt, dass in diesen Beobachtungen an wärmeren Tagen tendenziell weniger Regen fiel. Der Betrag beschreibt auf einer Skala von −1 über 0 bis 1, wie gut ein geradliniges Muster passt.

Ein Wert von 1 bedeutet einen perfekten steigenden geradlinigen Zusammenhang; −1 bedeutet einen perfekten fallenden. Ein Wert nahe null bedeutet einen geringen linearen Zusammenhang. Ein gekrümmter Zusammenhang kann dennoch stark sein, selbst wenn die Pearson-Korrelation nahe null liegt. Korrelation beschreibt außerdem einen Zusammenhang und ist kein Beleg dafür, dass die Änderung einer Variablen die Änderung der anderen verursacht.

Eine Korrelationsmatrix auslesen

weather.corr() liefert alle numerischen Paare gemeinsam. Die Matrix ist symmetrisch: Temperatur mit Regen hat dieselbe Korrelation wie Regen mit Temperatur. Eine variierende numerische Spalte hat mit sich selbst die Korrelation 1; eine konstante Spalte hat keine definierte Korrelation und ergibt stattdessen NaN.

Für Zusammenhänge, die durchgehend steigen oder fallen, ohne einer Geraden zu folgen, berechnet method="spearman" die Korrelation aus Rängen. Die Methode ändert, welche Art von Muster zusammengefasst wird; nenne sie daher bei der Berichterstattung über ein Ergebnis.

Die Wetterberechnung verwendet nur sieben Messwerte. Sie beschreibt diese kleine beobachtete Woche; starke Aussagen über ein umfassenderes Klimamuster benötigen mehr Belege. Ein aussagekräftiger Bericht enthält die Variablen, das Vorzeichen und die Größe des Koeffizienten, die Methode und die Anzahl der Beobachtungen.