Pandas DataFrame erklärt mit Beispielen im Jahr 2026

Ein Pandas DataFrame ist Eine zweidimensionale, tabellarische Datenstruktur in Python mit beschrifteten Zeilen und Spalten, die für die schnelle Datenbereinigung, -analyse und -transformation entwickelt wurde. Man kann sie sich als eine Art In-Memory-Tabellenkalkulation mit leistungsstarken Indizierungs-, Auswahl- und Aggregationsfunktionen vorstellen.

Im Folgenden finden Sie Erklärungen zu Pandas DataFrames anhand von Beispielen, die Sie kopieren, ausführen und anpassen können. Pandas DataFrames sind der zentrale Baustein der Datenanalyse in Python. Sie ermöglichen ein einfaches und effizientes Importieren, Bereinigen, Transformieren und Zusammenfassen von Daten.

In diesem Leitfaden erkläre ich, was ein DataFrame ist, wie man ihn erstellt und wie man damit arbeitet. Dabei zeige ich Ihnen anhand praktischer Beispiele und bewährter Methoden aus realen Analyse- und Entwicklungsprojekten, was ich meine.

Was ist ein Pandas-DataFrame?

Ein Pandas DataFrame ist eine zweidimensionale, beschriftete Tabelle, in der Folgendes gilt:

• Spalten können aufnehmen verschiedene Datentypen (int, float, string, datetime, kategorisch).
• Reihen und Spalten mit Beschriftungen (Index- und Spaltennamen) für einen schnellen, für Menschen lesbaren Zugriff.
• Vektorisierte Operationen Ermöglichen schnelle Arithmetik und Transformationen über Spalten hinweg.

DataFrames basieren auf Series. (1D-Arrays) und sind für eine optimale Performance eng mit NumPy integriert. Im Vergleich zu einfachen Python-Listen oder der Verarbeitung von CSV-Dateien bieten DataFrames integrierte Werkzeuge für fehlende Werte, Joins, Gruppierungsoperationen und Analysen.

Pandas DataFrame vs. Series vs. NumPy Array

• Serie: 1D beschriftetes Array (wie eine einzelne Spalte).
• DataFrame: 2D-Tabelle mit Beschriftungen, in der mehrere Serien nach Index ausgerichtet sind.
• NumPy-Array: Schnelles, homogenes n-dimensionales Array (ohne Spaltenbezeichnungen oder gemischte Datentypen).

Wählen Sie DataFrame für beschriftete, tabellarische Daten unterschiedlicher Datentypen; NumPy-Arrays für rein numerische Daten desselben Typs; Series für einzelne Spalten oder Merkmale.

Wie man einen DataFrame erstellt (mit Beispielen)

1. Aus Python-Dictionaries oder -Listen

import pandas as pd

data = {
    "name": ["Ava", "Ben", "Chad"],
    "age": [29, 34, 27],
    "city": ["Dallas", "Austin", "Houston"]
}

df = pd.DataFrame(data)
print(df)

Dies ist die einfachste Methode, um einen kleinen DataFrame für Testzwecke oder Demos zu erstellen.

2. Aus CSV, Excel, JSON oder SQL

# CSV
df = pd.read_csv("sales.csv")

# Excel
df_xls = pd.read_excel("sales.xlsx", sheet_name="Q1")

# JSON
df_json = pd.read_json("data.json")

# SQL (requires an engine, e.g., SQLite or PostgreSQL)
from sqlalchemy import create_engine
engine = create_engine("sqlite:///app.db")
df_sql = pd.read_sql("SELECT * FROM orders", engine)

Nutzen Sie diese Reader in realen Projekten, insbesondere für größere Datensätze und Produktionspipelines.

3. Aus NumPy-Arrays oder Series

import numpy as np
arr = np.array([[1, 2], [3, 4]])
df_np = pd.DataFrame(arr, columns=["a", "b"])
print(df_np)

Wenn die Daten numerisch und unbeschriftet sind, sollten Sie sofort Spaltennamen hinzufügen, um die Übersichtlichkeit zu gewährleisten und die Kompatibilität mit nachfolgenden Systemen sicherzustellen.

Daten auswählen, indizieren und filtern

.loc vs .iloc

# Sample setup
df = pd.DataFrame({
    "name": ["Ava", "Ben", "Chad", "Dana"],
    "age": [29, 34, 27, 31],
    "score": [85, 92, 88, 79]
}, index=["u1", "u2", "u3", "u4"])

# Label-based selection with .loc
print(df.loc["u2", "score"])        # row label "u2", column "score"
print(df.loc["u1":"u3", ["name","age"]])  # slice by labels

# Position-based selection with .iloc
print(df.iloc[1, 2])                # second row, third column (0-based)
print(df.iloc[0:2, 0:2])            # top-left 2x2 block

Boolesche Filterung und Abfrage

# Filter rows
adults = df[df["age"] >= 30]
high_scorers = df[(df["score"] >= 90) & (df["age"] < 35)]

# Using query (readable for complex filters)
top = df.query("score >= 90 and age < 35")

Verwenden Sie aus Geschwindigkeits- und Lesbarkeitsgründen lieber vektorisierte boolesche Masken oder Abfragezeichenfolgen anstelle von Schleifen.

Häufige DataFrame-Operationen

Spalten hinzufügen, umbenennen und löschen

# Create or transform columns
df["age_group"] = pd.cut(df["age"], bins=[0, 29, 100], labels=["Young", "Adult"])
df = df.rename(columns={"score": "exam_score"})
df = df.drop(columns=["age_group"])

Sortieren und Rangfolge

df_sorted = df.sort_values(by=["exam_score", "age"], ascending=[False, True])
df["rank"] = df["exam_score"].rank(ascending=False, method="dense")

Gruppierung und Aggregation

sales = pd.DataFrame({
    "region": ["US","US","EU","EU","APAC"],
    "rep": ["A","B","C","D","E"],
    "revenue": [100, 130, 90, 120, 150]
})

summary = sales.groupby("region")["revenue"].agg(["count","sum","mean","max"])
print(summary)

GroupBy teilt Daten in Gruppen auf, wendet Funktionen an und kombiniert die Ergebnisse. Es ist das Arbeitspferd für Berichte und BI-Zusammenfassungen.

Anwenden vs. Vektorisierung

# Prefer vectorized operations
df["double_score"] = df["exam_score"] * 2

# If you must use apply, keep it simple (it’s slower)
df["pass_fail"] = df["exam_score"].apply(lambda x: "Pass" if x >= 80 else "Fail")

Vektorisierte Operationen nutzen C-optimierte Routinen und sind deutlich schneller als zeilenweises Apply.

Umgang mit fehlenden Daten und Datentypen

Fehlende Werte erkennen, auffüllen oder verwerfen

df.isna().sum()                      # count of NaNs per column
df_filled = df.fillna({"exam_score": 0})
df_dropped = df.dropna(subset=["exam_score"])

Nutzen Sie domänenspezifische Strategien: Füllen Sie Zeitreihen vorwärts auf, füllen Sie schiefe numerische Daten mit Medianen auf oder lassen Sie sie gegebenenfalls weg.

Datentypen für Geschwindigkeit und Speicheroptimierung anpassen

# Convert strings that look like numbers
df["exam_score"] = pd.to_numeric(df["exam_score"], errors="coerce")

# Categorical for repeated strings
df["name"] = df["name"].astype("category")

# Parse datetimes
df["date"] = pd.to_datetime(df["date"], errors="coerce")

Die Verwendung geeigneter Datentypen (insbesondere kategorische und Datums-/Zeitdaten) reduziert den Speicherbedarf und ermöglicht ein schnelleres Filtern und Gruppieren.

Zusammenführen, Verbinden und Verketten

Mehrere DataFrames lassen sich genauso kombinieren wie SQL-Joins oder gestapelte Tabellen.

customers = pd.DataFrame({
    "cust_id": [1,2,3],
    "name": ["Ava","Ben","Chad"]
})
orders = pd.DataFrame({
    "order_id": [101,102,103],
    "cust_id": [1,1,3],
    "amount": [39.5, 12.0, 55.0]
})

# SQL-style inner join on a key
merged = pd.merge(orders, customers, on="cust_id", how="inner")

# Concatenate rows (stack)
stacked = pd.concat([orders, orders], ignore_index=True)

# Join by index
customers_i = customers.set_index("cust_id")
orders_i = orders.set_index("cust_id")
joined = customers_i.join(orders_i, how="left")

Wählen Sie „inner“ für die Schnittmenge, „left“ für die Beibehaltung aller Elemente der linken Tabelle und „outer“ für die vollständige Vereinigung. Überprüfen Sie stets die Eindeutigkeit der Schlüssel, um Duplikate zu vermeiden.

Ein-/Ausgabe und Serialisierung: CSV vs. Parquet vs. Feather

CSV ist zwar für Menschen lesbar, aber groß und langsam zu verarbeiten. Parquet und Feather sind binäre, spaltenorientierte Formate, die schneller geladen werden und weniger Speicherplatz benötigen.

# CSV
df.to_csv("data.csv", index=False)

# Parquet (requires pyarrow or fastparquet)
df.to_parquet("data.parquet", index=False)

# Feather (fast for Python-R interchange)
df.to_feather("data.feather")

Für Analysen im großen Maßstab empfiehlt sich Parquet oder Feather, um den I/O-Overhead zu reduzieren und die Pipelines zu beschleunigen.

Leistungstipps für große DataFrames

• In Abschnitten lesen: Verwenden Sie read_csv mit chunksize für sehr große Dateien.
• Negative Zahlen: Konvertiere float64/int64 in float32/int32, wenn es sicher ist.
• Verwenden Sie den kategorischen Datentyp für wiederholte Zeichenketten (z. B. Ländercodes, Produkt-IDs).
• Vektorisierte Operationen und integrierte Aggregationen sind Schleifen vorzuziehen.
• Frühzeitig filtern, nur die notwendigen Spalten auswählen (usecols=…).
• Zwischenergebnisse im Parquet-Format speichern, um schnellere Wiederholungen zu ermöglichen.

# Example: chunked CSV processing
import pandas as pd

total = 0
for chunk in pd.read_csv("events.csv", usecols=["user_id","amount"], chunksize=500_000):
    chunk["amount"] = pd.to_numeric(chunk["amount"], errors="coerce")
    total += chunk["amount"].sum(skipna=True)
print(total)

Die Arbeit mit Millionen von Zeilen bietet folgende Vorteile: Starke Rechenleistung und I/O-Leistung sind erforderlich. Wenn Sie Jupyter-, Airflow- oder ETL-Skripte in der Cloud ausführen, ist ein skalierbarer VPS mit NVMe-Speicher hilfreich. YouStableWir stellen SSD/NVMe-VPS bereit und managed Cloud-Instanzen, die für Daten-Workflows geeignet sind, damit Ihre Pandas-Jobs schneller und zuverlässiger abgeschlossen werden.

Beispiele aus der Praxis, die Sie wiederverwenden können

Web-Log-Analyse (Filterung und Gruppierung)

import pandas as pd

logs = pd.read_csv("access.log.csv", usecols=["ip","status","bytes","ts"])
# Parse timestamp and filter errors
logs["ts"] = pd.to_datetime(logs["ts"])
errors = logs[logs["status"].isin([500, 502, 503, 504])]

# Error rate by minute
rate = (errors
        .groupby(pd.Grouper(key="ts", freq="1min"))
        .size()
        .rename("errors_per_min"))
print(rate.tail())

Vertriebsanalysen (Verknüpfungen und Aggregationen)

orders = pd.read_csv("orders.csv")           # order_id, cust_id, amount, date
customers = pd.read_csv("customers.csv")     # cust_id, segment

df = pd.merge(orders, customers, on="cust_id", how="left")
df["date"] = pd.to_datetime(df["date"])

# Revenue by segment and month
monthly = (df
    .groupby([pd.Grouper(key="date", freq="MS"), "segment"])["amount"]
    .sum()
    .reset_index()
    .sort_values(["date", "segment"]))
print(monthly.head())

Diese Muster tauchen in Business-Dashboards, bei der Anomalieerkennung und bei der Kapazitätsplanung in den verschiedenen Engineering-Teams auf.

Best-Practice-Checkliste

• Benennen Sie die Spalten klar und einheitlich (SnakeCase empfohlen).
• Setzen Sie einen Index, wenn er Identität oder Zeit vermittelt (z. B. einen Datums-/Zeitindex für Zeitreihen).
• Joins validieren: Überprüfen Sie nach dem Zusammenführen die Eindeutigkeit der Schlüssel und die Anzahl der Zeilen.
• Verwenden Sie Parquet für große, mittlere Datensätze, CSV für den Austausch mit Menschen.
• Konvertieren Sie Datentypen frühzeitig, um Überraschungen zu vermeiden und Speicher zu sparen.
• Bevorzugen Sie Vektorisierung und integrierte Methoden; vermeiden Sie zeilenweises Apply in engen Schleifen.
• Schreiben Sie reproduzierbaren Code: Fixieren Sie Versionen und initialisieren Sie die Zufallszahlen bei Bedarf.

Häufig gestellte Fragen