# Pandas 3.0 en 2026 : nouvelles API, ruptures de compatibilité et questions d'entretien > Pandas 3.0 arrive avec Copy-on-Write par défaut, un dtype string basé sur PyArrow, et le nouveau constructeur d'expressions pd.col(). Analyse approfondie des changements majeurs, des patterns de migration et des questions d'entretien incontournables pour les data engineers. - Published: 2026-05-05 - Updated: 2026-05-05 - Author: Anthony Fillion-Maillet - Tags: pandas, python, data-analytics, interview, pandas-3 - Reading time: 10 min --- Pandas 3.0, sorti le 21 janvier 2026, introduit les changements architecturaux les plus significatifs depuis l'ère 1.x de la bibliothèque. Copy-on-Write devient le comportement par défaut, les colonnes textuelles passent à un dtype basé sur PyArrow, et le nouveau constructeur d'expressions `pd.col()` offre une alternative plus propre aux fonctions lambda. Ces modifications impactent chaque base de code existante et font désormais partie des sujets testés en entretien de data engineering. > **Point clé** > > Pandas 3.0 requiert Python 3.11+, applique la sémantique Copy-on-Write par défaut, et infère les colonnes textuelles avec le dtype `str` adossé à PyArrow. L'assignation chaînée provoque désormais une erreur au lieu d'un simple avertissement. ## Copy-on-Write : la fin du SettingWithCopyWarning Copy-on-Write (CoW) change fondamentalement la gestion mémoire partagée entre DataFrames dans pandas. Toute opération d'indexation retourne désormais ce qui se comporte comme une copie, mais pandas partage la mémoire en interne jusqu'à ce qu'une mutation intervienne réellement. L'impact pratique est immédiat : `SettingWithCopyWarning` n'existe plus. Les patterns d'assignation chaînée tels que `df[df['A'] > 0]['B'] = 1` lèvent désormais une `ChainedAssignmentError`, car le résultat intermédiaire de l'indexation est une copie. ```python # migration_cow.py import pandas as pd df = pd.DataFrame({"price": [100, 200, 300], "category": ["A", "B", "A"]}) # Pattern Pandas 2.x (lève maintenant ChainedAssignmentError) # df[df["category"] == "A"]["price"] = 150 # CASSÉ en 3.0 # Pattern correct Pandas 3.0 : utiliser .loc[] df.loc[df["category"] == "A", "price"] = 150 # Partage mémoire CoW en action df2 = df[["price"]] # partage la mémoire avec df df2["price"] = df2["price"] * 2 # copie déclenchée uniquement ici # df reste inchangé - aucun effet de bord ``` L'argument `copy` présent dans de nombreuses méthodes n'a plus aucun effet et peut être retiré en toute sécurité du code existant. Les méthodes supportant `inplace=True` (`replace()`, `fillna()`, `ffill()`, `bfill()`, `clip()`) retournent maintenant `self` au lieu de `None`, permettant le chaînage de méthodes même avec des opérations in-place. ## Backend PyArrow pour les chaînes : 5-10x plus rapide Pandas 3.0 infère les colonnes textuelles avec un dtype `str` dédié, adossé à Apache Arrow, remplaçant l'ancien dtype `object`. Si PyArrow n'est pas installé, un fallback utilise les tableaux object NumPy. Les gains de performance sont substantiels : `.str.contains()`, `.str.lower()` et les autres méthodes string s'exécutent 5 à 10 fois plus vite. La consommation mémoire pour les colonnes textuelles chute de 50%. Le format colonnaire Arrow permet également l'échange de données zero-copy avec Polars, DuckDB et d'autres outils natifs Arrow. ```python # string_dtype_comparison.py import pandas as pd import numpy as np # Pandas 3.0 : les colonnes string sont automatiquement str[pyarrow] df = pd.DataFrame({"name": ["Alice", "Bob", "Charlie", None]}) print(df.dtypes) # name string[pyarrow] # dtype: object # Les valeurs manquantes utilisent NaN (pas pd.NA), cohérent avec les autres dtypes print(df["name"].isna()) # True pour l'entrée None # Interopérabilité directe avec DuckDB (zero-copy) import duckdb result = duckdb.sql("SELECT name FROM df WHERE name LIKE '%li%'").df() ``` Une contrainte importante : les tableaux PyArrow sont immuables. Convertir une colonne adossée PyArrow en tableau NumPy modifiable nécessite une copie explicite via `.to_numpy(copy=True)`. > **Alerte migration** > > Le code qui vérifie `df['col'].dtype == object` pour détecter les chaînes ne fonctionnera plus. Il faut utiliser `pd.api.types.is_string_dtype(df['col'])` ou vérifier `pd.StringDtype()`. ## Le constructeur d'expressions pd.col() Pandas 3.0 introduit `pd.col()` comme moyen déclaratif de référencer les colonnes d'un DataFrame et de construire des expressions. La syntaxe s'inspire de PySpark et Polars, résolvant les problèmes bien connus de portée des lambdas et leur opacité. ```python # col_expressions.py import pandas as pd df = pd.DataFrame({ "revenue": [1000, 2500, 800, 3200], "cost": [400, 1200, 600, 1500], "region": ["US", "EU", "US", "APAC"] }) # Avant : basé sur les lambdas (opaque, problèmes de portée) df = df.assign(profit=lambda x: x["revenue"] - x["cost"]) # Après : pd.col() (déclaratif, introspectable) df = df.assign( profit=pd.col("revenue") - pd.col("cost"), margin=((pd.col("revenue") - pd.col("cost")) / pd.col("revenue") * 100) ) # Filtrage avec pd.col() high_margin = df.loc[pd.col("margin") > 50] ``` L'avantage principal sur les lambdas apparaît dans les boucles, où les closures lambda capturent les variables par référence et produisent des résultats incorrects : ```python # loop_scoping_fix.py import pandas as pd df = pd.DataFrame({"base": [10, 20, 30]}) # Bug lambda : toutes les colonnes utilisent factor=30 (dernière valeur) # cols = {} # for factor in [2, 5, 10]: # cols[f"x{factor}"] = lambda x: x["base"] * factor # BUG # Correction pd.col() : chaque expression capture la bonne valeur cols = {} for factor in [2, 5, 10]: cols[f"x{factor}"] = pd.col("base") * factor # Correct df = df.assign(**cols) ``` Depuis pandas 3.0.2, `pd.col()` fonctionne également dans `Series.case_when()`. Les agrégations groupby ne sont pas encore supportées. ## Ruptures de compatibilité : checklist de migration complète Le tableau suivant résume les changements cassants les plus susceptibles d'apparaître lors de la migration depuis pandas 2.x : | Changement | Comportement pandas 2.x | Comportement pandas 3.0 | Correctif | |-----------|--------------------------|--------------------------|----------| | Assignation chaînée | `SettingWithCopyWarning` | `ChainedAssignmentError` | Utiliser `.loc[]` | | Dtype string | `object` | `string[pyarrow]` | Mettre à jour les vérifications de dtype | | Argument `copy=` | Crée une copie | Aucun effet (déprécié) | Supprimer l'argument | | `groupby(observed=)` | Défaut `False` | Défaut `True` | Définir explicitement | | `Index.sort_values()` | Args positionnels permis | Args nommés uniquement | Nommer tous les arguments | | `offsets.Day` | Période fixe 24h | Jour calendaire (DST-aware) | Revoir la logique timezone | | `Categorical.map(na_action=)` | Défaut `None` | Défaut modifié | Définir explicitement | | `str.contains(na=)` | Non-bool autorisé | Uniquement bool ou `None` | Nettoyer le paramètre na | Le parcours de mise à jour recommandé : d'abord monter en pandas 2.3, résoudre tous les avertissements de dépréciation, puis passer à 3.0. ## Nouvelle politique de dépréciation : Pandas4Warning et Pandas5Warning Pandas 3.0 introduit un cycle de dépréciation structuré en 3 étapes. Les fonctionnalités émettent d'abord un `DeprecationWarning` standard, puis passent à un `FutureWarning` dans la dernière version mineure avant la prochaine majeure, et sont finalement supprimées dans la version majeure. Deux nouvelles classes d'avertissement facilitent le filtrage par version cible : ```python # filter_warnings.py import warnings import pandas as pd # Capturer uniquement les changements prévus pour pandas 4.0 warnings.filterwarnings("error", category=pd.errors.Pandas4Warning) # Capturer les changements prévus pour pandas 5.0 warnings.filterwarnings("default", category=pd.errors.Pandas5Warning) ``` Cette politique accorde aux mainteneurs de bibliothèques au minimum deux cycles de versions mineures pour s'adapter avant l'arrivée des changements cassants. > **Version Python** > > Pandas 3.0 requiert Python 3.11 ou supérieur. Les projets encore en Python 3.9 ou 3.10 doivent effectuer la mise à jour avant de migrer. ## Questions d'entretien : Pandas 3.0 en profondeur Ces questions apparaissent dans les entretiens de data engineering et d'analytics en 2026, testant à la fois la compréhension théorique et l'expérience pratique de migration. **Q1 : Expliquer Copy-on-Write dans pandas 3.0. Pourquoi a-t-il été introduit ?** CoW garantit que chaque DataFrame ou Series retourné par une opération d'indexation se comporte comme une copie indépendante. En interne, pandas partage la mémoire entre l'original et le résultat jusqu'à ce que l'un d'eux soit muté, moment auquel une copie physique intervient. Cela élimine l'ambiguïté entre vues et copies qui provoquait `SettingWithCopyWarning`, empêche la corruption accidentelle des données par effets de bord, et réduit l'utilisation mémoire pour les charges de travail en lecture. **Q2 : Que se passe-t-il avec `df[condition]['col'] = value` dans pandas 3.0 ?** Cela lève une `ChainedAssignmentError`. Le `df[condition]` intermédiaire est désormais toujours une copie (grâce à CoW), donc l'assignation sur une colonne de cette copie n'a aucun effet sur le DataFrame original. Le pattern correct est `df.loc[condition, 'col'] = value`. **Q3 : Comment le nouveau dtype string affecte-t-il l'interopérabilité avec d'autres outils ?** Le dtype string adossé à PyArrow stocke les données au format colonnaire Apache Arrow. Cela permet le transfert zero-copy vers d'autres outils natifs Arrow (Polars, DuckDB, Spark via PyArrow) sans surcoût de sérialisation. Cela réduit également l'empreinte mémoire par rapport aux tableaux object Python, puisque Arrow utilise des buffers binaires compacts au lieu d'objets string Python individuels. **Q4 : Quel problème pd.col() résout-il que les lambdas ne peuvent pas résoudre ?** `pd.col()` capture les références de colonnes et les valeurs au moment de la création de l'expression, pas au moment de l'exécution. Les lambdas en Python capturent les variables par référence, ce qui provoque des bugs dans les boucles où toutes les lambdas finissent par référencer la dernière valeur de la variable de boucle. De plus, les expressions `pd.col()` sont introspectables (pandas peut les optimiser), tandis que les lambdas sont des callables opaques. **Q5 : Comment migrer une base de code de pandas 2.x vers 3.0 ?** Étape 1 : Monter en pandas 2.3 et corriger tous les avertissements de dépréciation. Étape 2 : Activer CoW en opt-in via `pd.options.mode.copy_on_write = True` (disponible depuis 2.0) et corriger les patterns d'assignation chaînée. Étape 3 : Installer PyArrow et tester que l'inférence du dtype string ne casse pas la logique en aval (notamment les vérifications `dtype == object`). Étape 4 : Monter en 3.0 et exécuter la suite de tests complète. Étape 5 : Supprimer les arguments `copy=` morts et mettre à jour les appels `groupby(observed=)`. ## Benchmarks de performance : avant et après L'effet combiné de CoW et des strings PyArrow apporte des améliorations mesurables sur les charges de travail réelles : ```python # benchmark_example.py import pandas as pd import numpy as np # Générer un DataFrame avec 1M de lignes de données mixtes rng = np.random.default_rng(42) df = pd.DataFrame({ "user_id": rng.integers(0, 100_000, size=1_000_000), "event": rng.choice(["click", "view", "purchase", "scroll"], size=1_000_000), "value": rng.exponential(50, size=1_000_000) }) # Filtrage string : ~6x plus rapide avec le backend PyArrow clicks = df.loc[pd.col("event").str.contains("click")] # Mémoire : la colonne string utilise ~50% moins de RAM print(df["event"].memory_usage(deep=True)) # ~8MB vs ~16MB avec dtype object # Subsetting : CoW évite la copie jusqu'à la mutation subset = df[["user_id", "value"]] # zero-copy (mémoire partagée) subset["value"] = subset["value"].clip(upper=500) # copie déclenchée ici uniquement ``` Dans les pipelines ETL de production traitant des CSV à fort contenu textuel, le backend string PyArrow seul réduit le pic mémoire de 30-40% et diminue le temps d'exécution total de 20-30% sur les transformations intensives en chaînes de caractères. ## Patterns de migration concrets : correctifs réels Une base de code pandas 2.x typique nécessite ces refactorisations spécifiques : ```python # migration_patterns.py import pandas as pd # Pattern 1 : Remplacer l'assignation chaînée # Avant (pandas 2.x) # df[df["status"] == "active"]["score"] = 100 # Après (pandas 3.0) df.loc[df["status"] == "active", "score"] = 100 # Pattern 2 : Supprimer les arguments copy= # Avant # subset = df[["a", "b"]].copy() # inutile avec CoW # Après subset = df[["a", "b"]] # CoW gère l'isolation automatiquement # Pattern 3 : Mettre à jour les vérifications de dtype pour les strings # Avant # if df["name"].dtype == object: # Après if pd.api.types.is_string_dtype(df["name"]): pass # Pattern 4 : observed= explicite dans groupby # Avant (s'appuyait sur le défaut observed=False) # df.groupby("category")["value"].sum() # Après (explicite pour la clarté) df.groupby("category", observed=True)["value"].sum() # Pattern 5 : Index.sort_values() avec arguments nommés uniquement # Avant # idx.sort_values(True, "first") # Après idx.sort_values(ascending=True, na_position="first") ``` Pour approfondir les [compétences fondamentales en pandas et analyse de données Python](https://sharpskill.dev/fr/technologies/data-analytics/questions-entretien/python-pandas-basics), les modules de questions d'entretien couvrent ces patterns en détail. Le module [fonctions fenêtres SQL](https://sharpskill.dev/fr/technologies/data-analytics/questions-entretien/sql-window-functions) complète les connaissances pandas pour les postes d'analytics hybrides SQL/Python. ## Conclusion - Copy-on-Write élimine entièrement `SettingWithCopyWarning` et empêche la mutation accidentelle des données via les références partagées - Le backend string PyArrow apporte des opérations string 5-10x plus rapides et une réduction mémoire de 50% pour les colonnes textuelles - `pd.col()` remplace les patterns lambda sujets aux erreurs par des expressions déclaratives et introspectables - L'assignation chaînée (`df[cond]['col'] = val`) est désormais une erreur ferme nécessitant la migration vers `.loc[]` - La politique de dépréciation structurée (`Pandas4Warning`, `Pandas5Warning`) fournit des calendriers de mise à niveau clairs - Parcours de mise à jour : d'abord pandas 2.3 (corriger les avertissements), puis 3.0 (avec PyArrow installé et Python 3.11+) - La préparation aux entretiens doit se concentrer sur les mécanismes CoW, l'interopérabilité PyArrow et les patterns de migration pratiques --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/fr/blog/data-analytics/pandas-3-new-apis-breaking-changes-interview