Wenn Sie mit Python für Daten arbeiten, haben Sie wahrscheinlich schon einmal die frustrierende Erfahrung gemacht, mehrere Minuten auf den Abschluss einer Pandas-Operation warten zu müssen.
Zunächst scheint alles in Ordnung zu sein, aber wenn Ihr Datensatz wächst und Ihre Arbeitsabläufe komplexer werden, hat Ihr Laptop computer plötzlich das Gefühl, als würde er sich auf den Begin vorbereiten.
Vor ein paar Monaten habe ich an einem Projekt gearbeitet, bei dem E-Commerce-Transaktionen mit über 3 Millionen Datenzeilen analysiert wurden.
Es struggle eine ziemlich interessante Erfahrung, aber die meiste Zeit sah ich zu, wie sich einfache Gruppenoperationen, die normalerweise in Sekunden liefen, plötzlich in Minuten ausdehnten.
An diesem Punkt wurde mir klar, dass Pandas großartig ist, aber es reicht nicht immer aus.
Dieser Artikel untersucht moderne Alternativen zu Pandas, einschließlich Polars und DuckDB, und untersucht, wie sie die Handhabung großer Datensätze vereinfachen und verbessern können.
Lassen Sie mich aus Gründen der Klarheit einige Dinge im Voraus sagen, bevor wir beginnen.
Dieser Artikel ist kein tiefer Einblick in die Rust-Speicherverwaltung und auch keine Behauptung, Pandas sei veraltet.
Vielmehr handelt es sich um einen praktischen, praktischen Leitfaden. Sie werden reale Beispiele, persönliche Erfahrungen und umsetzbare Einblicke in Arbeitsabläufe sehen, die Ihnen Zeit und Verstand sparen können.
Warum Pandas sich langsam fühlen können
Ich erinnere mich, dass ich damals, als ich am E-Commerce-Projekt beteiligt struggle, mit CSV-Dateien gearbeitet habe, die mehr als zwei Gigabyte groß waren, und dass jeder Filter oder jede Aggregation in Pandas oft mehrere Minuten in Anspruch nahm.
Während dieser Zeit starrte ich auf den Bildschirm und wünschte, ich könnte einfach einen Kaffee trinken oder ein paar Episoden einer Present genießen, während der Code ausgeführt wurde.
Die Hauptprobleme, auf die ich gestoßen bin, waren Geschwindigkeit, Speicher und Komplexität des Arbeitsablaufs.
Wir alle wissen, wie große CSV-Dateien enorm viel RAM verbrauchen, manchmal mehr, als mein Laptop computer problemlos bewältigen kann. Darüber hinaus machte die Verkettung mehrerer Transformationen die Wartung des Codes schwieriger und die Ausführung langsamer.
Polars und DuckDB gehen diese Herausforderungen auf unterschiedliche Weise an.
Polars, erstellt in Rust, nutzt Multithread-Ausführung, um große Datensätze effizient zu verarbeiten.
DuckDB hingegen ist für Analysen konzipiert und führt SQL-Abfragen aus, ohne dass Sie alles in den Speicher laden müssen.
Im Grunde hat jeder von ihnen seine eigene Superkraft. Polars ist der Flitzer und DuckDB ist so etwas wie der Speichermagier.
Und das Beste daran? Beide lassen sich nahtlos in Python integrieren, sodass Sie Ihre Arbeitsabläufe verbessern können, ohne sie komplett neu schreiben zu müssen.
Einrichten Ihrer Umgebung
Bevor wir mit dem Codieren beginnen, stellen Sie sicher, dass Ihre Umgebung bereit ist. Aus Konsistenzgründen habe ich Pandas 2.2.0, Polars 0.20.0 und DuckDB 1.9.0 verwendet.
Das Anheften von Versionen kann Ihnen Kopfschmerzen ersparen, wenn Sie Tutorials folgen oder Code teilen.
pip set up pandas==2.2.0 polars==0.20.0 duckdb==1.9.0Importieren Sie in Python die Bibliotheken:
import pandas as pd
import polars as pl
import duckdb
import warnings
warnings.filterwarnings("ignore")
Ich verwende beispielsweise einen E-Commerce-Verkaufsdatensatz mit Spalten wie Bestell-ID, Produkt-ID, Area, Land, Umsatz und Datum. Ähnliche Datensätze können Sie hier herunterladen Kaggle oder synthetische Daten generieren.
Daten werden geladen
Das effiziente Laden von Daten gibt den Ton für den Relaxation Ihres Arbeitsablaufs vor. Ich erinnere mich an ein Projekt, bei dem die CSV-Datei quick 5 Millionen Zeilen hatte.
Pandas hat es geschafft, aber die Ladezeiten waren lang und das wiederholte Nachladen während des Assessments struggle schmerzhaft.
Es struggle einer dieser Momente, in denen Sie sich wünschten, Ihr Laptop computer hätte eine „Schnellvorlauf“-Style.
Der Wechsel zu Polars und DuckDB hat alles völlig verbessert, und plötzlich konnte ich quick sofort auf die Daten zugreifen und sie bearbeiten, was die Check- und Iterationsprozesse ehrlich gesagt viel angenehmer machte.
Mit Pandas:
df_pd = pd.read_csv("gross sales.csv")
print(df_pd.head(3))Mit Polaren:
df_pl = pl.read_csv("gross sales.csv")
print(df_pl.head(3))Mit DuckDB:
con = duckdb.join()
df_duck = con.execute("SELECT * FROM 'gross sales.csv'").df()
print(df_duck.head(3))DuckDB kann CSVs direkt abfragen, ohne die gesamten Datensätze in den Speicher laden zu müssen, was die Arbeit mit großen Dateien erheblich erleichtert.
Daten filtern
Das Drawback hierbei ist, dass die Filterung in Pandas langsam sein kann, wenn Millionen von Zeilen verarbeitet werden. Ich musste einmal europäische Transaktionen in einem riesigen Verkaufsdatensatz analysieren. Pandas brauchten Minuten, was meine Analyse verlangsamte.
Mit Pandas:
filtered_pd = df_pd(df_pd.area == "Europe")Polars ist schneller und kann mehrere Filter effizient verarbeiten:
filtered_pl = df_pl.filter(pl.col("area") == "Europe")DuckDB verwendet SQL-Syntax:
filtered_duck = con.execute("""
SELECT *
FROM 'gross sales.csv'
WHERE area = 'Europe'
""").df()Jetzt können Sie große Datensätze in Sekunden statt in Minuten filtern, sodass Sie mehr Zeit haben, sich auf die Erkenntnisse zu konzentrieren, die wirklich wichtig sind.
Große Datensätze schnell aggregieren
Durch die Aggregation fühlen sich Pandas oft langsam. Stellen Sie sich vor, für einen Marketingbericht den Gesamtumsatz professional Land zu berechnen.
Bei Pandas:
agg_pd = df_pd.groupby("nation")("income").sum().reset_index()In Polaren:
agg_pl = df_pl.groupby("nation").agg(pl.col("income").sum())
In DuckDB:
agg_duck = con.execute("""
SELECT nation, SUM(income) AS total_revenue
FROM 'gross sales.csv'
GROUP BY nation
""").df()Ich erinnere mich, dass ich diese Aggregation für einen Datensatz mit 10 Millionen Zeilen ausgeführt habe. Bei Pandas dauerte es quick eine halbe Stunde. Polars hat den gleichen Vorgang in weniger als einer Minute abgeschlossen.
Das Gefühl der Erleichterung struggle quick so, als würde man einen Marathon beenden und feststellen, dass die Beine noch funktionieren.
Zusammenführen von Datensätzen im großen Maßstab
Das Zusammenfügen von Datensätzen gehört zu den Dingen, die einfach klingen, bis man tatsächlich knietief in den Daten steckt.
In realen Projekten befinden sich Ihre Daten normalerweise in mehreren Quellen, sodass Sie sie mithilfe gemeinsamer Spalten wie Kunden-IDs kombinieren müssen.
Das habe ich auf die harte Tour gelernt, als ich an einem Projekt arbeitete, bei dem es darum ging, Millionen von Kundenbestellungen mit einem ebenso großen demografischen Datensatz zu kombinieren.
Jede Datei struggle für sich genommen groß genug, aber das Zusammenführen fühlte sich an, als würde man versuchen, zwei Puzzleteile zusammenzufügen, während Ihr Laptop computer um Gnade bettelte.
Pandas brauchten so lange, dass ich anfing, das Zusammenfügen auf die gleiche Weise zu messen, wie die Leute messen, wie lange es dauert, bis ihr Popcorn aus der Mikrowelle fertig ist.
Spoiler: Das Popcorn hat jedes Mal gewonnen.
Polars und DuckDB haben mir einen Ausweg verschafft.
Mit Pandas:
merged_pd = df_pd.merge(pop_df_pd, on="nation", how="left")Polaren:
merged_pl = df_pl.be a part of(pop_df_pl, on="nation", how="left")DuckDB:
merged_duck = con.execute("""
SELECT *
FROM 'gross sales.csv' s
LEFT JOIN 'pop.csv' p
USING (nation)
""").df()Tritt bei Arbeiten mit großen Datensätzen, die Ihren Arbeitsablauf früher eingefroren haben, laufen jetzt reibungslos und effizient.
Faule Auswertung in Polaren
Eine Sache, die mir zu Beginn meiner Reise in die Datenwissenschaft nicht bewusst struggle, struggle, wie viel Zeit verschwendet wird, wenn ich Transformationen Zeile für Zeile durchführe.
Polars geht das anders an.
Es nutzt eine Technik namens Lazy Analysis, die im Wesentlichen wartet, bis Sie die Definition Ihrer Transformationen abgeschlossen haben, bevor Sie irgendwelche Operationen ausführt.
Es untersucht die gesamte Pipeline, ermittelt den effizientesten Pfad und führt alles gleichzeitig aus.
Es ist, als hätte man einen Freund, der sich Ihre gesamte Bestellung anhört, bevor er in die Küche geht, statt jemanden, der jede Anweisung einzeln entgegennimmt und ständig hin und her geht.
Das TDS-Artikel erklärt ausführlich die verzögerte Bewertung.
So sieht der Ablauf aus:
Pandas:
df = df(df("quantity") > 100)
df = df.groupby("phase").agg({"quantity": "imply"})
df = df.sort_values("quantity")Polars Lazy-Modus:
import polars as pl
df_lazy = (
pl.scan_csv("gross sales.csv")
.filter(pl.col("quantity") > 100)
.groupby("phase")
.agg(pl.col("quantity").imply())
.kind("quantity")
)
outcome = df_lazy.accumulate()
Als ich den Lazy-Modus zum ersten Mal verwendete, fühlte es sich seltsam an, keine sofortigen Ergebnisse zu sehen. Aber einmal bin ich das Finale gelaufen .accumulate()der Geschwindigkeitsunterschied struggle offensichtlich.
Eine verzögerte Auswertung löst zwar nicht jedes Leistungsproblem auf magische Weise, bringt aber ein Maß an Effizienz mit sich, für das Pandas nicht konzipiert wurde.
Fazit und Erkenntnisse
Die Arbeit mit großen Datenmengen muss sich nicht wie ein Ringen mit Ihren Instruments anfühlen.
Die Verwendung von Polars und DuckDB hat mir gezeigt, dass das Drawback nicht immer bei den Daten lag. Manchmal struggle es das Werkzeug, mit dem ich damit umging.
Wenn Sie aus diesem Tutorial etwas mitnehmen, dann dieses: Sie müssen Pandas nicht aufgeben, können aber nach etwas Besserem greifen, wenn Ihre Datensätze an ihre Grenzen stoßen.
Polars bietet Ihnen Geschwindigkeit und eine intelligentere Ausführung, und mit DuckDB können Sie große Dateien abfragen, als wären sie winzig. Zusammen sorgen sie dafür, dass sich die Arbeit mit großen Datenmengen einfacher und weniger ermüdend anfühlt.
Wenn Sie tiefer in die in diesem Tutorial untersuchten Ideen eintauchen möchten, lesen Sie die offizielle Dokumentation von Polaren Und DuckDB sind gute Ausgangspunkte.