Débuter avec pandas

Un objet Series associe une suite de valeurs à des étiquettes. Ces étiquettes donnent un sens aux valeurs : un relevé de pluie appartient à un jour et une population à une ville. Importe pandas et NumPy sous leurs noms abrégés habituels.

import pandas as pd
import numpy as np
rain = pd.Series([4.5, 3.0, 6.2],
                 index=["Mon", "Tue", "Wed"], name="rain_mm")

Lire les valeurs et les étiquettes

Les valeurs sont 4,5 ; 3,0 et 6,2 ; l’index est composé de Mon, Tue et Wed. Sans index=, pandas fournit les étiquettes 0, 1 et 2. Un dictionnaire fournit les deux à la fois : pd.Series({"Lima": 10, "Oslo": 5, "Pune": 7}) tire ses étiquettes des clés, dans l’ordre du dictionnaire.

Les attributs décrivent l’objet Series sans parenthèses : rain.index contient les étiquettes, rain.dtype vaut float64, rain.name vaut "rain_mm" et rain.size vaut 3. Utilise rain.to_numpy() lorsqu’un tableau NumPy est nécessaire. L’ancien attribut .values renvoie différents types de tableaux selon le type de données ; les données textuelles peuvent donner un tableau pandas.

Un type de données indique à pandas quel genre de valeurs il stocke. Les types courants sont int64 pour les entiers, float64 pour les nombres décimaux, bool pour True/False, str pour le texte et datetime64 pour les dates et les heures. pandas 3 déduit le type str pour le texte ; les anciens exemples affichent souvent object.

Agir sur tout l’objet Series

Pour s = pd.Series([10, 20, 30], index=["a", "b", "c"]), s * 2 produit les valeurs 20, 40 et 60. s > 15 produit False, True et True. Les deux conservent les étiquettes. Ces opérations sont vectorisées : une expression agit sur tout l’objet Series sans boucle Python.

Recherche une étiquette avec s["b"], qui donne 20. Recherche une position avec s.iloc[0], qui donne 10. L’expression "b" in s vérifie l’index ; 20 in s vaut False. Même un entier entre crochets est une étiquette : avec l’index [2, 0, 1], s[0] désigne l’étiquette 0 et non la première entrée. Avec des étiquettes textuelles, s[0] déclenche une KeyError dans pandas 3.

Faire correspondre les étiquettes dans les calculs

a = pd.Series([1, 2, 3], index=["x", "y", "z"])
b = pd.Series([10, 20, 30], index=["y", "z", "w"])
a + b

L’étiquette commune y associe 2 et 10 pour donner 12.0 ; z associe 3 et 20 pour donner 23.0. Les étiquettes w et x n’apparaissent que dans une seule entrée et reçoivent donc NaN. Le résultat contient les quatre étiquettes. Une addition selon la position visuelle des lignes donnerait à tort 11, 22 et 33.

Utilise a.add(b, fill_value=0) lorsqu’une valeur absente doit compter pour zéro. Les résultats sont w 30.0, x 1.0, y 12.0 et z 23.0. Les méthodes apparentées comprennent sub, mul et div.

Reconnaître les valeurs manquantes

Une valeur flottante ou str manquante utilise NaN ; une date ou heure manquante utilise NaT ; un entier nullable manquant utilise <NA>. pd.Series([1, None, 3]) devient float64 et affiche 1.0, NaN et 3.0, car le type int64 ordinaire ne peut pas contenir NaN.

Un DataFrame est un tableau à deux dimensions. Chaque ligne représente une observation, comme une commande ; chaque colonne contient une variable, comme une quantité. Les colonnes peuvent avoir des types de données différents, mais elles partagent le même index de lignes.

Construire un tableau à partir de données Python

df = pd.DataFrame({
    "product": ["Notebook", "Desk lamp", "Pen set", "Mug"],
    "quantity": [3, 1, 2, 4],
    "unit_price": [2.50, 18.00, 4.75, 6.00]
})

Chaque clé du dictionnaire devient un nom de colonne ; chaque liste fournit les valeurs de cette colonne. Les listes doivent avoir la même longueur afin que chaque ligne ait une place dans chaque colonne. Ici, les étiquettes d’index vont de 0 à 3. Des listes de longueurs différentes déclenchent une ValueError.

Une liste de dictionnaires fournit quant à elle un dictionnaire par ligne. pd.DataFrame([{"a": 1, "b": 2}, {"a": 3, "c": 4}]) crée les colonnes a, b et c. La valeur b absente de la deuxième ligne et la valeur c absente de la première deviennent NaN : ces colonnes utilisent donc le type float64. Un tableau NumPy à deux dimensions peut aussi fournir les valeurs, avec columns=[...] pour nommer les colonnes.

Lire les dimensions du tableau

df.shape vaut (4, 3) : quatre lignes et trois colonnes, dans cet ordre. len(df) vaut 4, tandis que df.size vaut 12, car il compte les cellules. df.index contient les étiquettes de lignes, df.columns celles des colonnes et df.dtypes donne un type de données par colonne. Ce sont des attributs : df.shape() essaie d’appeler un tuple et déclenche une TypeError. df.T permute les lignes et les colonnes.

Obtenir un objet Series ou conserver un tableau

La liste intérieure demande un ensemble de colonnes. Sans elle, df["product", "unit_price"] fournit une seule clé sous forme de tuple, qui ne correspond à aucun des noms de colonnes ordinaires et déclenche une KeyError.

Les crochets fonctionnent aussi lorsque les noms contiennent des espaces ou coïncident avec des méthodes. La notation avec un point, comme df.quantity, ne fonctionne que pour les noms appropriés. Une colonne nommée size nécessite df["size"], car df.size désigne le nombre de cellules du tableau. Crée aussi les colonnes avec des crochets : df["total"] = 5 ajoute une colonne, tandis que df.total = 5 ne le fait pas.

Choisir un axe

Pour numbers = pd.DataFrame({"a": [1, 2], "b": [3, 4]}), numbers.sum() additionne les valeurs en parcourant les lignes et donne a 3 et b 7. C’est axis=0, aussi appelé "index". numbers.sum(axis=1) additionne les valeurs de chaque ligne et donne 4 et 6 ; cet axe est aussi appelé "columns". Précise d’abord le résultat souhaité : un total par colonne ou un total par ligne.

Extraire une ligne crée un objet Series dont les étiquettes sont les noms des colonnes. Cet objet Series doit avoir un seul type capable de contenir toutes les cellules de la ligne. Une ligne mélangeant entiers et flottants devient float64 ; une ligne mélangeant texte et nombres devient object. Les colonnes d’origine conservent leurs types distincts.

Les étiquettes de lignes peuvent avoir un sens, comme un numéro de commande, ou simplement désigner les lignes actuelles. Choisir un index utile rend les recherches et les résultats ultérieurs plus faciles à interpréter. Modifier les étiquettes renvoie un nouveau tableau : conserve donc le résultat avec une affectation.

Placer un identifiant dans l’index

orders = pd.DataFrame({
    "order_id": [1001, 1002, 1003],
    "product": ["Notebook", "Desk lamp", "Pen set"],
    "unit_price": [2.50, 18.00, 4.75]
})
orders_by_id = orders.set_index("order_id")

Le tableau d’origine possède un RangeIndex par défaut : 0, 1 et 2. Le nouveau tableau porte les étiquettes 1001, 1002 et 1003. order_id a quitté les colonnes pour devenir l’index. orders_by_id.loc[1002] identifie désormais la ligne Desk lamp par son identifiant.

Appeler orders.set_index("order_id") sans enregistrer son résultat laisse orders inchangé. Une réaffectation, comme orders = orders.set_index("order_id"), conserve la nouvelle structure. Dans pandas 3.1, inplace= est obsolète pour ces méthodes de modification des étiquettes et pour le tri ; utilise une affectation.

Replacer les étiquettes dans une colonne

orders_by_id.reset_index() rétablit order_id comme colonne ordinaire et fournit un nouveau RangeIndex. Un index sans nom devient une colonne appelée index. Cela conserve l’identité initiale des lignes.

reset_index(drop=True) supprime les anciennes étiquettes. Pour un index [10, 20, 30], reset_index() seul conserve ces nombres dans une colonne index ; reset_index(drop=True) les perd et utilise 0, 1 et 2. Après un filtrage ou un tri, détermine si les anciennes étiquettes sont utiles avant de les supprimer. Renuméroter l’index ne modifie pas les données et n’annule pas un tri.

Renommer ou supprimer des étiquettes

renamed = orders.rename(columns={"unit_price": "price"})
short = orders.drop(columns=["product"])
remaining = orders.drop(index=[0, 1])

rename associe les anciennes étiquettes aux nouvelles et conserve les noms non indiqués. Par défaut, un ancien nom mal orthographié est ignoré : examine donc .columns si le renommage semble n’avoir eu aucun effet. Pour remplacer tous les noms de colonnes, affecte une liste complète à orders.columns ; sa longueur doit correspondre au nombre de colonnes.

drop(columns=...) supprime des colonnes ; drop(index=...) supprime des lignes par étiquette. Une étiquette absente déclenche une KeyError. Après un tri, l’étiquette 0 peut ne plus correspondre à la première ligne : la supprimer retire toujours la ligne d’étiquette 0.

Sélectionne une liste pour choisir l’ordre des colonnes : orders = orders[["order_id", "unit_price", "product"]]. Les colonnes absentes de cette liste sont retirées du résultat.

Vérifier qu’un identifiant désigne bien une seule ligne

Les étiquettes d’index peuvent se répéter. Vérifie orders_by_id.index.is_unique avant de les considérer comme des identifiants uniques. Si l’étiquette 1002 apparaît deux fois, .loc[1002] renvoie les deux lignes sous forme de DataFrame. Avec des étiquettes uniques, la même recherche par une seule étiquette renvoie un objet Series.

Un index qui a un sens améliore aussi les indicateurs. Dans un tableau météorologique indexé par jour, weather["temp_c"].idxmax() indique un jour comme "Thu" ; avec un index par défaut, la méthode indique un numéro de ligne.

Un fichier CSV stocke un tableau sous forme de texte : les enregistrements occupent des lignes et un séparateur de champs sépare les champs. La première ligne contient souvent les noms des colonnes. Pour charger correctement le fichier, il faut identifier à la fois sa structure et le sens de ses valeurs.

Charger le tableau des commandes

orders = pd.read_csv("orders.csv")

Un chemin relatif est résolu à partir du répertoire de travail courant de Python. Un emplacement incorrect déclenche une FileNotFoundError. Un chemin absolu ou une URL peuvent aussi être passés à read_csv.

Les exemples utilisent ce fichier. Le champ de quantité de la dernière ligne est vide.

order_id,date,product,category,quantity,unit_price
1001,2026-03-02,Notebook,Stationery,3,2.50
1002,2026-03-02,Desk lamp,Home,1,18.00
1003,2026-03-03,Pen set,Stationery,2,4.75
1004,2026-03-04,Mug,Home,4,6.00
1005,2026-03-04,Backpack,Bags,1,35.00
1006,2026-03-05,Notebook,Stationery,,2.50

Avec les paramètres par défaut, le résultat a pour forme (6, 6) et ses étiquettes d’index vont de 0 à 5. pandas déduit les types : order_id est int64, unit_price est float64 et quantity devient aussi float64, car le champ vide devient NaN. Les autres colonnes, dont date, sont de type str. Une chaîne qui ressemble à une date reste du texte tant qu’elle n’est pas convertie.

Adapter la lecture à la structure du fichier

Pour un fichier dont les lignes sont a;b, 1,5;2 et 3,0;4, utilise pd.read_csv("file.csv", sep=";", decimal=","). La colonne a contient alors 1.5 et 3.0. Utiliser la virgule comme séparateur par défaut produit une seule colonne nommée a;b, signe qu’il faut vérifier le séparateur de champs.

index_col="order_id" transforme cette colonne en index de lignes lors du chargement. thousands="," lit un champ tel que "1,200" comme 1200 ; dans un fichier dont les champs sont séparés par des virgules, ce champ doit être mis entre guillemets selon les règles du CSV afin que sa virgule interne ne soit pas interprétée comme un autre séparateur.

Préserver le sens lors de l’inférence des types

Des codes tels que "001" sont des identifiants et non des quantités. dtype={"id": str} conserve leurs zéros initiaux. Si pandas les convertit d’abord en 1, reconvertir ce nombre en texte ne permet pas de retrouver le nombre de zéros présents dans le fichier.

Les champs vides et les marqueurs courants tels que NA, N/A, NULL, NaN et None sont considérés comme manquants par défaut. Ajoute un marqueur propre au fichier avec na_values=["-"]. Ce sont des règles de chargement : vérifie donc les conventions du fichier lorsqu’un code ressemble à un marqueur de valeur manquante.

Utilise parse_dates=["date"] pour lire les dates de l’exemple comme des dates et heures. Dans pandas 3, ces dates utilisent une résolution à la microseconde, datetime64[us]. UTF-8 est l’encodage de texte par défaut. Une UnicodeDecodeError invite à vérifier l’encodage du fichier et à fournir l’option correspondante, comme encoding="latin-1".

Une lecture réussie signifie que pandas a pu analyser le fichier. Elle ne prouve pas que les colonnes, les types et les valeurs manquantes correspondent à ce que le tableau doit représenter. Examine le nouveau DataFrame avant d’effectuer des calculs.

Vérifier les lignes visibles et les dimensions

orders.head(3)
orders.tail()
orders.shape
orders.columns.tolist()

head() affiche cinq lignes par défaut ; head(3) en affiche trois. tail() permet de vérifier la fin, où un export peut contenir des enregistrements différents. sample(3, random_state=0) donne un échantillon aléatoire reproductible de trois lignes. Dans un notebook, la dernière expression d’une cellule s’affiche automatiquement ; utilise print ailleurs.

Le fichier de commandes doit contenir six lignes et six colonnes. Un aperçu doit montrer des colonnes nommées et la première commande parmi les données. Si le premier enregistrement apparaît parmi les noms de colonnes, le fichier n’a probablement pas d’en-tête et nécessite header=None. Si tout occupe une seule colonne large, vérifie sep.

Les noms de colonnes doivent correspondre exactement, y compris la casse et les espaces. orders["Product"] échoue lorsque le nom est product. Examiner la liste permet de repérer plus facilement les espaces finaux. orders.columns = orders.columns.str.strip() supprime les espaces aux extrémités des noms d’en-tête.

Lire la structure avec info

orders.info() affiche l’étendue de l’index, le nom, le nombre de valeurs présentes et le type de chaque colonne, ainsi que l’occupation mémoire. Dans l’exemple de six lignes, quantity comporte cinq valeurs non manquantes ; chacune des autres colonnes en comporte six. Les types sont deux colonnes de flottants, une colonne d’entiers et trois colonnes str. orders.dtypes donne une liste compacte des types.

Une colonne qui semble numérique mais qui a le type str mérite un examen : une valeur telle que "unknown", une unité comme dans "12 kg" ou un séparateur de milliers non pris en compte peuvent empêcher l’inférence d’un type numérique. Les dates restent aussi du texte tant qu’elles ne sont pas converties. Choisis le type nécessaire d’après le sens de la colonne, et pas seulement d’après son apparence dans un aperçu.

Compter les valeurs manquantes et les valeurs répétées

orders.isna().sum()
orders.isna().any(axis=1).sum()
orders.nunique()

isna() crée un tableau booléen : True marque une cellule manquante. La somme dans chaque colonne compte ces cellules. Quantity comporte une valeur manquante et chaque autre colonne en comporte zéro. Pour compter les lignes concernées, .any(axis=1) vérifie d’abord si chaque ligne comporte une valeur manquante, puis .sum() compte ces lignes. Additionner tous les nombres obtenus par colonne pourrait compter plusieurs fois une même ligne.

nunique() compte les valeurs présentes distinctes : les commandes ont six identifiants, quatre dates, cinq produits, trois catégories, quatre quantités et cinq prix. Compare le nombre d’identifiants distincts au nombre de lignes pour vérifier leur unicité, et vérifie aussi le nombre d’identifiants manquants. orders.duplicated(subset="product") marque la deuxième ligne Notebook, d’étiquette 5, comme répétée. Un produit répété est normal ici ; un identifiant de commande répété demanderait un examen.

Lire un aperçu numérique rapide

orders.describe() indique l’effectif, la moyenne, l’écart-type, le minimum, les quartiles et le maximum des colonnes numériques. L’effectif de quantity est de cinq : sa moyenne décrit donc cinq quantités enregistrées. Vérifie les plages de valeurs plausibles et les unités en plus des types : une colonne peut être numérique tout en contenant une erreur de saisie. Lors de l’examen d’un nouveau chargement, rassemble le nombre de lignes, le nombre de colonnes, les types, les nombres de valeurs manquantes et la vérification des identifiants.

Le type de données d’une colonne détermine les opérations qui ont un sens. Une colonne textuelle contenant "12" stocke toujours du texte ; on ne peut pas en calculer la moyenne comme pour une colonne numérique. Effectue la conversion de manière réfléchie et réaffecte le résultat au tableau.

Choisir entre conversion stricte et coercition

astype convertit un objet Series vers un type indiqué, comme int, float, str ou "Int64". La conversion échoue lorsqu’une valeur ne peut pas être représentée dans le type demandé.

raw = pd.Series(["12", "7", "n/a", "3.5"])
numeric = pd.to_numeric(raw, errors="coerce")

raw.astype(float) déclenche une ValueError à "n/a". Avec errors="coerce", les valeurs de sortie sont 12.0, 7.0, NaN et 3.5. La valeur qui n’a pas pu être convertie devient manquante au lieu d’interrompre la conversion. Compare raw.isna().sum() avec numeric.isna().sum() : le nombre de valeurs manquantes passe de zéro à une, ce qui révèle une valeur à vérifier.

La coercition est une règle de conversion, pas une preuve que toute nouvelle valeur manquante est sans conséquence. Utilise les nombres obtenus avant et après pour repérer les pertes. Stocke le résultat de la conversion dans une nouvelle variable ou colonne lorsque le texte brut aide à retrouver une valeur dont la conversion a échoué.

Conserver les entiers avec des valeurs manquantes

La colonne de quantités des commandes contient des entiers et un NaN : elle est donc de type float64. Un simple astype(int) échoue, car NaN n’a pas de représentation entière ordinaire.

orders["quantity"] = orders["quantity"].astype("Int64")

Le I majuscule compte : le type nullable Int64 conserve la valeur manquante sous la forme <NA> tout en stockant les valeurs connues comme des entiers. Ce choix convient aux effectifs comportant des valeurs manquantes. Il ne transforme pas une quantité réellement fractionnaire en un effectif entier valide.

Les séparateurs de milliers dans le texte doivent aussi être traités. pd.Series(["1,200", "950"]).str.replace(",", "").astype(int) donne 1200 et 950. Lorsque le fichier utilise cette convention, thousands="," peut la prendre en compte lors de la lecture.

Convertir des dates textuelles

orders["date"] = pd.to_datetime(orders["date"])
orders["date"].dt.day_name()

La conversion permet d’utiliser .dt.year, .dt.month, .dt.day et .dt.day_name(). Pour les six dates de commande, les noms des jours sont Monday, Monday, Tuesday, Wednesday, Wednesday et Thursday. Exécuter pd.to_datetime(orders["date"]) seul produit un objet Series converti, mais laisse la colonne d’origine sous forme de texte. C’est l’affectation qui conserve le résultat.

Stocker des catégories répétées

orders["category"].astype("category") stocke les étiquettes répétées à l’aide d’un ensemble de catégories autorisées. Sur les grands tableaux, cela économise généralement de la mémoire. Affecte le résultat pour le conserver, comme pour les autres conversions.

Le type catégoriel modifie certaines opérations. Ses catégories ne sont pas ordonnées par défaut : min() et max() déclenchent donc une TypeError. La méthode value_counts() d’une colonne catégorielle affiche aussi les catégories connues absentes d’une sélection filtrée, avec un effectif nul. Le type catégoriel est utile pour les étiquettes répétées, mais il modifie le comportement autant que le stockage.

Les étiquettes permettent de demander une ligne ou une colonne d’après ce qu’elle représente. Avec loc, un numéro de commande identifie une ligne même si le tableau a été trié. La sélection comporte une partie pour les lignes, suivie d’une partie pour les colonnes : df.loc[rows, columns].

Partir d’un index qui a un sens

Le fichier de commandes comporte six lignes dont les identifiants vont de 1001 à 1006. Crée orders_by_id = orders.set_index("order_id"). Ses colonnes sont, dans l’ordre, date, product, category, quantity et unit_price. Les étiquettes de lignes sont les numéros de commande, et non les positions de 0 à 5.

orders_by_id.loc[1003]
orders_by_id.loc[1004, "product"]

La première expression renvoie la commande 1003 sous forme d’objet Series : date "2026-03-03", product "Pen set", category "Stationery", quantity 2.0 et prix 4.75. L’objet Series porte le nom 1003. La seconde renvoie une cellule, "Mug".

Une étiquette absente déclenche une KeyError. orders_by_id.loc[0] échoue : avoir une première ligne à la position 0 ne crée pas d’étiquette 0.

Sélectionner des ensembles d’étiquettes

orders_by_id.loc[[1001, 1005], ["product", "unit_price"]]

Les listes sélectionnent les étiquettes dans l’ordre demandé. On obtient deux lignes et deux colonnes : Notebook à 2.5, puis Backpack à 35.0. Une liste conserve un résultat sous forme de tableau même si elle ne contient qu’une étiquette : .loc[[1003]] est un DataFrame d’une ligne.

Deux-points utilisés seuls désignent toutes les étiquettes de cet axe. Omettre le sélecteur de colonnes demande aussi toutes les colonnes.

Inclure les deux bornes d’une tranche par étiquettes

orders_by_id.loc[1002:1004, "product":"quantity"]

Dans cet index ordonné, les lignes sont 1002, 1003 et 1004. La tranche de colonnes inclut product, category et quantity. L’étiquette finale des lignes et celle des colonnes sont toutes deux incluses : la forme est donc (3, 3). Appliquer ici la règle habituelle de Python, qui exclut la borne finale, ferait omettre une ligne et une colonne souhaitées.

Les étiquettes restent associées aux lignes lors du tri

Un index par défaut peut masquer la distinction entre étiquette et position. Supposons qu’un tri de scores donne les étiquettes de lignes 3, 0, 2, 1, 4. .loc[0] sélectionne toujours l’étiquette 0, désormais sur la deuxième ligne affichée. .iloc[0] sélectionne la première ligne affichée, d’étiquette 3. Le tri déplace une ligne avec son étiquette ; il ne renumérote pas l’index sans indication.

Combiner une condition et une sélection de colonnes

Le sélecteur de lignes peut être un objet Series booléen :

orders.loc[orders["unit_price"] > 5, ["product", "unit_price"]]

Cette sélection conserve Desk lamp à 18.0, Mug à 6.0 et Backpack à 35.0, et ne renvoie que les deux colonnes demandées. Le masque détermine les lignes retenues ; la liste de colonnes détermine ce qui est affiché. La même forme à deux axes permet de cibler des cellules à mettre à jour en plaçant la sélection à gauche d’une affectation.

Utilise iloc lorsque la demande concerne l’emplacement d’une ligne ou d’une colonne : les trois premières lignes, la dernière colonne ou une cellule affichée à un endroit précis. Ses sélecteurs sont des positions entières, indépendantes des étiquettes d’index.

Compter à partir de zéro

orders.iloc[0] sélectionne la première ligne et orders.iloc[-1] la dernière. Une position négative compte à rebours depuis la fin. Deux positions sélectionnent une cellule : orders.iloc[2, 2] vaut "Pen set" dans le tableau de commandes d’origine, où product est à la position de colonne 2.

Le tableau indexé orders_by_id comporte les colonnes date, product, category, quantity et unit_price. Le déplacement de order_id dans l’index a modifié les positions des colonnes : product est désormais à la position 1. Le code fondé sur les positions dépend de cette structure.

S’arrêter avant la borne finale de la tranche

orders_by_id.iloc[1:3, 0:2]

Les positions de lignes sélectionnées sont 1 et 2, qui contiennent les commandes 1002 et 1003. Les positions de colonnes sont 0 et 1, soit date et product. La position de ligne 3 et la colonne 2 sont exclues, ce qui donne la forme (2, 2). Une borne initiale vide signifie le début ; une borne finale vide signifie la fin.

Les listes demandent des positions précises, y compris un mélange de positions positives et négatives. orders.iloc[[0, -1], [2, 5]] sélectionne product et unit_price pour la première et la dernière commande. Les deux sont ici Notebook à 2.5.

Prévoir la forme du résultat

Un scalaire sélectionne un élément sur un axe et supprime cette dimension. Une tranche ou une liste conserve cet axe, même si elle ne sélectionne qu’un élément. Cela compte lorsque l’opération suivante attend un tableau plutôt qu’un objet Series.

Gérer la fin d’un tableau

Le tableau de commandes de six lignes possède des positions de lignes positives ou nulles valides de 0 à 5. orders.iloc[10] déclenche une IndexError. Une tranche peut dépasser le tableau : orders.iloc[4:100] renvoie simplement les deux dernières lignes. Une position individuelle absente est une demande d’élément invalide, tandis qu’une tranche décrit un intervalle qui s’arrête aux lignes disponibles.

Choisir délibérément les étiquettes ou les positions

Pour une cellule, at utilise les étiquettes et iat utilise les positions. orders.at[2, "product"] et orders.iat[2, 2] donnent tous deux "Pen set" avant le réordonnancement des lignes.

Choisis loc lorsque tu connais un identifiant ou le sens d’une colonne. Choisis iloc lorsque l’emplacement lui-même compte. Pour combiner les premières lignes avec un nom de colonne, orders.columns.get_loc("quantity") renvoie sa position, 4, ce qui permet d’utiliser orders.iloc[0:3, 4].

Des crochets seuls peuvent changer de rôle : orders["product"] sélectionne une colonne, mais orders[2:4] extrait les lignes aux positions 2 et 3. Écrire explicitement loc et iloc rend ce choix plus lisible.

Le filtrage sélectionne les observations qui répondent à une question, par exemple les commandes de la catégorie Home dont le prix unitaire dépasse 10. Crée d’abord un masque booléen, un objet Series contenant un True ou un False par ligne. Utilise-le ensuite pour sélectionner les lignes correspondantes.

Construire et appliquer un masque

is_stationery = orders["category"] == "Stationery"
stationery = orders[is_stationery]

Le masque contient True, False, True, False, False et True. La sélection conserve les étiquettes 0, 2 et 5, correspondant aux commandes 1001, 1003 et 1006. Le filtrage conserve ces étiquettes ; il ne les renumérote pas. reset_index(drop=True) fournit des étiquettes consécutives si nécessaire.

Les opérateurs de comparaison comprennent ==, !=, <, <=, > et >=. Les comparaisons de texte sont exactes : "home" diffère de "Home", et les espaces peuvent aussi empêcher une correspondance.

Combiner les conditions ligne par ligne

is_home = orders["category"] == "Home"
is_expensive = orders["unit_price"] > 10
orders[is_home & is_expensive]

Seule Desk lamp remplit les conditions : sa catégorie est Home et son prix est de 18,0. Mug appartient à Home mais coûte 6,0. Backpack coûte 35,0 mais appartient à Bags.

Lorsque tu écris directement les comparaisons, place chacune entre parenthèses :

orders[(orders["category"] == "Home") &
       (orders["unit_price"] > 10)]

Utilise & pour « et », | pour « ou » et ~ pour « non ». Les parenthèses maintiennent chaque comparaison ensemble avant que pandas combine les masques. Sans elles, les règles de priorité de Python peuvent conduire à combiner une chaîne et un objet Series avec & et déclencher une TypeError.

Les opérateurs Python and, or et not attendent une seule valeur de vérité, et non une colonne de valeurs de vérité. Les utiliser sur des masques déclenche une ValueError indiquant que la valeur de vérité est ambiguë. Une instruction if orders["quantity"] > 1: seule pose le même problème. Utilise .any() pour savoir si au moins une ligne correspond, ou .all() pour savoir si toutes les lignes correspondent.

Compter les correspondances et calculer leur proportion

is_stationery.sum() vaut 3, car True compte pour 1 et False pour 0. is_stationery.mean() vaut 0,5, la fraction des six commandes qui correspondent. Multiplie par 100 pour l’exprimer sous la forme 50 %.

Traiter explicitement les valeurs manquantes

Avec la colonne quantity d’origine de type float64, les comparaisons avec NaN donnent False, sauf !=, qui donne True. quantity >= 1 conserve cinq lignes ; quantity < 1 n’en conserve aucune. La quantité vide n’appartient à aucune des deux sélections. Pourtant, quantity != 3 inclut cette ligne vide : « différent de » ne signifie donc pas « connu et différent ».

Après conversion en Int64 nullable, une comparaison avec <NA> produit <NA>, et le filtrage exclut ces lignes. Utilise isna() ou notna() lorsque la question porte sur les valeurs manquantes.

Pour sélectionner des colonnes en plus des lignes, utilise orders.loc[is_home, "product"]. Cette expression renvoie Desk lamp et Mug. Un masque nommé peut être réutilisé pour examiner, compter et mettre à jour le même ensemble de lignes.

Certains filtres suivent des formes courantes : appartenance à une liste, intervalle numérique, valeur manquante ou fragment de texte. Des méthodes utilitaires expriment directement ces tests et produisent des masques qui peuvent toujours être combinés à d’autres conditions.

Tester l’appartenance et les intervalles

orders[orders["category"].isin(["Home", "Bags"])]
orders[orders["unit_price"].between(4.75, 18)]

isin reconnaît toute valeur présente dans la liste. La première sélection contient les commandes 1002, 1004 et 1005. ~orders["category"].isin(["Home"]) inverse le test d’appartenance et conserve les lignes Stationery et Bags. Une expression Python avec in ne crée pas ce masque d’appartenance ligne par ligne.

between inclut les deux bornes par défaut. La deuxième sélection inclut Desk lamp à 18,0, Pen set à 4,75 et Mug à 6,0. Utilise inclusive="neither" pour exclure les deux bornes, "left" pour inclure uniquement la borne inférieure ou "right" pour inclure uniquement la borne supérieure. Choisis la règle d’inclusion des bornes selon la question posée.

Trouver les entrées manquantes et présentes

orders[orders["quantity"].isna()] conserve la commande 1006. notna() fait l’inverse et conserve les quantités enregistrées. Ne teste pas l’égalité avec np.nan : NaN est différent même de lui-même, donc quantity == np.nan ne trouve pas la ligne manquante.

Chercher à l’intérieur du texte

orders[orders["product"].str.contains("note", case=False, na=False)]

str.contains vérifie si chaque valeur textuelle contient une correspondance. Ignorer la casse permet de trouver les deux lignes Notebook. na=False considère le texte manquant comme une non-correspondance. Par défaut, la recherche traite le motif comme une expression régulière ; pour un fragment de texte littéral contenant de la ponctuation, regex=False évite d’interpréter cette ponctuation comme un motif. str.startswith et str.endswith testent le début et la fin.

Écrire un filtre sous forme de requête

orders.query("quantity >= 2 and unit_price < 5")

Cette requête conserve les commandes 1001 et 1003. Dans une chaîne query, les noms de colonnes désignent les colonnes et and, or et not sont autorisés. La chaîne est une expression de requête pandas ; sa syntaxe n’est pas celle utilisée pour combiner directement des objets Series en Python ordinaire.

Une variable Python nécessite @ :

limit = 5
orders.query("unit_price > @limit")

Le résultat contient Desk lamp, Mug et Backpack. Un nom de colonne contenant un espace doit être placé entre accents graves dans la requête, comme dans orders.query("`unit price` > 5").

La même question peut être écrite sous forme de masque, d’appel à une méthode utilitaire ou de requête. Privilégie la forme qui présente clairement la règle. Pour un intervalle, between rassemble les bornes et leur règle d’inclusion. Pour un ensemble d’étiquettes autorisées, isin évite de répéter les tests d’égalité. Si un filtre se comporte de façon inattendue, examine le masque et les valeurs exactes des colonnes avant de modifier la condition.

Une mise à jour doit cibler le tableau que tu souhaites modifier. Dans pandas 3, une sélection se comporte comme un objet distinct sous le régime de copie à l’écriture : modifier un objet sélectionné ne modifie donc pas son tableau parent.

Placer toute la cible dans une seule affectation loc

sale = orders.copy()
is_home = sale["category"] == "Home"
sale.loc[is_home, "unit_price"] *= 0.9

Le masque sélectionne deux lignes Home. Le sélecteur de colonne cible leurs prix. La multiplication par 0,9 conserve 90 % de chaque prix et réduit 18,00 à 16,20 et 6,00 à 5,40. Les autres lignes restent inchangées. La forme développée lit la même sélection à droite et affecte les valeurs multipliées à gauche.

Ici, sale est un tableau distinct utilisé pour modifier les prix, ce qui laisse orders disponible pour la comparaison. Pour mettre à jour le tableau d’origine, place orders.loc[...] lui-même à gauche de l’affectation.

Éviter l’affectation chaînée

orders[orders["category"] == "Home"]["unit_price"] = 0

Cette instruction utilise deux étapes d’indexation. La première produit un objet sélectionné ; la seconde effectue une affectation dans cet objet. Dans pandas 3, elle ne met jamais orders à jour et un avertissement ChainedAssignmentError signale le problème. Le même problème concerne orders["unit_price"][1] = 0.

Utilise orders.loc[orders["category"] == "Home", "unit_price"] = 0 lorsque tu souhaites modifier le tableau d’origine. Le tableau, les lignes correspondantes et la colonne sont tous précisés dans une seule affectation.

Comprendre les tableaux sélectionnés

Après home = orders[orders["category"] == "Home"], modifier home["unit_price"] ne change que home. Les modifications ultérieures de orders ne changent pas non plus home. Les objets peuvent partager leur stockage en interne jusqu’à ce qu’une écriture soit nécessaire, mais leurs valeurs visibles se comportent de manière indépendante.

Les anciens exemples pandas peuvent afficher SettingWithCopyWarning et utiliser .copy() après une sélection pour éviter des mises à jour incertaines. pandas 3 a supprimé cet avertissement et garantit l’indépendance des sélections de manière cohérente. Un .copy() explicite reste utile pour exprimer l’intention, mais une sélection se comporte déjà de manière indépendante lors des mises à jour.

Faire correspondre les valeurs de droite à la cible

Un scalaire remplit toutes les cellules sélectionnées. Une liste exige exactement une valeur par ligne sélectionnée et les remplit dans l’ordre de sélection. Un objet Series s’aligne par étiquette d’index :

new_prices = pd.Series([16.2, 5.4], index=[1, 3])
sale.loc[is_home, "unit_price"] = new_prices

Les lignes Home portent les étiquettes 1 et 3 : elles reçoivent donc 16,2 et 5,4. Si une étiquette sélectionnée était absente de l’objet Series, la valeur qui lui serait affectée serait NaN ; les lignes hors de la sélection resteraient inchangées. Des longueurs égales ne suffisent pas à établir la correspondance entre l’objet Series et les lignes.

Examine sale.loc[is_home, "unit_price"] après la modification et compare le résultat avec orders.loc[is_home, "unit_price"]. La méthode .sum() du masque donne 2, soit le nombre attendu de lignes ciblées par cette remise.

Les nouvelles colonnes transforment les données enregistrées en quantités que tu peux analyser. Un calcul entre colonnes s’effectue ligne par ligne, tandis que l’index garde chaque résultat associé à son observation.

Calculer le chiffre d’affaires

orders["revenue"] = orders["quantity"] * orders["unit_price"]

Les six chiffres d’affaires sont 7,5 ; 18,0 ; 9,5 ; 24,0 ; 35,0 et NaN. Pour la première ligne, trois articles à 2,50 chacun donnent 7,50. La dernière ligne a une quantité inconnue, donc son chiffre d’affaires est également inconnu. Une affectation à un nouveau nom ajoute une colonne à droite ; une affectation à un nom existant remplace cette colonne.

Les calculs sur les colonnes sont vectorisés. Ils expriment une règle pour toute la colonne et évitent une boucle Python sur les lignes. Sur les grands tableaux, cette forme est beaucoup plus rapide que for ou iterrows, et l’expression rend claire la relation entre les données d’entrée.

Utiliser les valeurs enregistrées dans un total

orders["revenue"].sum() ignore NaN et donne 94,0, le total des cinq chiffres d’affaires connus. .mean() donne 18,8, car le dénominateur est le nombre de chiffres d’affaires enregistrés, soit cinq. Diviser 94,0 par les six lignes reviendrait à traiter implicitement le chiffre d’affaires manquant comme s’il contribuait au total par un zéro connu.

Pour calculer les parts en pourcentage :

orders["share_pct"] = (
    orders["revenue"] / orders["revenue"].sum() * 100
).round(1)

Les parts sont 8,0 ; 19,1 ; 10,1 ; 25,5 ; 37,2 et NaN. Ce sont des parts du total connu. L’entrée manquante reste manquante dans les calculs.

Renvoyer un tableau avec assign

assign renvoie un nouveau DataFrame avec des colonnes ajoutées ou remplacées, sans modifier le tableau d’entrée. Cette méthode s’intègre naturellement dans un enchaînement :

with_tax = orders.assign(
    tax=lambda d: (d["revenue"] * 0.2).round(2)
)

L’expression lambda lit le tableau tel qu’il est à ce stade de l’enchaînement. Elle donne les valeurs de taxe 1,5 ; 3,6 ; 1,9 ; 4,8 ; 7,0 et NaN. Dans pandas 3, pd.col("revenue") * 0.2 est une autre façon de désigner une colonne dans assign.

Les calculs décimaux peuvent révéler de minuscules erreurs de représentation binaire en virgule flottante : 9,5 multiplié par 0,2 peut être stocké sous la forme 1.9000000000000001. .round(2) donne une valeur utile pour la présentation. Évite les tests d’égalité exacte sur les décimaux calculés lorsque de petites erreurs de représentation sont possibles.

Comprendre comment l’affectation associe les lignes

orders["home_price"] = orders.loc[
    orders["category"] == "Home", "unit_price"
]

L’objet Series affecté porte les étiquettes 1 et 3. Ces lignes reçoivent 18,0 et 6,0 ; toutes les autres reçoivent NaN. L’affectation d’un objet Series associe les étiquettes, même lorsque sa longueur diffère de celle du tableau. Une liste ordinaire n’a pas d’étiquettes et doit contenir exactement une valeur par ligne. Un scalaire, comme dans orders["currency"] = "EUR", remplit toutes les lignes.

Calculer des valeurs à partir de texte ou de dates

Les accesseurs .str et .dt fournissent aussi des opérations vectorisées sur les colonnes. orders["product"].str.upper() donne les noms en majuscules, et .str.len() donne les longueurs 8, 9, 7, 3, 8 et 8. Affecte ces résultats à une nouvelle colonne lorsque les valeurs d’origine et les valeurs calculées sont toutes deux utiles.

Transformer une colonne peut consister à appliquer une règle numérique, à attribuer une étiquette ou à mettre des étiquettes existantes en correspondance. Choisis une méthode dont le comportement correspond à la règle, en particulier pour les valeurs que celle-ci ne mentionne pas.

Transformer une condition en étiquettes

orders["price_band"] = np.where(
    orders["unit_price"] >= 5, "high", "low"
)

np.where choisit son deuxième argument lorsque la condition vaut True et son troisième lorsqu’elle vaut False. Pour les prix 2,50 ; 18,00 ; 4,75 ; 6,00 ; 35,00 et 2,50, les étiquettes sont low, high, low, high, high et low. L’opérateur >= inclut un prix exactement égal à 5.

Mettre toutes les valeurs en correspondance ou en modifier quelques-unes

codes = {"Stationery": "ST", "Home": "HM", "Bags": "BG"}
orders["category_code"] = orders["category"].map(codes)

map avec le dictionnaire donne ST, HM, ST, HM, BG et ST. Une valeur absente du dictionnaire devient NaN. Avec seulement {"Stationery": "ST"}, Home et Bags deviennent tous deux des valeurs manquantes. Utilise une correspondance complète lorsque chaque catégorie doit recevoir un code.

replace modifie les valeurs indiquées et laisse les autres inchangées. orders["category"].replace({"Bags": "Luggage"}) conserve Stationery et Home tout en renommant Bags.

Appliquer une fonction personnalisée

Un objet Series peut transmettre chaque valeur à une fonction par map ou apply. orders["product"].apply(len) renvoie la longueur de chaque nom de produit. Passe len lui-même ; len() l’appellerait immédiatement sans valeur.

Une expression lambda peut exprimer une petite règle appliquée aux valeurs : orders["unit_price"].apply(lambda p: "budget" if p < 5 else "standard"). Elle renvoie budget, standard, budget, standard, standard et budget.

Pour une logique utilisant plusieurs cellules d’une même ligne, apply sur un DataFrame accepte axis=1 :

orders.apply(
    lambda r: r["quantity"] * r["unit_price"], axis=1
)

La fonction lit la quantité et le prix de chaque ligne. Pour ce calcul, la multiplication directe des colonnes est plus claire et beaucoup plus rapide sur un grand tableau. Utilise des expressions vectorisées ou np.where lorsqu’elles permettent d’exprimer le calcul ; réserve les fonctions appliquées ligne par ligne aux logiques qui en ont besoin.

Utiliser les transformations numériques intégrées

round(n) arrondit à n décimales, abs() donne les valeurs absolues et clip(lower=..., upper=...) écrête les valeurs aux bornes indiquées. orders["unit_price"].clip(upper=20) transforme 35,0 en 20,0 et laisse les cinq autres prix inchangés. La méthode ne supprime pas la ligne correspondant au prix élevé.

Ces transformations renvoient de nouvelles valeurs. Affecte-les à une nouvelle colonne pour conserver les données d’entrée et les vérifier, ou remplace la colonne d’origine si c’est le résultat voulu. Examine quelques lignes transformées ou exécute value_counts() pour vérifier que les nouvelles étiquettes et leurs effectifs correspondent à la règle.

Le tri modifie l’ordre d’apparition des observations. Il maintient ensemble les valeurs de chaque ligne et déplace son étiquette avec elle. Détermine ce qui est prioritaire et comment ordonner les valeurs ex æquo avant de sélectionner les plus grandes ou les plus petites.

Trier selon une colonne

scores = pd.DataFrame({
    "name": ["Ana", "Ben", "Chen", "Dara", "Eli"],
    "points": [88, 92, 88, 75, 92]
})
ordered = scores.sort_values("points")

La plus petite valeur vient en premier par défaut. Le score de Dara, 75, vient en premier, suivi des deux scores de 88 puis des deux scores de 92. Les étiquettes de lignes se déplacent avec les enregistrements. Pour les ex æquo, l’algorithme de tri par défaut ne garantit pas l’ordre initial ; les étiquettes affichées peuvent être 3, 0, 2, 1, 4, mais il ne faut pas supposer que les lignes ex æquo conservent cet ordre.

Utilise ascending=False pour placer les plus grandes valeurs en premier. sort_values renvoie un tableau et laisse scores inchangé, sauf si le résultat est affecté à cette variable.

Choisir comment départager les ex æquo

scores.sort_values(
    ["points", "name"], ascending=[False, True]
)

La première clé est prioritaire. Les scores décroissent ; les noms sont triés par ordre croissant pour les scores égaux. L’ordre est Ben, Eli, Ana, Chen et Dara. Trier d’abord les noms répondrait à une autre question, car les noms deviendraient la clé principale.

Lorsque les ex æquo d’un tri sur une colonne doivent conserver l’ordre d’entrée, utilise scores.sort_values("points", kind="stable"). La stabilité conserve les lignes ex æquo dans leur ordre existant. Une clé secondaire donne quant à elle une règle explicite pour ordonner les ex æquo.

Placer les valeurs manquantes et le texte

Les valeurs manquantes sont placées en dernier par défaut, tant dans un tri croissant que décroissant. pd.Series([3.0, np.nan, 1.0]).sort_values() donne 1,0 ; 3,0, puis NaN. na_position="first" place l’entrée manquante au début ; inverser uniquement le sens du tri ne le fait pas.

Le tri du texte suit les codes des caractères. "Zebra" est placé avant "apple", car les majuscules et les minuscules occupent des plages différentes. Des noms écrits de manière cohérente, comme Bags, Home et Stationery, sont triés dans l’ordre alphabétique attendu.

Trier les étiquettes ou les renuméroter

sort_index() ordonne les étiquettes de lignes, et non les valeurs des données. Après un tri par scores, la méthode peut rétablir l’ordre des étiquettes par défaut d’origine. sort_index(ascending=False) inverse l’ordre des étiquettes. En revanche, reset_index(drop=True) conserve l’ordre actuel des lignes et remplace leurs étiquettes par 0, 1, 2 et ainsi de suite.

Sélectionner les lignes aux plus grandes ou aux plus petites valeurs

scores.nlargest(2, "points") renvoie Ben et Eli, qui ont tous deux 92. nsmallest prend les valeurs les plus faibles. Si le seuil tombe au milieu d’un groupe d’ex æquo, décide si toutes les lignes ex æquo doivent être conservées. scores.nlargest(1, "points", keep="all") renvoie les deux scores de 92, même si n vaut 1. Le nombre demandé est alors un seuil et non une garantie sur le nombre final de lignes.

Un rang indique où se situe une valeur dans l’ordre trié sans déplacer sa ligne. Il est utile lorsque chaque observation doit recevoir un numéro de place à côté de ses données d’origine. Les ex æquo nécessitent une règle, car plusieurs valeurs peuvent occuper une même partie de cet ordre.

Choisir le sens

scores["points"].rank() attribue les rangs de la plus petite valeur à la plus grande. Utilise ascending=False pour un tableau de résultats où les scores élevés doivent obtenir les meilleurs rangs. La méthode de traitement des ex æquo détermine alors le numéro de place attribué à chaque groupe ex æquo.

Les scores de l’exemple, dans l’ordre des lignes, sont Ana 88, Ben 92, Chen 88, Dara 75 et Eli 92. Dans l’ordre décroissant, les scores de 92 occupent les places 1 et 2, ceux de 88 les places 3 et 4, et 75 la place 5. La méthode par défaut method="average" attribue à chaque valeur ex æquo la moyenne des places occupées. Les valeurs renvoyées, dans l’ordre initial des lignes, sont 3,5 ; 1,5 ; 3,5 ; 5,0 et 1,5.

Choisir une méthode pour les ex æquo

Avec min, deux gagnants au rang 1 signifient que le score suivant commence au rang 3. Avec dense, le score distinct suivant commence au rang 2. first départage les ex æquo même lorsque les scores eux-mêmes ne permettent pas de privilégier une personne ; la méthode suit l’ordre d’entrée.

Les rangs renvoyés sont des flottants, ce qui permet d’obtenir des valeurs comme 1,5. Lorsque la méthode choisie donne des rangs entiers et qu’aucun ne manque, .astype(int) les convertit pour l’affichage. Un type entier ordinaire ne peut pas contenir un rang manquant.

Exprimer les rangs sous forme de fractions

Avec la méthode de la moyenne par défaut et des valeurs non manquantes, rank(pct=True) divise chaque rang par le nombre de valeurs classées. Classer les cinq scores de l’exemple par ordre croissant donne 2,5 ; 4,5 ; 2,5 ; 1,0 et 4,5. La division par cinq donne 0,5 ; 0,9 ; 0,5 ; 0,2 et 0,9.

Les valeurs les plus élevées ex æquo reçoivent 0,9 et non 1, car leur rang moyen est de 4,5. Un rang centile décrit le rang par rapport aux valeurs classées ; ce n’est pas un pourcentage du score lui-même.

Traiter les rangs manquants et stocker les résultats

Les valeurs manquantes conservent des rangs NaN par défaut. Avec les chiffres d’affaires 7,5 ; 18,0 ; 9,5 ; 24,0 ; 35,0 et NaN, les rangs décroissants sont 5, 3, 4, 2, 1 et NaN. na_option="bottom" place l’entrée manquante après les valeurs enregistrées et lui donne le rang 6.

scores["place"] = scores["points"].rank(
    method="min", ascending=False
)

Les lignes restent dans l’ordre Ana, Ben, Chen, Dara et Eli. La nouvelle colonne de places contient 3, 1, 3, 5 et 1. Effectue un tri séparé si l’affichage doit présenter les gagnants en premier.

Une statistique descriptive condense de nombreuses observations en une quantité utile. Choisis une statistique adaptée à la question et lis son nombre de valeurs non manquantes afin de savoir sur combien de données elle repose.

Calculer la tendance centrale et la dispersion

weather = pd.DataFrame({
    "temp_c": [14.0, 17.5, 16.0, 21.0, 19.5, 12.5, 15.0],
    "rain_mm": [0.0, 2.4, 0.0, 0.0, 5.1, 12.3, 0.8]
}, index=["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"])

Pour weather["temp_c"], sum() vaut 115,5, mean() vaut 16,5 et median() vaut 16,0. Le minimum est de 12,5 et le maximum de 21,0, ce qui donne une étendue de 8,5 °C. idxmax() renvoie l’étiquette "Thu", tandis que idxmin() renvoie "Sat" : ces méthodes identifient les observations au lieu de renvoyer les valeurs extrêmes elles-mêmes.

std() et var() mesurent la dispersion. pandas utilise par défaut le dénominateur d’échantillon, ddof=1, en divisant les écarts au carré par le nombre d’observations moins un. Ici, l’écart-type est d’environ 3,028 °C et la variance d’environ 9,167 degrés Celsius au carré. std(ddof=0) utilise le nombre d’observations lui-même et donne environ 2,803 °C. La fonction np.std de NumPy utilise ddof=0 par défaut : harmonise donc ce paramètre avant de comparer les résultats.

Lire les quartiles et describe

quantile(0.25) donne le premier quartile, 14,5 ; quantile(0.5) donne la médiane, 16,0 ; quantile(0.75) donne le troisième quartile, 18,5. L’interpolation par défaut peut renvoyer une valeur située entre des relevés enregistrés.

weather.describe() rassemble l’effectif, la moyenne, l’écart-type, le minimum, les trois quartiles et le maximum des colonnes numériques. Pour la pluie, la moyenne est d’environ 2,94 mm et la médiane de 0,8 mm. Le relevé de 12,3 mm tire la moyenne vers le haut ; la médiane décrit mieux une journée typique de cette semaine dont la distribution des précipitations est asymétrique à droite.

Tenir compte des valeurs manquantes et des types

Pour pd.Series([1, np.nan, 3]), .mean() vaut 2,0, car les valeurs manquantes sont ignorées par défaut. .count() vaut 2, tandis que .size vaut 3. Avec skipna=False, la moyenne vaut NaN. N’utilise pas le nombre total de lignes comme dénominateur pour la moyenne par défaut lorsque certaines entrées sont manquantes.

Les synthèses textuelles sont différentes. orders["category"].describe() donne count 6, unique 3, top Stationery et freq 3. Calculer la moyenne du tableau de commandes contenant du texte déclenche une TypeError ; utilise orders.mean(numeric_only=True) ou sélectionne les colonnes numériques avec select_dtypes("number").

Calculer des indicateurs selon un axe

Par défaut, les statistiques d’un DataFrame effectuent une réduction en parcourant les lignes pour donner un résultat par colonne. axis=1 donne au contraire un résultat par ligne ; sélectionne des quantités dont les unités peuvent être combinées de façon cohérente.

orders[["quantity", "unit_price"]].agg(["mean", "max"])

agg calcule ensemble plusieurs statistiques nommées. Quantity a une moyenne de 2,2 et un maximum de 4,0 ; unit_price a une moyenne d’environ 11,46 et un maximum de 35,0. weather["rain_mm"].cumsum() donne les totaux cumulés 0,0 ; 2,4 ; 2,4 ; 2,4 ; 7,5 ; 19,8 et 20,6 mm, en conservant un résultat par jour.

Les effectifs décrivent le nombre d’occurrences des valeurs ; les corrélations décrivent comment deux variables numériques évoluent ensemble. Ces deux types d’indicateurs demandent une interprétation : que compte-t-on, que manque-t-il et quelle liaison la statistique mesure-t-elle ?

Compter les catégories ou lister les valeurs distinctes

orders["category"].value_counts() donne Stationery 3, Home 2 et Bags 1, par ordre de fréquence. L’objet Series renvoyé est nommé count. Les entrées manquantes sont exclues par défaut ; dropna=False les inclut dans un effectif distinct.

orders["category"].value_counts(normalize=True)

L’objet Series normalisé est nommé proportion : Stationery vaut 0,5, Home environ 0,333 et Bags environ 0,167. Une multiplication par 100 permet de les exprimer en pourcentages. Avec la règle par défaut pour les valeurs manquantes, ces proportions décrivent les valeurs présentes.

unique() conserve l’ordre de première apparition : Stationery, Home, Bags. mode() renvoie un objet Series, car plusieurs valeurs peuvent être ex æquo pour la fréquence la plus élevée. La méthode ne demande pas de choisir arbitrairement une seule valeur gagnante.

On peut compter directement les cas qui remplissent une condition. (weather["rain_mm"] > 0).sum() compte quatre jours de pluie. Sa méthode .mean() vaut environ 0,571 : il a donc plu pendant environ 57 % des sept jours.

Mesurer une liaison linéaire

weather["temp_c"].corr(weather["rain_mm"]) donne une corrélation de Pearson d’environ −0,397. Son signe négatif indique que les jours les plus chauds tendaient à être moins pluvieux dans ces observations. Sa valeur décrit à quel point les données suivent une droite, sur une échelle allant de −1 à 1 en passant par 0.

Une valeur de 1 signifie une liaison linéaire croissante parfaite ; −1 signifie une liaison linéaire décroissante parfaite. Une valeur proche de zéro indique une faible liaison linéaire. Une liaison courbe peut néanmoins être forte même lorsque la corrélation de Pearson est proche de zéro. La corrélation décrit aussi une liaison : elle ne prouve pas que modifier une variable provoque une modification de l’autre.

Lire une matrice de corrélation

weather.corr() donne toutes les paires de colonnes numériques ensemble. La matrice est symétrique : la corrélation de la température avec la pluie est la même que celle de la pluie avec la température. Une colonne numérique dont les valeurs ne sont pas toutes égales a une corrélation de 1 avec elle-même ; une colonne constante n’a pas de corrélation définie et donne NaN à la place.

Pour les liaisons toujours croissantes ou toujours décroissantes sans suivre une droite, method="spearman" calcule la corrélation à partir des rangs. La méthode modifie le type de relation décrit : indique-la donc lorsque tu présentes un résultat.

Le calcul météorologique n’utilise que sept relevés. Il décrit cette petite semaine observée ; des affirmations solides sur une tendance climatique plus large exigent davantage de données. Un compte rendu utile indique les variables, le signe et la valeur du coefficient, la méthode et le nombre d’observations.