
Choisissez pandas lorsque son code existant, ses intégrations et son modèle de données répondent déjà aux besoins du traitement. Évaluez Polars lorsqu’une part importante du travail repose sur des filtres, des jointures et des agrégations que vous pouvez exprimer avec ses opérations, notamment si le temps d’exécution ou la mémoire devient une contrainte.
Une comparaison utile entre Polars et pandas commence par un traitement précis et les résultats attendus. Une migration peut modifier la gestion des valeurs manquantes, les jointures, les types et l’ordre des lignes. Une exécution plus rapide apporte peu si le résultat change de sens.
Ce guide propose un exemple local original testé sous Windows avec Python 3.12.14, pandas 3.1.1 et Polars 2.1.0. Les 13 tests ont réussi, dont un test portant sur 30 variantes d’entrée déterministes. L’exemple vérifie les comportements et l’équivalence des résultats. Il ne mesure pas les performances comparées et ne teste aucun déploiement cloud.
Décrivez ce que fait le programme : format et volume des données d’entrée, colonnes nécessaires, jointures, résultat attendu et bibliothèques qui le consomment. Repérez ensuite ce qui prend du temps et de la mémoire. Un téléchargement lent, une boucle Python et une jointure coûteuse appellent des changements différents.
| Décision | pandas | Polars |
|---|---|---|
| Application existante | Implique souvent moins de changements lorsque le code environnant attend des objets pandas. | Demande de vérifier les expressions et les interfaces à modifier. |
| Lignes et étiquettes | Les index et l’alignement par étiquette font partie du modèle de données. | Utilise des colonnes explicites plutôt qu’un index de lignes de type pandas. |
| Exécution | Les opérations ordinaires sur les dataframes s’exécutent immédiatement. | Propose une exécution immédiate et des plans de requête différés. |
| Pression sur la mémoire | Envisagez moins de colonnes, des types adaptés et un traitement par blocs lorsque le calcul le permet. | Envisagez les lectures différées et le streaming lorsque les opérations réelles le permettent. |
| Vérifications de migration | Préservez les comportements dont dépend l’application. | Vérifiez les jointures, valeurs manquantes, types, ordre et consommateurs du résultat. |
Le guide de migration de Polars explique ces différences de conception. Considérez la réécriture comme un changement d’exécution et de sémantique des données. Remplacer chaque méthode par une méthode au nom proche ne suffit pas.
Polars utilise une représentation en colonnes fondée sur Arrow. pandas prend aussi en charge des types et opérations reposant sur Arrow. Résumer le choix à « pandas utilise NumPy, Polars utilise Arrow » est donc insuffisant. Consignez les types et le moteur effectivement utilisés dans la comparaison.
Polars peut paralléliser certaines opérations en interne. Cela ne rend pas automatiquement parallèle ou efficace chaque fonction Python intégrée à une transformation. Utilisez les expressions de la bibliothèque lorsqu’elles conviennent et mesurez les opérations du traitement. Ajouter des processus autour d’un calcul déjà parallèle peut provoquer de la contention et des copies supplémentaires.
Une requête différée décrit le travail avant de l’exécuter. Polars peut examiner ce plan et appliquer des optimisations. Dans l’exemple ci-dessous, collect() exécute le plan. Les données étant déjà en mémoire, l’exemple ne démontre pas l’évitement de colonnes ou de lignes lors de la lecture d’un fichier.
Notre rapport synthétique additionne les montants positifs des commandes par segment client. Ses règles sont explicites : écarter les lignes sans identifiant client, écarter les montants manquants ou non positifs, conserver les identifiants inconnus dans le groupe unmapped et refuser les clés non nulles répétées dans la table des clients. Il s’agit d’un rapport sur une sélection de montants positifs, pas d’un calcul comptable du chiffre d’affaires net.
Les montants sont de petits entiers exprimés en centimes, ce qui évite ici les comparaisons de nombres flottants. Les entrées sont des tuples Python de confiance. Un import en production doit encore valider ses unités, plages de valeurs, identifiants et valeurs acceptées. Pour ce travail plus large, consultez le guide du pipeline ETL Python, en anglais.
Dans un nouvel environnement Python, installez les versions testées :
python -m pip install pandas==3.1.1 polars==2.1.0
Enregistrez ce code dans dataframe_demo.py :
"""Compare a small, trusted, in-memory fixture. This is not a benchmark."""
import pandas as pd
import polars as pl
ORDERS = [(10, 1200), (10, 800), (20, None), (None, 500),
(30, 200), (20, -100), (20, 700)]
CUSTOMERS = [(10, "team"), (20, "solo")]
EXPECTED = [("solo", 700), ("team", 2000), ("unmapped", 200)]
def pandas_summary(orders, customers):
sales = pd.DataFrame(orders, columns=["customer_id", "cents"]).astype(
{"customer_id": "Int64", "cents": "Int64"})
lookup = pd.DataFrame(customers, columns=["customer_id", "segment"]).astype(
{"customer_id": "Int64", "segment": "string"})
accepted = sales.loc[
sales["customer_id"].notna() & sales["cents"].notna()
& sales["cents"].gt(0)]
joined = accepted.merge(
lookup.loc[lookup["customer_id"].notna()], on="customer_id",
how="left", validate="many_to_one")
joined["segment"] = joined["segment"].fillna("unmapped")
result = joined.groupby("segment", as_index=False)["cents"].sum()
return sorted((str(s), int(c)) for s, c in result.itertuples(index=False, name=None))
def polars_query(orders, customers):
sales = pl.DataFrame(orders, schema={"customer_id": pl.Int64,
"cents": pl.Int64}, orient="row")
lookup = pl.DataFrame(customers, schema={"customer_id": pl.Int64,
"segment": pl.String}, orient="row")
return (
sales.lazy()
.filter(pl.col("customer_id").is_not_null()
& pl.col("cents").is_not_null() & (pl.col("cents") > 0))
.join(lookup.lazy().filter(pl.col("customer_id").is_not_null()),
on="customer_id", how="left", validate="m:1")
.with_columns(pl.col("segment").fill_null("unmapped"))
.group_by("segment").agg(pl.col("cents").sum())
)
def polars_summary(orders, customers):
result = polars_query(orders, customers).collect()
return sorted((s, int(c)) for s, c in result.select("segment", "cents").rows())
def null_join_defaults():
left_pd = pd.DataFrame({"key": pd.Series([None], dtype="Int64")})
right_pd = pd.DataFrame({"key": pd.Series([None], dtype="Int64"),
"label": ["matched"]})
left_pl = pl.DataFrame({"key": [None]}, schema={"key": pl.Int64})
right_pl = pl.DataFrame({"key": [None], "label": ["matched"]},
schema={"key": pl.Int64, "label": pl.String})
return (left_pd.merge(right_pd, on="key", how="left")["label"].iloc[0],
left_pl.join(right_pl, on="key", how="left")["label"][0])
if __name__ == "__main__":
a = pandas_summary(ORDERS, CUSTOMERS)
b = polars_summary(ORDERS, CUSTOMERS)
assert a == b == EXPECTED
print("pandas:", a)
print("Polars:", b)
print("Default null-key joins (pandas, Polars):", null_join_defaults())
Exécutez-le :
python dataframe_demo.py
La sortie vérifiée est la suivante :
pandas: [('solo', 700), ('team', 2000), ('unmapped', 200)]
Polars: [('solo', 700), ('team', 2000), ('unmapped', 200)]
Default null-key joins (pandas, Polars): ('matched', None)
Les deux implémentations produisent un total de 2 900 centimes dans les trois mêmes groupes. Le résultat est trié avant comparaison, car l’ordre des groupes ne fait pas partie du sens de ce rapport. Les tests vérifient aussi les entrées vides, les libellés manquants, les identifiants sans correspondance, le rejet des clés répétées dans la table des clients et la conservation des tuples d’origine.
La dernière ligne de sortie provient d’un exemple distinct contenant une ligne avec une clé manquante de chaque côté. La fusion pandas associe les clés nulles. Une jointure Polars ne les associe pas par défaut ; l’option nulls_equal modifie ce comportement.
Aucun de ces comportements par défaut ne définit votre règle métier. Dans notre rapport, les lignes sans identifiant client sont écartées avant la jointure dans les deux implémentations. Un identifiant non nul absent de la table des clients reste présent dans le groupe unmapped. Ces situations doivent rester distinctes lors de la migration.
La cardinalité de la table de référence compte aussi. Une clé client répétée peut multiplier les lignes et gonfler un total. L’exemple demande aux deux bibliothèques de contrôler une jointure plusieurs-vers-un. Les tests confirment qu’une clé non nulle répétée provoque une erreur. Comparez les valeurs et la cardinalité avant de considérer une exécution sans erreur comme correcte.
Polars permet d’examiner le plan d’une requête. Cela aide à comprendre les opérations exécutées et à vérifier si la réécriture exprime le travail voulu. Nous avons examiné le plan de l’exemple, sans mesurer de gain de vitesse lié à une optimisation.
Le streaming de Polars peut exécuter les opérations compatibles par lots. Certaines opérations peuvent toutefois revenir à une exécution en mémoire. Activer le streaming ne prouve donc pas à lui seul qu’un traitement respectera une limite de mémoire donnée.
Cet exemple utilise l’appel ordinaire à collect() et une source en mémoire. Il ne demande pas le moteur de streaming. Testez la requête complète, y compris ses jointures et ses contrôles, avant de choisir une machine plus petite sur la base d’une hypothèse de streaming.
Commencez par corriger les inefficacités évidentes de l’implémentation actuelle. Le guide pandas consacré aux grands jeux de données explique comment charger moins de données, choisir des types efficaces et répartir les opérations compatibles en blocs. Ce découpage demande de la prudence lorsqu’une jointure ou une agrégation dépend de lignes situées dans plusieurs blocs.
Pour comparer les performances, gardez les mêmes entrées, colonnes sélectionnées, types, exigences de sortie et contrôles de justesse. Notez les versions, le matériel, les paramètres de threads et l’inclusion éventuelle des lectures et écritures de fichiers. Chronométrez le résultat complet, y compris la collecte Polars, plutôt que la seule construction d’un plan différé.
Répétez les mesures et distinguez les premières lectures des exécutions qui bénéficient du cache. Mesurez le pic de mémoire du processus avec la même méthode dans les deux cas. La taille déclarée d’un dataframe ne comprend pas tous les buffers temporaires ni le reste du processus. Excluez la génération des fichiers du chronométrage, sauf si elle fait partie du traitement que vous voulez comparer.
Ces mesures peuvent éclairer le choix pour votre charge de travail. Notre petit exemple de vérification ne permet pas d’établir un classement général des vitesses, un pourcentage d’économie de mémoire ou une taille de VM recommandée.
Conservez pandas lorsque le traitement respecte ses délais et son budget mémoire, et qu’un changement perturberait des intégrations utiles sans bénéfice mesuré. Essayez Polars sur une transformation limitée dont vous pouvez définir le résultat attendu et tester les cas particuliers. Vous pourrez ainsi évaluer le gain d’exécution et le travail de maintenance du nouveau code.
Le test de migration doit inclure le consommateur du résultat. Une bibliothèque en aval peut attendre un index pandas, des types nullables précis ou un ordre de tri particulier. La conversion entre formats ou implémentations de dataframe ajoute une étape dont le comportement et le coût doivent entrer dans la comparaison.
Une fois le traitement correct, utilisez sa durée mesurée, son pic mémoire, son volume d’entrée et sa fréquence pour évaluer les ressources CPU de Compute avec Hivenet. Appuyez le choix de capacité sur le traitement mesuré plutôt que sur le nom d’une bibliothèque.
Les jeux de données d’entrée et les résultats terminés peuvent être stockés séparément avec le stockage objet Hivenet. Intégrez le temps de transfert et la gestion des identifiants d’accès à cette conception. Cet exemple ne teste pas de connexion à un stockage distant, et le stockage objet ne supprime pas la mémoire nécessaire pendant l’exécution locale.
Commencez par une transformation représentative. Si ses résultats sont corrects et ses besoins d’exploitation compris, vous disposez d’une base concrète pour conserver pandas, adopter Polars ou modifier la capacité de calcul du traitement existant.
Choisissez une charge de travail d’IA, de calcul ou de stockage à tester sur Hivenet, ou échangez avec notre équipe sur sa mise en production.