Python Pandas und SQL | Leitfaden 2026 zur nahtlosen Datenanalyse

Python, Pandas und SQL bilden die Grundlage für Datenanalyse, maschinelles Lernen und ETL-Pipelines. Die Verarbeitung großer DataFrames und die Ausführung komplexer Datenbankabfragen erfordert Effizienz, ohne dabei die Codeübersichtlichkeit zu beeinträchtigen.

Dieser Leitfaden behandelt die Einrichtung von pandasql und die nativen SQL-Methoden von Pandas, stellt Beispiele für DataFrame-Abfragen aus der Praxis vor und beschreibt Best Practices zur Optimierung von Analyse-Workflows und Berichten.

Die Brücke: PandasSQL und native Pandas SQL-Integration

pandasql ermöglicht die direkte Ausführung von SQL-Abfragen auf Pandas DataFrames, wodurch der Export von Daten , die Bereitstellung einer separaten Datenbank oder die Verwendung zusätzlicher APIs entfällt; Benutzer schreiben einfach SQL-Anweisungen, erhalten einen resultierenden DataFrame und können ungestört fortfahren.

Pandasql installieren

python

pip install pandasql

Jetzt sind Sie bereit, SQL und Pandas wie ein Profi zu kombinieren.

Erste Schritte: Grundlegende Verwendung

Lassen Sie uns ein einfaches Beispiel durchgehen. Angenommen, Sie haben einen DataFrame:

python

import pandas as pd
import pandasql as psql

data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)

query = "SELECT * FROM df"
result = psql.sqldf(query, locals())
print(result)

Dies gibt den vollständigen DataFrame zurück, genau wie df.head() aber mit SQL-Syntax. Sie können jetzt filtern, gruppieren und verknüpfen, genau wie in einer Datenbank.

Realweltdatenanalyse mit Pandas und SQL

Lassen Sie uns einen praktischen Datensatz betrachten. Stellen Sie sich vor, Sie analysieren einen Datensatz zu Autoverkäufen mit Spalten wie brand, model, year, price, mileageund vieles mehr.

Laden und Untersuchen von Daten

python

import pandas as pd
import pandasql as ps

car_data = pd.read_csv("cars_datasets.csv")
print(car_data.head())

print(car_data.info())
print(car_data.isnull().sum())

Sie sehen die Spaltennamen, Datentypen und alle fehlenden Werte – unerlässlich für eine qualitativ hochwertige Datenanalyse.

Ausführen von SQL-Abfragen auf DataFrames

python

def q(query):
    return ps.sqldf(query, {'car_data': car_data})

q("""
SELECT brand, model, year, price
FROM car_data
ORDER BY price DESC
LIMIT 10
""")

python

q("""
SELECT brand, ROUND(AVG(price), 2) AS avg_price
FROM car_data
GROUP BY brand
ORDER BY avg_price DESC
""")

python

q("""
SELECT *
FROM car_data
WHERE year > 2015
ORDER BY year DESC
""")

python

q("""
SELECT brand, COUNT(*) as total_listed
FROM car_data
GROUP BY brand
ORDER BY total_listed DESC
LIMIT 5
""")

python

q("""
SELECT condition, ROUND(AVG(price), 2) AS avg_price, COUNT(*) as listings
FROM car_data
GROUP BY condition
ORDER BY avg_price DESC
""")

python

q("""
SELECT brand,
ROUND(AVG(mileage), 2) AS avg_mileage,
ROUND(AVG(price), 2) AS avg_price,
COUNT(*) AS total_listings
FROM car_data
GROUP BY brand
ORDER BY avg_price DESC
LIMIT 10
""")

python

q("""
SELECT brand,
ROUND(AVG(price/mileage), 4) AS price_per_mile,
COUNT(*) AS total
FROM car_data
WHERE mileage > 0
GROUP BY brand
ORDER BY price_per_mile DESC
LIMIT 10
""")

Sie können sogar Widgets und Plotly für interaktive Dashboards verwenden:

python

import plotly.express as px
import ipywidgets as widgets

state_dropdown = widgets.Dropdown(
    options=car_data['state'].unique().tolist(),
    value=car_data['state'].unique()[0],
    description='Select State:',
    layout=widgets.Layout(width='50%')
)

def plot_avg_price_state(state_selected):
    query = f"""
    SELECT brand, AVG(price) AS avg_price
    FROM car_data
    WHERE state = '{state_selected}'
    GROUP BY brand
    ORDER BY avg_price DESC
    """
    result = q(query)
    fig = px.bar(result, x='brand', y='avg_price', color='brand',
                 title=f"Average Car Price in {state_selected}")
    fig.show()

widgets.interact(plot_avg_price_state, state_selected=state_dropdown)

Dadurch wird Ihre Analyse interaktiv und visuell ansprechend – perfekt für Dashboards oder Präsentationen.

Über PandasSQL hinaus: Native Pandas SQL-Operationen

Während PandasSQL für schnelle Abfragen im SQL-Stil hervorragend geeignet ist, unterstützt Pandas auch die direkte SQL-Integration für die Arbeit mit echten Datenbanken (wie SQLite, PostgreSQL, MySQL):

Beispiel: Lesen und Schreiben in SQL

python

import pandas as pd
import sqlite3

# Connect to SQLite database
conn = sqlite3.connect(":memory:")

# Create a table and insert data
conn.execute("CREATE TABLE Students (id INTEGER, Name TEXT, Marks REAL, Age INTEGER)")
conn.execute("INSERT INTO Students VALUES (1, 'Kiran', 80, 16), (2, 'Priya', 60, 14), (3, 'Naveen', 82, 15)")

# Read from SQL
df = pd.read_sql("SELECT * FROM Students", conn)
print(df)

# Write to SQL
df.to_sql("Students_Copy", conn, if_exists="replace", index=False)

Dieser Ansatz eignet sich perfekt für ETL-Pipelines, Berichte und Produktionsdaten-Workflows.

Erweiterte Anwendungsfälle: ETL, maschinelles Lernen und Dashboards

Bei der Kombination von SQL und Pandas geht es nicht nur um Abfragen, sondern auch um die Erstellung intelligenterer Arbeitsabläufe:

Pandasql vs. Pure Pandas: Wann sollte was verwendet werden?

Funktion	Pandasql (SQL)	Reine Pandas
Syntax	SQL (vielen bekannt)	Python (flexibel, leistungsstark)
Ablesbarkeit	Hoch für komplexe Abfragen	Kann ausführlich werden
Leistung	Langsamer bei sehr großen Datensätzen	Schneller, optimiert für Python
Verknüpfungen/Gruppierung	Sehr intuitiv	Mehr Code, aber mehr Optionen
Integration	Ideal für schnelle Analysen	Am besten für Produktionsabläufe

Einschränkungen und bewährte Methoden

Fazit

Die integrierte Nutzung von Python Pandas und SQL stellt eine wesentliche Kompetenz für Datenanalysten dar, AI Ingenieure und Forscher. Diese Methodik verbindet relationale Datenbankabfragen mit Pandas‘ leistungsstarker DataFrame Geschäftstätigkeit, wodurch sowohl die Effizienz als auch die Code-Verständlichkeit verbessert werden. Durch die Nutzung von Tools wie PandasSQL und der nativen SQL-Integration von Pandas können Teams explorative Datenanalysen (EDA), robuste ETL-Workflows und Machine-Learning-Pipelines in einer einheitlichen Umgebung ausführen.

Wichtige Statistiken:

Die Einführung dieses dualen Ansatzes gewährleistet skalierbare, wartbare Analyseprozesse und positioniert Teams für langfristigen Erfolg.