Pandas Lire les fichiers Parquet / Feather

Parquet et Feather sont deux formats efficaces de stockage de données en colonnes, conçus pour l'analyse de big data et les scénarios de lecture/écriture rapides. Par rapport à CSV, ils offrent un meilleur taux de compression et de meilleures performances de requête.

Pourquoi utiliser Parquet et Feather

Principaux avantages des formats de stockage en colonnes :

Fonctionnalité CSV Parquet Feather
Format de stockage En lignes En colonnes En colonnes
Vitesse de lecture Lent Très rapide Extrêmement rapide
Vitesse d'écriture Moyenne Rapide Extrêmement rapide
Taux de compression Faible Élevée Moyenne
Support multi-langages Général Java/Python/R Python/R

Parquet est un projet de la fondation Apache, largement utilisé dans l'écosystème du big data (Hadoop, Spark, DuckDB, etc.). Feather est l'implémentation native du projet Arrow, axée sur une vitesse de lecture/écriture ultime.

Opérations sur les fichiers Parquet

Installer les dépendances

pip install pyarrow fastparquet

PyArrow et FastParquet sont tous deux des implémentations Python de Parquet. PyArrow est l'option par défaut, et FastParquet est plus rapide dans certains scénarios.

Lire les fichiers Parquet

Exemple

import pandas as pd

# Lire un fichier Parquet (utilise pyarrow par défaut)
df = pd.read_parquet("data.parquet")

# Spécifier un moteur spécifique
df = pd.read_parquet("data.parquet", engine="pyarrow")
df = pd.read_parquet("data.parquet", engine="fastparquet")

# Lire un fichier Parquet distant
df = pd.read_parquet("s3://bucket/data.parquet")

# Lire des colonnes spécifiques du fichier (élagage des colonnes, améliore les performances)
df = pd.read_parquet("data.parquet", columns=["name", "age", "city"])
print(df.head())

Écrire des fichiers Parquet

Exemple

import pandas as pd

# Préparer les données de test
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)]
})

# Écrire un fichier Parquet (utilise le moteur pyarrow par défaut)
df.to_parquet("data.parquet", index=False)

# Spécifier la méthode de compression (snappy rapide, gzip taux de compression élevé)
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)  # Aucune compression

# Afficher la taille du fichier
import os
print("Comparaison de la taille des fichiers :")
print(f"CSV brut estimé : {len(df) * 50 / 1024 / 1024:.2f} MB")
print(f"compressé snappy : {os.path.getsize('data_snappy.parquet') / 1024 / 1024:.2f} MB")
print(f"compressé gzip : {os.path.getsize('data_gzip.parquet') / 1024 / 1024:.2f} MB")
print(f"Aucune compression : {os.path.getsize('data_none.parquet') / 1024 / 1024:.2f} MB")

Utilisation du moteur FastParquet

Exemple

import pandas as pd
import time

# Tester les performances d'écriture des différents moteurs
df = pd.DataFrame({
    "id": range(1, 100001),
    "value": range(1, 100001)
})

# écriture avec le moteur pyarrow
start = time.time()
df.to_parquet("test_pyarrow.parquet", engine="pyarrow", compression="snappy")
print(f"temps d'écriture pyarrow : {time.time() - start:.3f}s")

# écriture avec le moteur fastparquet
start = time.time()
df.to_parquet("test_fastparquet.parquet", engine="fastparquet", compression="snappy")
print(f"temps d'écriture fastparquet : {time.time() - start:.3f}s")

Opérations sur les fichiers Feather

Feather est une implémentation Python du projet Arrow, axée sur la vitesse ultime de lecture/écriture en mémoire.

Installer les dépendances

pip install pyarrow

Lire les fichiers Feather

Exemple

import pandas as pd

# Lire le fichier Feather
df = pd.read_feather("data.feather")

# Lire la version v2 du fichier Feather (plus universelle)
df = pd.read_feather("data.feather", version="2.0")

# Lire des colonnes spécifiques
df = pd.read_feather("data.feather", columns=["name", "age"])
print(df.head())

Écrire des fichiers Feather

Exemple

import pandas as pd

# Préparer les données de test
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)]
})

# Écrire un fichier Feather
df.to_feather("data.feather")

# Compression LZ4 (plus rapide)
df.to_feather("data_lz4.feather", compression="lz4")

# Compression ZSTD (taux de compression plus élevé)
df.to_feather("data_zstd.feather", compression="zstd")

# Afficher la taille du fichier
import os
print(f"Aucune compression : {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")

Test de comparaison des performances

Exemple

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

# Créer des données de test
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")
})

# Créer un répertoire temporaire
with tempfile.TemporaryDirectory() as tmpdir:
    # Écriture CSV
    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

    # Écriture Parquet
    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

    # Écriture Feather
    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

    # Afficher les résultats
    print(f"{'Format':<10} {'Temps d’écriture':<12} {'Temps de lecture':<12} {'Taille du fichier':<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")

Cas d’utilisation et recommandations de sélection

Scénario Format recommandé Raison
Analyse de Big Data Parquet Ratio de compression élevé, requêtes columnaires rapides, écosystème étendu
Transfert de données Python/R Feather Lecture/écriture extrêmement rapide, prise en charge native d’Arrow
Intégration Spark/Hadoop Parquet Format standard dans l’écosystème du big data
Sauvegarde/archivage des données Parquet Fort taux de compression, prend en charge l’évolution du schéma
Cache de données temporaire Feather Lecture/écriture la plus rapide

Questions fréquentes

1. Erreur de lecture de Parquet

Assurez-vous que pyarrow ou fastparquet est installé :pip install pyarrow

2. Corruption de fichier

Lors de l’écriture, assurez-vous que les données sont complètement écrites sur le disque. Il est recommandé de vérifier que le fichier est lisible après l’écriture.

3. Compatibilité des versions

Différentes versions de Parquet peuvent avoir des problèmes de compatibilité. Il est recommandé d'utiliser une version fixe dans votre projet.

Autres extensions