Einführung in die Datenstrukturen von pandas

Um mit pandas zu beginnen, solltet ihr euch zunächst mit den beiden wichtigsten Datenstrukturen vertraut machen: Series und DataFrame.

Series

Eine Serie ist ein eindimensionales Array-ähnliches Objekt, das eine Folge von Werten (von ähnlichen Typen wie die NumPy-Typen) und ein zugehöriges Array von Datenbeschriftungen, genannt Index, enthält. Die einfachste Serie wird nur aus einem Array von Daten gebildet:

import numpy as np
import pandas as pd

rng = np.random.default_rng()
s = pd.Series(rng.normal(size=7))
s

0    0.573434
1   -0.300349
2   -0.119303
3    0.655773
4    0.169897
5    0.349193
6   -1.269180
dtype: float64

Die Zeichenkettendarstellung einer interaktiv angezeigten Reihe zeigt den Index auf der linken Seite und die Werte auf der rechten Seite. Da wir keinen Index für die Daten angegeben haben, wird ein Standardindex erstellt, der aus den ganzen Zahlen 0 bis N - 1 besteht (wobei N die Anzahl (Length) der Daten ist). Ihr könnt die Array-Darstellung und das Index-Objekt der Reihe über ihre pandas.Series.array- bzw. pandas.Series.index-Attribute erhalten:

s.array

<NumpyExtensionArray>
[   np.float64(0.573433989438075), np.float64(-0.30034850192585627),
 np.float64(-0.11930271928878755),   np.float64(0.6557731822576305),
  np.float64(0.16989728101236864),  np.float64(0.34919327629279334),
  np.float64(-1.2691801790122854)]
Length: 7, dtype: float64

s.index

RangeIndex(start=0, stop=7, step=1)

Oft werdet ihr einen Index erstellen wollen, der jeden Datenpunkt mit einer Bezeichnung kennzeichnet:

idx = pd.date_range("2022-01-31", periods=7)

s2 = pd.Series(rng.normal(size=7), index=idx)

s2

2022-01-31    0.127985
2022-02-01    0.918698
2022-02-02   -0.222105
2022-02-03    0.148317
2022-02-04   -0.271917
2022-02-05   -1.580597
2022-02-06    1.098741
Freq: D, dtype: float64

Siehe auch:

• Time series / date functionality

Im Vergleich zu NumPy-Arrays könnt ihr Label im Index verwenden, wenn ihr einzelne Werte oder eine Gruppe von Werten auswählen wollt:

s2["2022-02-02"]

np.float64(-0.22210539674044646)

s2[["2022-02-02", "2022-02-03", "2022-02-04"]]

2022-02-02   -0.222105
2022-02-03    0.148317
2022-02-04   -0.271917
dtype: float64

Hier wird ['2022-02-02', '2022-02-03', '2022-02-04'] als eine Liste von Indizes interpretiert, auch wenn sie Strings anstelle von ganzen Zahlen enthält.

Bei der Verwendung von NumPy-Funktionen oder NumPy-ähnlichen Operationen, wie z. B. dem Filtern mit einem booleschen Array, der skalaren Multiplikation oder der Anwendung mathematischer Funktionen, bleibt die Verknüpfung zwischen Index und Wert erhalten:

s2[s2 > 0]

2022-01-31    0.127985
2022-02-01    0.918698
2022-02-03    0.148317
2022-02-06    1.098741
dtype: float64

s2**2

2022-01-31    0.016380
2022-02-01    0.844005
2022-02-02    0.049331
2022-02-03    0.021998
2022-02-04    0.073939
2022-02-05    2.498286
2022-02-06    1.207231
Freq: D, dtype: float64

np.exp(s2)

2022-01-31    1.136536
2022-02-01    2.506025
2022-02-02    0.800831
2022-02-03    1.159881
2022-02-04    0.761917
2022-02-05    0.205852
2022-02-06    3.000385
Freq: D, dtype: float64

Ihr könnt euch eine Serie auch als ein ordered dict mit fester Länge vorstellen, da sie eine Zuordnung von Indexwerten zu Datenwerten darstellt. Sie kann in vielen Kontexten verwendet werden, in denen man ein dict verwenden könnte:

"2022-02-02" in s2

True

"2022-02-09" in s2

False

Fehlende Daten

NA und null werde ich synonym verwenden, um auf fehlende Daten hinzuweisen. Die Funktionen isna und notna in pandas sollten verwendet werden, um fehlende Daten zu erkennen:

pd.isna(s2)

2022-01-31    False
2022-02-01    False
2022-02-02    False
2022-02-03    False
2022-02-04    False
2022-02-05    False
2022-02-06    False
Freq: D, dtype: bool

pd.notna(s2)

2022-01-31    True
2022-02-01    True
2022-02-02    True
2022-02-03    True
2022-02-04    True
2022-02-05    True
2022-02-06    True
Freq: D, dtype: bool

Series hat diese auch als Instanzmethoden:

s2.isna()

2022-01-31    False
2022-02-01    False
2022-02-02    False
2022-02-03    False
2022-02-04    False
2022-02-05    False
2022-02-06    False
Freq: D, dtype: bool

Der Umgang mit fehlenden Daten wird im Abschnitt Verwalten fehlender Daten mit pandas ausführlicher behandelt.

Eine für viele Anwendungen nützliche Funktion von Series ist die automatische Ausrichtung nach Indexbezeichnungen bei arithmetischen Operationen:

idx = pd.date_range("2022-02-01", periods=7)

s3 = pd.Series(rng.normal(size=7), index=idx)

s2, s3

(2022-01-31    0.127985
 2022-02-01    0.918698
 2022-02-02   -0.222105
 2022-02-03    0.148317
 2022-02-04   -0.271917
 2022-02-05   -1.580597
 2022-02-06    1.098741
 Freq: D, dtype: float64,
 2022-02-01    1.807929
 2022-02-02    0.703514
 2022-02-03    0.073396
 2022-02-04    0.834801
 2022-02-05   -0.420684
 2022-02-06   -0.691464
 2022-02-07   -0.490131
 Freq: D, dtype: float64)

s2 + s3

2022-01-31         NaN
2022-02-01    2.726626
2022-02-02    0.481409
2022-02-03    0.221713
2022-02-04    0.562884
2022-02-05   -2.001280
2022-02-06    0.407276
2022-02-07         NaN
Freq: D, dtype: float64

Wenn ihr Erfahrung mit SQL habt, ähnelt dies einem JOIN-Vorgang.

Sowohl das Series-Objekt selbst als auch sein Index haben ein name-Attribut, das sich in andere Bereiche der pandas-Funktionalität integrieren lässt:

s3.name = "floats"
s3.index.name = "date"

s3

date
2022-02-01    1.807929
2022-02-02    0.703514
2022-02-03    0.073396
2022-02-04    0.834801
2022-02-05   -0.420684
2022-02-06   -0.691464
2022-02-07   -0.490131
Freq: D, Name: floats, dtype: float64

DataFrame

Ein DataFrame stellt eine rechteckige Datentabelle dar und enthält eine geordnete, benannte Sammlung von Spalten, von denen jede einen anderen Werttyp haben kann. Der DataFrame hat sowohl einen Zeilen- als auch einen Spaltenindex.

Bemerkung:

Ein DataFrame ist zwar zweidimensional, ihr könnt ihn aber auch verwenden, um mit join, combine und Reshaping höherdimensionale Daten in einem Tabellenformat mit hierarchischer Indizierung darzustellen.

data = {
    "Code": ["U+0000", "U+0001", "U+0002", "U+0003", "U+0004", "U+0005"],
    "Decimal": [0, 1, 2, 3, 4, 5],
    "Octal": ["001", "002", "003", "004", "004", "005"],
    "Key": ["NUL", "Ctrl-A", "Ctrl-B", "Ctrl-C", "Ctrl-D", "Ctrl-E"],
}
df = pd.DataFrame(data)

df

	Code	Decimal	Octal	Key
0	U+0000	0	001	NUL
1	U+0001	1	002	Ctrl-A
2	U+0002	2	003	Ctrl-B
3	U+0003	3	004	Ctrl-C
4	U+0004	4	004	Ctrl-D
5	U+0005	5	005	Ctrl-E

Bei großen DataFrames wählt die head-Methode nur die ersten fünf Zeilen aus:

df.head()

	Code	Decimal	Octal	Key
0	U+0000	0	001	NUL
1	U+0001	1	002	Ctrl-A
2	U+0002	2	003	Ctrl-B
3	U+0003	3	004	Ctrl-C
4	U+0004	4	004	Ctrl-D

Ihr könnt auch die Reihenfolge der Spalten angeben:

pd.DataFrame(data, columns=["Code", "Key"])

	Code	Key
0	U+0000	NUL
1	U+0001	Ctrl-A
2	U+0002	Ctrl-B
3	U+0003	Ctrl-C
4	U+0004	Ctrl-D
5	U+0005	Ctrl-E

Wenn ihr eine Spalte übergeben wollt, die nicht im Dict enthalten ist, wird sie ohne Werte im Ergebnis erscheinen:

df2 = pd.DataFrame(
    data, columns=["Code", "Decimal", "Octal", "Description", "Key"]
)

df2

	Code	Decimal	Octal	Description	Key
0	U+0000	0	001	NaN	NUL
1	U+0001	1	002	NaN	Ctrl-A
2	U+0002	2	003	NaN	Ctrl-B
3	U+0003	3	004	NaN	Ctrl-C
4	U+0004	4	004	NaN	Ctrl-D
5	U+0005	5	005	NaN	Ctrl-E

Ihr könnt eine Spalte in einem DataFrame mit einer Dict-ähnlichen Notation abrufen:

df["Code"]

0    U+0000
1    U+0001
2    U+0002
3    U+0003
4    U+0004
5    U+0005
Name: Code, dtype: object

So könnt ihr auch eine Spalte zum Index machen:

df2 = pd.DataFrame(
    data, columns=["Decimal", "Octal", "Description", "Key"], index=df["Code"]
)

df2

	Decimal	Octal	Description	Key
Code
U+0000	0	001	NaN	NUL
U+0001	1	002	NaN	Ctrl-A
U+0002	2	003	NaN	Ctrl-B
U+0003	3	004	NaN	Ctrl-C
U+0004	4	004	NaN	Ctrl-D
U+0005	5	005	NaN	Ctrl-E

Zeilen können nach Position oder Name mit dem pandas.DataFrame.loc-Attribut abgerufen werden:

df2.loc["U+0001"]

Decimal             1
Octal             002
Description       NaN
Key            Ctrl-A
Name: U+0001, dtype: object

Spaltenwerte können durch Zuweisung geändert werden. Zum Beispiel könnte der leeren Spalte Description ein Einzelwert oder ein Array von Werten zugewiesen werden:

df2["Description"] = [
    "Null character",
    "Start of Heading",
    "Start of Text",
    "End-of-text character",
    "End-of-transmission character",
    "Enquiry character",
]

df2

	Decimal	Octal	Description	Key
Code
U+0000	0	001	Null character	NUL
U+0001	1	002	Start of Heading	Ctrl-A
U+0002	2	003	Start of Text	Ctrl-B
U+0003	3	004	End-of-text character	Ctrl-C
U+0004	4	004	End-of-transmission character	Ctrl-D
U+0005	5	005	Enquiry character	Ctrl-E

Das Zuweisen einer nicht existierenden Spalte erzeugt eine neue Spalte.

Mit pandas.DataFrame.drop können Spalten entfernt und mit pandas.DataFrame.columns angezeigt werden:

df3 = df2.drop(columns=["Decimal", "Octal"])

df2.columns

Index(['Decimal', 'Octal', 'Description', 'Key'], dtype='object')

df3.columns

Index(['Description', 'Key'], dtype='object')

Eine weitere gängige Form von Daten sind verschachtelte Dict von Dicts:

u = {
    "U+0006": {
        "Decimal": "6",
        "Octal": "006",
        "Description": "Acknowledge character",
        "Key": "Ctrl-F",
    },
    "U+0007": {
        "Decimal": "7",
        "Octal": "007",
        "Description": "Bell character",
        "Key": "Ctrl-G",
    },
}

df4 = pd.DataFrame(u)

df4

	U+0006	U+0007
Decimal	6	7
Octal	006	007
Description	Acknowledge character	Bell character
Key	Ctrl-F	Ctrl-G

Ihr könnt den DataFrame transponieren, d.h. die Zeilen und Spalten vertauschen, mit einer ähnlichen Syntax wie bei einem NumPy-Array:

df4.T

	Decimal	Octal	Description	Key
U+0006	6	006	Acknowledge character	Ctrl-F
U+0007	7	007	Bell character	Ctrl-G

Warnung:

Beachtet, dass beim Transponieren die Datentypen der Spalten verworfen werden, wenn die Spalten nicht alle denselben Datentyp haben, so dass beim Transponieren und anschließenden Zurücktransponieren die vorherigen Typinformationen verloren gehen können. Die Spalten werden in diesem Fall zu Arrays aus reinen Python-Objekten.

Die Schlüssel in den inneren Dicts werden kombiniert, um den Index im Ergebnis zu bilden. Dies ist nicht der Fall, wenn ein expliziter Index angegeben wird:

df5 = pd.DataFrame(u, index=["Decimal", "Octal", "Key"])
df5

	U+0006	U+0007
Decimal	6	7
Octal	006	007
Key	Ctrl-F	Ctrl-G