Pandas & NumPy Academy · Leçon

Parquet : stockage colonnaire rapide

Écrivez un DataFrame Pandas au format Parquet avec to_parquet(), relisez-le plus rapidement qu’un CSV et utilisez la sélection de colonnes pour ne charger que les champs nécessaires.

Parquet : stockage colonnaire rapide est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Pandas & NumPy Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Pandas & NumPy Academy comprend 4 leçons au total.

Qu’est-ce que Parquet ?

Apache Parquet est un format de fichier binaire orienté colonnes, conçu pour les charges de travail analytiques. Contrairement au format CSV, qui stocke les données ligne par ligne sous forme de texte, Parquet stocke chaque colonne dans un bloc contigu, la compresse efficacement et encode ses métadonnées. Il est ainsi beaucoup plus rapide pour les requêtes qui ne lisent que quelques colonnes d’une table large. Parquet est le format de référence des lacs de données (AWS S3, Google Cloud Storage) et est pris en charge nativement par Pandas, Dask, Spark et BigQuery.

Écrire au format Parquet avec to_parquet()

Convertir un DataFrame Pandas en Parquet se fait en un seul appel de méthode : df.to_parquet('output.parquet'). Le moteur par défaut est pyarrow (à installer avec pip install pyarrow). Parquet conserve exactement les types de données des colonnes : les colonnes de dates ne sont plus relues sous forme de chaînes de caractères. Le format prend également en charge la compression sans configuration supplémentaire grâce au paramètre compression ; 'snappy' offre une lecture et une écriture rapides avec une compression modérée, tandis que 'gzip' fournit une compression plus élevée au prix d’une vitesse moindre.

import pandas as pd
import numpy as np

# Create a sample DataFrame
np.random.seed(0)
df = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=100000, freq='T'),
    'value': np.random.randn(100000),
    'category': np.random.choice(['A', 'B', 'C'], 100000)
})

# Write to Parquet
df.to_parquet('data.parquet', index=False, compression='snappy')
print('Written to data.parquet')

Lire du Parquet avec read_parquet()

pd.read_parquet('output.parquet') relit le fichier dans un DataFrame. Par rapport à la lecture du fichier CSV équivalent, la lecture de Parquet est généralement 5 à 10 fois plus rapide pour les tables larges comportant de nombreuses colonnes. Les types de données sont conservés exactement : les dates restent au format datetime64, les catégories restent au format category, et les entiers restent au format int32 ou int64, conformément à leur enregistrement. Aucune inférence de type n’est nécessaire, car les métadonnées sont intégrées au fichier.

import pandas as pd
import time

# Read Parquet
start = time.time()
df = pd.read_parquet('data.parquet')
print(f'Read Parquet: {time.time()-start:.3f}s')
print(df.dtypes)
print(df.shape)

Élagage des colonnes : lire uniquement les colonnes nécessaires

Le principal avantage du stockage orienté colonnes est l’élagage des colonnes : vous pouvez lire uniquement certaines colonnes sans parcourir le reste du fichier. Transmettez une liste de noms de colonnes au paramètre columns. Si une table de 100 colonnes occupe 100 MB par colonne et que vous n’en avez besoin que de 3, Parquet lit 3 MB au lieu de 10 GB. CSV doit parcourir chaque caractère pour extraire une colonne donnée. Parquet est donc idéal pour les tables larges utilisées dans les pipelines analytiques.

import pandas as pd

# Only load the 2 columns needed for this analysis
df = pd.read_parquet('large_table.parquet',
                     columns=['date', 'revenue'])
print(df.columns.tolist())
print(df.shape)
print(df.memory_usage(deep=True).sum() / 1e6, 'MB loaded')

Filtrage des groupes de lignes (propagation des prédicats)

Parquet stocke des statistiques (min/max) pour chaque groupe de lignes (bloc de lignes) dans le pied de page du fichier. Lorsque vous appliquez un filtre via le paramètre filters, le lecteur ignore les groupes de lignes entiers pour lesquels le filtre ne peut pas produire de correspondance : on appelle cela la propagation des prédicats. Par exemple, le filtrage des dates dans un fichier Parquet trié chronologiquement ignore les blocs mensuels entiers qui sont en dehors de l’intervalle, et ne lit que les parties pertinentes. Le moteur pyarrow prend cette fonctionnalité en charge nativement.

import pandas as pd

# Filter using predicate pushdown — row groups outside range are skipped
df = pd.read_parquet(
    'time_series.parquet',
    columns=['date', 'value'],
    filters=[('date', '>=', '2024-06-01'),
              ('date', '<', '2024-07-01')]
)
print(f'Loaded {len(df):,} rows (June only)')
print(df.head())

Parquet et CSV : comparaison

Voici une comparaison pratique de Parquet et CSV pour un jeu de données de 10 millions de lignes et 20 colonnes :

Taille du fichier : CSV ~2 GB, Parquet (snappy) ~400 MB
Temps de lecture (toutes les colonnes) : CSV ~15 s, Parquet ~2 s
Temps de lecture (3 colonnes) : CSV ~15 s (toutes les colonnes doivent être parcourues), Parquet ~0,3 s
Conservation des types : CSV perd les types, Parquet les conserve
Lisibilité humaine : CSV oui, Parquet non (binaire)

Pour les pipelines de production dans lesquels les données sont écrites une fois et lues de nombreuses fois, Parquet est presque toujours le meilleur choix.

Jeux de données Parquet partitionnés

Pour les très grands jeux de données, Parquet prend en charge les jeux de données partitionnés : les données sont réparties dans plusieurs fichiers organisés selon une hiérarchie de répertoires fondée sur les valeurs des colonnes. Par exemple, un partitionnement par année et par mois crée data/year=2024/month=01/part.parquet. La lecture d’un jeu de données partitionné filtre automatiquement les répertoires correspondant à une requête. Il s’agit de la disposition standard dans les lacs de données, qui permet d’effectuer efficacement des requêtes par intervalle sur des milliards de lignes.

import pandas as pd

# Write a partitioned dataset (requires pyarrow)
df = pd.read_parquet('all_data.parquet')
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month

df.to_parquet(
    'partitioned_data/',
    partition_cols=['year', 'month'],
    index=False
)
# Creates: partitioned_data/year=2024/month=1/part-0.parquet etc.

Lire des jeux de données partitionnés

Lire un répertoire Parquet partitionné est identique à lire un fichier unique : Pandas (via pyarrow) détecte automatiquement tous les fichiers de partition. Les valeurs de la colonne de partition sont incluses comme colonnes dans le DataFrame obtenu. Vous pouvez également utiliser filters pour exploiter l’élagage des partitions : des sous-arbres entiers de répertoires sont alors ignorés en fonction des valeurs de la colonne de partition. Interroger un jeu de données partitionné de 1 TB donne ainsi l’impression de lire seulement quelques MB.

import pandas as pd

# Read the entire partitioned dataset
df_all = pd.read_parquet('partitioned_data/')
print('All years:', df_all['year'].unique())

# Read only 2024 data using partition pruning
df_2024 = pd.read_parquet(
    'partitioned_data/',
    filters=[('year', '==', 2024)]
)
print('2024 rows:', len(df_2024))

Parquet avec Dask

Dask lit et écrit nativement les fichiers Parquet avec dd.read_parquet() et ddf.to_parquet(). Chaque fichier d’un répertoire Parquet partitionné devient une partition Dask, ce qui permet des lectures entièrement parallèles. Dask exploite également la propagation des prédicats lorsque des filtres sont spécifiés. Écrire un résultat Dask volumineux dans un jeu de données Parquet partitionné est la méthode standard pour produire des résultats dans les pipelines modernes d’ingénierie des données.

import dask.dataframe as dd

# Read partitioned Parquet with Dask (each file = one partition)
ddf = dd.read_parquet('partitioned_data/',
                      columns=['date', 'revenue', 'region'],
                      filters=[('year', '==', 2024)])

# Compute aggregation in parallel
result = ddf.groupby('region')['revenue'].sum().compute()
print(result.sort_values(ascending=False))

Options de compression et d’encodage

Parquet prend en charge plusieurs algorithmes de compression et schémas de codage internes. Snappy (par défaut) privilégie la vitesse avec une compression modérée. Gzip produit des fichiers environ 30 % plus petits, mais leur lecture et leur écriture sont plus lentes. Zstd offre un meilleur équilibre entre vitesse et compression que les deux autres. Pour les colonnes d'entiers, Parquet applique automatiquement un codage delta ou un codage par dictionnaire afin de réduire davantage la taille, sans configuration supplémentaire de votre part.

import pandas as pd
import numpy as np

np.random.seed(0)
df = pd.DataFrame({'id': range(500000), 'val': np.random.randn(500000)})

for comp in ['snappy', 'gzip', 'zstd']:
    fname = f'data_{comp}.parquet'
    df.to_parquet(fname, compression=comp, index=False)
    import os
    size_mb = os.path.getsize(fname) / 1e6
    print(f'{comp}: {size_mb:.2f} MB')

Remplacer CSV dans votre pipeline

La manière la plus simple d'adopter Parquet consiste à ajouter une étape de conversion unique au début d'un projet : lire votre CSV une fois, nettoyer les données et convertir leurs types, puis les enregistrer au format Parquet. Toutes les exécutions suivantes lisent le fichier Parquet au lieu du CSV. Vous bénéficiez ainsi immédiatement d'un gain de vitesse et d'espace de stockage, avec très peu de modifications du code. Pour les nouvelles données reçues au format CSV (par exemple, des exportations nocturnes), ajoutez à votre pipeline une étape de conversion qui écrit les données au format Parquet avant le début de toute analyse.

import pandas as pd

# One-time conversion
df = pd.read_csv('raw_data.csv',
                 parse_dates=['date'],
                 dtype={'category': 'category',
                        'amount': 'float32'})
df.to_parquet('clean_data.parquet', index=False)

# All future reads use Parquet
df_fast = pd.read_parquet('clean_data.parquet')
print('Loaded from Parquet:', df_fast.dtypes.to_dict())

Vérification rapide

Testez votre compréhension des concepts d'analyse de données présentés dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que to_parquet() et read_parquet() permettent d'effectuer des entrées-sorties de fichiers plus rapides, plus compactes et qui préservent les types de données, par rapport au CSV ; que la sélection des colonnes avec le paramètre columns ne lit que les colonnes nécessaires et évite d'analyser l'intégralité du fichier ; et que les jeux de données Parquet partitionnés, organisés selon les valeurs des colonnes, permettent d'élaguer les partitions pour exécuter efficacement des requêtes sur des intervalles dans de grands lacs de données. Nous allons maintenant connecter Pandas aux bases de données relationnelles avec SQLAlchemy.

Questions Fréquemment Posées

La leçon « Parquet : stockage colonnaire rapide » est-elle gratuite ?

Oui — le texte complet de « Parquet : stockage colonnaire rapide » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Pandas & NumPy Academy, passe à CoddyKit PRO. Le cours Pandas & NumPy Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Parquet : stockage colonnaire rapide » ?

Écrivez un DataFrame Pandas au format Parquet avec to_parquet(), relisez-le plus rapidement qu’un CSV et utilisez la sélection de colonnes pour ne charger que les champs nécessaires. Tu pratiques Pandas & NumPy Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Pandas & NumPy Academy ?

Aucune expérience préalable n'est requise. Pandas & NumPy Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Parquet : stockage colonnaire rapide » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Pandas & NumPy Academy ?

Oui. Chaque leçon Pandas & NumPy Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Pandas & NumPy Academy