Bild vom Herausgeber

# Einführung

Python Früher bedeutete die Projekteinrichtung, dass Sie ein Dutzend kleiner Entscheidungen treffen mussten, bevor Sie Ihre erste nützliche Codezeile schrieben. Welcher Umweltmanager? Welches Abhängigkeitstool? Welcher Formatierer? Welcher Linter? Welcher Typprüfer? Und wenn Ihr Projekt Daten berührt, sollten Sie damit beginnen? Pandas, DuckDBoder etwas neueres?

Im Jahr 2026 kann diese Einrichtung viel einfacher sein.

Für die meisten neuen Projekte ist der sauberste Standardstapel:

• UV für Python-Set up, Umgebungen, Abhängigkeitsmanagement, Sperren und Befehlsausführung.
• Halskrause zum Flusen und Formatieren.
• Ty zur Typprüfung.
• Polaren für Datenrahmenarbeit.

Dieser Stack ist schnell, fashionable und besonders kohärent. Drei der vier Werkzeuge (UV, Ruff und Ty) stammen tatsächlich von derselben Firma, Astralwas bedeutet, dass sie sich nahtlos untereinander und in Ihre integrieren lassen pyproject.toml.

# Verstehen, warum dieser Stack funktioniert

Ältere Setups sahen oft so aus:

pyenv + pip + venv + pip-tools or Poetry + Black + isort + Flake8 + mypy + pandas

Dies funktionierte, führte jedoch zu erheblichen Überschneidungen, Inkonsistenzen und Wartungsaufwand. Sie verfügten über separate Instruments für die Umgebungseinrichtung, Abhängigkeitssperre, Formatierung, Importsortierung, Linting und Typisierung. Jedes neue Projekt begann mit einer Auswahlexplosion. Der Standardstapel 2026 macht all das zunichte. Das Endergebnis sind weniger Instruments, weniger Konfigurationsdateien und weniger Reibungsverluste beim Onboarding von Mitwirkenden oder bei der Einrichtung der kontinuierlichen Integration (CI). Bevor wir mit der Einrichtung beginnen, werfen wir einen kurzen Blick darauf, was die einzelnen Instruments im 2026-Stack tun:

1. UV: Dies ist die Foundation für Ihr Projekt-Setup. Es erstellt das Projekt, verwaltet Versionen, verwaltet Abhängigkeiten und führt Ihren Code aus. Anstatt virtuelle Umgebungen manuell einzurichten und Pakete zu installieren, übernimmt uv die schwere Arbeit. Es hält Ihre Umgebung mithilfe einer Sperrdatei konsistent und stellt sicher, dass alles korrekt ist, bevor ein Befehl ausgeführt wird.
2. Halskrause: Dies ist Ihr All-in-One-Device für Codequalität. Es ist extrem schnell, prüft auf Probleme, behebt viele davon automatisch und formatiert auch Ihren Code. Sie können es anstelle von Instruments wie Black, isort, Flake8 und anderen verwenden.
3. Ty: Dies ist ein neueres Device zur Typprüfung. Es hilft beim Erkennen von Fehlern, indem es die Typen in Ihrem Code überprüft, und funktioniert mit verschiedenen Editoren. Obwohl neuer als Instruments wie mypy oder PyrrightEs ist für moderne Arbeitsabläufe optimiert.
4. Polaren: Dies ist eine moderne Bibliothek für die Arbeit mit Datenrahmen. Der Schwerpunkt liegt auf der effizienten Datenverarbeitung mittels Lazy Execution, was bedeutet, dass Abfragen vor der Ausführung optimiert werden. Dies macht es schneller und speichereffizienter als Pandas, insbesondere bei großen Datenaufgaben.

# Überprüfung der Voraussetzungen

Die Einrichtung ist recht einfach. Hier sind die wenigen Dinge, die Sie für den Anfang benötigen:

• Terminal: macOS Terminal, Home windows PowerShell oder eine beliebige Linux-Shell.
• Internetverbindung: Erforderlich für das einmalige UV-Installationsprogramm und Paket-Downloads.
• Code-Editor: VS-Code wird empfohlen, da es intestine mit Ruff und Ty funktioniert, aber jeder Editor ist in Ordnung.
• Git: Erforderlich für die Versionskontrolle; Beachten Sie, dass uv a initialisiert Git Repository automatisch.

Das ist es. Du tust nicht muss Python vorinstalliert sein. Du tust nicht brauche pip, venv, pyenv oder conda. uv übernimmt für Sie die Set up und das Umgebungsmanagement.

# Schritt 1: Set up von UV

uv bietet ein eigenständiges Installationsprogramm, das unter macOS, Linux und Home windows funktioniert, ohne dass Python oder erforderlich ist Rost auf Ihrem Pc vorhanden sein.

macOS und Linux:

curl -LsSf https://astral.sh/uv/set up.sh | sh

Home windows PowerShell:

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/set up.ps1 | iex"

Starten Sie nach der Set up Ihr Terminal neu und überprüfen Sie Folgendes:

Ausgabe:

uv 0.8.0 (Homebrew 2025-07-17)

Diese einzelne Binärdatei ersetzt nun pyenv, pip, venv, pip-tools und die Projektmanagementebene von Poetry.

# Schritt 2: Erstellen eines neuen Projekts

Navigieren Sie zu Ihrem Projektverzeichnis und erstellen Sie ein neues Projekt:

uv init my-project
cd my-project

UV schafft eine saubere Ausgangsstruktur:

my-project/
├── .python-version
├── pyproject.toml
├── README.md
└── primary.py

Forme es in ein um src/ Format, das Importe, Paketierung, Testisolierung und Typprüfkonfiguration verbessert:

mkdir -p src/my_project checks information/uncooked information/processed
mv primary.py src/my_project/primary.py
contact src/my_project/__init__.py checks/test_main.py

Ihre Struktur sollte nun so aussehen:

my-project/
├── .python-version
├── README.md
├── pyproject.toml
├── uv.lock
├── src/
│   └── my_project/
│       ├── __init__.py
│       └── primary.py
├── checks/
│   └── test_main.py
└── information/
    ├── uncooked/
    └── processed/

Wenn Sie eine bestimmte Model benötigen (z. B. 3.12), kann uv diese installieren und anheften:

uv python set up 3.12
uv python pin 3.12

Der pin Der Befehl schreibt die Model in .python-versionum sicherzustellen, dass jedes Teammitglied denselben Dolmetscher verwendet.

# Schritt 3: Abhängigkeiten hinzufügen

Das Hinzufügen von Abhängigkeiten ist ein einzelner Befehl, der gleichzeitig auflöst, installiert und sperrt:

uv erstellt automatisch eine virtuelle Umgebung (.venv/), falls nicht vorhanden, löst den Abhängigkeitsbaum auf, installiert Pakete und Updates uv.lock mit exakten, angepinnten Versionen.

Für Instruments, die nur während der Entwicklung benötigt werden, verwenden Sie die --dev Flagge:

uv add --dev ruff ty pytest

Dadurch werden sie in einem separaten Bereich platziert (dependency-groups) Abschnitt in pyproject.tomlwodurch Produktionsabhängigkeiten schlank bleiben. Du musst nie rennen supply .venv/bin/activate; wenn Sie es verwenden uv runaktiviert es automatisch die richtige Umgebung.

# Schritt 4: Konfigurieren von Ruff (Linting und Formatierung)

Ruff wird direkt in Ihrem konfiguriert pyproject.toml. Fügen Sie die folgenden Abschnitte hinzu:

(software.ruff)
line-length = 100
target-version = "py312"

(software.ruff.lint)
choose = ("E4", "E7", "E9", "F", "B", "I", "UP")

(software.ruff.format)
docstring-code-format = true
quote-style = "double"

Eine Zeilenlänge von 100 Zeichen ist für moderne Bildschirme ein guter Kompromiss. Regelgruppen flake8-bugbear (B), isort (ich) und pyupgrade (UP) einen echten Mehrwert schaffen, ohne ein neues Repository zu überfordern.

Laufkrause:

# Lint your code
uv run ruff test .

# Auto-fix points the place potential
uv run ruff test --fix .

# Format your code
uv run ruff format .

Beachten Sie das Muster: uv run <software> <args>. Sie installieren niemals Instruments world oder aktivieren Umgebungen manuell.

# Schritt 5: Ty für die Typprüfung konfigurieren

Ty ist auch in konfiguriert pyproject.toml. Fügen Sie diese Abschnitte hinzu:

(software.ty.surroundings)
root = ("./src")

(software.ty.guidelines)
all = "warn"

((software.ty.overrides))
embrace = ("src/**")

(software.ty.overrides.guidelines)
possibly-unresolved-reference = "error"

(software.ty.terminal)
error-on-warning = false
output-format = "full"

Diese Konfiguration startet Ty im Warnmodus, was splendid für die Übernahme ist. Sie beheben zunächst offensichtliche Probleme und stufen Regeln dann nach und nach in Fehler um. Behalten information/** Ausgeschlossen verhindert Typprüfungsrauschen aus Nicht-Code-Verzeichnissen.

# Schritt 6: Pytest konfigurieren

Fügen Sie einen Abschnitt für Pytest hinzu:

(software.pytest.ini_options)
testpaths = ("checks")

Führen Sie Ihre Testsuite aus mit:

# Schritt 7: Untersuchen der vollständigen pyproject.toml

So sieht Ihre endgültige Konfiguration aus, wenn alles verkabelt ist – eine Datei, jedes Device konfiguriert, ohne verstreute Konfigurationsdateien:

(venture)
identify = "my-project"
model = "0.1.0"
description = "Fashionable Python venture with uv, Ruff, Ty, and Polars"
readme = "README.md"
requires-python = ">=3.13"
dependencies = (
    "polars>=1.39.3",
)

(dependency-groups)
dev = (
    "pytest>=9.0.2",
    "ruff>=0.15.8",
    "ty>=0.0.26",
)

(software.ruff)
line-length = 100
target-version = "py312"

(software.ruff.lint)
choose = ("E4", "E7", "E9", "F", "B", "I", "UP")

(software.ruff.format)
docstring-code-format = true
quote-style = "double"

(software.ty.surroundings)
root = ("./src")

(software.ty.guidelines)
all = "warn"

((software.ty.overrides))
embrace = ("src/**")

(software.ty.overrides.guidelines)
possibly-unresolved-reference = "error"

(software.ty.terminal)
error-on-warning = false
output-format = "full"

(software.pytest.ini_options)
testpaths = ("checks")

# Schritt 8: Code mit Polaren schreiben

Ersetzen Sie den Inhalt von src/my_project/primary.py mit Code, der die Polars-Seite des Stapels ausübt:

"""Pattern information evaluation with Polars."""

import polars as pl

def build_report(path: str) -> pl.DataFrame:
    """Construct a income abstract from uncooked information utilizing the lazy API."""
    q = (
        pl.scan_csv(path)
        .filter(pl.col("standing") == "energetic")
        .with_columns(
            revenue_per_user=(pl.col("income") / pl.col("customers")).alias("rpu")
        )
        .group_by("section")
        .agg(
            pl.len().alias("rows"),
            pl.col("income").sum().alias("income"),
            pl.col("rpu").imply().alias("avg_rpu"),
        )
        .kind("income", descending=True)
    )
    return q.accumulate()

def primary() -> None:
    """Entry level with pattern in-memory information."""
    df = pl.DataFrame(
        {
            "section": ("Enterprise", "SMB", "Enterprise", "SMB", "Enterprise"),
            "standing": ("energetic", "energetic", "churned", "energetic", "energetic"),
            "income": (12000, 3500, 8000, 4200, 15000),
            "customers": (120, 70, 80, 84, 150),
        }
    )

    abstract = (
        df.lazy()
        .filter(pl.col("standing") == "energetic")
        .with_columns(
            (pl.col("income") / pl.col("customers")).spherical(2).alias("rpu")
        )
        .group_by("section")
        .agg(
            pl.len().alias("rows"),
            pl.col("income").sum().alias("total_revenue"),
            pl.col("rpu").imply().spherical(2).alias("avg_rpu"),
        )
        .kind("total_revenue", descending=True)
        .accumulate()
    )

    print("Income Abstract:")
    print(abstract)

if __name__ == "__main__":
    primary()

Vor dem Ausführen benötigen Sie ein Construct-System pyproject.toml Daher installiert UV Ihr Projekt als Paket. Wir werden verwenden Jungtier:

cat >> pyproject.toml << 'EOF'

(build-system)
requires = ("hatchling")
build-backend = "hatchling.construct"

(software.hatch.construct.targets.wheel)
packages = ("src/my_project")
EOF

Dann synchronisieren und ausführen:

uv sync
uv run python -m my_project.primary

Sie sollten eine formatierte Polartabelle sehen:

Income Abstract:
form: (2, 4)
┌────────────┬──────┬───────────────┬─────────┐
│ section    ┆ rows ┆ total_revenue ┆ avg_rpu │
│ ---        ┆ ---  ┆ ---           ┆ ---     │
│ str        ┆ u32  ┆ i64           ┆ f64     │
╞════════════╪══════╪═══════════════╪═════════╡
│ Enterprise ┆ 2    ┆ 27000         ┆ 100.0   │
│ SMB        ┆ 2    ┆ 7700          ┆ 50.0    │
└────────────┴──────┴───────────────┴─────────┘

# Verwalten des täglichen Arbeitsablaufs

Sobald das Projekt eingerichtet ist, ist der Tagesablauf unkompliziert:

# Pull newest, sync dependencies
git pull
uv sync

# Write code...

# Earlier than committing: lint, format, type-check, check
uv run ruff test --fix .
uv run ruff format .
uv run ty test
uv run pytest

# Commit
git add .
git commit -m "feat: add income report module"

# Ändern Sie die Artwork und Weise, wie Sie Python mit Polaren schreiben

Der größte Denkwandel in diesem Stack findet auf der Datenseite statt. Bei Polars sollten Ihre Standardeinstellungen sein:

• Ausdrücke über zeilenweise Operationen. Mit Polarausdrücken kann die Engine Vorgänge vektorisieren und parallelisieren. Vermeiden Sie benutzerdefinierte Funktionen (UDFs), es sei denn, es gibt keine native Various, da UDFs deutlich langsamer sind.
• Faule Ausführung statt eifrigem Laden. Verwenden scan_csv() anstatt read_csv(). Dadurch entsteht ein LazyFrame Dadurch wird ein Abfrageplan erstellt, der es dem Optimierer ermöglicht, Filter nach unten zu verschieben und nicht verwendete Spalten zu entfernen.
• Parquet-First-Workflows über CSV-lastige Pipelines. Ein gutes Muster für die interne Datenaufbereitung sieht so aus.

# Bewerten, wann dieses Setup nicht die beste Lösung ist

Möglicherweise möchten Sie eine andere Wahl, wenn:

• Ihr Workforce verfügt über einen ausgereiften Poetry- oder Mypy-Workflow, der intestine funktioniert.
• Ihre Codebasis hängt stark von Pandas-spezifischen APIs oder Ökosystembibliotheken ab.
• Ihre Organisation ist auf Pyright standardisiert.
• Sie arbeiten in einem alten Repository, in dem ein Wechsel der Instruments eher Störungen als Nutzen mit sich bringen würde.

# Profi-Tipps umsetzen

1. Aktivieren Sie virtuelle Umgebungen niemals manuell. Verwenden uv run für alles, um sicherzustellen, dass Sie die richtige Umgebung verwenden.
2. Verpflichten Sie sich immer uv.lock zur Versionskontrolle. Dadurch wird sichergestellt, dass das Projekt auf jeder Maschine identisch läuft.
3. Verwenden --frozen im CI. Dadurch werden Abhängigkeiten von der Sperrdatei installiert, um schnellere und zuverlässigere Builds zu ermöglichen.
4. Verwenden uvx für Einzelwerkzeuge. Führen Sie Instruments aus, ohne sie in Ihrem Projekt zu installieren.
5. Benutze Ruff’s --fix großzügig markieren. Es kann nicht verwendete Importe, veraltete Syntax und mehr automatisch reparieren.
6. Bevorzugen Sie standardmäßig die Lazy-API. Verwenden scan_csv() und nur anrufen .accumulate() Am Ende.
7. Zentralisieren Sie die Konfiguration. Verwenden pyproject.toml als einzige Quelle der Wahrheit für alle Instruments.

# Abschließende Gedanken

Der Python-Standardstack 2026 reduziert den Einrichtungsaufwand und fördert bessere Vorgehensweisen: gesperrte Umgebungen, eine einzige Konfigurationsdatei, schnelles Suggestions und optimierte Datenpipelines. Probieren Sie es aus; Sobald Sie die umgebungsunabhängige Ausführung erleben, werden Sie verstehen, warum Entwickler wechseln.

Kanwal Mehreen ist ein Ingenieur für maschinelles Lernen und ein technischer Redakteur mit einer großen Leidenschaft für Datenwissenschaft und die Schnittstelle zwischen KI und Medizin. Sie ist Mitautorin des E-Books „Maximizing Productiveness with ChatGPT“. Als Google Era Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie ist außerdem als Teradata Variety in Tech Scholar, Mitacs Globalink Analysis Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter von Veränderungen und hat FEMCodes gegründet, um Frauen in MINT-Bereichen zu stärken.

Bild vom Autor

# Einführung

Wenn Sie mit Daten in Python gearbeitet haben, haben Sie es mit ziemlicher Sicherheit verwendet Pandas. Seit über einem Jahrzehnt ist sie die Anlaufstelle für Datenmanipulation. Aber vor kurzem, Polaren hat ernsthaft an Bedeutung gewonnen. Polars verspricht schneller, speichereffizienter und intuitiver zu sein als Pandas. Aber lohnt es sich, es zu lernen? Und wie unterschiedlich ist es wirklich?

In diesem Artikel vergleichen wir Pandas und Eisbären nebeneinander. Sie sehen Leistungsbenchmarks und lernen die Syntaxunterschiede kennen. Am Ende können Sie eine fundierte Entscheidung für Ihr nächstes Datenprojekt treffen.

Den Code finden Sie auf GitHub.

# Erste Schritte

Lassen Sie uns zuerst beide Bibliotheken installieren:

pip set up pandas polars

Notiz: Dieser Artikel verwendet Pandas 2.2.2 und Polars 1.31.0.

Für diesen Vergleich verwenden wir auch einen Datensatz, der groß genug ist, um echte Leistungsunterschiede zu erkennen. Wir werden verwenden Schwindler So generieren Sie Testdaten:

Jetzt können wir mit dem Codieren beginnen.

# Messen der Geschwindigkeit durch Lesen großer CSV-Dateien

Beginnen wir mit einem der häufigsten Vorgänge: dem Lesen einer CSV-Datei. Wir erstellen einen Datensatz mit 1 Million Zeilen, um echte Leistungsunterschiede zu sehen.

Lassen Sie uns zunächst unsere Beispieldaten generieren:

import pandas as pd
from faker import Faker
import random

# Generate a big CSV file for testing
pretend = Faker()
Faker.seed(42)
random.seed(42)

information = {
    'user_id': vary(1000000),
    'title': (pretend.title() for _ in vary(1000000)),
    'electronic mail': (pretend.electronic mail() for _ in vary(1000000)),
    'age': (random.randint(18, 80) for _ in vary(1000000)),
    'wage': (random.randint(30000, 150000) for _ in vary(1000000)),
    'division': (random.selection(('Engineering', 'Gross sales', 'Advertising and marketing', 'HR', 'Finance'))
                   for _ in vary(1000000))
}

df_temp = pd.DataFrame(information)
df_temp.to_csv('large_dataset.csv', index=False)
print("✓ Generated large_dataset.csv with 1M rows")

Dieser Code erstellt eine CSV-Datei mit realistischen Daten. Vergleichen wir nun die Lesegeschwindigkeiten:

import pandas as pd
import polars as pl
import time

# pandas: Learn CSV
begin = time.time()
df_pandas = pd.read_csv('large_dataset.csv')
pandas_time = time.time() - begin

# Polars: Learn CSV
begin = time.time()
df_polars = pl.read_csv('large_dataset.csv')
polars_time = time.time() - begin

print(f"Pandas learn time: {pandas_time:.2f} seconds")
print(f"Polars learn time: {polars_time:.2f} seconds")
print(f"Polars is {pandas_time/polars_time:.1f}x sooner")

Ausgabe beim Lesen der Beispiel-CSV:

Pandas learn time: 1.92 seconds
Polars learn time: 0.23 seconds
Polars is 8.2x sooner

Folgendes passiert: Wir messen, wie lange es dauert, bis jede Bibliothek dieselbe CSV-Datei liest. Während Pandas seinen traditionellen Single-Threaded-CSV-Reader verwendet, parallelisiert Polars das Lesen automatisch über mehrere CPU-Kerne hinweg. Wir berechnen den Beschleunigungsfaktor.

Auf den meisten Geräten werden Sie feststellen, dass Polars CSVs zwei- bis fünfmal schneller liest. Dieser Unterschied wird bei größeren Dateien noch deutlicher.

# Messen der Speichernutzung während des Betriebs

Geschwindigkeit ist nicht die einzige Überlegung. Sehen wir uns an, wie viel Speicher jede Bibliothek verbraucht. Wir führen eine Reihe von Vorgängen durch und messen den Speicherverbrauch. Bitte pip set up psutil falls Sie es noch nicht in Ihrer Arbeitsumgebung haben:

import pandas as pd
import polars as pl
import psutil
import os
import gc # Import rubbish collector for higher reminiscence launch makes an attempt

def get_memory_usage():
    """Get present course of reminiscence utilization in MB"""
    course of = psutil.Course of(os.getpid())
    return course of.memory_info().rss / 1024 / 1024

# — - Check with Pandas — -
gc.gather()
initial_memory_pandas = get_memory_usage()

df_pandas = pd.read_csv('large_dataset.csv')
filtered_pandas = df_pandas(df_pandas('age') > 30)
grouped_pandas = filtered_pandas.groupby('division')('wage').imply()

pandas_memory = get_memory_usage() - initial_memory_pandas
print(f"Pandas reminiscence delta: {pandas_memory:.1f} MB")

del df_pandas, filtered_pandas, grouped_pandas
gc.gather()

# — - Check with Polars (keen mode) — -
gc.gather()
initial_memory_polars = get_memory_usage()

df_polars = pl.read_csv('large_dataset.csv')
filtered_polars = df_polars.filter(pl.col('age') > 30)
grouped_polars = filtered_polars.group_by('division').agg(pl.col('wage').imply())

polars_memory = get_memory_usage() - initial_memory_polars
print(f"Polars reminiscence delta: {polars_memory:.1f} MB")

del df_polars, filtered_polars, grouped_polars
gc.gather()

# — - Abstract — -
if pandas_memory > 0 and polars_memory > 0:
  print(f"Reminiscence financial savings (Polars vs Pandas): {(1 - polars_memory/pandas_memory) * 100:.1f}%")
elif pandas_memory == 0 and polars_memory > 0:
  print(f"Polars used {polars_memory:.1f} MB whereas Pandas used 0 MB.")
elif polars_memory == 0 and pandas_memory > 0:
  print(f"Polars used 0 MB whereas Pandas used {pandas_memory:.1f} MB.")
else:
  print("Can not compute reminiscence financial savings as a consequence of zero or unfavorable reminiscence utilization delta in each frameworks.")

Dieser Code misst den Speicherbedarf:

1. Wir nutzen die psutil-Bibliothek um die Speichernutzung vor und nach Vorgängen zu verfolgen
2. Beide Bibliotheken lesen dieselbe Datei und führen Filterung und Gruppierung durch
3. Wir berechnen den Unterschied im Speicherverbrauch

Beispielausgabe:

Pandas reminiscence delta: 44.4 MB
Polars reminiscence delta: 1.3 MB
Reminiscence financial savings (Polars vs Pandas): 97.1%

Die obigen Ergebnisse zeigen das Speichernutzungsdelta für Pandas und Polars, wenn Filter- und Aggregationsvorgänge für durchgeführt werden large_dataset.csv.

• Pandas Speicherdelta: Gibt den von Pandas für die Vorgänge verbrauchten Speicher an.
• Polarspeicher-Delta: Gibt den von Polars für dieselben Vorgänge verbrauchten Speicher an.
• Speichereinsparungen (Polaren vs. Pandas): Diese Metrik gibt einen Prozentsatz an, wie viel weniger Speicher Polars im Vergleich zu Pandas verbrauchten.

Aufgrund der spaltenorientierten Datenspeicherung und der optimierten Ausführungs-Engine weist Polars häufig Speichereffizienz auf. Normalerweise werden Sie durch die Verwendung von Polars eine Verbesserung von 30 bis 70 % feststellen.

Notiz: Allerdings werden sequentielle Speichermessungen innerhalb desselben Python-Prozesses verwendet psutil.Course of(...).memory_info().rss kann manchmal irreführend sein. Der Speicherzuweiser von Python gibt Speicher nicht immer sofort an das Betriebssystem zurück, sodass eine „bereinigte“ Basislinie für einen nachfolgenden Check möglicherweise immer noch von früheren Vorgängen beeinflusst wird. Für möglichst genaue Vergleiche sollten Assessments idealerweise in separaten, isolierten Python-Prozessen ausgeführt werden.

# Vergleich der Syntax für grundlegende Operationen

Schauen wir uns nun an, wie sich die Syntax zwischen den beiden Bibliotheken unterscheidet. Wir behandeln die häufigsten Vorgänge, die Sie verwenden werden.

// Spalten auswählen

Wählen wir eine Teilmenge von Spalten aus. Wir erstellen hierfür (und für die folgenden Beispiele) einen viel kleineren DataFrame.

import pandas as pd
import polars as pl

# Create pattern information
information = {
    'title': ('Anna', 'Betty', 'Cathy'),
    'age': (25, 30, 35),
    'wage': (50000, 60000, 70000)
}

# Pandas strategy
df_pandas = pd.DataFrame(information)
result_pandas = df_pandas(('title', 'wage'))

# Polars strategy
df_polars = pl.DataFrame(information)
result_polars = df_polars.choose(('title', 'wage'))
# Different: Extra expressive
result_polars_alt = df_polars.choose((pl.col('title'), pl.col('wage')))

print("Pandas consequence:")
print(result_pandas)
print("nPolars consequence:")
print(result_polars)

Die wichtigsten Unterschiede hier:

• Pandas verwendet die Klammernotation: df(('col1', 'col2'))
• Polars verwendet die .choose() Verfahren
• Polars unterstützt auch das Ausdrucksstärkere pl.col() Syntax, die für komplexe Operationen leistungsstark ist

Ausgabe:

Pandas consequence:
    title  wage
0   Anna   50000
1  Betty   60000
2  Cathy   70000

Polars consequence:
form: (3, 2)
┌───────┬────────┐
│ title  ┆ wage │
│ — -   ┆ — -    │
│ str   ┆ i64    │
╞═══════╪════════╡
│ Anna  ┆ 50000  │
│ Betty ┆ 60000  │
│ Cathy ┆ 70000  │
└───────┴────────┘

Beide erzeugen die gleiche Ausgabe, aber die Syntax von Polars beschreibt deutlicher, was Sie tun.

// Zeilen filtern

Jetzt filtern wir die Zeilen:

# pandas: Filter rows the place age > 28
filtered_pandas = df_pandas(df_pandas('age') > 28)

# Different Pandas syntax with question
filtered_pandas_alt = df_pandas.question('age > 28')

# Polars: Filter rows the place age > 28
filtered_polars = df_polars.filter(pl.col('age') > 28)

print("Pandas filtered:")
print(filtered_pandas)
print("nPolars filtered:")
print(filtered_polars)

Beachten Sie die Unterschiede:

• In Pandas verwenden wir die boolesche Indizierung mit Klammernotation. Sie können auch die verwenden .question() Verfahren.
• Polars verwendet die .filter() Methode mit pl.col() Ausdrücke.
• Die Syntax von Polars liest sich eher wie SQL: „Filtern, wenn das Spaltenalter größer als 28 ist“.

Ausgabe:

Pandas filtered:
    title  age  wage
1  Betty   30   60000
2  Cathy   35   70000

Polars filtered:
form: (2, 3)
┌───────┬─────┬────────┐
│ title  ┆ age ┆ wage │
│ — -   ┆ — - ┆ — -    │
│ str   ┆ i64 ┆ i64    │
╞═══════╪═════╪════════╡
│ Betty ┆ 30  ┆ 60000  │
│ Cathy ┆ 35  ┆ 70000  │
└───────┴─────┴────────┘

// Neue Spalten hinzufügen

Jetzt fügen wir dem DataFrame neue Spalten hinzu:

# pandas: Add a brand new column
df_pandas('bonus') = df_pandas('wage') * 0.1
df_pandas('total_comp') = df_pandas('wage') + df_pandas('bonus')

# Polars: Add new columns
df_polars = df_polars.with_columns((
    (pl.col('wage') * 0.1).alias('bonus'),
    (pl.col('wage') * 1.1).alias('total_comp')
))

print("Pandas with new columns:")
print(df_pandas)
print("nPolars with new columns:")
print(df_polars)

Ausgabe:

Pandas with new columns:
    title  age  wage   bonus  total_comp
0   Anna   25   50000  5000.0     55000.0
1  Betty   30   60000  6000.0     66000.0
2  Cathy   35   70000  7000.0     77000.0

Polars with new columns:
form: (3, 5)
┌───────┬─────┬────────┬────────┬────────────┐
│ title  ┆ age ┆ wage ┆ bonus  ┆ total_comp │
│ — -   ┆ — - ┆ — -    ┆ — -    ┆ — -        │
│ str   ┆ i64 ┆ i64    ┆ f64    ┆ f64        │
╞═══════╪═════╪════════╪════════╪════════════╡
│ Anna  ┆ 25  ┆ 50000  ┆ 5000.0 ┆ 55000.0    │
│ Betty ┆ 30  ┆ 60000  ┆ 6000.0 ┆ 66000.0    │
│ Cathy ┆ 35  ┆ 70000  ┆ 7000.0 ┆ 77000.0    │
└───────┴─────┴────────┴────────┴────────────┘

Folgendes passiert:

• Pandas verwendet die direkte Spaltenzuweisung, die den vorhandenen DataFrame ändert
• Polars verwendet .with_columns() und gibt einen neuen DataFrame zurück (standardmäßig unveränderlich)
• In Polars verwenden Sie .alias() um die neue Spalte zu benennen

Der Polars-Ansatz fördert die Unveränderlichkeit und macht Datentransformationen lesbarer.

# Messen der Leistung beim Gruppieren und Aggregieren

Schauen wir uns ein nützlicheres Beispiel an: das Gruppieren von Daten und das Berechnen mehrerer Aggregationen. Dieser Code zeigt, wie wir Daten nach Abteilung gruppieren, mehrere Statistiken für verschiedene Spalten berechnen und beide Vorgänge zeitlich festlegen, um den Leistungsunterschied zu erkennen:

# Load our giant dataset
df_pandas = pd.read_csv('large_dataset.csv')
df_polars = pl.read_csv('large_dataset.csv')

# pandas: Group by division and calculate stats
import time

begin = time.time()
result_pandas = df_pandas.groupby('division').agg({
    'wage': ('imply', 'median', 'std'),
    'age': 'imply'
}).reset_index()
result_pandas.columns = ('division', 'avg_salary', 'median_salary', 'std_salary', 'avg_age')
pandas_time = time.time() - begin

# Polars: Identical operation
begin = time.time()
result_polars = df_polars.group_by('division').agg((
    pl.col('wage').imply().alias('avg_salary'),
    pl.col('wage').median().alias('median_salary'),
    pl.col('wage').std().alias('std_salary'),
    pl.col('age').imply().alias('avg_age')
))
polars_time = time.time() - begin

print(f"Pandas time: {pandas_time:.3f}s")
print(f"Polars time: {polars_time:.3f}s")
print(f"Speedup: {pandas_time/polars_time:.1f}x")
print("nPandas consequence:")
print(result_pandas)
print("nPolars consequence:")
print(result_polars)

Ausgabe:

Pandas time: 0.126s
Polars time: 0.077s
Speedup: 1.6x

Pandas consequence:
    division    avg_salary  median_salary    std_salary    avg_age
0  Engineering  89954.929266        89919.0  34595.585863  48.953405
1      Finance  89898.829762        89817.0  34648.373383  49.006690
2           HR  90080.629637        90177.0  34692.117761  48.979005
3    Advertising and marketing  90071.721095        90154.0  34625.095386  49.085454
4        Gross sales  89980.433386        90065.5  34634.974505  49.003168

Polars consequence:
form: (5, 5)
┌─────────────┬──────────────┬───────────────┬──────────────┬───────────┐
│ division  ┆ avg_salary   ┆ median_salary ┆ std_salary   ┆ avg_age   │
│ — -         ┆ — -          ┆ — -           ┆ — -          ┆ — -       │
│ str         ┆ f64          ┆ f64           ┆ f64          ┆ f64       │
╞═════════════╪══════════════╪═══════════════╪══════════════╪═══════════╡
│ HR          ┆ 90080.629637 ┆ 90177.0       ┆ 34692.117761 ┆ 48.979005 │
│ Gross sales       ┆ 89980.433386 ┆ 90065.5       ┆ 34634.974505 ┆ 49.003168 │
│ Engineering ┆ 89954.929266 ┆ 89919.0       ┆ 34595.585863 ┆ 48.953405 │
│ Advertising and marketing   ┆ 90071.721095 ┆ 90154.0       ┆ 34625.095386 ┆ 49.085454 │
│ Finance     ┆ 89898.829762 ┆ 89817.0       ┆ 34648.373383 ┆ 49.00669  │
└─────────────┴──────────────┴───────────────┴──────────────┴───────────┘

Aufschlüsselung der Syntax:

• Pandas verwendet ein Wörterbuch, um Aggregationen anzugeben, was bei komplexen Vorgängen verwirrend sein kann
• Polars verwendet Methodenverkettung: Jede Operation ist klar und benannt

Die Polars-Syntax ist ausführlicher, aber auch besser lesbar. Sie können sofort sehen, welche Statistiken berechnet werden.

# Verstehen der verzögerten Auswertung bei Polaren

Die verzögerte Auswertung ist eine der hilfreichsten Funktionen von Polars. Das heisst Ihre Abfrage wird nicht sofort ausgeführt. Stattdessen wird der gesamte Vorgang geplant und vor der Ausführung optimiert.

Sehen wir uns das in Aktion an:

import polars as pl

# Learn in lazy mode
df_lazy = pl.scan_csv('large_dataset.csv')

# Construct a posh question
consequence = (
    df_lazy
    .filter(pl.col('age') > 30)
    .filter(pl.col('wage') > 50000)
    .group_by('division')
    .agg((
        pl.col('wage').imply().alias('avg_salary'),
        pl.len().alias('employee_count')
    ))
    .filter(pl.col('employee_count') > 1000)
    .kind('avg_salary', descending=True)
)

# Nothing has been executed but!
print("Question plan created, however not executed")

# Now execute the optimized question
import time
begin = time.time()
result_df = consequence.gather()  # This runs the question
execution_time = time.time() - begin

print(f"nExecution time: {execution_time:.3f}s")
print(result_df)

Ausgabe:

Question plan created, however not executed

Execution time: 0.177s
form: (5, 3)
┌─────────────┬───────────────┬────────────────┐
│ division  ┆ avg_salary    ┆ employee_count │
│ — -         ┆ — -           ┆ — -            │
│ str         ┆ f64           ┆ u32            │
╞═════════════╪═══════════════╪════════════════╡
│ HR          ┆ 100101.595816 ┆ 132212         │
│ Advertising and marketing   ┆ 100054.012365 ┆ 132470         │
│ Gross sales       ┆ 100041.01049  ┆ 132035         │
│ Finance     ┆ 99956.527217  ┆ 132143         │
│ Engineering ┆ 99946.725458  ┆ 132384         │
└─────────────┴───────────────┴────────────────┘

Hier, scan_csv() lädt die Datei nicht sofort; es ist nur geplant, es zu lesen. Wir verketten mehrere Filter, Gruppierungen und Sortierungen. Polars analysiert die gesamte Abfrage und optimiert sie. Es könnte beispielsweise vor dem Lesen aller Daten gefiltert werden.

Nur wenn wir anrufen .gather() findet die eigentliche Berechnung statt? Die optimierte Abfrage wird viel schneller ausgeführt, als wenn jeder Schritt einzeln ausgeführt würde.

# Zusammenfassung

Wie man sieht, ist Polars für die Datenverarbeitung mit Python äußerst nützlich. Es ist schneller, speichereffizienter und verfügt über eine sauberere API als Pandas. Das heißt, Pandas gehen nirgendwo hin. Es hat über ein Jahrzehnt Entwicklungszeit, ein riesiges Ökosystem und Millionen von Benutzern. Für viele Projekte ist Pandas immer noch die richtige Wahl.

Lernen Sie Polars, wenn Sie groß angelegte Analysen für Knowledge-Engineering-Projekte und dergleichen in Betracht ziehen. Die Syntaxunterschiede sind nicht groß und die Leistungssteigerungen sind actual. Behalten Sie jedoch Pandas in Ihrem Toolkit, um Kompatibilität und schnelle Erkundungsarbeiten zu gewährleisten.

Probieren Sie Polars zunächst in einem Nebenprojekt oder einer Datenpipeline aus, die langsam läuft. Sie werden schnell ein Gefühl dafür bekommen, ob es für Ihren Anwendungsfall das Richtige ist. Viel Spaß beim Daten-Wrangeln!

Bala Priya C ist ein Entwickler und technischer Redakteur aus Indien. Sie arbeitet gerne an der Schnittstelle von Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Zu ihren Interessen- und Fachgebieten gehören DevOps, Datenwissenschaft und Verarbeitung natürlicher Sprache. Sie liebt es zu lesen, zu schreiben, zu programmieren und Kaffee zu trinken! Derzeit arbeitet sie daran, zu lernen und ihr Wissen mit der Entwickler-Neighborhood zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt außerdem ansprechende Ressourcenübersichten und Programmier-Tutorials.

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.0

Importieren 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.

Bild vom Herausgeber

# Einführung

Pandas ist zweifellos eine beeindruckende und vielseitige Bibliothek Datenabläufe verwalten und analysierenetwas Grundlegendes im Gesamtbild der Datenwissenschaft. Wenn die Datensätze jedoch sehr groß werden, ist dies möglicherweise nicht die effizienteste Choice, da sie hauptsächlich in einem einzelnen Thread ausgeführt wird und stark auf den Python-Interpreter angewiesen ist, was zu einer erheblichen Verarbeitungszeit führen kann.

Dieser Artikel verlagert den Fokus auf eine neuere Bibliothek, die Pandas-ähnliche Vorgänge beschleunigt: Polaren. Insbesondere werde ich mit Ihnen teilen 10 aufschlussreiche Polars-Einzeiler täglich zu rationalisieren und zu beschleunigen Datenmanipulations- und -verarbeitungsaufgaben.

Vergessen Sie dies nicht, bevor Sie beginnen import polars as pl Erste!

# 1. CSV-Dateien laden

Die Methode von Polars zum Lesen eines Datensatzes aus einer CSV-Datei sieht dem Pandas-Pendant sehr ähnlich, mit der Ausnahme, dass sie multithreaded ist (und intern in Rust geschrieben ist), wodurch Daten viel effizienter geladen werden können. Dieses Beispiel zeigt, wie eine CSV-Datei in einen Polars DataFrame geladen wird.

df = pl.read_csv("dataset.csv")

Selbst bei einem mittelgroßen Datensatz (nicht nur extrem großen) könnte der Zeitunterschied zum Lesen der Datei mit Polars etwa fünfmal schneller sein als mit Pandas.

# 2. Lazy Loading für skalierbarere Arbeitsabläufe

Das Erstellen eines sogenannten „Lazy Dataframe“ anstelle des eifrigen Lesens in einem Rutsch ist ein Ansatz, der es ermöglicht, nachfolgende Vorgänge im gesamten Datenworkflow zu verketten und sie nur dann auszuführen, wenn der accumulate() -Methode wird schließlich aufgerufen – eine sehr praktische Strategie für große Datenpipelines! Hier erfahren Sie, wie Sie das verzögerte Laden von Datenrahmen mithilfe von anwenden scan_csv() Verfahren:

df_lazy = pl.scan_csv("dataset.csv")

# 3. Auswählen und Umbenennen relevanter Spalten

Um die spätere Verarbeitung einfacher und übersichtlicher zu gestalten, empfiehlt es sich, sicherzustellen, dass Sie nur mit Spalten des Datensatzes arbeiten, die für Ihr Datenwissenschafts- oder Analyseprojekt related sind. Hier erfahren Sie, wie Sie dies effizient mit Polars-Datenrahmen tun. Angenommen, Sie verwenden einen Kundendatensatz wie Dieses hier. Sie können dann den folgenden Einzeiler verwenden, um relevante Spalten Ihrer Wahl wie folgt auszuwählen:

df = df.choose((pl.col("Buyer Id"), pl.col("First Identify")))

# 4. Filtern nach einer Teilmenge von Zeilen

Natürlich können wir auch bestimmte Zeilen, z. B. Kunden, nach Polars-Artwork filtern. Dieser Einzeiler wird verwendet, um Kunden zu filtern, die in einer bestimmten Stadt leben.

df_filtered = df.filter(pl.col("Metropolis") == "Hatfieldshire")

Möglicherweise möchten Sie eine Methode wie verwenden show() oder head() um das Ergebnis dieser „Abfrage“ zu sehen, additionally die Zeilen, die die angegebenen Kriterien erfüllen.

# 5. Gruppierung nach Kategorie und Berechnung von Aggregationen

Bei Vorgängen wie Gruppierung und Aggregation zeigt sich der Wert der Effizienz von Polars erst in größeren Datensätzen. Nehmen Sie diesen Einzeiler als Beispiel: Der Schlüssel hier ist das Kombinieren group_by auf einer kategorialen Spalte, mit agg() um eine Aggregation für alle Zeilen in jeder Gruppe durchzuführen, z. B. einen Durchschnitt für eine numerische Spalte oder einfach eine Anzahl von Zeilen in jeder Gruppe, wie unten gezeigt:

df_city = df.group_by("Metropolis").agg((pl.len().alias("num_customers")))

Seien Sie vorsichtig! Bei Pandas ist das groupby() hat kein Unterstrich-Image, in Polars jedoch schon.

# 6. Abgeleitete Spalten erstellen (Easy Function Engineering)

Dank der vektorisierten Berechnungsfunktionen von Polars ist die Erstellung neuer Spalten aus arithmetischen Operationen auf bestehenden deutlich schneller. Dieser Einzeiler demonstriert dies (berücksichtigt man nun das beliebte Wohnen in Kalifornien Datensatz für die folgenden Beispiele!):

df = df.with_columns((pl.col("total_rooms") / pl.col("households")).alias("rooms_per_household"))

# 7. Anwenden bedingter Logik

Kontinuierliche Attribute wie Einkommensniveaus oder ähnliche Attribute können vektorisiert und ohne Overhead kategorisiert und in beschriftete Segmente umgewandelt werden. In diesem Beispiel wird eine erstellt income_category Spalte basierend auf dem Durchschnittseinkommen professional Bezirk in Kalifornien:

df = df.with_columns(pl.when(pl.col("median_income") > 5).then(pl.lit("Excessive")).in any other case(pl.lit("Low")).alias("income_category"))

# 8. Ausführen einer Lazy Pipeline

Dieser Einzeiler ist zwar etwas größer, fasst jedoch mehrere der in den vorherigen Beispielen gezeigten Ideen zusammen, um eine Lazy-Pipeline zu erstellen, die mit ausgeführt wird accumulate Verfahren. Denken Sie daran: Damit dieser Lazy-Ansatz funktioniert, müssen Sie den Einzeiler Nummer 2 verwenden, um Ihre Datensatzdatei „auf die Lazy-Artwork“ zu lesen.

consequence = (pl.scan_csv("https://uncooked.githubusercontent.com/ageron/handson-ml/grasp/datasets/housing/housing.csv")
        .filter(pl.col("median_house_value") > 200000)
        .with_columns((pl.col("total_rooms") / pl.col("households")).alias("rooms_per_household"))
        .group_by("ocean_proximity").agg(pl.imply("rooms_per_household").alias("avg_rooms_per_household"))
        .kind("avg_rooms_per_household", descending=True)
        .accumulate())

# 9. Zusammenfügen von Datensätzen

Nehmen wir an, wir hätten einen zusätzlichen Datensatz namens region_stats.csv mit statistischen Informationen, die für die kalifornischen Bezirke gesammelt wurden. Wir könnten dann einen Einzeiler wie diesen verwenden, um Verknüpfungsoperationen auf eine bestimmte kategoriale Spalte anzuwenden, wie folgt:

df_joined = df.be part of(pl.read_csv("region_stats.csv"), on="ocean_proximity", how="left")

Das Ergebnis wäre eine effiziente Kombination der Wohnungsdaten mit Metadaten auf Bezirksebene über die Multithread-Joins von Polars, die die Leistung auch über größere Datensätze hinweg bewahren.

# 10. Durchführen rollierender Berechnungen

Bei stark schwankenden Datenvariablen sind rollierende Combination nützlich, um beispielsweise durchschnittliche Hauswerte über Breiten- und Längengrade hinweg zu glätten. Dieser Einzeiler veranschaulicht, wie eine so schnelle, vektorisierte Operation angewendet wird: perfekt für zeitliche oder geografische Sequenzen.

df = df.kind("longitude").with_columns(pl.col("median_house_value").rolling_mean(window_size=7).alias("rolling_value_avg"))

# Zusammenfassung

In diesem Artikel haben wir 10 praktische Einzeiler für den effizienten Einsatz von Polars als schnelle Various zu Pandas für die Verarbeitung großer Datenmengen aufgelistet. Diese Einzeiler fassen schnelle, optimierte Strategien für die Verarbeitung großer Datenmengen in kürzerer Zeit zusammen. Nutzen Sie diese, wenn Sie das nächste Mal mit Polars in Ihren Projekten zusammenarbeiten, und Sie werden zweifellos eine Reihe von Verbesserungen feststellen.

Iván Palomares Carrascosa ist ein führender Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.

Einführung

Angenommen, Sie befinden sich mitten in einem Datenprojekt, arbeiten mit riesigen Datensätzen und versuchen, so viele Muster wie möglich so schnell wie möglich zu finden. Sie greifen nach dem üblichen Datenmanipulation Werkzeug, aber was, wenn es ein am besten geeignetes Werkzeug gibt, das Ihre Arbeitsleistung verbessert? Wechseln Sie zum weniger bekannten Datenprozessor Polars, der erst vor kurzem auf den Markt gekommen ist, aber dennoch ein würdiger Anwärter auf die ausgereizten Pandas-Bibliothekselten. Dieser Artikel hilft Ihnen, den Unterschied zwischen Pandas und Polars zu verstehen, wie und wann Sie sie verwenden, und zeigt die Stärken und Schwächen der einzelnen Datenanalysetools.

Lernerfolge

• Verstehen Sie die wesentlichen Unterschiede zwischen Pandas und Polars.
• Erfahren Sie mehr über die Leistungsbenchmarks beider Bibliotheken.
• Entdecken Sie die einzigartigen Merkmale und Funktionen jedes Instruments.
• Entdecken Sie die Szenarien, in denen jede Bibliothek herausragt.
• Erhalten Sie Einblicke in die zukünftigen Entwicklungen und den Group-Help für Pandas und Polars.

Was ist Pandas?

Pandas ist eine robuste Bibliothek für die Datenanalyse und -bearbeitung in Python. Sie bietet Datencontainer wie DataFrames und Sequence, mit denen Benutzer relativ einfach verschiedene Analysen der verfügbaren Daten durchführen können. Pandas ist eine hochflexible Bibliothek, die auf einem äußerst umfangreichen Funktionsumfang basiert. Sie verfügt außerdem über eine starke Kopplung mit anderen Datenanalysebibliotheken.

Hauptmerkmale von Pandas:

• DataFrames und Serien zur strukturierten Datenmanipulation.
• Umfangreiche E/A-Funktionen (Lesen/Schreiben aus CSV-, Excel-, SQL-Datenbanken usw.).
• Umfangreiche Funktionalität zur Datenbereinigung, -transformation und -aggregation.
• Integration mit NumPySciPy und Matplotlib.
• Breite Group-Unterstützung und ausführliche Dokumentation.

Beispiel:

import pandas as pd

information = {'Identify': ('Alice', 'Bob', 'Charlie'),
        'Age': (25, 30, 35),
        'Metropolis': ('New York', 'Los Angeles', 'Chicago')}
df = pd.DataFrame(information)
print(df)

Ausgabe:

      Identify  Age         Metropolis
0    Alice   25     New York
1      Bob   30  Los Angeles
2  Charlie   35      Chicago

Was ist Polars?

Polars ist eine leistungsstarke DataFrame-Bibliothek, die auf Geschwindigkeit und Effizienz ausgelegt ist. Sie nutzt Rust für ihre Kernberechnungen und kann so große Datensätze mit beeindruckender Geschwindigkeit verarbeiten. Polars zielt darauf ab, eine schnelle, speichereffiziente Various zu Pandas bereitzustellen, ohne dabei an Funktionalität einzubüßen.

Hauptmerkmale von Polars:

• Blitzschnelle Leistung dank Rust-basierter Implementierung.
• Lazy Analysis für eine optimierte Abfrageausführung.
• Speichereffizienz durch Zero-Copy-Datenverarbeitung.
• Parallele Berechnungsfunktionen.
• Kompatibilität mit Arrow-Datenformat für Interoperabilität.

Beispiel:

import polars as pl

information = {'Identify': ('Alice', 'Bob', 'Charlie'),
        'Age': (25, 30, 35),
        'Metropolis': ('New York', 'Los Angeles', 'Chicago')}
df = pl.DataFrame(information)
print(df)

Ausgabe:

form: (3, 3)
┌─────────┬─────┬────────────┐
│ Identify    ┆ Age ┆ Metropolis       │
│ ---     ┆ --- ┆ ---        │
│ str     ┆ i64 ┆ str        │
╞═════════╪═════╪════════════╡
│ Alice   ┆  25 ┆ New York   │
│ Bob     ┆  30 ┆ Los Angeles│
│ Charlie ┆  35 ┆ Chicago    │
└─────────┴─────┴────────────┘

Leistungsvergleich

Die Leistung ist ein entscheidender Faktor bei der Auswahl einer Datenbearbeitungsbibliothek. Polars übertrifft Pandas aufgrund seines Rust-basierten Backends und seines effizienten Ausführungsmodells häufig in Bezug auf Geschwindigkeit und Speichernutzung.

Benchmark-Beispiel:
Vergleichen wir die Zeit, die zum Ausführen einer einfachen Gruppierungsoperation auf einem großen Datensatz benötigt wird.

Pandas:

import pandas as pd
import numpy as np
import time

# Create a big DataFrame
df = pd.DataFrame({
    'A': np.random.randint(0, 100, measurement=1_000_000),
    'B': np.random.randint(0, 100, measurement=1_000_000),
    'C': np.random.randint(0, 100, measurement=1_000_000)
})

start_time = time.time()
consequence = df.groupby('A').sum()
end_time = time.time()
print(f"Pandas groupby time: {end_time - start_time} seconds")

Polare:

import polars as pl
import numpy as np
import time

# Create a big DataFrame
df = pl.DataFrame({
    'A': np.random.randint(0, 100, measurement=1_000_000),
    'B': np.random.randint(0, 100, measurement=1_000_000),
    'C': np.random.randint(0, 100, measurement=1_000_000)
})

start_time = time.time()
consequence = df.groupby('A').agg(pl.sum('B'), pl.sum('C'))
end_time = time.time()
print(f"Polars groupby time: {end_time - start_time} seconds")

Ausgabebeispiel:

Pandas groupby time: 1.5 seconds
Polars groupby time: 0.2 seconds

Vorteile von Pandas

• Ausgereiftes Ökosystem: Pandas hingegen gibt es schon seit geraumer Zeit und daher verfügen sie über einen stabilen, üppigen Lebensraum.
• Umfangreiche Dokumentation: Flexibel, mit vollem Funktionsumfang und mit guter Dokumentation versehen.
• Breite Akzeptanz: Aktive Benutzer-Group; Es hat eine sehr große Fangemeinde und wird im Bereich der Datenwissenschaft häufig verwendet.
• Integration: Sie verfügen über eine beeindruckende Kompatibilität und Interoperabilität mit anderen erstklassigen Bibliotheken wie NumPy, SciPy und Matplotlib.

Vorteile von Polars

• Leistung: Polars ist auf Geschwindigkeit optimiert und kann große Datensätze effizienter verarbeiten.
• Speichereffizienz: Nutzt den Speicher effizienter und ist daher für Large Information-Anwendungen geeignet.
• Parallelverarbeitung: Unterstützt die parallele Verarbeitung, die Berechnungen erheblich beschleunigen kann.
• Faule Auswertung: Führt Vorgänge nur bei Bedarf aus und optimiert den Abfrageplan für eine bessere Leistung.

Wann werden Pandas und Polars verwendet?

Sehen wir uns nun an, wie Pandas und Polars verwendet werden.

Pandas

• Beim Arbeiten mit kleinen bis mittelgroßen Datensätzen.
• Wenn Sie umfangreiche Datenmanipulationsfunktionen benötigen.
• Wenn Sie eine Integration mit anderen Python-Bibliotheken.
• Wenn Sie in einer Umgebung mit umfassender Pandas-Unterstützung und -Ressourcen arbeiten.

Polars

• Beim Umgang mit großen Datensätzen, die eine hohe Leistung erfordern.
• Wenn Sie eine effiziente Speichernutzung benötigen.
• Beim Arbeiten an Aufgaben, die von der Parallelverarbeitung profitieren können.
• Wenn Sie zur Optimierung der Abfrageausführung eine verzögerte Auswertung benötigen.

Hauptunterschiede zwischen Pandas und Polars

Sehen wir uns nun die folgende Tabelle zum Vergleich von Pandas und Polars an.

Weitere Anwendungsfälle

Pandas:

• Zeitreihenanalyse: Es eignet sich am besten für die Manipulation von Zeitreihendaten und enthält spezielle Funktionen, die Resampling, gleitende Fenster und Zeitzonenkonvertierung ermöglichen.
• Datenreinigung: enthält leistungsstarke Verfahren zum Umgang mit fehlenden Werten, Duplikaten und Typkonvertierungen von Daten.
• Zusammenführen und Verbinden: Funktionen zum Zusammenführen, Verknüpfen und Verketten von Daten – Options, die die Weitergabe von Daten aus verschiedenen Quellen durch eine breite Palette von Manipulationen ermöglichen.

Polare:

• Large Information-Verarbeitung: Dank seines optimierten Ausführungsmodells können große Datensätze effizient verarbeitet werden, was in Pandas mühsam wäre.
• Stream-Verarbeitung: Geeignet für Echtzeit-Datenverarbeitungsanwendungen, bei denen Leistung und Speichereffizienz entscheidend sind.
• Stapelverarbeitung: Excellent für Stapelverarbeitungsaufgaben in Datenpipelines. Durch Nutzung der Parallelverarbeitungsfunktionen werden Berechnungen beschleunigt.

Abschluss

Wenn man rechenintensive Operationen beibehält, eignet sich Pandas am besten für Berechnungen professional Datensatz und umgekehrt für Polars. Die Datenmanipulation in Pandas ist umfangreich, flexibel und wird intestine unterstützt, was es in vielen Information-Science-Kontexten zu einer sinnvollen und geeigneten Wahl macht. Während Pandas im Vergleich zu NumPy eine höhere Geschwindigkeit bietet, gibt es eine Hochleistungsdatenstruktur namens Polars, insbesondere beim Umgang mit großen Datensätzen und speicherintensiven Operationen. Wir schätzen diese Unterschiede und Vorteile und glauben, dass es wertvoll ist, die Kriterien zu verstehen, auf deren Grundlage Sie eine Entscheidung darüber treffen möchten, welches Studienprogramm für Sie am besten geeignet ist.

Häufig gestellte Fragen