DataFrames modernes en Python : un didacticiel pratique avec Polars et DuckDB
Si vous utilisez Python pour les données, vous avez probablement éprouvé la frustration d’attendre des minutes pour qu’une opération Pandas se termine.
Au début, tout semble bien, mais à mesure que votre ensemble de données s’agrandit et que vos flux de travail deviennent plus complexes, votre ordinateur portable a soudain l’impression qu’il se prépare au décollage.
Il y a quelques mois, j’ai travaillé sur un projet analysant les transactions de commerce électronique avec plus de 3 millions de lignes de données.
C’était une expérience assez intéressante, mais la plupart du temps, j’ai vu de simples opérations de regroupement qui se déroulaient normalement en quelques secondes se transformer soudainement en quelques minutes.
À ce moment-là, j’ai réalisé que Pandas était incroyable, mais ce n’était pas toujours suffisant.
Cet article explore les alternatives modernes à Pandas, notamment Polars et DuckDB, et examine comment elles peuvent simplifier et améliorer la gestion de grands ensembles de données.
Pour plus de clarté, permettez-moi d’être franc sur quelques points avant de commencer.
Cet article n’est pas une plongée approfondie dans la gestion de la mémoire Rust ni une proclamation selon laquelle Pandas est obsolète.
Il s’agit plutôt d’un guide pratique et pratique. Vous verrez des exemples réels, des expériences personnelles et des informations exploitables sur les flux de travail qui peuvent vous faire gagner du temps et vous faire gagner du temps.
Pourquoi les pandas peuvent se sentir lents
À l’époque où je participais au projet de commerce électronique, je me souviens avoir travaillé avec des fichiers CSV de plus de deux gigaoctets, et chaque filtre ou agrégation dans Pandas prenait souvent plusieurs minutes.
Pendant ce temps, je regardais l’écran, souhaitant pouvoir simplement prendre un café ou me gaver de quelques épisodes d’une émission pendant que le code s’exécutait.
Les principaux problèmes que j’ai rencontrés étaient la vitesse, la mémoire et la complexité du flux de travail.
Nous savons tous à quel point les fichiers CSV volumineux consomment d’énormes quantités de RAM, parfois plus que ce que mon ordinateur portable pourrait gérer confortablement. En plus de cela, l’enchaînement de plusieurs transformations rendait également le code plus difficile à maintenir et plus lent à exécuter.
Polars et DuckDB relèvent ces défis de différentes manières.
Polars, construit dans Rust, utilise une exécution multithread pour traiter efficacement de grands ensembles de données.
DuckDB, quant à lui, est conçu pour l’analyse et exécute des requêtes SQL sans que vous ayez besoin de tout charger en mémoire.
Fondamentalement, chacun d’eux possède son propre super pouvoir. Polars est le speedster et DuckDB est un peu comme le magicien de la mémoire.
Et le meilleur ? Les deux s’intègrent parfaitement à Python, vous permettant d’améliorer vos flux de travail sans réécriture complète.
Configuration de votre environnement
Avant de commencer à coder, assurez-vous que votre environnement est prêt. Par souci de cohérence, j’ai utilisé Pandas 2.2.0, Polars 0.20.0 et DuckDB 1.9.0.
Épingler des versions peut vous éviter des maux de tête lorsque vous suivez des didacticiels ou partagez du code.
pip install pandas==2.2.0 polars==0.20.0 duckdb==1.9.0En Python, importez les bibliothèques :
import pandas as pd
import polars as pl
import duckdb
import warnings
warnings.filterwarnings("ignore")
Par exemple, j’utiliserai un ensemble de données de ventes de commerce électronique avec des colonnes telles que l’ID de commande, l’ID de produit, la région, le pays, les revenus et la date. Vous pouvez télécharger des ensembles de données similaires à partir de Kaggle ou générer des données synthétiques.
Chargement des données
Le chargement efficace des données donne le ton au reste de votre flux de travail. Je me souviens d’un projet où le fichier CSV contenait près de 5 millions de lignes.
Les pandas l’ont géré, mais les temps de chargement étaient longs et les rechargements répétés pendant les tests étaient pénibles.
C’était l’un de ces moments où vous souhaiteriez que votre ordinateur portable ait un bouton « avance rapide ».
Le passage à Polars et DuckDB a complètement amélioré tout, et tout à coup, j’ai pu accéder et manipuler les données presque instantanément, ce qui a honnêtement rendu les processus de test et d’itération beaucoup plus agréables.
Avec les Pandas :
df_pd = pd.read_csv("sales.csv")
print(df_pd.head(3))Avec les polaires :
df_pl = pl.read_csv("sales.csv")
print(df_pl.head(3))Avec DuckDB :
con = duckdb.connect()
df_duck = con.execute("SELECT * FROM 'sales.csv'").df()
print(df_duck.head(3))DuckDB peut interroger les CSV directement sans charger l’intégralité des ensembles de données en mémoire, ce qui facilite grandement le travail avec des fichiers volumineux.
Filtrage des données
Le problème ici est que le filtrage dans Pandas peut être lent lorsqu’il s’agit de millions de lignes. Une fois, j’ai eu besoin d’analyser les transactions européennes dans un ensemble massif de données de ventes. Les pandas prenaient quelques minutes, ce qui ralentissait mon analyse.
Avec les Pandas :
filtered_pd = df_pd[df_pd.region == "Europe"]Polars est plus rapide et peut traiter plusieurs filtres efficacement :
filtered_pl = df_pl.filter(pl.col("region") == "Europe")DuckDB utilise la syntaxe SQL :
filtered_duck = con.execute("""
SELECT *
FROM 'sales.csv'
WHERE region = 'Europe'
""").df()Vous pouvez désormais filtrer de grands ensembles de données en quelques secondes au lieu de quelques minutes, ce qui vous laisse plus de temps pour vous concentrer sur les informations qui comptent vraiment.
Agrégation rapide de grands ensembles de données
L’agrégation est souvent le point où les Pandas commencent à se sentir lents. Imaginez calculer le chiffre d’affaires total par pays pour un rapport marketing.
Chez les Pandas :
agg_pd = df_pd.groupby("country")["revenue"].sum().reset_index()Dans les polaires :
agg_pl = df_pl.groupby("country").agg(pl.col("revenue").sum())
Dans DuckDB :
agg_duck = con.execute("""
SELECT country, SUM(revenue) AS total_revenue
FROM 'sales.csv'
GROUP BY country
""").df()Je me souviens avoir exécuté cette agrégation sur un ensemble de données de 10 millions de lignes. Chez Pandas, cela a pris près d’une demi-heure. Polars a réalisé la même opération en moins d’une minute.
Le sentiment de soulagement était presque comme terminer un marathon et réaliser que vos jambes fonctionnent encore.
Rejoindre des ensembles de données à grande échelle
Rejoindre des ensembles de données est l’une de ces choses qui semblent simples jusqu’à ce que vous soyez réellement plongé dans les données.
Dans les projets réels, vos données résident généralement dans plusieurs sources, vous devez donc les combiner à l’aide de colonnes partagées comme les identifiants clients.
J’ai appris cela à mes dépens en travaillant sur un projet qui nécessitait de combiner des millions de commandes de clients avec un ensemble de données démographiques tout aussi important.
Chaque fichier était suffisamment volumineux à lui seul, mais les fusionner revenait à essayer de forcer deux pièces de puzzle ensemble pendant que votre ordinateur portable implorait grâce.
Les pandas ont pris tellement de temps que j’ai commencé à chronométrer les jointures de la même manière que les gens chronométrent le temps qu’il faut pour terminer leur pop-corn au micro-ondes.
Spoiler : le pop-corn a gagné à chaque fois.
Polars et DuckDB m’ont donné une issue.
Avec les Pandas :
merged_pd = df_pd.merge(pop_df_pd, on="country", how="left")Polaires :
merged_pl = df_pl.join(pop_df_pl, on="country", how="left")CanardDB :
merged_duck = con.execute("""
SELECT *
FROM 'sales.csv' s
LEFT JOIN 'pop.csv' p
USING (country)
""").df()Rejoint sur de grands ensembles de données qui gelaient votre flux de travail fonctionnent désormais de manière fluide et efficace.
Évaluation paresseuse dans les polaires
Une chose que je n’ai pas appréciée au début de mon parcours en science des données était le temps perdu à exécuter des transformations ligne par ligne.
Polars aborde cela différemment.
Il utilise une technique appelée évaluation paresseuse, qui attend essentiellement que vous ayez terminé de définir vos transformations avant d’exécuter des opérations.
Il examine l’ensemble du pipeline, détermine le chemin le plus efficace et exécute tout simultanément.
C’est comme avoir un ami qui écoute l’intégralité de votre commande avant de se rendre à la cuisine, au lieu d’un ami qui prend chaque instruction séparément et continue de faire des allers-retours.
Cet article TDS explique en profondeur l’évaluation paresseuse.
Voici à quoi ressemble le flux :
Pandas :
df = df[df["amount"] > 100]
df = df.groupby("segment").agg({"amount": "mean"})
df = df.sort_values("amount")Mode paresseux des polaires :
import polars as pl
df_lazy = (
pl.scan_csv("sales.csv")
.filter(pl.col("amount") > 100)
.groupby("segment")
.agg(pl.col("amount").mean())
.sort("amount")
)
result = df_lazy.collect()
La première fois que j’ai utilisé le mode paresseux, c’était étrange de ne pas voir de résultats instantanés. Mais une fois que j’ai couru la finale .collect()la différence de vitesse était évidente.
Une évaluation paresseuse ne résoudra pas comme par magie tous les problèmes de performances, mais elle apporte un niveau d’efficacité pour lequel Pandas n’a pas été conçu.
Conclusion et points à retenir
Travailler avec de grands ensembles de données ne nécessite pas nécessairement l’impression de lutter avec vos outils.
L’utilisation de Polars et DuckDB m’a montré que le problème ne venait pas toujours des données. Parfois, c’était l’outil que j’utilisais pour le gérer.
S’il y a une chose que vous retenez de ce didacticiel, c’est bien celle-ci : vous n’êtes pas obligé d’abandonner Pandas, mais vous pouvez rechercher quelque chose de mieux lorsque vos ensembles de données commencent à repousser leurs limites.
Polars vous offre une exécution plus rapide et plus intelligente, puis DuckDB vous permet d’interroger des fichiers volumineux comme s’ils étaient minuscules. Ensemble, ils rendent le travail avec des données volumineuses plus facile à gérer et moins fatiguant.
Si vous souhaitez approfondir les idées explorées dans ce tutoriel, la documentation officielle de Polaires et CanardDB sont de bons points de départ.
