Tu attends que Pandas finisse de mouliner ton CSV du matin ? Normal : il exécute tout en Python, cœur par cœur, et n'exploite qu'une fraction de ta machine. Polars, lui, est écrit en Rust et traite tes données en parallèle sur tous les cœurs disponibles. Résultat : jusqu'à dix fois plus rapide, avec nettement moins de mémoire. Voyons comment l'adopter en quelques minutes, sans tout réécrire.
Polars n'est pas un simple Pandas dopé aux stéroïdes. Il apporte deux idées neuves : une API d'expressions (pl.col(...)) qui remplace les boucles et les .apply() douloureux, et l'évaluation paresseuse, qui optimise ton pipeline avant même de l'exécuter. On démarre.
Installe Polars
Un simple pip, rien de plus. Polars est un paquet autonome, sans dépendance lourde.
pip install polarsCrée ton premier DataFrame
On reprend les ventes d'une petite boutique. La construction ressemble à Pandas, tu ne seras pas dépaysé.
import polars as pl
df = pl.DataFrame({
"ville": ["Paris", "Lyon", "Paris", "Marseille", "Lyon"],
"produit": ["chaise", "table", "chaise", "table", "chaise"],
"prix": [49.9, 129.0, 59.9, 149.0, 39.9],
"quantite": [2, 1, 3, 1, 5],
})
print(df)L'affichage est propre : chaque colonne montre son type (str, f64, i64), et le tableau est aligné sans effort.
Filtre et crée des colonnes
Ici, on oublie les df["colonne"] à rallonge. Tout passe par pl.col("colonne"), que l'on combine comme des blocs de Lego.
# Garder uniquement les chaises
chaises = df.filter(pl.col("produit") == "chaise")
# Ajouter une colonne "ca" (chiffre d'affaires)
df = df.with_columns(
(pl.col("prix") * pl.col("quantite")).alias("ca")
)
print(df)L'opération (prix * quantite) s'écrit comme une expression mathématique, et Polars la vectorise tout seul. Pas de boucle, pas de .apply(), et c'est du code que tu peux relire dans six mois.
Regroupe et agrège
Le chiffre d'affaires par ville, trié, tient en trois lignes chaînées.
ca_par_ville = (
df.group_by("ville")
.agg(pl.col("ca").sum().alias("total_ca"))
.sort("total_ca", descending=True)
)
print(ca_par_ville)group_by, agg, sort : la grammaire ressemble au SQL que tu connais déjà, mais chaînée en Python et donc testable, lisible, versionnable.
L'évaluation paresseuse
C'est le vrai tour de force. Ajoute .lazy() au début et .collect() à la fin : Polars construit alors un plan d'exécution optimisé avant de calculer quoi que ce soit.
lazy = (
df.lazy()
.filter(pl.col("produit") == "chaise")
.group_by("ville")
.agg(pl.col("ca").sum().alias("total_ca"))
.sort("total_ca", descending=True)
)
print(lazy.explain()) # le plan, sans rien calculer
resultat = lazy.collect() # l'exécution réelle
print(resultat)explain() te montre exactement ce que Polars va faire : il peut réordonner les filtres, supprimer les colonnes inutiles et fusionner des étapes. Sur des millions de lignes, cette réorganisation fait toute la différence.
Lis des fichiers et fais la navette avec Pandas
CSV, Parquet, JSON : tout est intégré et nettement plus rapide qu'en Python pur.
df = pl.read_csv("ventes.csv")
df = pl.read_parquet("ventes.parquet") # format binaire, encore plus rapide
# Faire la navette avec ton code Pandas existant
import pandas as pd
mon_df_pandas = pd.DataFrame({"a": [1, 2, 3]})
df_pl = pl.from_pandas(mon_df_pandas)
retour_pandas = df_pl.to_pandas()Tu n'as donc pas à tout migrer d'un coup : pl.from_pandas() et df.to_pandas() laissent tes vieux scripts cohabiter avec les nouveaux.
Quand garder Pandas, quand passer à Polars
Pandas reste roi pour les petites données, les notebooks exploratoires et l'écosystème d'extensions. Dès que ton CSV dépasse quelques centaines de milliers de lignes, que la RAM grimpe ou que ton script tourne en batch, passe à Polars : la différence est flagrante, souvent sans changer grand-chose à ta logique. Commence par un seul script, mesure, et laisse Rust faire le sale boulot.
Auteur
Krugz
Développeur fullstack
Développeur fullstack qui tente, tant bien que mal, de suivre l'actualité de l'IA au milieu d'une marée d'informations imbuvables et des milliers d'outils et de modèles qui sortent chaque jour.
