Pandas DataFrame: Tabellen in Python effizient und struk­tu­riert be­ar­bei­ten!

Der pandas DataFrame ist eine Python-Da­ten­struk­tur, mit der du Tabellen erstellen und be­ar­bei­ten kannst. Wir erklären dir den Aufbau dieser Struktur sowie die 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 erlaubt es, Daten leicht ver­ständ­lich zu or­ga­ni­sie­ren, ähnlich wie in Excel oder Libre­Of­fice. Jede Spalte kann un­ter­schied­li­che Python-Da­ten­ty­pen enthalten. Ein DataFrame kann also he­te­ro­ge­ne Daten speichern – etwa Zahlen, Text und Booleans in einer einzigen Tabelle.

Aufbau von pandas Da­ta­Frames

Ein DataFrame besteht aus drei Kern­kom­po­nen­ten: den Daten, den Zei­len­in­di­zes und den Spal­ten­na­men. Der Zei­len­in­dex dient als ein­deu­ti­ge Kennung für jede Zeile. Stan­dard­mä­ßig sind Zeilen numerisch indexiert, du kannst sie aber durch Strings ersetzen. Beachte, dass pandas Da­ta­Frames null-indexiert sind, die Indizes beginnen also bei 0.

Close

Der Umgang mit pandas Da­ta­Frames

pandas Da­ta­Frames bieten viele Methoden, um Daten effizient zu be­ar­bei­ten, zu ana­ly­sie­ren und zu vi­sua­li­sie­ren. Hier lernst du die wich­tigs­ten Konzepte zur Da­ten­ma­ni­pu­la­ti­on kennen.

Pandas DataFrame erstellen

Hast du deine Daten bereits in einer Python-Liste oder einem Python-Dic­tion­a­ry, kannst du daraus leicht einen DataFrame erstellen. Übergib die Struktur einfach dem Kon­struk­tor pandas.DataFrame([Daten]). Die In­ter­pre­ta­ti­on hängt vom Typ ab. So erstellst du einen DataFrame aus einer Liste:

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 du im Beispiel siehst, entstehen aus einfachen Listen Da­ta­Frames mit nur einer einzelnen, un­be­schrif­te­ten Spalte. Daher ist es besser, Da­ta­Frames aus Dic­tio­n­a­ries mit Listen zu erstellen. Dabei werden die Schlüssel zu Spal­ten­na­men und die Listen zu den Daten. Hier ein Beispiel:

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

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 enthalten nun alle Daten aus der Datei daten.csv bzw. der SQL-Tabelle tabelle. Du kannst beim Import weitere Details festlegen, etwa ob Indizes über­nom­men werden sollen. Details dazu findest du in der of­fi­zi­el­len pandas-Do­ku­men­ta­ti­on.

Pandas Da­ta­Frames: Daten anzeigen

Du kannst die ganze Tabelle oder gezielt Zeilen und Spalten ausgeben. Das folgende Beispiel zeigt, wie du einzelne oder mehrere Bereiche se­lek­tierst:

# 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']])

Spalten sprichst du über ihren Namen in Klammern an, ähnlich wie bei Dic­tio­n­a­ries. Für Zeilen nutzt du das Attribut loc. Mit loc kannst du Daten auch nach logischen Be­din­gun­gen filtern. Hier werden nur Zeilen aus­ge­ge­ben, in denen „Alter“ über 30 liegt:

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

Mit dem Attribut iloc wählst du Daten basierend auf ihrer Position aus. So greifst du etwa auf die Zelle in der dritten Zeile und vierten Spalte zu:

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

Oft musst du jede Zeile einzeln be­ar­bei­ten. pandas bietet dafür zwei Methoden: itertuples() und iterrows(). Beide haben Vor- und Nachteile bei Per­for­mance und Komfort.

Die Methode iterrows() liefert für jede Zeile ein Tupel aus Index und Series zurück. Eine Series ist ähnlich wie eine Liste, aber per­for­man­ter. Der Zugriff erfolgt bequem über den Spal­ten­na­men.

Obwohl Series effizient sind, ver­ur­sa­chen sie Re­chen­auf­wand. Daher ist itertuples() bei sehr großen Da­ta­Frames besser. Im Gegensatz zu iterrows() gibt itertuples() die ganze Zeile inkl. Index als Tupel zurück. Diese sind schneller, und der Zugriff erfolgt per Punkt-Notation, wie bei Objekt-At­tri­bu­ten.

Wichtig: Tupel sind un­ver­än­der­bar (immutable). Willst du Werte während der Iteration mit itertuples() ändern, musst du den DataFrame über das at-Attribut und den Index re­fe­ren­zie­ren. Das funk­tio­niert ähnlich wie loc. Hier der Vergleich:

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