À mesure que le paysage de la data science se complexifie et que de nouvelles technologies apparaissent chaque jour, choisir la bonne boîte à outils devient crucial pour votre projet. Plus le projet est complexe, plus vous devrez être vigilant dans le choix des outils, car vos décisions auront un impact majeur sur le développement et, in fine, sur la réussite du projet.
Si vous travaillez sur un projet de data science, les choix de conception vont bien au‑delà du débat Python vs R. Il s’agit aussi des bibliothèques à utiliser une fois le langage de programmation du projet défini.
Dans le cas de Python pour la data science, pandas est l’outil standard de facto pour la manipulation de données. Les raisons d’utiliser pandas sont nombreuses et convaincantes, mais il présente aussi des limites qui peuvent créer des goulots d’étranglement importants. En particulier, pandas est réputé pour ses performances limitées avec de très grands ensembles de données.
Pour répondre à ces enjeux, pandas a récemment publié sa version 2.0, qui apporte des révisions majeures et des gains de performance significatifs (consultez cet article pour découvrir tout ce qu’il faut savoir sur pandas 2.0).
Parallèlement, de nouvelles alternatives ont émergé dans l’écosystème Python pour remettre en question la domination de pandas. L’une des plus populaires est polars, une bibliothèque basée sur Python et Rust pour des analyses de données plus rapides.
Cet article analyse les différences entre pandas 2.0 et polars pour la manipulation de données. Nous commencerons par passer en revue les stratégies d’optimisation des performances, puis nous enchaînerons avec une série de tests comparant les performances des deux outils. C’est parti !
Comment choisir entre pandas et polars
Aucune technologie n’est « meilleure » en soi pour résoudre tous les problèmes et cas de figure qui peuvent survenir dans vos workflows de data science. Plusieurs facteurs doivent être mis en balance avant de trancher. Voici les principaux critères à considérer :
- Performances de calcul. En règle générale, plus le projet est vaste et complexe, plus vous devez envisager des outils haute performance pour éviter les goulots d’étranglement.
- Compatibilité avec votre stack technologique. Les outils d’un projet data ne fonctionnent que rarement isolément. Ils s’intègrent au contraire aux autres composants de la stack. Avant de choisir, veillez aux synergies et à l’alignement entre technologies.
- Compatibilité du code. Adopter une nouvelle technologie pose aussi la question de la compatibilité et de l’efficacité du code. Si l’adoption d’un nouvel outil implique de réécrire du code existant, il faut l’intégrer dans votre calcul coût/bénéfice.
- Popularité. Enfin, la popularité d’un outil reflète le nombre d’utilisateurs, ce qui peut faciliter les recrutements et la résolution de problèmes sur des plateformes comme Stack Overflow.
Comment améliorer les performances de manipulation de données ?
Dans cette section, nous passons en revue les techniques clés pour accélérer la manipulation de données.
Réduire les copies avec le copy-on-write
Avec les outils traditionnels de manipulation, chaque opération crée une nouvelle copie de l’ensemble des données. Ce comportement peut poser problème côté mémoire lorsqu’on traite de grands volumes.
Le copy-on-write est la technique la plus utilisée pour résoudre ce problème. En substance, c’est une méthode de gestion des ressources qui permet d’implémenter efficacement une opération de « duplication » sur des ressources modifiables. Autrement dit, si un jeu de données est dupliqué mais pas (entièrement) modifié, il n’est pas nécessaire de créer une nouvelle ressource : la mémoire peut être partagée entre la copie et l’original.
Calcul parallèle
L’une des principales limites de pandas est son exécution monothread, ce qui l’empêche de tirer parti des techniques de calcul parallèle désormais courantes en data science. Le parallélisme s’appuie principalement sur des machines multi‑cœurs ou sur du calcul distribué (un groupe de machines travaillant en cluster).
Prenons l’exemple de la fonction group by. Si vous souhaitez calculer l’âge moyen des basketteurs par équipe, vous pouvez paralléliser en confiant le calcul de la moyenne de chaque groupe à un cœur ou une machine, plutôt que de procéder séquentiellement, ce qui améliore les performances.
Optimiser l’import de données
Le point de départ d’une analyse consiste généralement à lire les jeux de données à étudier. Or, c’est souvent un goulot d’étranglement dans les projets impliquant de gros volumes. Voici quelques techniques pour accélérer la lecture :
- Découpage en blocs (chunking). Au lieu de lire le fichier en entier, vous pouvez le découper en petits blocs. Cette approche accélère l’import tout en réduisant la mémoire nécessaire pour tout stocker simultanément.
- Lecture des seules colonnes utiles. Il arrive que vous connaissiez à l’avance les colonnes nécessaires à votre analyse. Plutôt que de tout lire, filtrez en amont et chargez uniquement ces colonnes.
- Downcasting des types. Des outils comme pandas attribuent par défaut des types aux colonnes importées. Or, d’autres types moins gourmands peuvent parfois convenir sans perte d’information. Le downcasting consiste à réduire le type au plus petit capable de porter la valeur.
Évaluation paresseuse et planification de requêtes
L’ordre d’exécution des opérations peut influer sur les performances. Souvent, on peut réordonner des calculs et obtenir le même résultat plus efficacement.
Deux stratégies existent : l’évaluation paresseuse (lazy evaluation), qui diffère les calculs jusqu’au moment nécessaire, et la planification de requêtes (query planning), qui cherche la manière la plus efficace d’exécuter plusieurs manipulations pour un ensemble de requêtes. Cette dernière s’appuie généralement sur un optimiseur de requêtes.
Traitement out‑of‑core
Des outils comme pandas stockent l’intégralité des données en mémoire vive, ce qui peut être problématique lorsque les jeux de données dépassent la mémoire disponible ou que certaines opérations sont très consommatrices.
C’est là que le traitement out‑of‑core devient pertinent. En bref, il s’appuie sur une mémoire externe (p. ex. un disque) pour stocker des données qui ne tiennent pas en mémoire centrale. Le traitement out‑of‑core permet de traiter ces données par blocs, pour aboutir au même résultat qu’un traitement complet en mémoire.
Quelles alternatives performantes à pandas ?
Cet article se concentre sur la comparaison pandas 2.0 vs polars, mais d’autres outils peuvent aussi répondre à vos besoins en alternative à pandas. Parmi les plus prometteurs :
- Koalas. Une API pandas bâtie sur PySpark. Si vous utilisez Spark, cet outil mérite votre attention.
- Vaex. Une API pandas pour le calcul hors mémoire, idéale pour analyser de grands tableaux à un milliard de lignes par seconde.
- Modin. Une API pandas pour la programmation parallèle, basée sur Dask ou Ray pour les projets big data. Si vous utilisez Dask ou Ray, Modin est une excellente option.
- cuDF. Intégrée au projet RAPIDS, cuDF est une API de type pandas pour le calcul sur GPU s’appuyant sur les GPU NVIDIA ou d’autres briques de RAPIDS pour des manipulations ultra‑rapides.
Pourquoi choisir polars ?
Pandas est le choix naturel des praticiens Python, mais, comme expliqué plus haut, il présente des limites importantes sur les grands volumes. La mission centrale de polars est d’offrir une bibliothèque de dataframes ultra‑rapide qui corrige les écueils de pandas.
Écrite en Rust (un langage puissant offrant des performances proches de C/C++ et un contrôle précis des parties critiques d’un moteur de requêtes), polars intègre des méthodes de pointe pour gagner en performance, conçues pour :
- Renforcer le calcul parallèle afin d’exploiter tous les cœurs disponibles de votre machine.
- Optimiser les requêtes pour réduire le travail et les allocations mémoire inutiles via l’évaluation paresseuse et la planification de requêtes.
- Améliorer les performances d’E/S grâce aux sémantiques copy‑on‑write et à Apache Arrow.
- Gérer des jeux de données bien plus grands grâce à ses capacités out‑of‑core et son API de streaming.
Dernier point important : polars adopte une syntaxe très proche de pandas et partage les mêmes briques de base, comme Series et DataFrames. Si vous migrez vers polars, l’apprentissage sera plus fluide.
Comment pandas répond‑il à la concurrence avec pandas 2.0 ?
Pour traiter ses problèmes de performance et faire face à la pression concurrentielle, pandas a publié sa très attendue version 2.0. Cette mise à jour majeure apporte de nouvelles fonctionnalités et des dépréciations appliquées, entraînant des changements d’API.
Le nouveau backend PyArrow est le grand pari de pandas pour dépasser ses limites de performance. Les utilisateurs peuvent désormais choisir entre le backend NumPy traditionnel et le tout nouveau backend PyArrow. PyArrow est une bibliothèque Python qui fournit une interface pour manipuler de grands jeux de données via les structures mémoire Arrow.
pd.read_csv(my_file, engine='pyarrow')Autre nouveauté importante : l’intégration de plusieurs améliorations liées au copy‑on‑write afin d’économiser la mémoire et d’accroître les performances.
Ainsi, de nombreuses opérations pandas incorporent désormais un paramètre « copy » par défaut qui renvoie une copie paresseuse d’objets pandas de base (series et dataframes), au lieu de copies identiques mises en cache.
Il est encore trop tôt pour savoir si ces capacités suffiront à résoudre les problèmes de performance. Même si d’autres outils le dépassent, il restera de bonnes raisons de continuer à utiliser pandas : vous n’aurez pas à réécrire du code existant ni à apprendre de nouvelles syntaxes si vous l’utilisez déjà.
pandas 2.0 vs polars : cadre de comparaison
Maintenant que la théorie est posée, passons à la pratique. Dans les sections suivantes, nous allons exécuter une série de tests pour comparer les performances de pandas 2.0 et polars. Notre benchmark sera le temps nécessaire à l’exécution des tâches. Pour cela, nous utiliserons le module time, qui permet de mesurer simplement les temps d’exécution.
Au‑delà des performances, nous analyserons aussi la compatibilité du code de polars avec pandas (autrement dit, quelle quantité de code faut‑il modifier pour basculer vers polars ?).
Le jeu de données
Nous testerons les performances de pandas 2.0 et polars sur un jeu de données fictif d’achats horaires d’une entreprise disposant de bureaux dans plusieurs pays, sur la période 1980‑2022. Pour complexifier le benchmark, nous y ajoutons des valeurs manquantes aléatoires.
Au total, le dataset dépasse 22 millions de lignes et 1,6 Go en mémoire, de quoi mettre pandas sous pression. L’ensemble du code des tests de benchmark est disponible dans ce workbook DataLab.
Test d’import
Commençons par comparer les performances de pandas 2.0 et polars à l’import des données. Polars met en avant d’excellentes performances d’import depuis des CSV. Est‑ce vérifié ?
Nous allons mesurer le temps nécessaire à pandas et polars pour lire un sous‑ensemble de colonnes et de lignes. Par exemple, supposons que vous ne vouliez analyser que les ventes du bureau France. Avec pandas, vous devez lire toutes les lignes puis filtrer pour supprimer les lignes indésirables. Nous utiliserons la toute nouvelle méthode .query() pour cela. Pour évaluer pandas 2.0, nous importerons le CSV avec le moteur numpy classique et le nouveau moteur pyarrow.
À l’inverse, polars propose la méthode filter() qui, combinée à des conditions, permet de lire uniquement les lignes d’intérêt.
# pandas query
df_pd = pd.read_csv("./example.csv", engine="pyarrow")
df_pd = df_pd[['id', 'date', 'office', 'sales']]
df_pd = df_pd.query("office=='France'")
# polars filter
df_pl = pl.read_csv('example.csv').filter(
(pl.col('office') == 'France'))
df_pl.select(pl.col(['id', 'date', 'office', 'sales']))
Dans notre test, polars surpasse nettement pandas, comme l’illustre le graphique. De façon surprenante, le moteur pyarrow ne fait pas mieux que le moteur numpy standard.
Côté compatibilité syntaxique, polars reprend clairement l’esprit de pandas, avec des fonctions comme pl.read_csv() qui font écho à pandas. Cependant, les deux bibliothèques fonctionnent différemment sous le capot, d’où des divergences inévitables de syntaxe, comme entre query() et filter().
Test de group by
Les opérations groupby se prêtent bien à la parallélisation. Voyons comment pandas et polars se comportent pour plusieurs agrégations. Nous calculerons en particulier la moyenne et la médiane des ventes par bureau et par mois.
df_pd.groupby([df_pd.office, df_pd.date.dt.month])['sales'].agg('mean') # pandas groupby mean
df_pl.groupby([pl.col('office'), pl.col('date').dt.month()]).agg([pl.mean('sales')]) # polars groupby mean
df_pd.groupby([df_pd.office, df_pd.date.dt.month])['sales'].agg('median') # pandas groupby median
df_pl.groupby([pl.col('office'), pl.col('date').dt.month()]).agg([pl.median('sales')]) pandas groupby median
Les résultats montrent que, pour les group by et agrégations, polars est plus performant que pandas. Là encore, la syntaxe de polars rappelle celle de pandas.
Test de statistiques glissantes
Autre opération intéressante pour comparer pandas et polars : les statistiques glissantes. L’optimisation de ces calculs fait intervenir des aspects algorithmiques subtils. Observons le comportement lors du calcul de la moyenne glissante quotidienne des ventes.
# pandas rolling mean
df_pd['sales'].rolling(1440, min_periods=1).mean()
# polars rolling mean
df_pl['sales'].rolling_mean(1440, min_periods=1)Ici encore, polars l’emporte. Notez la différence de syntaxe : polars propose rolling_mean(), tandis que pandas s’appuie sur rolling() à combiner avec d’autres méthodes, comme mean().
Test d’échantillonnage
Étudier l’ensemble d’une population est rarement possible. L’échantillonnage est donc une pratique courante en statistiques et en data science. Il s’agit de tirer des échantillons aléatoires via des techniques de simulation de Monte‑Carlo, comme le bootstrap et la permutation. Toutefois, ces opérations impliquent de nombreuses copies de variables, ce qui peut être difficile avec des ressources limitées.
Voyons le comportement de pandas et polars lors d’un bootstrap (rééchantillonnage avec remise). Nous estimerons la moyenne des ventes sur 10 000 échantillons de 1 000 valeurs.
#pandas bootstrap
simu_weights = []
for i in range(10000):
bootstrap_sample = random.choices(df_pd['sales'], k=1000)
simu_weights.append(np.nanmean(bootstrap_sample))
#polars bootstrap
simu_weights = []
for i in range(10000):
bootstrap_sample = df_pl['sales'].sample(n=1000,with_replacement=True)
simu_weights.append(bootstrap_sample.mean())Sur ce test de bootstrap, polars est presque 5 fois plus rapide que pandas.
Côté syntaxe, pandas s’appuie sur numpy pour l’échantillonnage, tandis que polars propose une méthode intégrée pratique, sample().
Manipulations composées
Pour le dernier test, nous enchaînons une série de manipulations connectées. C’est le quotidien des professionnels de la donnée. Pourtant, ces pipelines multi‑étapes sont faciles à écrire de façon sous‑optimale.
Imaginons que le bureau italien de l’entreprise fictive envisage d’embaucher certains stagiaires 2022 à l’issue de leur période de stage. Notre objectif : identifier les dix stagiaires ayant réalisé les plus grosses ventes en 2022 afin de retenir les meilleurs profils.
Pour ce faire, nous devons joindre notre dataset à un second jeu de données, « italy_2022 », qui contient des informations sur l’auteur de chaque transaction en 2022. La colonne « id » est la clé commune.
# pandas compound operations
df_pd.merge(italy_2022, on='id').query("responsibility =='Sales Intern'").sort_values('sales', ascending=False).head(10)[['name','surname','sales','sex']]
#polars compound manipulations
df_pl.join(italy_2022_pl, on="id").filter(pl.col('responsability') == 'Sales Intern').sort('sales',descending=True).head(10).select(pl.col(['name','surname','sales','sex']))
Comme dans tous les tests précédents, polars bat pandas en performance. Ici, l’opération de jointure semble être le principal point faible de pandas. À l’inverse, polars s’en sort nettement mieux, avec moins de deux secondes pour exécuter l’ensemble de la chaîne.
Tableau de comparaison pandas 2.0 vs polars
Nous avons synthétisé les tests ci‑dessus dans un tableau pour une comparaison rapide :
|
Test |
Pandas 2.0 |
Polars |
Vainqueur |
Similarité de syntaxe |
|
Test d’import |
Lecture de toutes les lignes puis filtrage des lignes indésirables via .query() |
Lit directement les seules lignes d’intérêt via filter() |
Polars (meilleures performances) |
Proches, mais avec des différences dues à l’implémentation (query() vs filter()) |
|
Test de group by |
Utilise .groupby() pour agréger (moyenne et médiane des ventes par bureau et par mois) |
Identique côté usage, mais plus performant |
Polars (meilleures performances) |
Similaire |
|
Test de statistiques glissantes |
Utilise rolling() combiné à d’autres méthodes, comme mean(), pour la moyenne glissante |
Utilise rolling_mean() pour la moyenne glissante |
Polars (meilleures performances) |
Proche, avec de légères différences (.rolling().mean() vs rolling_mean()) |
|
Test d’échantillonnage |
S’appuie sur numpy pour le bootstrap |
Utilise la méthode intégrée sample() pour le bootstrap |
Polars (presque 5× plus rapide) |
Différent : pandas s’appuie sur numpy, polars propose des méthodes intégrées |
|
Test de manipulations composées |
Joint un autre dataset puis trie et sélectionne les données |
Effectue les mêmes tâches, mais plus efficacement |
Polars (nettement plus rapide) |
Proche, avec des différences (merge().query().sort_values().head() vs join().filter().sort().head().select()) |
Passez à la vitesse supérieure
Félicitations d’être allé au bout de ce tutoriel. D’après nos tests, polars surpasse nettement pandas 2.0 dans presque tous les cas. Si cela remet en cause sa domination, pandas conserve toutefois l’avantage d’être l’option de référence pour la manipulation de données en Python, avec tous les bénéfices d’une communauté d’utilisateurs bien plus large.
Si vous travaillez avec de très grands jeux de données, améliorer les performances est indispensable. DataCamp vous accompagne. Voici une sélection de cours pour monter en puissance :
