Bild vom Autor
# Einführung
Es gibt heute zahlreiche Instruments zur Verarbeitung von Datensätzen. Sie alle behaupten – und das tun sie natürlich auch –, dass sie die beste und richtige Wahl für Sie sind. Aber sind sie es? Es gibt zwei Hauptanforderungen, die diese Instruments erfüllen sollten: Sie sollten alltägliche Datenanalysevorgänge einfach und schnell durchführen, selbst unter dem Druck großer Datenmengen.
Um das beste Werkzeug zu ermitteln DuckDB, SQLiteUnd Pandaswir haben sie unter diesen Bedingungen getestet.
Zunächst gaben wir ihnen nur alltägliche Analyseaufgaben: Summieren von Werten, Gruppieren nach Kategorien, Filtern mit Bedingungen und Aggregationen mehrerer Felder. Dies spiegelte wider, wie Analysten tatsächlich mit realen Datensätzen arbeiten, im Vergleich zu Szenarien, die darauf ausgelegt sind, die besten Eigenschaften eines Instruments darzustellen.
Zweitens haben wir diese Operationen an einem Kaggle-Datensatz mit über 1 Million Zeilen durchgeführt. Es ist ein realistischer Wendepunkt – klein genug, um auf einem einzelnen Laptop ausgeführt zu werden, aber groß genug, dass Speicherdruck und Abfragegeschwindigkeit deutliche Unterschiede zwischen den Instruments erkennen lassen.
Mal sehen, wie diese Exams verlaufen sind.
# Der von uns verwendete Datensatz
// Datensatzübersicht
Wir haben den Bankdatensatz von verwendet Kaggle. Dieser Datensatz enthält über 1 Million Zeilen, bestehend aus fünf Spalten:
| Spaltenname | Beschreibung |
|---|---|
| Datum | Das Datum, an dem die Transaktion stattgefunden hat |
| Area | Die Unternehmenskategorie oder -art (EINZELHANDEL, RESTAURANT) |
| Standort | Geografische Area (Goa, Mathura) |
| Wert | Transaktionswert |
| Transaktionsanzahl | Die Gesamtzahl der Transaktionen an diesem Tag |
Dieser Datensatz wird mit Python generiert. Auch wenn es möglicherweise nicht ganz den realen Daten ähnelt, reichen Größe und Struktur aus, um die Leistungsunterschiede zwischen den Instruments zu testen und zu vergleichen.
// Mit Pandas einen Blick in die Daten werfen
Wir haben verwendet Pandas um den Datensatz in ein Jupyter-Notizbuch zu laden und seine allgemeine Struktur, Abmessungen und Nullwerte zu untersuchen. Hier ist der Code.
import pandas as pd
df = pd.read_excel('bankdataset.xlsx')
print("Dataset form:", df.form)
df.head()Hier ist die Ausgabe.
Wenn Sie einen schnellen Überblick über gängige Vorgänge beim Durchsuchen von Datensätzen benötigen, schauen Sie sich dieses praktische Handbuch an Pandas-Spickzettel.
Sehen wir uns vor dem Benchmarking an, wie die Umgebung eingerichtet wird.
# Einrichten einer fairen Testumgebung
Alle drei Instruments – DuckDB, SQLite und Pandas – wurden in derselben Jupyter Pocket book-Umgebung eingerichtet und ausgeführt, um sicherzustellen, dass der Check truthful battle. Dadurch wurde sichergestellt, dass die Bedingungen zur Laufzeit und die Speichernutzung durchgehend konstant blieben.
Zuerst haben wir die notwendigen Pakete installiert und geladen.
Hier sind die Instruments, die wir brauchten:
- Pandas: für Normal
DataFrameOperationen - duckdb: für die SQL-Ausführung auf a
DataFrame - sqlite3: zum Verwalten einer eingebetteten SQL-Datenbank
- Zeit: zum Erfassen der Ausführungszeit
- Memory_profiler: um die Speicherzuordnung zu messen
# Set up if any of them should not in your surroundings
!pip set up duckdb --quiet
import pandas as pd
import duckdb
import sqlite3
import time
from memory_profiler import memory_usageBereiten wir nun die Daten in einem Format vor, das von allen drei Instruments gemeinsam genutzt werden kann.
// Daten in Pandas laden
Wir verwenden Pandas, um den Datensatz einmal zu laden, und geben ihn dann für DuckDB und SQLite frei oder registrieren ihn.
df = pd.read_excel('bankdataset.xlsx')
df.head()Hier ist die zu validierende Ausgabe.
// Registrieren von Daten bei DuckDB
Mit DuckDB können Sie direkt auf Pandas zugreifen DataFrameS. Sie müssen nichts umrechnen – einfach registrieren und abfragen. Hier ist der Code.
# Register DataFrame as a DuckDB desk
duckdb.register("bank_data", df)
# Question through DuckDB
duckdb.question("SELECT * FROM bank_data LIMIT 5").to_df()Hier ist die Ausgabe.
// Vorbereiten von Daten für SQLite
Da SQLite Excel-Dateien nicht direkt liest, haben wir zunächst die Pandas hinzugefügt DataFrame an eine In-Reminiscence-Datenbank. Anschließend verwendeten wir eine einfache Abfrage, um das Datenformat zu untersuchen.
conn_sqlite = sqlite3.join(":reminiscence:")
df.to_sql("bank_data", conn_sqlite, index=False, if_exists="change")
pd.read_sql_query("SELECT * FROM bank_data LIMIT 5", conn_sqlite)Hier ist die Ausgabe.
# Wie wir die Instruments bewertet haben
Wir haben dieselben vier Abfragen für DuckDB, SQLite und Pandas verwendet, um ihre Leistung zu vergleichen. Jede Abfrage wurde für eine allgemeine Analyseaufgabe entwickelt, die widerspiegelt, wie die Datenanalyse in der realen Welt angewendet wird.
// Sicherstellung einer konsistenten Einrichtung
Der In-Reminiscence-Datensatz wurde von allen drei Instruments verwendet.
- Pandas befragte die
DataFramedirekt - DuckDB führte SQL-Abfragen direkt gegen die aus
DataFrame - SQLite hat eine Kopie davon gespeichert
DataFramein einer In-Reminiscence-Datenbank und führte darauf SQL-Abfragen aus
Diese Methode stellte sicher, dass alle drei Instruments dieselben Daten verwendeten und mit denselben Systemeinstellungen arbeiteten.
// Messung der Ausführungszeit
Um die Abfragedauer zu verfolgen, verwendet Python time Das Modul verpackte jede Abfrage in einen einfachen Begin-/Finish-Timer. Es wurde nur die Ausführungszeit der Abfrage aufgezeichnet; Datenlade- und Vorbereitungsschritte wurden ausgeschlossen.
// Verfolgen der Speichernutzung
Zusammen mit der Verarbeitungszeit zeigt die Speichernutzung an, wie intestine jede Engine bei großen Datenmengen funktioniert.
Bei Bedarf kann die Speichernutzung unmittelbar vor und nach jeder Abfrage abgetastet werden, um den inkrementellen RAM-Verbrauch abzuschätzen.
// Die Benchmark-Abfragen
Wir haben jede Engine anhand derselben vier alltäglichen Analyseaufgaben getestet:
- Gesamttransaktionswert: Summieren einer numerischen Spalte
- Nach Domäne gruppieren: Aggregieren der Transaktionszahlen professional Kategorie
- Nach Standort filtern: Zeilen werden vor der Aggregation nach einer Bedingung gefiltert
- Gruppieren nach Domäne und Standort: Mehrfeldaggregation mit Durchschnittswerten
# Benchmark-Ergebnisse
// Abfrage 1: Gesamttransaktionswert
Hier messen wir, wie Pandas, DuckDB und SQLite bei der Summierung abschneiden Worth Spalte im gesamten Datensatz.
// Pandas-Leistung
Wir berechnen den Gesamttransaktionswert anhand von .sum() auf der Worth Spalte. Hier ist der Code.
pandas_results = ()
def pandas_q1():
return df('Worth').sum()
mem_before = memory_usage(-1)(0)
begin = time.time()
pandas_q1()
finish = time.time()
mem_after = memory_usage(-1)(0)
pandas_results.append({
"engine": "Pandas",
"question": "Complete transaction worth",
"time": spherical(finish - begin, 4),
"reminiscence": spherical(mem_after - mem_before, 4)
})
pandas_resultsHier ist die Ausgabe.
// DuckDB-Leistung
Wir berechnen den Gesamttransaktionswert mithilfe einer Vollspaltenaggregation. Hier ist der Code.
duckdb_results = ()
def duckdb_q1():
return duckdb.question("SELECT SUM(worth) FROM bank_data").to_df()
mem_before = memory_usage(-1)(0)
begin = time.time()
duckdb_q1()
finish = time.time()
mem_after = memory_usage(-1)(0)
duckdb_results.append({
"engine": "DuckDB",
"question": "Complete transaction worth",
"time": spherical(finish - begin, 4),
"reminiscence": spherical(mem_after - mem_before, 4)
})
duckdb_resultsHier ist die Ausgabe.
// SQLite-Leistung
Wir berechnen den gesamten Transaktionswert durch Summieren worth Spalte. Hier ist der Code.
sqlite_results = ()
def sqlite_q1():
return pd.read_sql_query("SELECT SUM(worth) FROM bank_data", conn_sqlite)
mem_before = memory_usage(-1)(0)
begin = time.time()
sqlite_q1()
finish = time.time()
mem_after = memory_usage(-1)(0)
sqlite_results.append({
"engine": "SQLite",
"question": "Complete transaction worth",
"time": spherical(finish - begin, 4),
"reminiscence": spherical(mem_after - mem_before, 4)
})
sqlite_resultsHier ist die Ausgabe.
// Gesamtleistungsanalyse
Vergleichen wir nun die Ausführungszeit und die Speichernutzung. Hier ist der Code.
import matplotlib.pyplot as plt
all_q1 = pd.DataFrame(pandas_results + duckdb_results + sqlite_results)
fig, axes = plt.subplots(1, 2, figsize=(10,4))
all_q1.plot(x="engine", y="time", form="barh", ax=axes(0), legend=False, title="Execution Time (s)")
all_q1.plot(x="engine", y="reminiscence", form="barh", colour="salmon", ax=axes(1), legend=False, title="Reminiscence Utilization (MB)")
plt.tight_layout()
plt.present()Hier ist die Ausgabe.
Pandas ist bei weitem das schnellste und speichereffizienteste hier und wird bei minimaler RAM-Nutzung quick sofort ausgeführt. DuckDB ist etwas langsamer und benötigt mehr Speicher, bleibt aber effizient, während SQLite sowohl am langsamsten als auch am höchsten im Hinblick auf den Speicherverbrauch ist.
// Abfrage 2: Nach Domäne gruppieren
Hier messen wir die Leistung von Pandas, DuckDB und SQLite beim Gruppieren von Transaktionen Area und summieren ihre Zählungen.
// Pandas-Leistung
Wir berechnen die Gesamttransaktionszahl professional Area anhand von .groupby() auf der Area Spalte.
def pandas_q2():
return df.groupby('Area')('Transaction_count').sum()
mem_before = memory_usage(-1)(0)
begin = time.time()
pandas_q2()
finish = time.time()
mem_after = memory_usage(-1)(0)
pandas_results.append({
"engine": "Pandas",
"question": "Group by area",
"time": spherical(finish - begin, 4),
"reminiscence": spherical(mem_after - mem_before, 4)
})
(p for p in pandas_results if p("question") == "Group by area")Hier ist die Ausgabe.
// DuckDB-Leistung
Wir berechnen die Gesamtzahl der Transaktionen professional Area mithilfe einer SQL-Anweisung GROUP BY auf der area Spalte.
def duckdb_q2():
return duckdb.question("""
SELECT area, SUM(transaction_count)
FROM bank_data
GROUP BY area
""").to_df()
mem_before = memory_usage(-1)(0)
begin = time.time()
duckdb_q2()
finish = time.time()
mem_after = memory_usage(-1)(0)
duckdb_results.append({
"engine": "DuckDB",
"question": "Group by area",
"time": spherical(finish - begin, 4),
"reminiscence": spherical(mem_after - mem_before, 4)
})
(p for p in duckdb_results if p("question") == "Group by area")Hier ist die Ausgabe.
// SQLite-Leistung
Wir berechnen die Gesamtzahl der Transaktionen professional Area mithilfe von SQL GROUP BY auf der In-Reminiscence-Tabelle.
def sqlite_q2():
return pd.read_sql_query("""
SELECT area, SUM(transaction_count) AS total_txn
FROM bank_data
GROUP BY area
""", conn_sqlite)
mem_before = memory_usage(-1)(0)
begin = time.time()
sqlite_q2()
finish = time.time()
mem_after = memory_usage(-1)(0)
sqlite_results.append({
"engine": "SQLite",
"question": "Group by area",
"time": spherical(finish - begin, 4),
"reminiscence": spherical(mem_after - mem_before, 4)
})
(p for p in sqlite_results if p("question") == "Group by area")Hier ist die Ausgabe.
// Gesamtleistungsanalyse
Vergleichen wir nun die Ausführungszeit und die Speichernutzung. Hier ist der Code.
import pandas as pd
import matplotlib.pyplot as plt
groupby_results = (r for r in (pandas_results + duckdb_results + sqlite_results)
if "Group by" in r("question"))
df_groupby = pd.DataFrame(groupby_results)
fig, axes = plt.subplots(1, 2, figsize=(10,4))
df_groupby.plot(x="engine", y="time", form="barh", ax=axes(0), legend=False, title="Execution Time (s)")
df_groupby.plot(x="engine", y="reminiscence", form="barh", colour="salmon", ax=axes(1), legend=False, title="Reminiscence Utilization (MB)")
plt.tight_layout()
plt.present()Hier ist die Ausgabe.
DuckDB ist am schnellsten, Pandas benötigt etwas mehr Zeit für weniger Speicher, während SQLite sowohl am langsamsten als auch am speicherintensivsten ist.
// Abfrage 3: Nach Standort filtern (Goa)
Hier messen wir die Leistung von Pandas, DuckDB und SQLite beim Filtern des Datensatzes Location = 'Goa' und Summieren der Transaktionswerte.
// Pandas-Leistung
Wir filtern Zeilen nach Location == 'Goa' und summieren ihre Werte. Hier ist der Code.
def pandas_q3():
return df(df('Location') == 'Goa')('Worth').sum()
mem_before = memory_usage(-1)(0)
begin = time.time()
pandas_q3()
finish = time.time()
mem_after = memory_usage(-1)(0)
pandas_results.append({
"engine": "Pandas",
"question": "Filter by location",
"time": spherical(finish - begin, 4),
"reminiscence": spherical(mem_after - mem_before, 4)
})
(p for p in pandas_results if p("question") == "Filter by location")Hier ist die Ausgabe.
// DuckDB-Leistung
Wir filtern Transaktionen nach Location = 'Goa' und berechnen Sie ihren Gesamtwert. Hier ist der Code.
def duckdb_q3():
return duckdb.question("""
SELECT SUM(worth)
FROM bank_data
WHERE location = 'Goa'
""").to_df()
mem_before = memory_usage(-1)(0)
begin = time.time()
duckdb_q3()
finish = time.time()
mem_after = memory_usage(-1)(0)
duckdb_results.append({
"engine": "DuckDB",
"question": "Filter by location",
"time": spherical(finish - begin, 4),
"reminiscence": spherical(mem_after - mem_before, 4)
})
(p for p in duckdb_results if p("question") == "Filter by location")Hier ist die Ausgabe.
// SQLite-Leistung
Wir filtern Transaktionen nach Location = 'Goa' und summieren ihre Werte. Hier ist der Code.
def sqlite_q3():
return pd.read_sql_query("""
SELECT SUM(worth) AS total_value
FROM bank_data
WHERE location = 'Goa'
""", conn_sqlite)
mem_before = memory_usage(-1)(0)
begin = time.time()
sqlite_q3()
finish = time.time()
mem_after = memory_usage(-1)(0)
sqlite_results.append({
"engine": "SQLite",
"question": "Filter by location",
"time": spherical(finish - begin, 4),
"reminiscence": spherical(mem_after - mem_before, 4)
})
(p for p in sqlite_results if p("question") == "Filter by location")Hier ist die Ausgabe.
// Gesamtleistungsanalyse
Vergleichen wir nun die Ausführungszeit und die Speichernutzung. Hier ist der Code.
import pandas as pd
import matplotlib.pyplot as plt
filter_results = (r for r in (pandas_results + duckdb_results + sqlite_results)
if r("question") == "Filter by location")
df_filter = pd.DataFrame(filter_results)
fig, axes = plt.subplots(1, 2, figsize=(10, 4))
df_filter.plot(x="engine", y="time", form="barh", ax=axes(0), legend=False, title="Execution Time (s)")
df_filter.plot(x="engine", y="reminiscence", form="barh", colour="salmon", ax=axes(1), legend=False, title="Reminiscence Utilization (MB)")
plt.tight_layout()
plt.present()Hier ist die Ausgabe.
DuckDB ist die schnellste und effizienteste; Pandas ist bei höherer Speichernutzung langsamer; und SQLite ist am langsamsten, benötigt aber weniger Speicher.
// Abfrage 4: Gruppieren nach Domäne und Standort
// Pandas-Leistung
Wir berechnen den durchschnittlichen Transaktionswert gruppiert nach beiden Area Und Location. Hier ist der Code.
def pandas_q4():
return df.groupby(('Area', 'Location'))('Worth').imply()
mem_before = memory_usage(-1)(0)
begin = time.time()
pandas_q4()
finish = time.time()
mem_after = memory_usage(-1)(0)
pandas_results.append({
"engine": "Pandas",
"question": "Group by area & location",
"time": spherical(finish - begin, 4),
"reminiscence": spherical(mem_after - mem_before, 4)
})
(p for p in pandas_results if p("question") == "Group by area & location")Hier ist die Ausgabe.
// DuckDB-Leistung
Wir berechnen den durchschnittlichen Transaktionswert gruppiert nach beiden area Und location. Hier ist der Code.
def duckdb_q4():
return duckdb.question("""
SELECT area, location, AVG(worth) AS avg_value
FROM bank_data
GROUP BY area, location
""").to_df()
mem_before = memory_usage(-1)(0)
begin = time.time()
duckdb_q4()
finish = time.time()
mem_after = memory_usage(-1)(0)
duckdb_results.append({
"engine": "DuckDB",
"question": "Group by area & location",
"time": spherical(finish - begin, 4),
"reminiscence": spherical(mem_after - mem_before, 4)
})
(p for p in duckdb_results if p("question") == "Group by area & location")Hier ist die Ausgabe.
// SQLite-Leistung
Wir berechnen den durchschnittlichen Transaktionswert gruppiert nach beiden area Und location. Hier ist der Code.
def sqlite_q4():
return pd.read_sql_query("""
SELECT area, location, AVG(worth) AS avg_value
FROM bank_data
GROUP BY area, location
""", conn_sqlite)
mem_before = memory_usage(-1)(0)
begin = time.time()
sqlite_q4()
finish = time.time()
mem_after = memory_usage(-1)(0)
sqlite_results.append({
"engine": "SQLite",
"question": "Group by area & location",
"time": spherical(finish - begin, 4),
"reminiscence": spherical(mem_after - mem_before, 4)
})
(p for p in sqlite_results if p("question") == "Group by area & location")Hier ist die Ausgabe.
// Gesamtleistungsanalyse
Vergleichen wir nun die Ausführungszeit und die Speichernutzung. Hier ist der Code.
import pandas as pd
import matplotlib.pyplot as plt
gdl_results = (r for r in (pandas_results + duckdb_results + sqlite_results)
if r("question") == "Group by area & location")
df_gdl = pd.DataFrame(gdl_results)
fig, axes = plt.subplots(1, 2, figsize=(10, 4))
df_gdl.plot(x="engine", y="time", form="barh", ax=axes(0), legend=False,
title="Execution Time (s)")
df_gdl.plot(x="engine", y="reminiscence", form="barh", ax=axes(1), legend=False,
title="Reminiscence Utilization (MB)", colour="salmon")
plt.tight_layout()
plt.present()Hier ist die Ausgabe.
DuckDB verarbeitet Mehrfeld-Gruppierungen am schnellsten bei mäßiger Speichernutzung, Pandas ist bei sehr hoher Speichernutzung langsamer und SQLite ist bei erheblichem Speicherverbrauch am langsamsten.
# Endgültiger Vergleich aller Abfragen
Wir haben diese drei Engines hinsichtlich Speicher und Geschwindigkeit miteinander verglichen. Schauen wir uns noch einmal die Ausführungszeit an. Hier ist der Code.
import pandas as pd
import matplotlib.pyplot as plt
all_results = pd.DataFrame(pandas_results + duckdb_results + sqlite_results)
measure_order = (
"Complete transaction worth",
"Group by area",
"Filter by location",
"Group by area & location",
)
engine_colors = {"Pandas": "#1f77b4", "DuckDB": "#ff7f0e", "SQLite": "#2ca02c"}
fig, axes = plt.subplots(2, 2, figsize=(12, 8))
axes = axes.ravel()
for i, q in enumerate(measure_order):
d = all_results(all_results("question") == q)
axes(i).barh(d("engine"), d("time"),
colour=(engine_colors(e) for e in d("engine")))
for y, v in enumerate(d("time")):
axes(i).textual content(v, y, f" {v:.3f}", va="heart")
axes(i).set_title(q, fontsize=10)
axes(i).set_xlabel("Seconds")
fig.suptitle("Per-Measure Comparability — Execution Time", fontsize=14)
plt.tight_layout()
plt.present()Hier ist die Ausgabe.
Dieses Diagramm zeigt, dass DuckDB bei quick allen Abfragen durchweg die niedrigsten Ausführungszeiten aufweist, mit Ausnahme des Gesamttransaktionswerts, bei dem Pandas die Nase vorn hat. SQLite ist auf der ganzen Linie mit Abstand das langsamste. Lassen Sie uns als nächstes den Speicher überprüfen. Hier ist der Code.
import pandas as pd
import matplotlib.pyplot as plt
all_results = pd.DataFrame(pandas_results + duckdb_results + sqlite_results)
measure_order = (
"Complete transaction worth",
"Group by area",
"Filter by location",
"Group by area & location",
)
engine_colors = {"Pandas": "#1f77b4", "DuckDB": "#ff7f0e", "SQLite": "#2ca02c"}
fig, axes = plt.subplots(2, 2, figsize=(12, 8))
axes = axes.ravel()
for i, q in enumerate(measure_order):
d = all_results(all_results("question") == q)
axes(i).barh(d("engine"), d("reminiscence"),
colour=(engine_colors(e) for e in d("engine")))
for y, v in enumerate(d("reminiscence")):
axes(i).textual content(v, y, f" {v:.1f}", va="heart")
axes(i).set_title(q, fontsize=10)
axes(i).set_xlabel("MB")
fig.suptitle("Per-Measure Comparability — Reminiscence Utilization", fontsize=14)
plt.tight_layout()
plt.present()Hier ist die Ausgabe.
Dieses Diagramm zeigt, dass SQLite bei der Speichernutzung zwischen der besten und der schlechtesten Leistung schwankt, Pandas mit zwei besten und zwei schlechtesten Fällen extrem ist, während DuckDB bei allen Abfragen konstant im Mittelfeld bleibt. Infolgedessen erweist sich DuckDB insgesamt als die ausgewogenste Wahl und liefert eine konstant schnelle Leistung bei moderater Speichernutzung. Pandas zeigt Excessive – manchmal die schnellsten, manchmal die schwersten –, während SQLite mit der Geschwindigkeit zu kämpfen hat und beim Speicher oft auf der ineffizienten Seite landet.
Nate Rosidi ist Datenwissenschaftler und in der Produktstrategie tätig. Er ist außerdem außerordentlicher Professor für Analytik und Gründer von StrataScratch, einer Plattform, die Datenwissenschaftlern hilft, sich mit echten Interviewfragen von High-Unternehmen auf ihre Interviews vorzubereiten. Nate schreibt über die neuesten Traits auf dem Karrieremarkt, gibt Ratschläge zu Vorstellungsgesprächen, stellt Knowledge-Science-Projekte vor und behandelt alles rund um SQL.