Pandas Parquet-/Feather-Dateien lesen

Parquet und Feather sind zwei effiziente spaltenorientierte Datenspeicherformate, die für Big-Data-Analysen und schnelle Lese-/Schreibszenarien entwickelt wurden. Im Vergleich zu CSV bieten sie eine bessere Kompressionsrate und Abfrageleistung.

Warum Parquet und Feather verwenden

Hauptvorteile spaltenorientierter Speicherformate:

Merkmal CSV Parquet Feather
Speicherformat Zeilenbasiert Spaltenorientiert Spaltenorientiert
Lesegeschwindigkeit Langsam Sehr schnell Extrem schnell
Schreibgeschwindigkeit Mittel Schnell Extrem schnell
Kompressionsrate Niedrig Hoch Mittel
Sprachübergreifende Unterstützung Allgemein Java/Python/R Python/R

Parquet ist ein Projekt der Apache Foundation und wird im Big-Data-Ökosystem (Hadoop, Spark, DuckDB usw.) weit verbreitet eingesetzt. Feather ist die native Implementierung des Arrow-Projekts und konzentriert sich auf maximale Lese-/Schreibgeschwindigkeit.

Parquet-Dateioperationen

Abhängigkeiten installieren

pip install pyarrow fastparquet

Sowohl PyArrow als auch FastParquet sind Python-Implementierungen von Parquet. PyArrow ist die Standardoption, und FastParquet ist in einigen Szenarien schneller.

Parquet-Dateien lesen

Beispiel

import pandas as pd

# Parquet-Datei lesen (verwendet standardmäßig pyarrow)
df = pd.read_parquet("data.parquet")

# Eine bestimmte Engine angeben
df = pd.read_parquet("data.parquet", engine="pyarrow")
df = pd.read_parquet("data.parquet", engine="fastparquet")

# Remote-Parquet-Datei lesen
df = pd.read_parquet("s3://bucket/data.parquet")

# Bestimmte Spalten der Datei lesen (Spalten-Pruning, verbessert die Performance)
df = pd.read_parquet("data.parquet", columns=["name", "age", "city"])
print(df.head())

Parquet-Dateien schreiben

Beispiel

import pandas as pd

# Testdaten vorbereiten
df = pd.DataFrame({
    "id": range(1, 10001),
    "name": ["User" + str(i) for i in range(1, 10001)],
    "age": [20, 25, 30, 35] * 2500,
    "city": ["Beijing", "Shanghai", "Guangzhou", "Shenzhen"] * 2500,
    "score": [round(i * 0.1, 2) for i in range(1, 10001)]
})

# Parquet-Datei schreiben (verwendet standardmäßig die pyarrow-Engine)
df.to_parquet("data.parquet", index=False)

# Komprimierungsmethode angeben (snappy schnell, gzip hohe Komprimierungsrate)
df.to_parquet("data_snappy.parquet", compression="snappy", index=False)
df.to_parquet("data_gzip.parquet", compression="gzip", index=False)
df.to_parquet("data_none.parquet", compression=None, index=False)  # Keine Komprimierung

# Dateigröße anzeigen
import os
print("Dateigrößenvergleich:")
print(f"Geschätzte Roh-CSV: {len(df) * 50 / 1024 / 1024:.2f} MB")
print(f"snappy komprimiert: {os.path.getsize('data_snappy.parquet') / 1024 / 1024:.2f} MB")
print(f"gzip komprimiert: {os.path.getsize('data_gzip.parquet') / 1024 / 1024:.2f} MB")
print(f"Keine Komprimierung: {os.path.getsize('data_none.parquet') / 1024 / 1024:.2f} MB")

Verwendung der FastParquet-Engine

Beispiel

import pandas as pd
import time

# Schreibleistung verschiedener Engines testen
df = pd.DataFrame({
    "id": range(1, 100001),
    "value": range(1, 100001)
})

# pyarrow-Engine schreiben
start = time.time()
df.to_parquet("test_pyarrow.parquet", engine="pyarrow", compression="snappy")
print(f"pyarrow-Schreibzeit: {time.time() - start:.3f}s")

# Schreiben mit fastparquet-Engine
start = time.time()
df.to_parquet("test_fastparquet.parquet", engine="fastparquet", compression="snappy")
print(f"fastparquet-Schreibzeit: {time.time() - start:.3f}s")

Feather-Dateioperationen

Feather ist eine Python-Implementierung des Arrow-Projekts, die auf ultimative In-Memory-Lese-/Schreibgeschwindigkeit ausgerichtet ist.

Abhängigkeiten installieren

pip install pyarrow

Feather-Dateien lesen

Beispiel

import pandas as pd

# Feather-Datei lesen
df = pd.read_feather("data.feather")

# v2-Version der Feather-Datei lesen (universeller)
df = pd.read_feather("data.feather", Version="2.0")

# Bestimmte Spalten lesen
df = pd.read_feather("data.feather", columns=["name", "age"])
print(df.head())

Feather-Dateien schreiben

Beispiel

import pandas as pd

# Testdaten vorbereiten
df = pd.DataFrame({
    "id": range(1, 10001),
    "name": ["User" + str(i) for i in range(1, 10001)],
    "value": [round(i * 0.1, 2) for i in range(1, 10001)]
})

# Feather-Datei schreiben
df.to_feather("data.feather")

# LZ4-Komprimierung (schneller)
df.to_feather("data_lz4.feather", compression="lz4")

# ZSTD-Komprimierung (höhere Komprimierungsrate)
df.to_feather("data_zstd.feather", compression="zstd")

# Dateigröße anzeigen
import os
print(f"Keine Komprimierung: {os.path.getsize('data.feather') / 1024:.2f} KB")
print(f"LZ4: {os.path.getsize('data_lz4.feather') / 1024:.2f} KB")
print(f"ZSTD: {os.path.getsize('data_zstd.feather') / 1024:.2f} KB")

Leistungsvergleichstest

Beispiel

import pandas as pd
import numpy as np
import time
import os
import tempfile

# Testdaten erstellen
np.random.seed(42)
n_rows = 1000000
df = pd.DataFrame({
    "id": range(n_rows),
    "category": np.random.choice(["A", "B", "C", "D"], n_rows),
    "value": np.random.randn(n_rows),
    "flag": np.random.choice([True, False], n_rows),
    "date": pd.date_range("2020-01-01", periods=n_rows, freq="1min")
})

# Temporäres Verzeichnis erstellen
with tempfile.TemporaryDirectory() as tmpdir:
    # CSV schreiben
    start = time.time()
    df.to_csv(f"{tmpdir}/data.csv", index=False)
    csv_write = time.time() - start

    start = time.time()
    df_csv = pd.read_csv(f"{tmpdir}/data.csv")
    csv_read = time.time() - start

    # Parquet schreiben
    start = time.time()
    df.to_parquet(f"{tmpdir}/data.parquet", index=False)
    pq_write = time.time() - start

    start = time.time()
    df_pq = pd.read_parquet(f"{tmpdir}/data.parquet")
    pq_read = time.time() - start

    # Feather schreiben
    start = time.time()
    df.to_feather(f"{tmpdir}/data.feather")
    feather_write = time.time() - start

    start = time.time()
    df_feather = pd.read_feather(f"{tmpdir}/data.feather")
    feather_read = time.time() - start

    # Ergebnisse ausgeben
    print(f"{'Format':<10} {'Schreibzeit':<12} {'Lesezeit':<12} {'Dateigröße':<12}")
    print("-" * 50)
    print(f"{'CSV':<10} {csv_write:.3f}s{'':<5} {csv_read:.3f}s{'':<5} {os.path.getsize(f'{tmpdir}/data.csv')/1024/1024:.2f}MB")
    print(f"{'Parquet':<10} {pq_write:.3f}s{'':<5} {pq_read:.3f}s{'':<5} {os.path.getsize(f'{tmpdir}/data.parquet')/1024/1024:.2f}MB")
    print(f"{'Feather':<10} {feather_write:.3f}s{'':<5} {feather_read:.3f}s{'':<5} {os.path.getsize(f'{tmpdir}/data.feather')/1024/1024:.2f}MB")

Anwendungsfälle und Auswahlempfehlungen

Szenario Empfohlenes Format Grund
Big-Data-Analyse Parquet Hohe Kompressionsrate, schnelle spaltenbasierte Abfragen, breites Ökosystem
Python/R-Datenübertragung Feather Extrem schnelles Lesen/Schreiben, native Arrow-Unterstützung
Spark/Hadoop-Integration Parquet Standardformat im Big-Data-Ökosystem
Datensicherung/Archivierung Parquet Hohe Kompressionsrate, unterstützt Schema-Evolution
Temporärer Daten-Cache Feather Schnellstes Lesen/Schreiben

Häufig gestellte Fragen

1. Fehler beim Lesen von Parquet

Stellen Sie sicher, dass pyarrow oder fastparquet installiert ist:pip install pyarrow

2. Dateibeschädigung

Stellen Sie beim Schreiben sicher, dass die Daten vollständig auf die Festplatte geschrieben werden. Es wird empfohlen, nach dem Schreiben zu überprüfen, ob die Datei lesbar ist.

3. Versionskompatibilität

Verschiedene Versionen von Parquet können Kompatibilitätsprobleme haben. Es wird empfohlen, in Ihrem Projekt eine feste Version zu verwenden.

Andere Erweiterungen