Einführung in Polars: Pythons Tool für großskalige Datenanalyse

In der Datenanalyse ist Python dank seiner Vielseitigkeit und der großen Bibliothekslandschaft eine der beliebtesten Sprachen. Datenmanipulation und -analyse sind entscheidend, um Erkenntnisse zu gewinnen und fundierte Entscheidungen zu treffen. Mit dem Wachstum von Datensätzen in Umfang und Komplexität steigt jedoch der Bedarf an High-Performance-Lösungen.

Um große Datensätze effizient zu verarbeiten, braucht es Werkzeuge, die schnelle Berechnungen und optimierte Operationen liefern. Hier kommt Polars ins Spiel. Polars ist eine leistungsstarke Open-Source-Bibliothek, die speziell für performante Datenmanipulation und -analyse in Python entwickelt wurde.

Polars: Features

Polars ist eine vollständig in Rust geschriebene DataFrame-Bibliothek. Sie bietet Python-Entwicklerinnen und -Entwicklern ein skalierbares, effizientes Framework für die Datenverarbeitung und gilt als Alternative zur sehr beliebten pandas-Bibliothek. Polars stellt zahlreiche Funktionen bereit, die typische Aufgaben der Datenmanipulation und -analyse erleichtern. Zu den wichtigsten Stärken von Polars zählen:

1. Geschwindigkeit und Performance

Polars ist konsequent auf Leistung ausgelegt. Durch Parallelisierung und speichereffiziente Verfahren verarbeitet es große Datensätze deutlich schneller als herkömmliche Ansätze.

2. Umfassende Datenmanipulation

Polars bringt einen kompletten Werkzeugkasten für Datenmanipulation mit – darunter Filtern, Sortieren, Gruppieren, Joinen und Aggregieren. Auch wenn Polars aufgrund seines noch jungen Alters nicht ganz den Funktionsumfang von pandas erreicht, deckt es rund 80 % der gängigen Operationen ab.

3. Ausdrucksstarke Syntax

Polars setzt auf eine prägnante, intuitive Syntax. Wer mit beliebten Python-Bibliotheken wie pandas vertraut ist, findet sich schnell zurecht und kann vorhandenes Wissen direkt nutzen.

4. DataFrame- und Series-Strukturen

Im Kern von Polars stehen DataFrame- und Series-Strukturen – eine vertraute, leistungsstarke Abstraktion für tabellarische Daten. DataFrame-Operationen lassen sich in Polars verketten, was effiziente und kompakte Transformationen ermöglicht.

5. Lazy Evaluation

Polars unterstützt Lazy Evaluation: Abfragen werden analysiert und optimiert, um Ausführung und Speicherbedarf zu verbessern. Polars untersucht deine Queries, beschleunigt die Ausführung, wo möglich, oder reduziert den Speicherverbrauch. Im Gegensatz dazu setzt pandas ausschließlich auf Eager Evaluation, bei der Ausdrücke unmittelbar ausgewertet werden.

Warum Polars, wenn es doch pandas gibt?

pandas ist weit verbreitet, flexibel und einfach zu nutzen. Bei sehr großen Datensätzen stößt pandas jedoch aufgrund seiner überwiegend Single-Threaded-Ausführung an Performance-Grenzen. Mit wachsender Datenmenge steigen die Laufzeiten stark an – das bremst die Produktivität.

Polars wurde gezielt für die effiziente Verarbeitung großer Datensätze entwickelt. Dank Lazy Evaluation und paralleler Ausführung glänzt Polars bei der schnellen Verarbeitung großer Datenmengen. Durch die Verteilung von Berechnungen auf mehrere CPU-Kerne erzielt Polars deutliche Performancegewinne. Sieh dir den Geschwindigkeitsvergleich zwischen pandas und Polars von Yuki an.

Bildquelle

Eine ausführliche Gegenüberstellung von Polars vs. pandas findest du in unserem separaten Artikel.

Polars installieren

Polars lässt sich über pip, den Python-Paketmanager, installieren. Öffne dazu die Kommandozeile und führe folgenden Befehl aus:

install polars

Ein Dataset in Polars laden

Polars bietet bequeme Methoden, um Daten aus verschiedenen Quellen zu laden – etwa aus CSV- und Parquet-Dateien oder aus pandas-DataFrames. Die Methoden zum Einlesen von CSV- oder Parquet-Dateien entsprechen denen der Bibliothek pandas.

# read csv file
import polars as pl
data = pl.read_csv('https://raw.githubusercontent.com/pycaret/pycaret/master/datasets/diamond.csv')


# check the head
data.head()

Ausgabe:

Der Typ von data ist polars.DataFrame.

type(data)
>>> polars.dataframe.frame.DataFrame

Ausgabe:

Häufige Datenmanipulationen mit Polars

Polars stellt einen umfangreichen Funktionsumfang für Datenmanipulation bereit. So kannst du Daten selektieren, filtern, sortieren, transformieren und bereinigen. Hier sind einige gängige Aufgaben und wie du sie mit Polars umsetzt:

1. Daten auswählen und filtern

Um bestimmte Spalten aus einem DataFrame zu wählen, nutzt du select(). Ein Beispiel:

import polars as pl


# Load diamond data from a CSV file
df = pl.read_csv('https://raw.githubusercontent.com/pycaret/pycaret/master/datasets/diamond.csv')


# Select specific columns: carat, cut, and price
selected_df = df.select(['Carat Weight', 'Cut', 'Price'])


# show selected_df head
selected_df.head()

Ausgabe:

Zeilen lassen sich mit filter() anhand von Bedingungen selektieren. Um zum Beispiel nur Zeilen mit einem Karatwert größer als 2,0 zu behalten, gehst du so vor:

import polars as pl


# Load diamond data from a CSV file
df = pl.read_csv('https://raw.githubusercontent.com/pycaret/pycaret/master/datasets/diamond.csv')


# filter the df with condition
filtered_df = df.filter(pl.col('Carat Weight') > 2.0)


# show filtered_df head
filtered_df.head()

Ausgabe:

2. Daten sortieren

Mit sort() sortierst du einen DataFrame nach einer oder mehreren Spalten. Beispiel:

import polars as pl


# Load diamond data from a CSV file
df = pl.read_csv('https://raw.githubusercontent.com/pycaret/pycaret/master/datasets/diamond.csv')


# sort the df by price
sorted_df = df.sort(by='Price')


# show sorted_df head
sorted_df.head()

Ausgabe:

3. Fehlende Werte behandeln

Polars bietet bequeme Methoden für den Umgang mit fehlenden Werten. Mit drop_nulls() entfernst du Zeilen, die fehlende Werte enthalten:

import polars as pl


# Load diamond data from a CSV file
df = pl.read_csv('https://raw.githubusercontent.com/pycaret/pycaret/master/datasets/diamond.csv')


# drop missing values
cleaned_df = df.drop_nulls()


# show cleaned_df head
cleaned_df.head()

Ausgabe:

Alternativ ersetzt fill_nulls() fehlende Werte durch einen angegebenen Standardwert oder nach einer gewählten Füllmethode.

4. Daten nach Spalten gruppieren

Zum Gruppieren nach bestimmten Spalten verwendest du groupby(). Im folgenden Beispiel gruppieren wir nach Cut und berechnen den durchschnittlichen Price je Gruppe:

import polars as pl


# Load diamond data from a CSV file
df = pl.read_csv('https://raw.githubusercontent.com/pycaret/pycaret/master/datasets/diamond.csv')


# group by cut and calc mean of price
grouped_df = df.groupby(by='Cut').agg(pl.col('Price').mean())


# show grouped_df head
grouped_df.head()

Ausgabe:

In der Ausgabe siehst du den durchschnittlichen Diamantpreis nach der Dimension Cut.

5. DataFrames joinen und kombinieren

Polars bietet flexible Optionen, um DataFrames zu verbinden und zu kombinieren. Zum Ausführen eines Join verwendest du join(). Das folgende Beispiel zeigt einen Inner Join zweier DataFrames über eine gemeinsame Schlüsselspalte:

import polars as pl


# Create the first DataFrame
df1 = pl.DataFrame({
    'id': [1, 2, 3, 4],
    'name': ['Alice', 'Bob', 'Charlie', 'David']
})


# Create the second DataFrame
df2 = pl.DataFrame({
    'id': [2, 3, 5],
    'age': [25, 30, 35]
})


# Perform an inner join on the 'id' column
joined_df = df1.join(df2, on='id')


# Display the joined DataFrame
joined_df

Ausgabe:

In diesem Beispiel erstellen wir zwei DataFrames (df1 und df2) mit dem Konstruktor pl.DataFrame. Der erste DataFrame df1 enthält die Spalten id und name, der zweite df2 die Spalten id und age. Anschließend führen wir über join() einen Inner Join auf der Spalte id aus und geben id als Join-Key an.

Integration und Interoperabilität

Polars integriert sich nahtlos mit anderen beliebten Python-Bibliotheken, sodass Datenanalystinnen und -analysten auf ein breites Toolset zugreifen können. Schauen wir uns zwei zentrale Aspekte an: die Zusammenarbeit mit anderen Bibliotheken und die Interoperabilität mit pandas.

Polars mit anderen Python-Bibliotheken verbinden

Polars spielt gut zusammen mit Bibliotheken wie NumPy und PyArrow und kombiniert so die Stärken mehrerer Tools in einem Workflow. Dank NumPy-Integration lassen sich Polars-DataFrames mühelos in NumPy-Arrays umwandeln und umgekehrt – inklusive Zugriff auf die leistungsfähigen numerischen Funktionen von NumPy. So bleiben Datentransfers reibungslos, und NumPy-Funktionen können direkt auf Polars-Daten angewandt werden.

Ebenso optimiert Polars über PyArrow den Datenaustausch zwischen Polars und Arrow-basierten Systemen. Das ermöglicht nahtloses Arbeiten mit im Arrow-Format gespeicherten Daten und nutzt gleichzeitig die performanten Datenmanipulationsfähigkeiten von Polars.

Polars-DataFrames in pandas-DataFrames umwandeln

Polars bietet eine unkomplizierte Konvertierung von Polars- in pandas-DataFrames. Hier ein Beispiel, das die Umwandlung von Polars zu pandas zeigt.

import polars as pl
import pandas as pd


# Create a Polars DataFrame
df_polars = pl.DataFrame({
    'column_A': [1, 2, 3],
    'column_B': ['apple', 'banana', 'orange']
})


# Convert Polars DataFrame to Pandas DataFrame
df_pandas = df_polars.to_pandas()


# Display the Pandas DataFrame
df_pandas

Ausgabe:

Fazit

Polars ist eine starke Bibliothek für performante Datenmanipulation und -analyse in Python. Dank Geschwindigkeit und optimierter Ausführung ist sie ideal, um große Datensätze effizient zu verarbeiten.

Mit seiner ausdrucksstarken Syntax und den DataFrame-Strukturen bietet Polars eine vertraute, intuitive Oberfläche für Aufgaben der Datenmanipulation. Darüber hinaus integriert sich Polars nahtlos mit anderen Python-Bibliotheken wie NumPy und PyArrow, erweitert so seine Möglichkeiten und eröffnet Zugang zu einem vielfältigen Ökosystem.

Die Möglichkeit, Polars- in pandas-DataFrames zu konvertieren, gewährleistet Interoperabilität und erleichtert die Einbindung in bestehende Workflows. Ob komplexe Datentypen, große Datenmengen oder der Wunsch nach mehr Performance – Polars liefert den Werkzeugkasten, um das volle Potenzial deiner Datenanalyse auszuschöpfen.