Pandas basics

Die beiden einfachsten Varianten sind der offset-basierte Zugriff über iloc, sowie der label-basierte Zugriff über loc.

    print(df.iloc[0])
    print(df.loc[5])

eins    1
zwei    3
Name: 5, dtype: int64
eins    1
zwei    3
Name: 5, dtype: int64

In beiden Fällen erhalten wir die Werte der ersten Reihe als Serie. Für loc musste ich jedoch den Index (oder das "Label") der ersten Zeile angeben, nicht den Offset innerhalb des Dataframe. Ein Pandas-Dataframe unterstützt auch die normale Python-Indizierungs-Syntax. Diese funktioniert wie eine Mischung aus loc und iloc. Aus Gründen der Lesbarkeit ist es meist einfacher, explizit label- oder offset-basierte Indizierung zu verwenden.

Wie wir sehen, haben wir als Rückgabewert der Indizierungs-Aktionen eine Serie mit Werten erhalten, die als Index den Spaltennamen verwenden.

loc und iloc lassen sich allerdings nicht nur mit Namen und einzelenen Indizes verwenden⁵, sondern auch, ähnlich wie normale Python-Indizierung, mit Slices.

  print(df.loc[5:20])
  print(df.iloc[0:3])

    eins  zwei
5      1     3
10     2     4
20     3     5
    eins  zwei
5      1     3
10     2     4
20     3     5

In diesem Falle haben wir uns alle Reihen zwischen den Labels 5 und 20 (inklusive), sowie alle Reihen zwischen Offset 0 und 3 (inklusive) ausgeben lassen, was dem gesamten Dataframe entspricht. Möchte ich alle Reihen auswählen, kann ich : als Slice verwenden, dies entspricht einer Slice vom Anfang bis zum Ende des Dataframe. Der Rückgabewert bei der Indizierung mit Slices ist allerdings ein Dataframe, keine Serie mehr, also Obacht!

Ich kann auch direkt eine Liste von Indizes oder Namen übergeben, um nur diese Indizes aus dem Dataframe herauszupicken.

  df.loc[[5, 20, 10]]

    eins  zwei
5      1     3
20     3     5
10     2     4

Wie man sieht, kann ich auch die Reihenfolge der Reihen verändern.

Bisher haben wir nur eindimensional indiziert, entweder per Label oder per Offset. Pandas unterstützt aber auch mehrdimensionale Indizierung, um gleichzeitig Reihen und Spalten auszuwählen.

  df.loc[5, "eins"]

1

In diesem Fall erhalten wir einen skalaren Wert zurück, und zwar den Wert der Spalte "eins" der Reihe mit dem Label "5". Auch die anderen Dimensionen des Index kann ich slicen, auch beide gleichzeitig, oder wie oben Listen von Indizes übergeben.

  print(df.loc[5:10, "eins":"zwei"])
  print(df.loc[[5, 20], ["eins", "zwei"]])

    eins  zwei
5      1     3
10     2     4
    eins  zwei
5      1     3
20     3     5

Und zu guter Letzt kann ich neue Spalten erzeugen, indem ich dem entsprechenden Slice eine neue Series zuweise. Dies funktioniert auch mit komplizierteren Slices, oder boole'schem Indizieren wie im nächsten Abschnitt beschrieben. Nicht verfügbare Werte werden automatisch mit einem NaN-Wert befüllt.

  new_column = df.copy()
  new_column.loc[5:10, "drei"] = [1, 2]
  new_column

    eins  zwei  drei
5      1     3   1.0
10     2     4   2.0
20     3     5   NaN

Auch hier können wie beim Indizieren nicht nur skalare Daten übergeben werden, sondern Werte in verschiedenen Formen, die Pandas automatisch versucht, in die korrekte Form zu überführen.

Neben den oben beschriebenen Indizierungsmöglichkeiten gibt es noch eine weitere wichtige Indizierung von Dataframes, die fast die nützlichste Indizierungsart ist: Die boolesche Indizierung. Sie erlaubt es mir, aus einem Dataframe Sub-Dataframes zu extrahieren. Die Extraktion wird durch eine boolesche Serie gesteuert: Steht in einer Reihe der Serie True, wird die Reihe im Dataframe beibehalten, wenn nicht, ist sie nicht im Ergebnis-Dataframe enthalten.

  print(df.eins == 1)
  print(df.loc[df.eins == 1])

5      True
10    False
20    False
Name: eins, dtype: bool
   eins  zwei
5     1     3

Diese Funktionalität erlaubt es, Abfragen auf Dataframe-Daten ähnlich wie ein SQL SELECT durchzuführen: Boolesche Serien können über die bitweisen Operatoren von Python kombiniert werden. Hierbei müssen allerdings Klammern gesetzt werden, da sonst die Operatorpräzedenz dazwischenfunkt. Serien selber verfügen über eine große Anzahl an Methoden, die ebenfalls boolesche Serien erzeugen, die dann zum Indizieren benutzt werden können. Als kleiner Geschmackshappen für eigene Versuche:

  df.loc[(df.eins == 1) & df.zwei.isin([3, 4, 5])]

   eins  zwei
5     1     3

Diese Abfrage gibt mir alle Reihen, in denen der Wert der Spalte "eins" 1 und der Wert der Spalte "zwei" entweder 3, 4 oder 5 ist.

Aber Achtung: Wer boole'sch indiziert, benötigt eine Serie. Beim Indizieren mit einem boole'schen Dataframe wird stattdessen maskiert. Das Ergebnis diese Operation ist ein Dataframe, bei dem an allen Stellen, an denen der boole'sche Dataframe einen False-Wert hat, ein "nicht verfügbar"-Wert eingefügt wird. Alle anderen Werte werden unverändert beibehalten.

Die "normale" Python-Indizierung wird von Dataframes auch unterstützt, jedoch ist das Verhalten oft subtil anders als bei iloc und loc. Generell versucht die Indizierung über eckige Klammern "intuitiv" zu sein, dies kann jedoch auch schief gehen. Einige Abkürzungen, die ich häufig nutze, sind das Extrahieren von Spalten mit df[["eins","zwei"]] und das boolesche Indizieren wie oben beschrieben. Bei der interaktiven Analyse ist es oft schneller, auf loc und Konsorten zu verzichten, beim Debuggen hilft es aber oft, dann doch explizit zu sein und loc zu verwenden.

Das Gruppieren von Daten in Pandas ist eine wichtige Funktionalität, die jedoch leider nicht ganz einfach zu benutzen ist. Über Gruppierungen kann ein Dataframe aufgetrennt, die aufgetrennten Dataframes individuell bearbeitet und verändert, und anschließlich wieder zu einem Dataframe zusammengefügt werden. In gewisser Hinsicht entspricht dies einem "Map-Reduce"-Ansatz, der im Big-Data-Bereich weit verbreitet ist. Natürlich kann man diese Funktionalität auch via selbst geschriebenem Python-code realisieren, die Implementierung in Pandas wird einer eigenen Python-Implementierung jedoch immer überlegen sein.

Eine Gruppierung in Pandas kann über groupby erzeugt werden. Das Ergebnis dieser Gruppierung ist leider ein opakes Objekt, welches Python nicht sinnvoll ausgeben kann (im Gegensatz zu Dataframes). Im häufigsten Fall möchte ich einen Dataframe nach dem Inhalt einer Spalte gruppieren, und eine statistische Metrik erheben.

  df = pd.DataFrame({"type":
                     [1, 2, 1, 2],
                     "value":
                     [5, 8, 3, 2]})
  print(df)
  print(df.groupby("type").mean())

   type  value
0     1      5
1     2      8
2     1      3
3     2      2
      value
type       
1       4.0
2       5.0

Wir erstellen einen neuen Dataframe mit Daten, die sich interessanter gruppieren lassen, führen eine Gruppierung nach der Spalte "type" aus, und berechnen den Durchschnitt der Gruppen. Die Ergebnisse sind wie erwartet: Für "type=1" erhalten wir den Durchschnitt (5+3)/2 = 4, für "type=2" ist der Durchschnitt (8 + 2) / 2 = 5.

Der Aufruf von selbstdefinierten Funktionen auf Gruppen ist aus Performance-Gründen leider komplex, weswegen ich hier nur den die Grundfunktionalität zeige.

Die letzte wichtige Grundfunktionalität ist die Anwendung selbstdefinierter Funktionen auf einen Dataframe (oder via Indizierung daraus extrahierter Teile). Dies kann man durch die Funktion apply bewerkstelligen. Man muss jedoch aufpassen, welchen Datentyp man gerade hat, da apply auf Serien und Dataframes leicht anders funktioniert. Am einfachsten ist es auch hier, erst einmal Numpy-Funktionen zu verwenden.

Das wichtigste Argument für apply ist neben der anzuwendenen Funktion das axis-Argument. Dies gibt an, ob die Funktion auf Spalten oder auf Zeilen angewendet werden soll. Da ich Spalten leicht als Serie extrahieren kann, verwende ich eher selten apply auf Spalten, sondern meistens auf Zeilen. So kann ich z.B. herausfinden, in welchen meiner Spalten Werte fehlen, indem ich erst np.isnan anwende, um fehlende Werte zu finden, und dann mit einer zeilenweisen Anwendung von np.any alle Reihen zu finden, in denen mindestens ein nicht verfügbarer Wert vorkommt. Mit axis=0 könnte ich dann Spalten finden, in denen Werte fehlen.

  print("Fehlende Werte") 
  print(np.isnan(df))
  print("\nZeilen mit fehlenden Werten")
  print(np.isnan(df).apply(np.any, axis=1))

Fehlende Werte
    type  value
0  False  False
1  False  False
2  False  False
3  False  False

Zeilen mit fehlenden Werten
0    False
1    False
2    False
3    False
dtype: bool

Statt numpy-Funktionen kann ich auch eigene Funktionen verwenden. Die Funktion erhält beide Male als Argument eine Serie, einmal spaltenweise, einmal zeilenweise. So kann ich z.B. die Werte in der Spalte "value" mit apply wie folgt um eins erhöhen:

df.apply(lambda x: x.value + 1, axis=1)

0    6
1    9
2    4
3    3
dtype: int64