Pandas DataFrame: In Python Tabellen schnell und über­sicht­lich ma­ni­pu­lie­ren!

Der Pandas DataFrame ist eine Python Da­ten­struk­tur, mit der man Tabellen erstellen und ma­ni­pu­lie­ren kann. Wir erklären Ihnen den Aufbau der Da­ten­struk­tur sowie ihre wich­tigs­ten Methoden und Ei­gen­schaf­ten.

Wie funk­tio­nie­ren Pandas Da­ta­Frames?

Pandas Da­ta­Frames sind das Herzstück der Python-Pandas-Bi­blio­thek und er­mög­li­chen eine ef­fi­zi­en­te und flexible Da­ten­ana­ly­se in Python. Ein Pandas DataFrame ist eine zwei­di­men­sio­na­le ta­bel­la­ri­sche Da­ten­struk­tur mit num­me­rier­ten Zeilen und be­schrif­te­ten Spalten. Diese Struktur er­mög­licht es, Daten in einer leicht ver­ständ­li­chen und ma­ni­pu­lier­ba­ren Form zu or­ga­ni­sie­ren, ähnlich wie bei Ta­bel­len­kal­ku­la­ti­ons­pro­gram­men wie Excel oder Libre­Of­fice. Jede Spalte in einem DataFrame kann un­ter­schied­li­che Python-Da­ten­ty­pen enthalten, was bedeutet, dass ein DataFrame he­te­ro­ge­ne Daten speichern kann – bei­spiels­wei­se nu­me­ri­sche Werte, Zei­chen­ket­ten und Booleans in einer einzigen Tabelle.

Aufbau von Pandas Da­ta­Frames

Ein DataFrame besteht aus drei Haupt­kom­po­nen­ten: den Daten selbst, den Zei­len­in­di­zes und den Spal­ten­na­men. Der Zei­len­in­dex (oder einfach Index) dient als ein­deu­ti­ger Be­zeich­ner für jede Zeile. Stan­dard­mä­ßig werden Zeilen mit nu­me­ri­schen Werten indexiert, al­ler­dings können diese durch Strings ersetzt werden. Beachten Sie, dass Pandas Da­ta­Frames null-indexiert sind, also dass die Indizes bei 0 anfangen.

Close

Der Umgang mit Pandas Da­ta­Frames

Pandas Da­ta­Frames bieten eine Vielzahl von Techniken und Methoden, die es er­mög­li­chen, Daten effizient zu be­ar­bei­ten, zu ana­ly­sie­ren und zu vi­sua­li­sie­ren. Im Folgenden lernen Sie einige der wich­tigs­ten Konzepte und Methoden zur Da­ten­ma­ni­pu­la­ti­on mit Pandas Da­ta­Frames kennen.

Pandas DataFrame erstellen

Falls Sie Ihre ge­wünsch­ten Daten schon in einer Python-Liste oder Python-Dic­tion­a­ry ge­spei­chert haben, können Sie sehr leicht daraus einen DataFrame erstellen. Dafür müssen Sie nur die exis­tie­ren­de Da­ten­struk­tur dem DataFrame-Kon­struk­tor pandas.DataFrame([Daten]) als Argument übergeben. Wie Pandas Ihre Daten in­ter­pre­tiert, hängt al­ler­dings davon ab, welche Da­ten­struk­tur Sie dem Kon­struk­tor übergeben. So können Sie aus einer Python-Liste einen Pandas DataFrame erstellen:

import pandas
liste = ["Ahmed", "Beatrice", "Candice", "Donovan", "Elisabeth", "Frank"]
df = pandas.DataFrame(liste)
print(df)
# Ausgabe:
#            0
# 0     Ahmed
# 1      Beatrice
# 2     Candice
# 3    Donovan
# 4    Elisabeth
# 5  Frank

Wie Sie im obigen Beispiel sehen können, kann man mit einfachen Listen nur Da­ta­Frames mit einer einzelnen, un­be­schrif­te­ten Spalte erstellen. Aus diesem Grund empfiehlt es sich, Da­ta­Frames aus Dic­tion­a­rys zu erstellen, die Listen enthalten. Dabei werden die Schlüssel als Spal­ten­na­men und die Listen als die zu­ge­hö­ri­gen Daten in­ter­pre­tiert. Das folgende Beispiel dient zur Ver­an­schau­li­chung:

import pandas
daten = {
    'Name': ['Arthur', 'Bruno', 'Christoph'],
    'Alter': [34, 30, 55],
    'Gehalt': [75000.0, 60000.5, 90000.3],
}
df = pandas.DataFrame(daten)
print(df)
# Ausgabe:
#         Name  Alter   Gehalt
# 0     Arthur     34  75000.0
# 1      Bruno     30  60000.5
# 2  Christoph     55  90000.3

Mit dieser Methode hat der DataFrame sofort das er­wünsch­te Format und die er­wünsch­ten Über­schrif­ten. Falls Sie sich aber nicht auf die ein­ge­bau­ten Python-Da­ten­struk­tu­ren verlassen möchten, können Sie Ihre Daten auch aus einer externen Quelle laden, etwa einer CSV-Datei oder einer SQL-Datenbank. Dafür müssen Sie nur die passende Pandas-Funktion aufrufen:

import pandas
import sqlalchemy
# DataFrame von CSV:
csv = pandas.read_csv("csv-dateien/daten.csv")
# DataFrame von SQL:
engine = create_engine('postgresql://benutzername:passwort@localhost:5432/meine_datenbank')
sql = pandas.read_sql_query('SELECT * FROM tabelle', engine)

Die Da­ta­Frames csv und sql aus dem obigen Beispiel enthalten nun jeweils alle Daten aus der Datei daten.csv und der SQL-Tabelle tabelle. Sie können bei der Er­stel­lung eines Da­ta­Frames aus einer externen Quelle auch zu­sätz­li­che Details spe­zi­fi­zie­ren, zum Beispiel ob die nu­me­ri­schen Indizes im DataFrame in­klu­diert werden sollen oder nicht. Genaueres zu den zu­sätz­li­chen Ar­gu­men­ten der beiden Funk­tio­nen können Sie auf der of­fi­zi­el­len Pandas-DataFrame-Do­ku­men­ta­ti­ons­sei­te nachlesen.

Pandas Da­ta­Frames: Daten anzeigen

Mit Pandas Da­ta­Frames können Sie sich nicht nur die gesamte Tabelle anzeigen lassen, sondern auch einzelne Zeil und Spalten. Darüber hinaus können Sie aussuchen, welche Zeilen und Spalten Sie sehen möchten. Das folgende Beispiel zeigt, wie Sie sich in­di­vi­du­el­le oder mehrere Zeilen bzw. Spalten anzeigen lassen können:

# 0-te Zeile ausgeben
print(df.loc[0])
# Zeilen 3 bis 6 ausgeben
print(df.loc[3:6])
# Zeilen 3 und 6 ausgeben
print(df.loc[[3, 6]])
# Spalte „Beruf“ ausgeben
print(df["Beruf"])
# Spalten „Beruf“ und „Alter“ ausgeben
print(df[["Beruf", "Alter"]])
# Auswahl mehrerer Zeilen und Spalten
print(df.loc[[3, 6], ['Beruf', 'Alter']])

Wie im Beispiel zu sehen ist, nutzt man beim Re­fe­ren­zie­ren einer Spalte nur den Spal­ten­na­men in einfachen Klammern, wie bei Python Dic­tion­a­rys. Da­hin­ge­gen nutzt man beim Re­fe­ren­zie­ren einer Zeile immer das Attribut loc. Mit loc kann man auch logische Be­din­gun­gen verwenden, um Daten zu fil­trie­ren. Dies sehen Sie im folgenden Code-Block, in dem nur Zeilen aus­ge­ge­ben werden, in denen der Wert für „Alter“ größer ist als 30:

print(df.loc[df['Alter'] > 30])

Man kann aber auch das Attribut iloc nutzen, um Zeilen und Spalten basierend auf ihrer Position im DataFrame aus­zu­wäh­len. So kann man sich bei­spiels­wei­se die Zelle ausgeben lassen, die sich in der dritten Zeile und der vierten Spalte befindet:

print(df.iloc[3, 4])
# Ausgabe:
# Hamburg
print(df.iloc[[3, 4, 6], 4])
# Ausgabe:
# 3    Hamburg
# 4    München
# 6    Saarbrücken

Pandas Da­ta­Frames: Über Zeilen iterieren

Bei der Be­ar­bei­tung von Daten in Python muss man sehr häufig über die Zeilen eines Pandas Da­ta­Frames iterieren, um bei­spiels­wei­se dieselbe Operation auf allen Daten an­zu­wen­den. Pandas bietet für diesen Zweck zwei ver­schie­de­ne DataFrame-Methoden an: itertuples() und iterrows(). Beide Methoden haben ihre Vorteile und Nachteile hin­sicht­lich Per­for­mance und Nut­zer­freund­lich­keit.

Die Methode iterrows() gibt für jede Zeile im DataFrame einen Tupel aus Index und Series zurück. Eine Series ist eine weitere Pandas- bzw. NumPy-Da­ten­struk­tur, die in vielen Punkten sehr ähnlich zu einer Python-Liste ist, aber bessere Per­for­mance bietet. Der Zugriff auf in­di­vi­du­el­le Elemente in der Series erfolgt mit dem Spal­ten­na­men, was den Umgang mit den Daten um einiges er­leich­tert.

Obwohl Pandas Series we­sent­lich ef­fi­zi­en­ter sind als Python-Listen, hat diese Da­ten­struk­tur immer noch ein gewisses Per­for­mance-Overhead. Deshalb ist die Methode itertuples() vor allem bei sehr großen Da­ta­Frames zu empfehlen. Im Gegensatz zu iterrows() gibt itertuples() die gesamte Zeile inklusive Index als Tupel zurück, die we­sent­lich per­for­man­ter als Series sind. Bei Tupeln wird mittels eines Punkts auf in­di­vi­du­el­le Elemente zu­ge­grif­fen, wie bei At­tri­bu­ten eines Objekts.

Noch ein wichtiger Un­ter­schied zwischen Series und Tupeln ist, dass Tupel nicht mutable (ver­än­der­bar) sind. Will man also mittels itertuples() über ein DataFrame iterieren und Werte ändern, muss man mit dem at-Attribut und dem Index des Tupels den DataFrame re­fe­ren­zie­ren. Dieses Attribut funk­tio­niert sehr ähnlich wie loc. Folgendes Beispiel dient zur Ver­an­schau­li­chung der Un­ter­schie­de zwischen iterrows() und itertuples():

import pandas
df = pandas.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Alter': [25, 30, 35],
    'Gehalt': [70000.0, 80000.5, 90000.3]
})
for index, row in df.iterrows():
        row['Gehalt'] += 1000
        print(f"Index: {index}, Alter: {row['Alter']}, Gehalt: {row['Gehalt']}")
for tup in df.itertuples():
        df.at[tup.Index, 'Gehalt'] += 1000 # Wert mittels at[] direkt im DataFrame ändern
        print(f"Index: {tup.Index}, Alter: {tup.Alter}, Gehalt: {df.loc[tup.Index, 'Gehalt']}")
# Beide Schleifen haben dieselbe Ausgabe