Je komplexer die Data-Science-Landschaft wird und je schneller neue Technologien auftauchen, desto entscheidender ist die richtige Tool-Auswahl für dein Projekt. Je umfangreicher das Vorhaben, desto sorgfältiger solltest du bei der Wahl der Werkzeuge vorgehen, denn sie beeinflusst Entwicklung und letztlich den Erfolg deines Projekts maßgeblich.
Wenn du an einem Data-Science-Projekt arbeitest, gehen Designentscheidungen weit über die Python-vs.-R-Diskussion hinaus. Es geht auch um die Bibliotheken, die du einsetzt, sobald die Programmiersprache(n) feststehen.
Für Data Science mit Python ist pandas der De-facto-Standard für Datenmanipulation. Die Gründe für das Arbeiten mit pandas sind zahlreich und überzeugend, doch es gibt auch Einschränkungen, die zu Engpässen führen können. Besonders bekannt ist pandas für begrenzte Performance bei sehr großen Datensätzen.
Um diese Probleme anzugehen, hat pandas kürzlich Version 2.0 veröffentlicht – mit wichtigen Überarbeitungen und Performance-Verbesserungen (siehe diesen Artikel für alles, was du über pandas 2.0 wissen musst).
Parallel dazu sind im Python-Ökosystem neue Alternativen entstanden, die die Dominanz von pandas herausfordern. Eine der populärsten ist polars, eine auf Python und Rust basierende Bibliothek für schnellere Datenanalyse.
Dieser Artikel beleuchtet die Unterschiede zwischen pandas 2.0 und polars bei der Datenmanipulation. Wir starten mit Strategien zur Performance-Optimierung und schließen mit Tests, die die Geschwindigkeit beider Tools vergleichen. Los geht’s!
Wie wählst du zwischen pandas und polars?
Es gibt keine einzelne Technologie, die absolut betrachtet für alle Probleme und Situationen im Data-Science-Workflow die beste ist. Vor einer Entscheidung sind verschiedene Faktoren abzuwägen. Hier sind einige der wichtigsten:
- Rechenperformance. Als Faustregel gilt: Je größer und komplexer das Projekt, desto eher solltest du leistungsstarke Tools einplanen, um Rechenengpässe zu vermeiden.
- Passung zum Technologiestack. Tools in Data-Science-Projekten arbeiten selten isoliert, sondern im Zusammenspiel mit dem restlichen Stack. Bevor du etwas auswählst, achte auf Synergien und Kompatibilitäten.
- Code-Kompatibilität. Eine neue Technologie einzuführen betrifft auch Code-Kompatibilität und Effizienz. Wenn ein neues Tool bedeutet, bestehenden Code umzuschreiben, gehört das in deine Abwägung.
- Popularität. Die Verbreitung eines Tools ist ein Indikator dafür, wie viele Menschen es nutzen – hilfreich beim Recruiting und beim Lösen von Fragen auf Plattformen wie Stack Overflow.
Wie lässt sich die Performance bei der Datenmanipulation verbessern?
In diesem Abschnitt schauen wir uns Techniken an, die die Performance bei der Datenmanipulation steigern können.
Weniger Kopieren mit Copy-on-Write
In klassischen Tools für Datenmanipulation führt jede Operation zur Erstellung einer neuen Kopie des gesamten Datasets. Das kann bei großen Datenmengen problematisch für den Speicher werden.
Copy-on-Write ist die gängigste Technik, um das zu lösen. Vereinfacht gesagt handelt es sich um ein Ressourcen-Management-Verfahren, das ein effizientes „Duplizieren“ veränderlicher Ressourcen ermöglicht. Wird ein Dataset dupliziert, aber nicht (vollständig) verändert, muss keine neue Ressource angelegt werden. Stattdessen können sich Kopie und Original die Speicherressourcen teilen.
Paralleles Rechnen
Einer der großen Nachteile von pandas ist, dass es single-threaded arbeitet und damit keine parallele Verarbeitung nutzt, die heute in Data Science üblich ist. Paralleles Rechnen erfolgt vor allem über Multi-Core-Maschinen oder verteiltes Rechnen (also einen Cluster mehrerer Rechner).
Nimm folgendes Beispiel mit der beliebten Group-By-Funktion: Möchtest du das durchschnittliche Alter von Basketballspielern je Team berechnen, kannst du per Parallelisierung die Mittelwertberechnung jeder Gruppe einem eigenen Kern oder Rechner zuweisen, statt sie nacheinander auszuführen – das erhöht die Performance.
Datenimport optimieren
Am Anfang der Analyse steht meist das Einlesen der Daten. Bei großen Datensätzen ist das oft ein Flaschenhals. Diese Techniken helfen beim Beschleunigen:
- Daten in Chunks laden. Statt die komplette Datei zu lesen, teilst du sie in kleine Blöcke. Das beschleunigt den Import und reduziert den gleichzeitig benötigten Speicher.
- Nur benötigte Spalten lesen. Wenn du die relevanten Spalten schon kennst, lies gezielt nur diese ein, statt das gesamte Dataset.
- Datentypen downcasten. Tools wie pandas vergeben beim Import Standard-Datentypen. Mitunter gibt es speichersparendere Typen ohne Informationsverlust. Downcasting wandelt Datentypen in den kleinsten passenden Typ.
Lazy Evaluation und Query Planning
Die Reihenfolge von Operationen kann die Performance beeinflussen. Oft lässt sich durch Umordnung derselben Berechnung effizienter zum gleichen Ergebnis kommen.
Zwei Strategien helfen dabei: Lazy Evaluation und Query Planning. Erstere verzögert Berechnungen, bis sie wirklich nötig sind. Letzteres sucht den effizientesten Weg, mehrere Manipulationen über verschiedene Abfragen hinweg auszuführen – typischerweise mit einem Query-Optimizer.
Out-of-Core-Verarbeitung
Tools wie pandas halten komplette Datensätze im Arbeitsspeicher. Das wird kritisch, wenn die Daten nicht in den Speicher passen oder speicherintensive Operationen anstehen.
Hier hilft Out-of-Core-Processing: Daten werden extern gespeichert (z. B. auf einer Festplatte) und in Blöcken verarbeitet. So kommst du zum gleichen Ergebnis, als würdest du alles im RAM verarbeiten.
Welche High-Performance-Alternativen zu pandas gibt es?
Dieser Artikel fokussiert den Vergleich pandas 2.0 vs. polars, aber es gibt weitere Alternativen, die je nach Bedarf passen können. Hier einige vielversprechende Optionen:
- Koalas. Eine pandas-API auf Basis von PySpark. Wenn du Spark nutzt, ist das eine Überlegung wert.
- Vaex. Eine pandas-ähnliche API für Out-of-Memory-Berechnungen – ideal für tabellarische Big Data mit Milliarden Zeilen pro Sekunde.
- Modin. Eine pandas-API für parallele Verarbeitung, basierend auf Dask oder Ray für Big-Data-Projekte. Wenn du Dask oder Ray nutzt, ist Modin eine starke Option.
- cuDF. Teil des RAPIDS-Projekts. Eine pandas-ähnliche API für GPU-Computing, die auf NVIDIA-GPUs oder anderen RAPIDS-Komponenten für High-Speed-Datenmanipulation setzt.
Warum polars?
Pandas ist für viele Python-Anwender die erste Wahl, bringt aber – wie beschrieben – bei großen Datensätzen spürbare Grenzen mit. Die Kernmission von polars ist eine superschnelle DataFrame-Bibliothek, die genau diese Probleme adressiert.
Geschrieben in Rust (eine leistungsstarke Programmiersprache mit C/C++-Performance, die volle Kontrolle über performanzkritische Teile einer Query-Engine erlaubt) integriert polars moderne Methoden zur Performance-Steigerung, um:
- Paralleles Rechnen zu maximieren und alle verfügbaren Kerne deiner Maschine zu nutzen.
- Abfragen durch Lazy Evaluation und Query Planning zu optimieren und unnötige Arbeit/Speicherallokationen zu vermeiden.
- Die Speicherleistung via Copy-on-Write-Semantik und Apache Arrow zu verbessern.
- Dank Streaming-API Out-of-Core-Daten zu verarbeiten und so deutlich größere Datensätze zu handhaben.
Nicht zuletzt ist die Syntax von polars pandas sehr ähnlich und nutzt die gleichen Grundbausteine wie Series und DataFrames. Das macht den Umstieg deutlich einfacher.
Wie reagiert pandas mit Version 2.0 auf den steigenden Wettbewerb?
Um Performance-Probleme anzugehen und dem Wettbewerbsdruck zu begegnen, hat pandas die lang erwartete Version 2.0 veröffentlicht. Als Major-Update bringt pandas 2.0 zahlreiche neue Features und setzt Deprecations durch, was API-Änderungen nach sich zieht.
Das neue PyArrow-Backend ist der große Hebel, um Performance-Grenzen zu adressieren. Nutzende können jetzt zwischen dem traditionellen NumPy-Backend und dem neuen PyArrow-Backend wählen. PyArrow ist eine Python-Bibliothek, die eine Schnittstelle für große Datensätze auf Basis von Arrow-Speicherstrukturen bereitstellt.
pd.read_csv(my_file, engine='pyarrow')Ein weiteres wichtiges Feature sind verschiedene Copy-on-Write-Verbesserungen, die durch sparsamen Speicherverbrauch die Performance erhöhen sollen.
Viele pandas-Operationen enthalten nun standardmäßig einen „copy“-Parameter, der eine „Lazy“-Kopie grundlegender pandas-Objekte wie Series und DataFrames zurückgibt, statt identischer, zwischengespeicherter Kopien.
Ob pandas damit seine Performance-Probleme vollständig löst, ist noch offen. Selbst wenn andere Tools schneller sind, gibt es gute Gründe, bei pandas zu bleiben: Du musst keinen bestehenden Code umschreiben und nichts Neues lernen, weil du es vermutlich ohnehin schon einsetzt.
pandas 2.0 vs. polars: Vergleichsrahmen
Genug Theorie, jetzt wird’s praktisch. In den folgenden Abschnitten führen wir Tests durch, um die Performance von pandas 2.0 und polars zu vergleichen. Unser Benchmark ist die Zeit, die zur Ausführung einer Aufgabe benötigt wird. Dafür nutzen wir das time-Modul, das einfache Laufzeitmessungen erlaubt.
Zusätzlich zur Performance prüfen wir die Code-Kompatibilität von polars mit pandas (wie viel Code musst du anpassen, wenn du zu polars wechselst?).
Das Dataset
Wir testen pandas 2.0 vs. polars auf einem fiktiven Datensatz mit stündlichen Umsätzen eines Unternehmens mit Büros in verschiedenen Ländern im Zeitraum 1980–2022. Für zusätzliche Komplexität fügen wir zufällige fehlende Werte ein.
In Summe umfasst der Datensatz über 22 Millionen Zeilen und mehr als 1,6 GB Speicher – genug, um pandas ernsthaft zu fordern. Den vollständigen Code der Benchmarks findest du in diesem DataLab-Workbook.
Import-Test
Starten wir mit dem Datenimport. Polars wirbt ausdrücklich mit starker CSV-Import-Performance. Stimmt das?
Wir messen, wie lange pandas und polars benötigen, um einen Teil der Spalten und Zeilen zu lesen. Angenommen, du willst nur die Verkäufe des Frankreich-Büros analysieren. Mit pandas liest du alle Zeilen und filterst dann die unerwünschten heraus. Dafür nutzen wir die neue .query()-Methode. Um pandas 2.0 zu testen, importieren wir die CSV einmal mit dem traditionellen NumPy- und einmal mit dem neuen PyArrow-Engine.
Polars dagegen bietet filter(), um mit Bedingungen direkt nur die interessierenden Zeilen einzulesen.
# pandas query
df_pd = pd.read_csv("./example.csv", engine="pyarrow")
df_pd = df_pd[['id', 'date', 'office', 'sales']]
df_pd = df_pd.query("office=='France'")
# polars filter
df_pl = pl.read_csv('example.csv').filter(
(pl.col('office') == 'France'))
df_pl.select(pl.col(['id', 'date', 'office', 'sales']))
Im Test ist polars deutlich schneller als pandas, wie die Grafik zeigt. Überraschend lieferte die PyArrow-Engine keine besseren Ergebnisse als die Standard-NumPy-Engine.
Zur Syntax: Polars fühlt sich sehr ähnlich an wie pandas, mit Funktionen wie pl.read_csv(), die pandas spiegeln. Unter der Haube arbeiten beide Bibliotheken jedoch unterschiedlich – daher weichen Methoden wie query() vs. filter() voneinander ab.
Group-By-Test
Group-By-Operationen eignen sich hervorragend zur Parallelisierung. Schauen wir, wie sich pandas und polars bei Aggregationen verhalten. Konkret berechnen wir Mittelwert und Median der Verkäufe je Büro und Monat.
df_pd.groupby([df_pd.office, df_pd.date.dt.month])['sales'].agg('mean') # pandas groupby mean
df_pl.groupby([pl.col('office'), pl.col('date').dt.month()]).agg([pl.mean('sales')]) # polars groupby mean
df_pd.groupby([df_pd.office, df_pd.date.dt.month])['sales'].agg('median') # pandas groupby median
df_pl.groupby([pl.col('office'), pl.col('date').dt.month()]).agg([pl.median('sales')]) pandas groupby median
Die Ergebnisse zeigen: Bei Group-By- und Aggregationsberechnungen ist polars schneller als pandas. Auch hier wirkt die Syntax sehr vertraut.
Rolling-Statistics-Test
Auch gleitende Statistiken eignen sich gut für Performance-Tests. Ihre Optimierung erfordert knifflige Algorithmen. Testen wir eine gleitende Tagesmittelwert-Berechnung der Verkäufe.
# pandas rolling mean
df_pd['sales'].rolling(1440, min_periods=1).mean()
# polars rolling mean
df_pl['sales'].rolling_mean(1440, min_periods=1)Wieder liegt polars vorn. Beachte die kleine Syntax-Differenz: Polars hat eine Methode rolling_mean(), während pandas rolling() mit z. B. mean() kombiniert.
Sampling-Test
In Statistik und Data Science ist es selten möglich, die gesamte Grundgesamtheit zu untersuchen – daher ist Sampling eine Standardaufgabe. Dazu zählen Zufallsstichproben via Monte-Carlo-Simulation, etwa Bootstrapping und Permutation. Diese Operationen erfordern jedoch viel Kopierarbeit und können bei knappen Ressourcen herausfordernd sein.
Schauen wir uns Bootstrapping an, also Ziehen mit Zurücklegen. Wir schätzen den durchschnittlichen Umsatz in 10000 Stichproben mit jeweils 1000 Punkten.
#pandas bootstrap
simu_weights = []
for i in range(10000):
bootstrap_sample = random.choices(df_pd['sales'], k=1000)
simu_weights.append(np.nanmean(bootstrap_sample))
#polars bootstrap
simu_weights = []
for i in range(10000):
bootstrap_sample = df_pl['sales'].sample(n=1000,with_replacement=True)
simu_weights.append(bootstrap_sample.mean())Beim Bootstrapping ist polars fast fünfmal so schnell wie pandas.
Zur Syntax: Während pandas für Sampling auf NumPy setzt, bringt polars eine praktische, eingebaute sample()-Methode mit.
Verkettete Manipulationen
Zum Schluss kombinieren wir mehrere Datenmanipulationen. Das gehört zum Alltag von Datenprofis. Gerade mehrstufige Operationen sind aber schnell suboptimal implementiert.
Angenommen, das italienische Büro erwägt, einige Praktikantinnen und Praktikanten aus 2022 nach dem Ende ihres Trainee-Zeitraums zu übernehmen. Wir wollen herausfinden, welche Praktis 2022 die zehn größten Verkaufsabschlüsse erzielt haben, um die besten Kandidatinnen und Kandidaten auszuwählen.
Dazu verknüpfen wir unseren Datensatz mit einem zweiten namens „italy_2022“, der Informationen zur ausführenden Person je Transaktion 2022 enthält. Die gemeinsame Spalte ist „id“.
# pandas compound operations
df_pd.merge(italy_2022, on='id').query("responsibility =='Sales Intern'").sort_values('sales', ascending=False).head(10)[['name','surname','sales','sex']]
#polars compound manipulations
df_pl.join(italy_2022_pl, on="id").filter(pl.col('responsability') == 'Sales Intern').sort('sales',descending=True).head(10).select(pl.col(['name','surname','sales','sex']))
Wie in allen vorherigen Tests schlägt polars pandas in Sachen Performance. Besonders die Join-Operation scheint pandas auszubremsen. Polars hingegen erledigt die gesamte Kette in unter zwei Sekunden.
pandas 2.0 vs. polars: Vergleichstabelle
Die Tests oben haben wir in einer Tabelle kompakt zusammengefasst:
|
Test |
Pandas 2.0 |
Polars |
Gewinner |
Syntax-Ähnlichkeit |
|
Import-Test |
Liest alle Zeilen und filtert anschließend per .query() unerwünschte Zeilen |
Liest mit filter() direkt nur die relevanten Zeilen |
Polars (bessere Performance) |
Ähnlich, aber mit Unterschieden durch die Implementierung (.query() vs. filter()) |
|
Group-By-Test |
Verwendet .groupby() für Aggregationen wie Mittel- und Medianwerte nach Büro und Monat |
Wie pandas, aber mit besserer Performance |
Polars (bessere Performance) |
Ähnlich |
|
Rolling-Statistics-Test |
Nutzt rolling() kombiniert mit z. B. mean() für gleitende Mittelwerte |
Nutzt rolling_mean() für gleitende Mittelwerte |
Polars (bessere Performance) |
Ähnlich, mit kleinen Unterschieden (.rolling().mean() vs. rolling_mean()) |
|
Sampling-Test |
Verwendet NumPy für Bootstrapping |
Verwendet eingebaute sample()-Methode fürs Bootstrapping |
Polars (nahezu 5× schneller) |
Unterschiedlich – pandas setzt auf NumPy, polars bringt eigene Methoden mit |
|
Test verketteter Manipulationen |
Führt einen Join mit einem zweiten Dataset aus und sortiert/selektiert anschließend |
Gleiche Aufgaben, aber effizienter |
Polars (deutlich schneller) |
Ähnlich, mit leichten Unterschieden (merge().query().sort_values().head() vs. join().filter().sort().head().select()) |
Nächste Schritte
Glückwunsch, du hast dieses Tutorial bis zum Ende gelesen. Laut unseren Tests ist polars in nahezu allen Fällen spürbar schneller als pandas 2.0. Das ist eine echte Herausforderung für pandas, doch pandas bleibt die erste Wahl für Datenmanipulation in Python – mit allen Vorteilen einer großen Community.
Wenn du mit großen Datensätzen arbeitest, ist mehr Performance Pflicht. DataCamp unterstützt dich dabei. Diese Kurse helfen dir, deine Rechenleistung auf das nächste Level zu bringen:
