Préparer les données avec pandas

Une donnée manquante est une valeur inconnue ou indisponible. pandas stocke un marqueur spécial à sa place. Détecte ce marqueur avant de calculer des totaux ou de décider quelles lignes sont utilisables.

Reconnaître les marqueurs

Le marqueur dépend du type de données. Les colonnes de nombres à virgule flottante utilisent NaN, les colonnes de dates et heures utilisent NaT, et les types nullables comme "Int64", "boolean" et "string" utilisent pd.NA. pandas 3 infère le type str pour les colonnes textuelles, avec NaN pour le texte manquant. Le None de Python est lui aussi reconnu comme manquant. Utilise import pandas as pd et import numpy as np pour les exemples.

df.isna() produit un tableau booléen ayant les mêmes lignes et colonnes que df. Un True marque une valeur manquante ; df.notna() marque les valeurs présentes. Les alias isnull() et notnull() remplissent les mêmes fonctions. Ne compare pas une colonne à np.nan : NaN est différent même de lui-même, donc s == np.nan ne repère pas les valeurs manquantes.

Compter les cellules et les lignes concernées

Considère ces relevés météorologiques :

Un True booléen compte pour 1, donc df.isna().sum() donne 0 ville, 2 températures et 2 relevés de pluie manquants. df.isna().mean() donne les proportions 0.0, 0.5 et 0.5. La proportion de chaque colonne utilise les quatre lignes comme dénominateur.

Pour trouver les lignes concernées, utilise df.isna().any(axis=1). Le résultat est False, True, True, True ; sa somme vaut 3. En revanche, df.isna().sum().sum() donne 4 cellules manquantes. Kyiv compte pour deux cellules mais une seule ligne concernée. Utilise la mesure qui répond à ta question.

Reconnaître les codes cachés de valeurs manquantes

Un instrument peut enregistrer un relevé indisponible sous la forme -999, "-" ou "unknown". Ce sont des valeurs ordinaires tant que tu ne les convertis pas. Après avoir confirmé la signification du code, utilise df.replace([-999, "unknown"], np.nan). Lors du chargement d’un CSV, na_values=[-999, "unknown"] ajoute ces codes aux marqueurs reconnus. Les champs CSV vides et les chaînes courantes comme "NA", "n/a" et "NULL" sont déjà reconnus par défaut.

Un relevé de pluie égal à zéro peut signifier qu’il n’a pas plu ; remplacer tous les zéros détruirait donc des observations réelles. De plus, une chaîne vide créée en mémoire, "", et une chaîne contenant des espaces ne sont pas considérées comme manquantes par isna(). Examine le texte stocké ainsi que les décomptes de marqueurs. Pour inclure les catégories manquantes dans un tableau des effectifs et des fréquences, utilise value_counts(dropna=False).

Vérifier les calculs et les types de données

Pour s = pd.Series([4, np.nan, 8]), s.mean() vaut 6.0 : la méthode utilise les deux valeurs connues. s.count() vaut 2, tandis que len(s) vaut 3. Diviser s.sum() par len(s) donne 4.0 et traite à tort la valeur manquante comme un zéro. La plupart des statistiques ignorent les valeurs manquantes par défaut ; une colonne entièrement manquante a une somme de 0 mais une moyenne de NaN.

Une valeur manquante peut aussi modifier le stockage. pd.Series([3, None, 5]) devient float64 et contient 3.0, NaN et 5.0. Indiquer dtype="Int64" conserve des valeurs entières avec <NA> pour la valeur manquante. Le I majuscule identifie le type entier nullable de pandas.

Supprimer une ligne retire ses valeurs connues en même temps que ses valeurs manquantes. Remplacer une valeur manquante conserve la ligne mais introduit une estimation. Choisis selon la signification de l’observation et les colonnes nécessaires à l’analyse.

Maîtriser les lignes supprimées

df.dropna() supprime toutes les lignes qui comportent une valeur manquante. Dans la table météorologique, seule Lima reste. Limite la décision avec subset, ou exige un nombre minimal de cellules présentes avec thresh.

axis="columns" supprime les colonnes qui comportent des valeurs manquantes et ne conserve ici que city. Dans une table comportant de nombreuses colonnes, la règle par défaut appliquée aux lignes peut supprimer une grande partie des données, car une valeur manquante dans n’importe quelle colonne suffit. Compare len(df) avant et après la suppression.

Affecter le résultat

Apprends la forme avec réaffectation : df = df.dropna(). Par défaut, les méthodes de nettoyage renvoient un nouvel objet. pandas 3.1 déprécie inplace=True pour des méthodes comme dropna, drop_duplicates et rename.

Pour une colonne, écris df["temp_c"] = df["temp_c"].fillna(0). Avec la copie à l’écriture de pandas 3, un appel chaîné comme df["temp_c"].fillna(0, inplace=True) ne modifie jamais le DataFrame parent. L’affectation indique explicitement la destination.

Remplacer par une valeur compatible

Un dictionnaire par colonne permet de fournir des valeurs adaptées à une table mixte : df.fillna({"rain_mm": 0, "city": "Unknown"}). Les colonnes absentes du dictionnaire conservent leurs valeurs manquantes. Un scalaire comme 0 est pratique pour une table composée uniquement de nombres dont toutes les colonnes l’acceptent. Remplacer du texte manquant par un nombre est incompatible ; pandas 3.1 émet un avertissement et une future version le refusera.

Les températures connues sont 18,0 et 31,0. Leur moyenne est de 24,5, donc df["temp_c"].fillna(df["temp_c"].mean()) place 24,5 dans les deux cases manquantes. Une valeur extrême peut fortement tirer la moyenne ; la médiane y est moins sensible. Avant le remplacement, conserve un indicateur avec df["temp_missing"] = df["temp_c"].isna() afin de pouvoir distinguer les valeurs estimées des valeurs observées.

Le remplacement par la moyenne réduit la dispersion apparente de la colonne. Une valeur fixe éloignée peut l’augmenter. Remplacer une mesure de pluie manquante par 0 affirme qu’il n’a pas plu, ce qui ne convient pas si le capteur était éteint.

Utiliser les relevés voisins lorsque l’ordre compte

ffill() propage la dernière valeur connue vers l’avant ; bfill() propage la prochaine valeur connue vers l’arrière. Pour 12,0 ; NaN ; NaN ; NaN ; 15,0, la propagation vers l’avant donne quatre valeurs 12.0 suivies de 15.0. ffill(limit=1) ne remplace que la première valeur manquante de cette suite. Une valeur manquante en début de série n’a pas de valeur précédente et reste manquante. Utilise directement ffill() ; fillna(method="ffill") a été supprimé dans pandas 3.

interpolate() estime les valeurs entre des positions voisines. Pour 10, NaN, NaN, 16, l’interpolation linéaire donne 10, 12, 14, 16. Elle convient aux mesures qui évoluent progressivement dans un ordre qui a un sens. Propager ou interpoler des valeurs entre des villes sans lien imposerait une relation que les lignes n’ont pas.

Après toute opération, exécute à nouveau isna().sum() et vérifie le nombre de lignes. Un appel de méthode réussi indique que le code s’est exécuté ; ces vérifications indiquent ce qui a changé.

Deux lignes peuvent se ressembler sans décrire le même événement. Avant de supprimer des doublons, détermine quelles valeurs identifient un enregistrement. Un identifiant de commande peut identifier une commande ; le client et la date seuls peuvent désigner plusieurs achats légitimes.

Marquer les copies supplémentaires

df.duplicated() renvoie un booléen par ligne. Par défaut, cette méthode compare toutes les colonnes, conserve la première occurrence et marque les copies suivantes par True. La somme du résultat compte les copies supplémentaires, et non tous les membres des groupes répétés.

Considère six lignes de commandes d’identifiants 101, 102, 102, 103, 104, 104. Les deux lignes 102 sont identiques. Les deux lignes 104 ont des poids enregistrés différents, 0,5 kg et 0,8 kg. Lorsque toutes les colonnes sont comparées, il y a une copie supplémentaire : df.duplicated().sum() vaut 1. df.drop_duplicates() conserve cinq lignes car les deux lignes 104 différentes ne sont pas des copies exactes.

Comparer les colonnes qui définissent l’identité

df.duplicated(subset=["order_id"]) ne compare que les identifiants. Cette méthode marque le deuxième 102 et le deuxième 104, soit deux copies supplémentaires. Les valeurs des autres colonnes n’influent plus sur cette décision. Examine les poids contradictoires avant de choisir l’enregistrement de commande à conserver.

df.drop_duplicates(subset="order_id", keep="last") conserve la version de 0,8 kg de la commande 104 dans cet ordre. Conserver la dernière ligne ne signifie pas en soi conserver l’enregistrement le plus récent. Établis d’abord cet ordre :

latest = df.sort_values("updated").drop_duplicates(
    subset="customer_id", keep="last"
)

Le tri selon updated place les enregistrements anciens avant les plus récents. La recherche de doublons ne compare ensuite que customer_id : des dates de mise à jour différentes n’empêchent donc pas de reconnaître deux lignes comme des versions du même client.

Distinguer les valeurs des lignes des étiquettes d’index

Ces méthodes comparent les valeurs et ignorent les étiquettes d’index. Des lignes identiques portant les étiquettes 4 et 9 comptent tout de même comme des doublons. Pour cette vérification, les valeurs manquantes aux positions correspondantes sont considérées comme égales. Pour rechercher les étiquettes elles-mêmes répétées, utilise df.index.duplicated().

La comparaison exacte tient aussi compte des différences de casse et d’espacement. Les valeurs « Lisbon » précédée d’un espace, « lisbon » et « LISBON » suivie d’un espace sont distinctes. Nettoie-les avec .str.strip().str.lower() avant de rechercher les doublons lorsque ces écritures désignent la même ville. Sinon, nunique() comptera trois noms pour un seul lieu.

Vérifier l’unicité là où la relation l’exige

Une table de correspondance doit comporter une ligne par clé de correspondance lorsque chaque enregistrement doit recevoir un seul ensemble de détails. lookup["customer_id"].is_unique vérifie cette exigence. Des identifiants de clients répétés dans une table de commandes sont normaux, car un client peut passer plusieurs commandes.

Si une clé de correspondance se répète, une fusion ultérieure répète chaque commande correspondante pour chaque ligne correspondante de la table de correspondance. Supprimer les doublons des commandes éliminerait de véritables achats sans corriger la table de correspondance. Vérifie la clé prévue dans la bonne table, examine les enregistrements contradictoires et compare le nombre de lignes après la suppression.

Un remplacement modifie les valeurs correspondantes, une mise en correspondance traduit les valeurs et un renommage modifie les étiquettes. Ces opérations peuvent se ressembler dans le code, mais produisent des résultats différents lorsqu’une valeur est absente d’un dictionnaire.

Remplacer des valeurs exactes

s.replace("N/A", np.nan) ne modifie que les cellules égales à "N/A". Une liste peut indiquer plusieurs anciennes valeurs : s.replace(["-", "?"], np.nan). Un dictionnaire fournit des remplacements distincts, comme dans s.replace({"M": "male", "F": "female"}). Les valeurs sans correspondance restent inchangées.

Pour une table entière, un dictionnaire imbriqué limite la modification à une colonne : df.replace({"status": {0: "open", 1: "closed"}}). Cela évite de modifier d’autres zéros et uns sans rapport ailleurs dans la table. Affecte le résultat renvoyé pour conserver la modification.

replace recherche des cellules entières. Avec « Main St » et « St », s.replace("St", "Street") ne modifie que « St ». Pour modifier des parties d’une chaîne, utilise s.str.replace("St", "Street", regex=False), qui produit aussi « Main Street ».

Mettre en correspondance à l’aide d’un dictionnaire

Pour les codes « PT », « JP » et « KE », compare le même dictionnaire dans deux méthodes :

Un dictionnaire transmis à map définit les sorties disponibles. Une clé absente n’a pas de sortie et devient une valeur manquante. Vérifie ensuite isna().sum() pour repérer une correspondance incomplète.

map accepte aussi une fonction : s.map(lambda x: x * 1000) convertit des valeurs en kilomètres en mètres. Pour ce calcul, s * 1000 est plus simple et plus rapide car l’opération porte sur toute la colonne. DataFrame.map applique une fonction cellule par cellule ; cette méthode remplace applymap, qui a été supprimée.

Convertir du texte en nombres

astype demande un type de données, comme "float64", "Int64" ou "category". Cette méthode déclenche une erreur si une valeur ne peut pas être convertie. Pour les textes "12", "7.5" et "n/a", pd.to_numeric(s, errors="coerce") produit en revanche 12.0, 7.5 et NaN. La coercition conserve les nombres lisibles mais impose d’examiner les échecs.

Le formatage peut empêcher la conversion même lorsque le nombre est valide. Pour « 1,200 » et « 950 », supprime d’abord le séparateur de milliers :

cleaned = s.str.replace(",", "", regex=False)
numbers = pd.to_numeric(cleaned, errors="coerce")
failed = s.notna() & numbers.isna()

Ici, failed marque les valeurs qui étaient présentes avant la conversion mais sont devenues manquantes. Comparer uniquement les nombres de valeurs manquantes donne un total utile ; le masque permet aussi de retrouver le texte d’origine à examiner. Supprime de la même manière et de façon réfléchie les unités connues des mesures textuelles avant la conversion.

Renommer les étiquettes

df.rename(columns={"Qty": "quantity"}) modifie un en-tête de colonne sans changer ses cellules. df.rename(columns=str.lower) met tous les en-têtes en minuscules. Une séquence comme df.columns.str.strip().str.lower().str.replace(" ", "_", regex=False) transforme « Total KG » suivi d’un espace en total_kg ; affecte-la à df.columns.

Utilise replace ou map pour les valeurs à l’intérieur d’une colonne. Utilise rename pour les étiquettes qui servent à sélectionner ces valeurs.

Certaines analyses nécessitent des mesures exactes, d’autres des groupes ou des plages numériques comparables. Garde leur signification claire : la discrétisation crée des catégories, la mise à l’échelle modifie l’échelle numérique et l’écrêtage remplace les valeurs extrêmes.

Répartir les valeurs dans des intervalles

pd.cut(ages, [18, 30, 45, 65]) utilise les intervalles (18, 30], (30, 45] et (45, 65]. La parenthèse exclut la borne gauche ; le crochet fermant inclut la borne droite. Les âges 19, 25 et 30 entrent dans le premier intervalle, 41 dans le deuxième et 64 dans le troisième. L’âge 18 devient manquant car il se trouve sur la borne gauche exclue.

include_lowest=True inclut cette valeur minimale dans le premier intervalle. right=False crée au contraire des intervalles fermés à gauche comme [18, 30), si bien que 30 entre dans le deuxième intervalle. Les valeurs situées hors de tous les intervalles restent manquantes. Teste les bornes exactes ainsi que des valeurs typiques situées entre elles.

Il faut une étiquette par intervalle, soit une de moins que le nombre de bornes. Avec labels=["18-30", "31-45", "46-65"] et include_lowest=True, les six âges ci-dessus donnent les effectifs 4, 1 et 1. Ces étiquettes décrivent des âges entiers ; les bornes des intervalles continuent de déterminer l’affectation.

Choisir les bornes ou les effectifs des groupes

Pour 2, 4, 6, 8, 10, 12, 14, 16, qcut donne deux valeurs par groupe défini par les quartiles. Des groupes de même effectif ne couvrent pas nécessairement des intervalles de même amplitude.

Mettre à l’échelle sans créer de groupes

La normalisation min-max utilise (x - x.min()) / (x.max() - x.min()). Pour 10, 20, 40, l’étendue est de 30 : les résultats sont 0, environ 0,333 et 1. Le minimum et le maximum sont tous deux nécessaires ; diviser par le seul maximum est une opération différente. Une colonne constante a une étendue nulle, donc cette expression ne peut pas lui donner une dispersion mise à l’échelle utile.

Le centrage et la réduction utilisent (x - x.mean()) / x.std(). Pour 10, 20, 30, la moyenne est de 20 et l’écart-type d’échantillon utilisé par défaut par pandas est de 10. Soustraire 20 et diviser par 10 donne les scores z -1, 0 et 1. Un score z décrit la distance à la moyenne en unités d’écart-type, pas une étiquette d’intervalle.

Écrêter et encoder

pd.Series([5, 12, 250, 8]).clip(upper=100) donne 5, 12, 100, 8. Contrairement à un filtre, clip conserve la ligne et remplace le nombre extrême. Examine les grandes valeurs avec describe() ou un filtre avant de les écrêter : une grande mesure réelle reste une donnée.

pd.get_dummies(s) crée une colonne indicatrice booléenne par catégorie. Avec rouge, vert, rouge, bleu, chaque ligne vaut True uniquement dans la colonne de sa couleur. Utilise dtype=int pour obtenir des zéros et des uns. Les valeurs manquantes donnent des indicateurs tous faux, sauf si dummy_na=True ajoute une colonne de valeurs manquantes. Pour une régression par les moindres carrés ordinaires avec une constante, drop_first=True supprime une colonne de catégorie redondante ; d’autres modèles peuvent conserver toutes les catégories. Avec une catégorie par ligne, la somme de toutes les indicatrices est égale à la constante 1, ce qui crée une dépendance linéaire.

Pour les cellules contenant plusieurs étiquettes, s.str.get_dummies(sep="|") découpe une valeur comme « Action|Comedy » en indicateurs distincts. Les intervalles obtenus par discrétisation peuvent aussi être transmis à get_dummies, ce qui donne une colonne par intervalle.

Une personne reconnaît la même ville dans « Lisbon » précédé d’un espace, « lisbon » et « LISBON » suivi d’un espace. pandas voit trois chaînes différentes. Nettoyer une colonne textuelle fournit un ensemble cohérent de valeurs à comparer lors des décomptes, des recherches de doublons et des fusions ultérieurs.

Appliquer des méthodes de chaînes à une Series

L’expression Python "Lima ".strip() agit sur une seule chaîne. Pour une colonne, utilise l’accesseur .str : s.str.strip() supprime les espaces superflus de chaque valeur non manquante. s.lower() déclenche une AttributeError car la Series elle-même ne possède pas de méthode lower. Utilise s.str.lower().

pandas 3 infère normalement le type str pour le texte, en remplacement de l’ancien type par défaut object. Le type str contient du texte et des valeurs manquantes, avec NaN pour le texte manquant. Les méthodes de chaînes fonctionnent sur les deux types. Affecte du texte à une colonne str ; si un nombre doit y figurer sous forme de texte, convertis-le d’abord.

Combine les opérations de nettoyage compatibles et affecte le résultat :

df["city"] = df["city"].str.strip().str.lower()

Les trois écritures de Lisbon deviennent « lisbon ». strip() supprime les caractères d’espacement aux extrémités, pas les espaces à l’intérieur d’un nom. upper() met toutes les lettres en majuscules, tandis que title() met une majuscule à chaque mot et transforme « new york » en « New York ». Choisis une forme cohérente pour les clés et les décomptes.

Découper des chaînes structurées

Pour « Silva, Ana » et « Tanaka, Yui », s.str.split(", ") renvoie des listes comme ["Silva", "Ana"]. Ajoute expand=True pour produire des colonnes distinctes. Récupère une partie de chaque liste avec .str[0] ou .str.get(1).

Si seul le premier séparateur doit découper une valeur, utilise n=1. Découper « a,b,c » aux virgules avec n=1 donne « a » et « b,c ». Sans limite, le résultat comporte trois parties. Indique exactement le séparateur, y compris tout espace faisant partie du format.

Rechercher et filtrer

s.str.contains("lis", case=False) recherche le texte n’importe où en ignorant la casse. s.str.startswith("ID") vérifie le début ; s.str.endswith(".csv") vérifie la fin. Les résultats booléens peuvent servir à sélectionner des lignes :

mask = df["city"].str.contains("san", case=False, na=False)
selected = df[mask]

Pour le type str de pandas 3, le texte manquant donne False dans ces tests de recherche. Écrire na=False indique aussi clairement le traitement voulu lorsque tu utilises des données textuelles nullables. contains interprète par défaut un motif comme une expression régulière ; ajoute regex=False pour rechercher littéralement du texte contenant des caractères spéciaux.

Remplacer des parties et construire de nouvelles chaînes

s.str.replace("kg", "", regex=False) supprime « kg » partout où il apparaît. s.replace("kg", "") ne modifie que les cellules qui valent exactement « kg ». Cette distinction compte pour des valeurs comme « 12 kg ».

str.replace traite son texte de recherche littéralement par défaut. Pour « 3.5 kg », .str.replace(".", "", regex=False) supprime le point et donne « 35 kg ». Avec regex=True, le point est un motif correspondant à presque n’importe quel caractère et supprime tous les caractères dans cet exemple sur une seule ligne. N’utilise jamais cette modification pour analyser une mesure décimale.

s.str.len() compte les caractères ; une valeur manquante produit NaN et peut donner une colonne de nombres à virgule flottante. s.str[:3] extrait les trois premiers caractères. Pour combiner des colonnes, df["first"] + " " + df["last"] associe Ana et Silva sous la forme « Ana Silva » ; str.cat est une autre méthode d’association. Chaque opération renvoie un résultat : enregistre-le donc dans la colonne que tu souhaites utiliser.

Une expression régulière décrit un motif dans un texte. Elle peut reconnaître une quantité même lorsque le nombre de chiffres ou l’espacement varie. Commence par un petit motif dont tu peux expliquer les éléments.

Lire les éléments du motif

Écris les motifs Python sous forme de chaînes brutes, comme r"\d+", pour que Python conserve leurs barres obliques inverses. Par défaut, un point correspond à n’importe quel caractère sauf un saut de ligne. Échappe-le sous la forme r"\." pour trouver un vrai point. Pour une recherche de texte littéral, regex=False évite entièrement l’interprétation du motif.

Choisir la portion de texte qui doit correspondre

contains trouve un motif n’importe où, match commence au début et fullmatch exige que la valeur entière corresponde. Pour « 123a », s.str.contains(r"\d+") et s.str.match(r"\d+") réussissent, mais s.str.fullmatch(r"\d+") échoue. Utilise le test sur la chaîne entière pour vérifier un code complet. case=False ou flags=re.IGNORECASE après import re permet une recherche sans distinction de casse là où ces options sont prises en charge.

Capturer une mesure

Prends « Rice 5 kg », « Flour 2kg », « Salt » et « Beans 12 kg, 3 kg ». Le motif r"(\d+)\s*kg" signifie un ou plusieurs chiffres capturés dans un groupe, suivis de zéro ou plusieurs espaces puis de « kg ».

quantity = s.str.extract(r"(\d+)\s*kg", expand=False)
quantity = pd.to_numeric(quantity)

Les chaînes extraites sont « 5 », « 2 », une valeur manquante et « 12 ». La conversion donne les valeurs numériques 5.0, 2.0, NaN et 12.0. extract prend la première correspondance de chaque ligne, donc la deuxième quantité dans la description des haricots n’est pas incluse. Sans expand=False, un seul groupe renvoie un DataFrame à une colonne.

Les groupes nommés donnent des étiquettes aux sorties. s.str.extract(r"(?P<year>\d{4})-(?P<month>\d{2})") trouve « 2024-03 » dans « Report 2024-03 final » et renvoie les colonnes textuelles year et month. Le motif reconnaît la disposition des chiffres ; la conversion numérique est une étape distincte.

Trouver toutes les correspondances ou nettoyer à l’aide d’un motif

findall(r"\d+") donne une liste par ligne, notamment ["12", "3"] pour le texte sur les haricots et [] pour « Salt ». count(r"\d+") compte les correspondances. extractall donne une ligne par correspondance avec un niveau d’index supplémentaire nommé match.

Avec regex=True, s.str.replace(r"\s+", " ", regex=True) réduit les suites de caractères d’espacement à un seul espace. r"\D" désigne un caractère qui n’est pas un chiffre ; le supprimer transforme donc « +351 912-345-678 » en « 351912345678 ». Les formes majuscules \S et \W désignent de même les caractères qui n’appartiennent pas respectivement aux classes des caractères d’espacement et des caractères de mot.

La répétition est gloutonne par défaut. Dans "<b>x</b>", r"<.*>" va du premier symbole ouvrant au dernier symbole fermant. Supprimer cette correspondance supprime tout. Le motif non glouton r"<.*?>" correspond à chaque balise séparément et laisse « x ». Vérifie des exemples de résultats avant d’utiliser un motif sur toute une colonne.

Une colonne contenant peu de valeurs répétées de nombreuses fois peut utiliser le type category. Celui-ci stocke les étiquettes distinctes une seule fois et représente chaque ligne par un petit code entier. La valeur visible reste l’étiquette.

Comprendre les catégories et les codes

Pour les tailles M, S, L, M, M, s.astype("category") infère les catégories L, M, S par ordre alphabétique. Les codes sont 1, 2, 0, 1, 1. Utilise s.cat.categories pour examiner les étiquettes et s.cat.codes pour examiner les identifiants. Un code de 0 désigne la première catégorie stockée ; ce n’est pas une quantité mesurée.

Les étiquettes répétées peuvent permettre d’économiser beaucoup de mémoire. Jusqu’à 126 catégories, les codes occupent chacun un octet ; à partir de 127 catégories, ils occupent deux octets. Dans une configuration pandas 3.1 avec PyArrow, trois noms de pays répétés sur 3 000 000 de lignes occupaient environ 3 Mo sous forme de données catégorielles, environ 42 Mo en str et environ 165 Mo en object. Le moteur de stockage du texte influe sur ces chiffres. Une colonne dont les valeurs sont presque toutes uniques ne tire aucun avantage du stockage d’une liste de catégories et d’un code par ligne.

Définir un ordre qui a un sens

L’ordre alphabétique des tailles place L avant M, puis S. Définis explicitement l’ordre réel des tailles :

size_type = pd.CategoricalDtype(["S", "M", "L"], ordered=True)
sizes = s.astype(size_type)

Le tri suit maintenant l’ordre S, M, L, les comparaisons comme sizes > "S" ont un sens, et sizes.max() vaut « L » lorsque L est présent. Pour des étiquettes non ordonnées comme les pays, les tests d’égalité fonctionnent, mais les comparaisons de supériorité déclenchent une TypeError. as_ordered() utilise la séquence existante des catégories ; examine-la avant de considérer que cet ordre a un sens.

Modifier les étiquettes autorisées

Tu ne peux pas affecter « XL » à une colonne catégorielle qui n’autorise que S, M et L. Affecte d’abord le résultat enrichi, sizes = sizes.cat.add_categories("XL"), puis affecte la nouvelle valeur.

Convertir du texte vers une liste fixe de catégories peut transformer les valeurs absentes de la liste en valeurs manquantes. pandas 3.1 avertit que cette conversion avec perte deviendra une erreur. Vérifie les valeurs sources avec value_counts() avant la conversion, en particulier après avoir nettoyé les graphies.

Les méthodes .cat ont des fonctions différentes :

• rename_categories({"S": "small"}) modifie une étiquette tout en conservant ses éléments.
• remove_categories("L") supprime une étiquette autorisée et rend manquantes les valeurs L existantes.
• set_categories([...]) remplace toute la liste des catégories.
• reorder_categories([...], ordered=True) modifie l’ordre sans changer les étiquettes autorisées.
• remove_unused_categories() supprime les étiquettes auxquelles aucun élément n’appartient actuellement.

value_counts() affiche toutes les catégories autorisées, y compris celles qui ne comptent aucune observation. Avec un type S/M/L contenant uniquement S et M, L apparaît tout de même avec un effectif de 0. Cela fait apparaître un groupe vide dont les données textuelles ordinaires ne stockent pas l’étiquette.

Garder les catégories utiles pour la suite

cut produit des intervalles catégoriels, et get_dummies convertit l’appartenance aux catégories en colonnes indicatrices. Fournir à un modèle les codes de pays non ordonnés sous forme de nombres imposerait un ordre et des distances artificiels. Les indicatrices évitent cette interprétation.

La concaténation de colonnes catégorielles dont les listes de catégories diffèrent fait normalement perdre le type catégoriel. Harmonise d’abord leurs listes de catégories ou utilise pd.concat(..., union_categories=True) dans pandas 3.1 lorsque tu souhaites réunir les listes. Examine à la fois le type obtenu et l’ordre des catégories.

Une fusion fait correspondre des lignes à l’aide de valeurs de clé et place leurs informations côte à côte. La clé doit désigner la même chose dans les deux tables, comme l’identifiant du client sur une commande et l’identifiant du client dans une table de correspondance.

Nommer la clé et choisir la jointure

Utilise orders.merge(customers, on="customer_id"). Sans on, pandas utilise tous les noms de colonnes communs aux deux tables. Une colonne commune sans rapport comme date pourrait alors empêcher des correspondances valides entre clients.

Supposons que les commandes portent les identifiants de clients 10, 20, 20, 30, 50. La table des clients contient une ligne pour chacun des identifiants 10, 20, 30, 40.

La jointure interne est celle par défaut. Dans une fusion à gauche, les détails du client 50 sont manquants. Une fusion à droite inclut le client 40 sans commande, ainsi que les deux commandes du client 20. Une fusion externe complète inclut les deux clés sans correspondance. Une fusion croisée n’a pas besoin de clé car elle associe volontairement toutes les lignes entre elles. pandas 3 fournit aussi left_anti et right_anti pour les lignes dont la clé n’a pas de correspondance de l’autre côté.

Vérifier le nombre de correspondances possibles par ligne

Deux lignes à gauche pour la clé 20 et trois lignes à droite pour la clé 20 produisent six paires. La fusion ne choisit pas une seule ligne de droite. Dans l’exemple, ajouter une deuxième ligne de correspondance pour le client 20 fait passer le résultat de la fusion interne de quatre à six lignes.

Indique la relation prévue avec validate :

merged = orders.merge(
    customers, on="customer_id", how="left",
    validate="many_to_one"
)

Cela autorise plusieurs commandes par client mais exige que les identifiants de clients à droite soient uniques. Une clé répétée à droite déclenche une MergeError. one_to_one exige l’unicité des deux côtés ; one_to_many l’exige à gauche. many_to_many autorise les répétitions des deux côtés et ne vérifie pas l’unicité.

Examiner les lignes sans correspondance

Une fusion externe complète avec indicator=True ajoute _merge. Ici, les effectifs sont de quatre lignes both, une ligne left_only et une ligne right_only. Ce sont des lignes, pas des clés distinctes : des commandes répétées peuvent produire plusieurs lignes both pour un même client.

Pour compter les clés distinctes sans correspondance du côté des commandes, utilise m.loc[m["_merge"] == "left_only", "customer_id"].nunique(). Examiner les lignes peut révéler des entrées manquantes dans la table de correspondance ou du texte incohérent.

Maîtriser les noms et les formats des clés

Si les clés ont des noms différents, utilise left_on="customer_id", right_on="id". Les deux colonnes clés restent disponibles. Plusieurs clés peuvent être comparées ensemble avec on=["city", "year"] ; les deux valeurs doivent concorder.

Les noms communs aux colonnes qui ne sont pas des clés reçoivent _x et _y. Choisis des suffixes explicites comme suffixes=("_order", "_ship") pour que les provenances restent claires.

Les clés doivent avoir des types de données compatibles et des valeurs égales. La valeur numérique 1 peut correspondre à la valeur numérique 1,0, mais des colonnes clés entières et textuelles peuvent déclencher une erreur de fusion. Convertis leurs formats de façon réfléchie. « ana » et « Ana » suivi d’un espace sont des textes différents ; harmonise la casse et les espaces aux extrémités avant la fusion lorsqu’ils désignent la même personne.

Les clés manquantes doivent aussi être examinées : pandas fait correspondre les clés manquantes d’un côté à celles de l’autre. Si les deux côtés contiennent plusieurs lignes de ce type, ces correspondances peuvent elles aussi se multiplier.

Un index peut contenir la clé que tu souhaites faire correspondre. pandas utilise ces étiquettes pour joindre des tables, compléter des valeurs manquantes ou additionner deux Series. La position des lignes ne détermine pas à elle seule les correspondances.

Effectuer une jointure sur les étiquettes d’index

left.join(right) fait correspondre les deux index et effectue par défaut une jointure à gauche. À l’inverse, merge effectue par défaut une jointure interne. Tu peux aussi écrire left.merge(right, left_index=True, right_index=True) lorsque les deux clés se trouvent dans l’index.

Supposons que stations possède les étiquettes d’index A, B, C et les altitudes 120, 850, 15 m. Une table de relevés possède les étiquettes d’index de stations A, B, B, D. readings.join(stations) conserve quatre lignes et ajoute les altitudes 120, 850, 850 et NaN. Les deux relevés B reçoivent tous deux l’altitude de B. Avec how="inner", seuls les trois relevés A/B sont conservés.

Si la table des relevés conserve les identifiants de stations dans une colonne ordinaire, utilise readings.join(stations, on="station"). La colonne de gauche correspond à l’index de droite. La forme équivalente avec une fusion est readings.merge(stations, left_on="station", right_index=True, how="left").

Indiquer clairement l’emplacement de la clé

set_index("station") déplace la colonne des stations dans l’index. reset_index() la rétablit comme colonne ordinaire. Ces opérations permettent de choisir une disposition qui rend la correspondance facile à examiner. left.join([t1, t2]) peut joindre en une fois plusieurs tables partageant des étiquettes d’index.

Si les deux tables jointes contiennent une colonne qui n’est pas une clé, comme source, join déclenche une ValueError sauf si tu distingues les noms. Dans pandas 3.1, écris suffixes=("_left", "_right") ; cela remplace les anciens arguments lsuffix et rsuffix. Les suffixes conservent les deux versions sans décider quelle valeur fait autorité.

Compléter les valeurs manquantes depuis une source de secours

a.combine_first(b) conserve les valeurs connues de a, remplace ses valeurs manquantes par celles de b aux étiquettes correspondantes et inclut les étiquettes présentes uniquement dans b.

Le résultat conserve 1 et 3 car la première source les connaît déjà. Il utilise 20 pour remplacer la valeur manquante et ajoute l’étiquette d avec 40. Inverser l’appel change la source prioritaire. C’est utile lorsqu’une source principale doit avoir priorité sur une source de secours, même si leurs lignes sont dans des ordres différents.

Reconnaître l’alignement dans les calculs

Soit x avec a = 5 et b = 7 ; soit y avec b = 1 et c = 2. x + y donne b = 8, avec des résultats manquants pour a et c car il manque un opérande pour chacun. L’opération n’additionne pas la première valeur de x à la première valeur de y.

x.add(y, fill_value=0) fournit zéro pour le côté manquant et produit a = 5, b = 8, c = 2. Utilise cette règle lorsqu’une contribution absente doit compter pour zéro. L’alignement des étiquettes est le même principe d’organisation derrière ces opérations, mais leurs règles sur les valeurs diffèrent : join ajoute des colonnes, combine_first complète les valeurs manquantes et les calculs opèrent sur les valeurs correspondantes.

Les fichiers mensuels contiennent généralement davantage de lignes correspondant au même type d’observation. La concaténation rassemble ces parties dans une seule table. Elle aligne les étiquettes sur l’autre axe ; elle ne recherche pas les valeurs correspondantes des clés de clients ou de commandes.

Empiler les lignes et aligner les colonnes

pd.concat([jan, feb]) empile les lignes car l’option par défaut est axis=0. Supposons que janvier contienne trois trajets avec les colonnes trip et km, tandis que février contient deux trajets avec trip, km et note. Le résultat comporte cinq lignes et trois colonnes. Les cellules note manquantes de janvier deviennent NaN.

join="outer" est l’option par défaut : elle conserve l’union des noms de colonnes. join="inner" ne conserve que les noms communs ; le résultat contient donc cinq lignes et les deux colonnes trip et km. Il inclut toujours les cinq observations ; le réglage de jointure agit sur l’autre axe.

L’ordre des colonnes dans les parties ne détermine pas la correspondance. Ce sont les noms exacts qui la déterminent. Si une partie utilise km et l’autre Km, le résultat contient deux colonnes partiellement vides. Renomme les en-têtes avant la concaténation.

Décider de la signification des étiquettes de lignes

Les index d’origine sont conservés par défaut. Avec les index de départ 0, 1, 2 et 0, 1, le résultat répète les étiquettes 0 et 1. result.loc[0] sélectionne deux lignes. Utilise ignore_index=True lorsque ces nombres n’ont pas de signification et que tu veux de nouvelles étiquettes de 0 à 4.

Lorsque la provenance compte, utilise un niveau d’index externe :

result = pd.concat(
    [jan, feb], keys=["jan", "feb"], names=["month", "row"]
)

result.loc["feb"] sélectionne maintenant les deux lignes de février. keys conserve la provenance dans un MultiIndex. Dans pandas 3, combiner keys avec ignore_index=True déclenche une ValueError ; choisis des étiquettes de provenance ou un nouvel index simple pour cette opération.

Placer les colonnes côte à côte

pd.concat([x, y], axis=1) aligne les lignes selon les étiquettes d’index. Pour x avec a = 1, b = 2 et y avec b = 3, c = 4, le résultat comporte les lignes a, b, c. La colonne x est manquante pour c et y est manquant pour a. Avec join="inner", seul b reste.

Vérifier le stockage et rassembler efficacement les parties

Une colonne mélangeant des valeurs numériques et du texte peut devenir de type object. Si des données NumPy ordinaires int64 acquièrent une valeur manquante, elles deviennent float64 ; le type nullable "Int64" de pandas peut conserver des entiers avec <NA>. Harmonise les types avant de combiner les données lorsque la colonne possède un type défini.

DataFrame.append a été supprimé dans pandas 2.0. Pour de nombreux fichiers, rassemble les DataFrame dans une liste et appelle pd.concat une seule fois après la boucle. Reconstruire un résultat qui grandit à chaque itération recopie sans cesse les données accumulées et devient lent.

Vérifie que la longueur d’une concaténation de lignes est égale à la somme des longueurs des entrées. Examine ensuite les noms de colonnes, les nombres de valeurs manquantes et les types de données.

Un MultiIndex donne plusieurs étiquettes à chaque ligne. Une ligne de ventes peut être identifiée à la fois par la ville et l’année, sous la forme d’un tuple comme ("Osaka", 2024). Chaque étiquette appartient à un niveau, et l’ordre de ces niveaux compte pour la sélection.

Construire et nommer l’index

df.set_index(["city", "year"]) déplace ces colonnes dans l’index. pd.MultiIndex.from_product([["Lima", "Osaka"], [2024, 2025]], names=["city", "year"]) construit toutes les combinaisons des étiquettes fournies. La concaténation avec keys ajoute également un niveau.

Pour les exemples, sales contient ces paires d’index et ces valeurs :

Après la définition des deux niveaux d’index, df.index.names vaut ["city", "year"]. rename_axis(["town", "yr"]) modifie les noms des niveaux sans modifier leurs valeurs.

Sélectionner une étiquette externe ou un tuple complet

df.loc["Osaka"] sélectionne les deux lignes d’Osaka. Le niveau de la ville sélectionnée disparaît, laissant 2024 et 2025 comme index. df.loc[("Lima", 2025), "sales"] sélectionne une cellule et renvoie 95.

Une seule étiquette passée à loc est recherchée dans le niveau le plus externe. df.loc[2024] cherche donc une ville nommée 2024 et déclenche une KeyError dans cette table. Pour sélectionner une année pour toutes les villes, utilise df.xs(2024, level="year"). Cette méthode renvoie 120 pour Osaka et 80 pour Lima, avec la ville comme index restant.

Pour une sélection plus générale, df.loc[pd.IndexSlice[:, 2025], :] conserve toutes les villes pour l’année 2025. Les deux-points en première position désignent toutes les étiquettes de ce niveau ; les derniers deux-points sélectionnent toutes les colonnes.

Trier avant d’extraire des tranches d’étiquettes

La sélection d’une étiquette exacte ne nécessite pas un index entièrement trié, mais l’extraction d’une tranche d’étiquettes exige un tri approprié. Utilise df.sort_index() avant df.loc["Lima":"Osaka"]. Un MultiIndex non trié peut déclencher une UnsortedIndexError pour une telle tranche.

sort_index() trie tous les niveaux dans leur ordre actuel : les villes viennent donc en premier, puis les années au sein de chaque ville. sort_index(level="year") trie selon le niveau nommé. swaplevel("city", "year") place l’année en position externe ; fais suivre cette opération de sort_index() pour regrouper et trier la nouvelle disposition. Permuter les positions des niveaux ne trie pas les lignes à lui seul.

Replacer les étiquettes dans les colonnes

reset_index() rétablit les deux niveaux comme colonnes. reset_index(level="year") ne rétablit que l’année et laisse la ville comme index. Ces opérations permettent de préparer une table pour une fusion ou un enregistrement sans perdre ses valeurs d’identification.

Les colonnes peuvent elles aussi comporter plusieurs niveaux. Un remodelage avec des valeurs de ventes et d’effectifs peut produire les étiquettes de colonnes ("sales", 2024) et ("staff", 2025). df["sales"] sélectionne toutes les colonnes situées sous l’étiquette de niveau supérieur correspondant aux ventes.

Pour obtenir un total par ville, df.groupby(level="city")["sales"].sum() donne 175 pour Lima et 255 pour Osaka. Utilise le regroupement pour calculer cet indicateur ; l’ancien argument sum(level="city") a été supprimé dans pandas 2.0.

stack et unstack modifient l’emplacement des étiquettes. Les valeurs conservent leur combinaison d’identification, mais la table peut faire apparaître des combinaisons pour lesquelles aucune observation n’existait.

Empiler les étiquettes de colonnes dans l’index

Supposons qu’un DataFrame au format large ait les villes Osaka et Lima comme index et les années 2024 et 2025 comme colonnes. Osaka possède les valeurs 120 et 135 ; Lima possède 80 et 95. Nomme les axes city et year pour que leur signification reste visible.

long = wide.stack() déplace les étiquettes d’années dans un nouveau niveau d’index interne. Avec ces colonnes à un seul niveau, le résultat est une Series contenant quatre valeurs :

• ("Osaka", 2024) donne 120.
• ("Osaka", 2025) donne 135.
• ("Lima", 2024) donne 80.
• ("Lima", 2025) donne 95.

Les étiquettes de villes se répètent car chaque ville possède désormais une ligne par année. L’empilement n’a pas additionné les valeurs ni créé de mesures supplémentaires.

Désempiler un niveau d’index dans les colonnes

long.unstack() déplace le niveau d’index le plus interne, l’année, dans les colonnes et retrouve la disposition au format large. long.unstack("city") déplace la ville à la place, ce qui produit des années en lignes et des villes en colonnes. Une position numérique de niveau comme unstack(0) peut sélectionner le même niveau, mais un nom rend l’intention plus facile à lire.

Si l’entrée possède des colonnes hiérarchiques, empiler un niveau peut laisser un autre niveau comme colonnes. Pour des colonnes comme ("sales", 2024) et ("staff", 2024), stack("year") renvoie un DataFrame avec des colonnes de ventes et d’effectifs. Empiler tous les niveaux de colonnes renvoie une Series.

Garder les combinaisons manquantes visibles

Supposons maintenant que la Series au format long ne contienne pas d’entrée pour Lima en 2025. Le désempilement crée une table rectangulaire ville par année et introduit donc NaN à cette position. Les valeurs entières ordinaires deviennent des nombres à virgule flottante lorsque cette cellule manquante nécessite un marqueur de valeur manquante de ce type.

unstack(fill_value=0) peut remplacer par zéro une combinaison nouvellement absente. Utilise cette option uniquement si l’absence signifie zéro, par exemple aucune vente enregistrée dans un jeu complet d’événements de vente. Une observation manquante d’un capteur est inconnue et doit rester manquante.

Dans pandas 3, stack() conserve les cellules manquantes. Empiler la table incomplète de 2 × 2 renvoie donc quatre entrées, dont NaN. Ajoute .dropna() si tu ne veux que les trois valeurs connues. Supprimer les valeurs manquantes modifie les combinaisons qui restent représentées : vérifie donc la longueur du résultat.

Résoudre d’abord les combinaisons en double

Le désempilement nécessite une seule valeur pour chaque combinaison complète d’index. Deux entrées étiquetées ("Lima", 2025) se disputent la même cellule de sortie et déclenchent ValueError: Index contains duplicate entries, cannot reshape.

Utilise long.index.duplicated() pour examiner les étiquettes complètes répétées, ou vérifie les colonnes clés correspondantes avant de définir l’index. Détermine si les lignes sont des copies accidentelles ou des observations distinctes qu’il faut combiner. Les supprimer ou les agréger est une décision relative aux données ; unstack ne choisit pas de règle à ta place.

Au format long, des colonnes d’identification accompagnent une colonne de valeurs. Au format large, les mesures sont réparties sur plusieurs colonnes, par exemple une colonne par année. Choisis la disposition qui facilite la tâche suivante : les tables au format long conviennent au filtrage et au regroupement, tandis que les tables au format large facilitent les comparaisons côte à côte.

Pivoter des paires uniques dans des cellules

Une table au format long contenant les colonnes city, year et sales passe au format large avec df.pivot(index="city", columns="year", values="sales"). Les étiquettes de villes forment les lignes, les années les colonnes et les ventes remplissent les cellules. Cette opération équivaut à df.set_index(["city", "year"])["sales"].unstack().

Les ventes d’Osaka de 120 et 135 en 2024 et 2025 deviennent deux cellules d’une même ligne. Les valeurs 80 et 95 de Lima forment la deuxième ligne. Inverser les arguments index et columns transpose cette disposition. Omettre values pivote toutes les colonnes de données restantes et peut créer des colonnes hiérarchiques, par exemple un niveau de ventes et un niveau d’effectifs au-dessus des années.

Déterminer si les répétitions sont des erreurs ou des observations

pivot réorganise les valeurs et ne peut pas les combiner. Deux lignes pour Lima en 2025 exigeraient deux valeurs dans une même cellule de sortie et déclencheraient donc une ValueError. Compte les paires répétées avec df.duplicated(subset=["city", "year"]).sum().

Si des observations distinctes doivent être combinées, utilise pivot_table avec une agrégation choisie. Pour les valeurs 95 et 105 de Lima en 2025, sa moyenne par défaut donne 100.0. Avec aggfunc="sum", la cellule vaut 200. Si chaque paire aurait dû apparaître une seule fois, conserve pivot pour qu’il révèle une erreur dans les données au lieu de calculer un indicateur sans avertissement.

Dépivoter les colonnes de mesures en lignes

Supposons qu’un CSV fournisse les colonnes city, 2023, 2024 et 2025. Les valeurs d’Osaka sont 110, 120, 135 ; celles de Lima sont 70, 80, 95. Dépivote les colonnes d’années :

long = wide.melt(
    id_vars="city", var_name="year", value_name="sales"
)

id_vars reste en place et se répète. Chaque étiquette de colonne de mesures devient une valeur d’année ; chaque cellule devient une valeur de ventes. Deux lignes et trois colonnes de mesures produisent six lignes au format long, dont une comme Osaka, « 2023 », 110. Les cellules de mesures manquantes deviennent elles aussi des lignes, sauf si tu les supprimes ensuite.

Comme ces étiquettes de colonnes proviennent du texte CSV, les années obtenues sont du texte. Utilise long["year"] = long["year"].astype(int) avant d’effectuer des calculs avec elles. Des étiquettes de colonnes entières en entrée donneraient déjà des années entières.

Maîtriser les éléments dépivotés et rétablir la forme

value_vars=["2024", "2025"] limite le dépivotage à ces colonnes. Oublier id_vars peut dépivoter les noms de villes dans la même colonne de valeurs que les mesures. Distingue toujours les identifiants des colonnes qui contiennent les valeurs.

Sans noms explicites, la colonne de valeurs s’appelle value. La colonne des variables hérite de wide.columns.name, ou s’appelle variable si ce nom est vide. Des paramètres var_name et value_name explicites rendent le résultat plus facile à utiliser.

Pivote à nouveau les six lignes avec index="city", columns="year", values="sales" pour rétablir les trois colonnes d’années. Après le pivotement, la ville est l’index et l’axe des colonnes s’appelle year. reset_index() rétablit la ville comme colonne, et rename_axis(columns=None) supprime le nom de l’axe des colonnes. Vérifie la forme et les étiquettes avant de fusionner ou d’enregistrer la table.