{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---\n",
"title : \"Introduction aux structures de données pandas : les DataFrames (tableaux bidimensionnels)\"\n",
"---"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Commençons par importer la bibliothèque Pandas (et la bibliotèque NumPy) avec les alias classiques `pd` et `np` :"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.193416Z",
"iopub.status.busy": "2026-10-30T13:14:17.192332Z",
"iopub.status.idle": "2026-10-30T13:14:17.511614Z",
"shell.execute_reply": "2026-10-30T13:14:17.510670Z"
}
},
"outputs": [],
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"\n",
"# Pour l'affichage dans les notebooks\n",
"from IPython.display import display, Markdown"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La deuxième structure fondamentale de Pandas est le `DataFrame`. Elle peut être considérée comme une généralisation d'une matrice NumPy, où les lignes et les colonnes sont identifiées par des étiquettes, ou encore comme un dictionnaire de Series partageant le même index."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Contrairement à une matrice, les colonnes peuvent être de types différents.\n",
"\n",
"Un DataFrame est composé des éléments suivants :\n",
"\n",
"- l’indice de la ligne ;\n",
"- le nom de la colonne ;\n",
"- la valeur de la donnée ;\n",
"\n",
""
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.514992Z",
"iopub.status.busy": "2026-10-30T13:14:17.514635Z",
"iopub.status.idle": "2026-10-30T13:14:17.518450Z",
"shell.execute_reply": "2026-10-30T13:14:17.517726Z"
}
},
"outputs": [],
"source": [
"# ?pd.DataFrame"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Création d'un DataFrame"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut créer un DataFrame \n",
"\n",
"- à partir d'une matrice NumPy (en précisant éventuellement les noms des colonnes et des lignes)\n",
"\n",
"- à partir d'un fichier CSV, Excel, SQL, etc.\n",
"\n",
"- colonne par colonne à partir\n",
" - d'une seule Series \n",
" - d'un dictionnaire de Series ou d'un dictionnaire de listes (chaque élément du dictionnaire est une colonne)\n",
" \n",
"- ligne par ligne à partir\n",
" - d'une liste de Series ou d'une liste de dictionnaires (chaque élément de la liste est une ligne)\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## À partir d'un tableau NumPy à deux dimensions"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut aussi créer un DataFrame à partir d'un tableau NumPy à deux dimensions. "
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.521160Z",
"iopub.status.busy": "2026-10-30T13:14:17.520916Z",
"iopub.status.idle": "2026-10-30T13:14:17.534533Z",
"shell.execute_reply": "2026-10-30T13:14:17.533841Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
"États Suisse France USA Chine\n",
"Caractéristiques \n",
"Population 8.516 67.06 328.2 1386.0"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df0.T # transposée, comme en numpy"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### ... à partir d'un dictionnaire de Series `{label_1: serie_1, label_2: serie_2, etc}` ou de listes de valeurs `{label_1: [val_1, val_2, etc], label_2: [val_1, val_2, etc], etc}`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Chaque Series devient une **colonne** du DataFrame.\n",
"\n",
"Les clés du dictionnaire sont les noms des colonnes et les valeurs associées sont les Series ou listes de valeurs pour chaque colonne. \n",
"Les index peuvent être passés ou générés automatiquement. \n",
"Depuis Python 3.7, les dictionnaires conservent l'ordre d'insertion des clés : les colonnes du DataFrame apparaissent donc dans l'ordre où elles ont été écrites dans le dictionnaire."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.626422Z",
"iopub.status.busy": "2026-10-30T13:14:17.626242Z",
"iopub.status.idle": "2026-10-30T13:14:17.632690Z",
"shell.execute_reply": "2026-10-30T13:14:17.632207Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" Population Area\n",
"Suisse 8.516 41285.0\n",
"France 67.060 551695.0\n",
"USA 328.200 NaN\n",
"Chine NaN 9596961.0"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df2bis.T # transposée, comme en numpy"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## À partir d'un fichier : `read_csv`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dans la pratique, on construit rarement un DataFrame à la main : on le **lit depuis un fichier**. Pandas sait lire de très nombreux formats : `read_excel`, `read_json`, `read_sql`, `read_parquet`, `read_html`… : et chacun a sa fonction d'écriture correspondante (`to_excel`, `to_json`, etc.). Nous nous limiterons au format le plus répandu, le **CSV**.\n",
"\n",
"Un fichier **CSV** (*Comma Separated Values*) est un simple fichier texte : une ligne par observation, des champs séparés par un caractère convenu. C'est à la fois son grand avantage : n'importe quel tableur, n'importe quel langage sait le lire : et sa grande faiblesse : **rien n'y est normalisé**, ni le séparateur, ni le marqueur décimal, ni l'encodage. Lire un CSV correctement, c'est donc d'abord regarder à quoi il ressemble.\n",
"\n",
"Fabriquons-en un pour l'exemple :"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.689170Z",
"iopub.status.busy": "2026-10-30T13:14:17.688961Z",
"iopub.status.idle": "2026-10-30T13:14:17.692758Z",
"shell.execute_reply": "2026-10-30T13:14:17.692362Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"'ville;population;superficie;recensement\\nToulon;176 198;42,84;2021-01-01\\nMarseille;873 076;240,62;2021-01-01\\nNice;342 669;71,92;2021-01-01\\nHyères;57 635;132,38;\\nLa Seyne-sur-Mer;65 691;22,02;2021-01-01\\n'"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"contenu = \"\"\"ville;population;superficie;recensement\n",
"Toulon;176 198;42,84;2021-01-01\n",
"Marseille;873 076;240,62;2021-01-01\n",
"Nice;342 669;71,92;2021-01-01\n",
"Hyères;57 635;132,38;\n",
"La Seyne-sur-Mer;65 691;22,02;2021-01-01\n",
"\"\"\"\n",
"\n",
"with open(\"villes_demo.csv\", \"w\", encoding=\"utf-8\") as f:\n",
" f.write(contenu)\n",
"\n",
"display(contenu)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ce petit fichier cumule les habitudes françaises : séparateur `;`, **virgule** décimale, **espace** comme séparateur de milliers, et une date manquante. Voyons ce que donne une lecture naïve."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.694758Z",
"iopub.status.busy": "2026-10-30T13:14:17.694507Z",
"iopub.status.idle": "2026-10-30T13:14:17.701378Z",
"shell.execute_reply": "2026-10-30T13:14:17.700838Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
ville;population;superficie;recensement
\n",
"
\n",
" \n",
" \n",
"
\n",
"
Toulon;176 198;42
\n",
"
84;2021-01-01
\n",
"
\n",
"
\n",
"
Marseille;873 076;240
\n",
"
62;2021-01-01
\n",
"
\n",
"
\n",
"
Nice;342 669;71
\n",
"
92;2021-01-01
\n",
"
\n",
"
\n",
"
Hyères;57 635;132
\n",
"
38;
\n",
"
\n",
"
\n",
"
La Seyne-sur-Mer;65 691;22
\n",
"
02;2021-01-01
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" ville;population;superficie;recensement\n",
"Toulon;176 198;42 84;2021-01-01\n",
"Marseille;873 076;240 62;2021-01-01\n",
"Nice;342 669;71 92;2021-01-01\n",
"Hyères;57 635;132 38;\n",
"La Seyne-sur-Mer;65 691;22 02;2021-01-01"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pd.read_csv(\"villes_demo.csv\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Une seule colonne ! C'est normal : `read_csv` attend par défaut la **virgule** comme séparateur. On le corrige avec `sep` :"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.703096Z",
"iopub.status.busy": "2026-10-30T13:14:17.702932Z",
"iopub.status.idle": "2026-10-30T13:14:17.711012Z",
"shell.execute_reply": "2026-10-30T13:14:17.710520Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
ville
\n",
"
population
\n",
"
superficie
\n",
"
recensement
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
Toulon
\n",
"
176 198
\n",
"
42,84
\n",
"
2021-01-01
\n",
"
\n",
"
\n",
"
1
\n",
"
Marseille
\n",
"
873 076
\n",
"
240,62
\n",
"
2021-01-01
\n",
"
\n",
"
\n",
"
2
\n",
"
Nice
\n",
"
342 669
\n",
"
71,92
\n",
"
2021-01-01
\n",
"
\n",
"
\n",
"
3
\n",
"
Hyères
\n",
"
57 635
\n",
"
132,38
\n",
"
NaN
\n",
"
\n",
"
\n",
"
4
\n",
"
La Seyne-sur-Mer
\n",
"
65 691
\n",
"
22,02
\n",
"
2021-01-01
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" ville population superficie recensement\n",
"0 Toulon 176 198 42,84 2021-01-01\n",
"1 Marseille 873 076 240,62 2021-01-01\n",
"2 Nice 342 669 71,92 2021-01-01\n",
"3 Hyères 57 635 132,38 NaN\n",
"4 La Seyne-sur-Mer 65 691 22,02 2021-01-01"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"ville object\n",
"population object\n",
"superficie object\n",
"recensement object\n",
"dtype: object"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"villes_csv = pd.read_csv(\"villes_demo.csv\", sep=\";\")\n",
"\n",
"display(villes_csv)\n",
"display(villes_csv.dtypes)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Le tableau a la bonne forme, mais regardez les types : `population` et `superficie` sont de type `object`, c'est-à-dire **du texte**. Impossible d'en calculer la moyenne. Deux raisons : l'espace des milliers et la virgule décimale, que pandas ne devine pas. On les déclare :"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.712691Z",
"iopub.status.busy": "2026-10-30T13:14:17.712538Z",
"iopub.status.idle": "2026-10-30T13:14:17.720970Z",
"shell.execute_reply": "2026-10-30T13:14:17.720490Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
ville
\n",
"
population
\n",
"
superficie
\n",
"
recensement
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
Toulon
\n",
"
176198
\n",
"
42.84
\n",
"
2021-01-01
\n",
"
\n",
"
\n",
"
1
\n",
"
Marseille
\n",
"
873076
\n",
"
240.62
\n",
"
2021-01-01
\n",
"
\n",
"
\n",
"
2
\n",
"
Nice
\n",
"
342669
\n",
"
71.92
\n",
"
2021-01-01
\n",
"
\n",
"
\n",
"
3
\n",
"
Hyères
\n",
"
57635
\n",
"
132.38
\n",
"
NaN
\n",
"
\n",
"
\n",
"
4
\n",
"
La Seyne-sur-Mer
\n",
"
65691
\n",
"
22.02
\n",
"
2021-01-01
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" ville population superficie recensement\n",
"0 Toulon 176198 42.84 2021-01-01\n",
"1 Marseille 873076 240.62 2021-01-01\n",
"2 Nice 342669 71.92 2021-01-01\n",
"3 Hyères 57635 132.38 NaN\n",
"4 La Seyne-sur-Mer 65691 22.02 2021-01-01"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"ville object\n",
"population int64\n",
"superficie float64\n",
"recensement object\n",
"dtype: object"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"villes_csv = pd.read_csv(\"villes_demo.csv\", sep=\";\", thousands=\" \", decimal=\",\")\n",
"\n",
"display(villes_csv)\n",
"display(villes_csv.dtypes)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Il reste la colonne `recensement`, toujours lue comme du texte. `parse_dates` la convertit en véritables dates : et la valeur absente devient `NaT` (*Not a Time*), l'équivalent de `NaN` pour les dates :"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.722780Z",
"iopub.status.busy": "2026-10-30T13:14:17.722626Z",
"iopub.status.idle": "2026-10-30T13:14:17.732874Z",
"shell.execute_reply": "2026-10-30T13:14:17.732342Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" population superficie recensement\n",
"ville \n",
"Toulon 176198 42.84 2021-01-01\n",
"Marseille 873076 240.62 2021-01-01\n",
"Nice 342669 71.92 2021-01-01\n",
"Hyères 57635 132.38 NaT\n",
"La Seyne-sur-Mer 65691 22.02 2021-01-01"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"villes_csv = pd.read_csv(\"villes_demo.csv\", sep=\";\", thousands=\" \", decimal=\",\",\n",
" parse_dates=[\"recensement\"], index_col=\"ville\")\n",
"villes_csv"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Les options à connaître\n",
"\n",
"| Option | Rôle |\n",
"|---|---|\n",
"| `sep` | caractère séparant les champs (`,` par défaut, souvent `;` en France) |\n",
"| `decimal` | marqueur décimal (`.` par défaut, `,` en France) |\n",
"| `thousands` | séparateur de milliers à supprimer |\n",
"| `encoding` | `\"utf-8\"` par défaut ; essayez `\"latin-1\"` sur un vieux fichier Windows |\n",
"| `index_col` | colonne à utiliser comme index |\n",
"| `usecols` | liste des colonnes à charger : précieux sur un gros fichier |\n",
"| `na_values` | valeurs à interpréter comme manquantes (`\"N/A\"`, `\"-\"`, `\"inconnu\"`…) |\n",
"| `parse_dates` | colonnes à convertir en dates |\n",
"| `dtype` | forcer le type d'une ou plusieurs colonnes |\n",
"| `nrows` | ne lire que les premières lignes, pour inspecter un gros fichier |\n",
"| `skiprows` | ignorer des lignes d'en-tête parasites |\n",
"| `header` | numéro de la ligne d'en-tête, ou `None` s'il n'y en a pas |"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"**Le réflexe à prendre.** Ouvrez d'abord le fichier dans un éditeur de texte et regardez ses premières lignes ; écrivez l'appel à `read_csv` **ensuite**. Puis vérifiez systématiquement `.dtypes` : une colonne numérique lue comme `object` est de loin le symptôme le plus fréquent d'un mauvais paramétrage, et toutes vos statistiques en dépendent.\n",
"\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Un cas réel : l'espace insécable\n",
"\n",
"Les exports de l'INSEE séparent les milliers par un **espace insécable**, un caractère invisible qui ressemble à une espace mais n'en est pas une (son code Unicode est 160). Vous le rencontrerez dans l'exercice sur la population des communes."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.743544Z",
"iopub.status.busy": "2026-10-30T13:14:17.743389Z",
"iopub.status.idle": "2026-10-30T13:14:17.749921Z",
"shell.execute_reply": "2026-10-30T13:14:17.749425Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"commune object\n",
"population object\n",
"dtype: object"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"valeur brute : `'176\\xa0198'`"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"NBSP = chr(160) # l'espace insécable\n",
"\n",
"with open(\"insee_demo.csv\", \"w\", encoding=\"utf-8\") as f:\n",
" f.write(f\"commune;population\\nToulon;176{NBSP}198\\nNice;342{NBSP}669\\n\")\n",
"\n",
"brut = pd.read_csv(\"insee_demo.csv\", sep=\";\")\n",
"\n",
"display(brut.dtypes)\n",
"display(Markdown(\"valeur brute : `\" + repr(brut[\"population\"][0]) + \"`\")) # le \\xa0 est bien là"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.751681Z",
"iopub.status.busy": "2026-10-30T13:14:17.751525Z",
"iopub.status.idle": "2026-10-30T13:14:17.761591Z",
"shell.execute_reply": "2026-10-30T13:14:17.761108Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"commune object\n",
"population object\n",
"dtype: object"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"commune object\n",
"population int64\n",
"dtype: object"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
commune
\n",
"
population
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
Toulon
\n",
"
176198
\n",
"
\n",
"
\n",
"
1
\n",
"
Nice
\n",
"
342669
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" commune population\n",
"0 Toulon 176198\n",
"1 Nice 342669"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# thousands ne connaît que l'espace ORDINAIRE : il ne règle pas le problème\n",
"display(pd.read_csv(\"insee_demo.csv\", sep=\";\", thousands=\" \").dtypes)\n",
"\n",
"# il faut nettoyer la colonne à la main, puis convertir le type\n",
"propre = pd.read_csv(\"insee_demo.csv\", sep=\";\")\n",
"propre[\"population\"] = propre[\"population\"].str.replace(chr(160), \"\", regex=False).astype(int)\n",
"\n",
"display(propre.dtypes)\n",
"display(propre)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exporter : `to_csv`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"L'écriture suit la même logique, avec les mêmes options :"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.763344Z",
"iopub.status.busy": "2026-10-30T13:14:17.763190Z",
"iopub.status.idle": "2026-10-30T13:14:17.767996Z",
"shell.execute_reply": "2026-10-30T13:14:17.767542Z"
}
},
"outputs": [
{
"data": {
"text/markdown": [
"```\n",
"ville;population;superficie;recensement\n",
"Toulon;176198;42,84;2021-01-01\n",
"Marseille;873076;240,62;2021-01-01\n",
"Nice;342669;71,92;2021-01-01\n",
"Hyères;57635;132,38;\n",
"La Seyne-sur-Mer;65691;22,02;2021-01-01\n",
"\n",
"```"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"villes_csv.to_csv(\"villes_export.csv\", sep=\";\", decimal=\",\", encoding=\"utf-8\")\n",
"\n",
"display(Markdown(\"```\\n\" + open(\"villes_export.csv\", encoding=\"utf-8\").read() + \"\\n```\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Par défaut l'index est écrit dans le fichier. Si c'est une simple numérotation sans signification, on l'omet avec `index=False` :"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.769864Z",
"iopub.status.busy": "2026-10-30T13:14:17.769679Z",
"iopub.status.idle": "2026-10-30T13:14:17.774817Z",
"shell.execute_reply": "2026-10-30T13:14:17.774426Z"
}
},
"outputs": [
{
"data": {
"text/markdown": [
"```\n",
"ville;population;superficie;recensement\n",
"Toulon;176198;42,84;2021-01-01\n",
"Marseille;873076;240,62;2021-01-01\n",
"Nice;342669;71,92;2021-01-01\n",
"Hyères;57635;132,38;\n",
"La Seyne-sur-Mer;65691;22,02;2021-01-01\n",
"\n",
"```"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"villes_csv.reset_index().to_csv(\"villes_export.csv\", sep=\";\", decimal=\",\", index=False)\n",
"\n",
"display(Markdown(\"```\\n\" + open(\"villes_export.csv\", encoding=\"utf-8\").read() + \"\\n```\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Bonus : manipuler des dates"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"**Bonus : hors séance.** Les dates sont omniprésentes dans les jeux de données ouverts ; cette section vous servira dès que vous en rencontrerez.\n",
"\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`parse_dates` convertit les dates **au moment de la lecture**. Quand la colonne a déjà été chargée comme du texte, `pd.to_datetime` fait la conversion après coup.\n",
"\n",
"Une fois la colonne de type `datetime64`, l'accesseur **`.dt`** donne accès à l'année, au mois, au jour de la semaine : exactement comme `.str` donne accès aux méthodes de chaînes."
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.776447Z",
"iopub.status.busy": "2026-10-30T13:14:17.776295Z",
"iopub.status.idle": "2026-10-30T13:14:17.781869Z",
"shell.execute_reply": "2026-10-30T13:14:17.781490Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"dtype('O')"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"dtype('\n",
"\n",
"
"
],
"text/plain": [
" Population Area\n",
"Suisse 8.516 41285\n",
"France 67.060 551695\n",
"USA 328.200 3796742\n",
"Chine 1386.000 9596961"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"display(df1) "
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.817462Z",
"iopub.status.busy": "2026-10-30T13:14:17.817250Z",
"iopub.status.idle": "2026-10-30T13:14:17.822204Z",
"shell.execute_reply": "2026-10-30T13:14:17.821795Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"array([[8.516000e+00, 4.128500e+04],\n",
" [6.706000e+01, 5.516950e+05],\n",
" [3.282000e+02, 3.796742e+06],\n",
" [1.386000e+03, 9.596961e+06]])"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"Index(['Suisse', 'France', 'USA', 'Chine'], dtype='object')"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"Index(['Population', 'Area'], dtype='object')"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"display(df1.values) # tableau numpy à 2 dimensions\n",
"display(df1.index) # objet de type Index\n",
"display(df1.columns) # objet de type Index"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Selectionner une colonne : `df['nom_colonne']` ou `df.nom_colonne`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour séléctionner la colonne `col1` d'un DataFrame on peut utiliser `df.col1`, mais on préfèrera généralement `df[\"col1\"]`. En effet, la première syntaxe ne fonctionne pas si le nom de la colonne contient des espaces ou des caractères spéciaux, ou si le nom de la colonne est identique à une méthode ou un attribut du DataFrame. \n",
"Le résultat est une Series."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.823817Z",
"iopub.status.busy": "2026-10-30T13:14:17.823668Z",
"iopub.status.idle": "2026-10-30T13:14:17.830427Z",
"shell.execute_reply": "2026-10-30T13:14:17.829813Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"Suisse 8.516\n",
"France 67.060\n",
"USA 328.200\n",
"Chine 1386.000\n",
"Name: Population, dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
Population
\n",
"
Area
\n",
"
\n",
" \n",
" \n",
"
\n",
"
Suisse
\n",
"
8.516
\n",
"
41285
\n",
"
\n",
"
\n",
"
France
\n",
"
67.060
\n",
"
551695
\n",
"
\n",
"
\n",
"
USA
\n",
"
328.200
\n",
"
3796742
\n",
"
\n",
"
\n",
"
Chine
\n",
"
1386.000
\n",
"
9596961
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" Population Area\n",
"Suisse 8.516 41285\n",
"France 67.060 551695\n",
"USA 328.200 3796742\n",
"Chine 1386.000 9596961"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# La colonne \"Population\" : c'est une Series\n",
"display(df1[\"Population\"])\n",
"\n",
"# Les colonnes \"Population\" et \"Area\" : c'est un DataFrame\n",
"display(df1[[\"Population\", \"Area\"]])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"**Attention :** \n",
"\n",
"- dans un tableau **numpy** à 2 dimensions, `A[0]` renvoi la première **ligne** du tableau `A`\n",
"- pour un objet **DataFrame**, l'écriture `A[0]` renvoi la première **colonne**. \n",
"\n",
"C'est pourquoi il vaut mieux considérer un objet Dataframe comme un dictionnaire dont les clés sont les labels des colonnes plutôt que comme un tableau NumPy.\n",
"\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Une fois une colonne selectionnée (c'est une série), on peut selecionner un élément :\n"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.832144Z",
"iopub.status.busy": "2026-10-30T13:14:17.831984Z",
"iopub.status.idle": "2026-10-30T13:14:17.836904Z",
"shell.execute_reply": "2026-10-30T13:14:17.836498Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"67.06"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"67.06"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"67.06"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# La valeur de la cellule \"Population\" de la ligne \"France\"\n",
"col1 = \"Population\"\n",
"row1 = \"France\"\n",
"num_row1 = 1\n",
"\n",
"display( df1[col1][row1] )\n",
"# display( df1[col1][num_row1] ) # deprecated\n",
"display( df1[col1].loc[row1] )\n",
"display( df1[col1].iloc[num_row1] )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Puisque les colonnes sont des Series, on peut utiliser les méthodes de Series sur les colonnes d'un DataFrame. En particulier, tout ce que l'on a dit sur le slicing des Series est valable pour les colonnes d'un DataFrame."
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.838548Z",
"iopub.status.busy": "2026-10-30T13:14:17.838391Z",
"iopub.status.idle": "2026-10-30T13:14:17.844476Z",
"shell.execute_reply": "2026-10-30T13:14:17.843989Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"France 67.06\n",
"USA 328.20\n",
"Name: Population, dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"Suisse 8.516\n",
"France 67.060\n",
"USA 328.200\n",
"Chine 1386.000\n",
"Name: Population, dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# SLICING\n",
"# =========\n",
"\n",
"# Slicing sur les lignes: les valeurs de la colonne \"Population\" des lignes de \"France\" à \"USA\" inclus\n",
"display(df1[\"Population\"][\"France\":\"USA\"])\n",
"\n",
"# La colonne \"Population\", toutes les lignes\n",
"display(df1[\"Population\"][:]) # idem que df1[\"Population\"]\n",
"\n",
"# Les valeurs de la ligne France\n",
"# ERROR : on ne peut pas extraire une ligne avec [:] !!!\n",
"# display(df1[:][\"France\"]) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Selectionner une ligne : `loc` et `iloc`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si on veut selectionner une ligne, on utilise \n",
"\n",
"- soit la méthode `.loc[label]` qui utilise les labels et est la méthode recommandée ; \n",
"- soit la méthode `.iloc[indice]` qui utilise les indices de position (de $0$ à $N$ où $N$ est égal à `df.shape[0]`) et qui est deconsillée car les indices peuvent changer si on modifie le DataFrame. \n",
"\n",
"Dans les deux cas, on obtient une Series dont les index sont les noms des colonnes. Ensuite, on pourra utiliser les méthodes de Series pour accéder aux éléments de la ligne.\n",
"\n",
"**NB** Avec `loc` ou `iloc`, on peut accéder à un élément d'un DataFrame avec la syntaxe `df.loc[label_ligne, nom_colonne]` ou `df.iloc[indice_ligne, indice_colonne]` et retrouver ainsi l'ordre d'indexation des lignes et des colonnes de numpy : `.iloc[i,j]` renvoi l'élément de la ligne `i` et de la colonne `j`. "
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.846081Z",
"iopub.status.busy": "2026-10-30T13:14:17.845915Z",
"iopub.status.idle": "2026-10-30T13:14:17.850575Z",
"shell.execute_reply": "2026-10-30T13:14:17.850170Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" Population Area\n",
"France 67.06 551695\n",
"USA 328.20 3796742"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"Suisse 8.516\n",
"France 67.060\n",
"USA 328.200\n",
"Chine 1386.000\n",
"Name: Population, dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"Suisse 8.516\n",
"France 67.060\n",
"USA 328.200\n",
"Chine 1386.000\n",
"Name: Population, dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Selectionner avec .loc (label de ligne)\n",
"# ========================================================\n",
"\n",
"# Une ligne\n",
"display(df1.loc[\"France\"]) # la ligne \"France\"\n",
"\n",
"# Une cellule\n",
"display(df1.loc[\"France\", \"Population\"]) # la valeur de la cellule \"Population\" de la ligne \"France\"\n",
"\n",
"# Un slicing de lignes, une colonne\n",
"display(df1.loc[\"France\":\"USA\", \"Population\"]) # les valeurs de la colonne \"Population\" des lignes de \"France\" à \"USA\" inclus\n",
"\n",
"# Un slicing de lignes, plusieurs colonnes\n",
"display(df1.loc[\"France\":\"USA\", [\"Population\", \"Area\"]]) # les valeurs des colonnes \"Population\" et \"Area\" des lignes de \"France\" à \"USA\" inclus\n",
"\n",
"# Toutes les valeurs d'une colonne\n",
"display(df1.loc[:, \"Population\"]) # toutes les valeurs de la colonne \"Population\", idem que df1[\"Population\"]\n",
"display(df1.iloc[:, 0]) # toutes les valeurs de la colonne \"Population\", idem que df1[\"Population\"]"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.865949Z",
"iopub.status.busy": "2026-10-30T13:14:17.865792Z",
"iopub.status.idle": "2026-10-30T13:14:17.877461Z",
"shell.execute_reply": "2026-10-30T13:14:17.877073Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"Population 67.06\n",
"Area 551695.00\n",
"Name: France, dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"Population 67.06\n",
"Area 551695.00\n",
"Name: France, dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"67.06"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"France 67.06\n",
"USA 328.20\n",
"Name: Population, dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
Population
\n",
"
Area
\n",
"
\n",
" \n",
" \n",
"
\n",
"
France
\n",
"
67.06
\n",
"
551695
\n",
"
\n",
"
\n",
"
USA
\n",
"
328.20
\n",
"
3796742
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" Population Area\n",
"France 67.06 551695\n",
"USA 328.20 3796742"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"Suisse 8.516\n",
"France 67.060\n",
"USA 328.200\n",
"Chine 1386.000\n",
"Name: Population, dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Selectionner avec .iloc (indices de position)\n",
"# ========================================================\n",
"\n",
"# Une ligne\n",
"display(df1.iloc[1]) # la ligne d'indice 1, toutes les colonnes\n",
"display(df1.iloc[1,:]) # la ligne d'indice 1, toutes les colonnes\n",
"\n",
"# Une cellule\n",
"display(df1.iloc[1, 0]) # la valeur de la cellule d'indice 1, 0\n",
"\n",
"# Un slicing de lignes, une colonne\n",
"display(df1.iloc[1:3, 0]) # les valeurs de la colonne \"Population\" des lignes d'indice 1 à 3 exclus\n",
"\n",
"# Un slicing de lignes, plusieurs colonnes\n",
"display(df1.iloc[1:3, [0, 1]]) # les valeurs des colonnes \"Population\" et \"Area\" des lignes d'indice 1 à 3 exclus\n",
"\n",
"# Toutes les valeurs d'une colonne\n",
"display(df1.iloc[:, 0]) # toutes les valeurs de la colonne \"Population\" idem que df1[\"Population\"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut alors utiliser les masques de numpy etc."
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.879202Z",
"iopub.status.busy": "2026-10-30T13:14:17.879045Z",
"iopub.status.idle": "2026-10-30T13:14:17.887715Z",
"shell.execute_reply": "2026-10-30T13:14:17.887320Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" Population Area Density\n",
"Suisse 8.516 41285.0 0.000206\n",
"France 67.060 551695.0 0.000122\n",
"USA 328.200 3796742.0 0.000086\n",
"Italie 60.360 301338.0 0.000200"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Supprimons une ligne\n",
"\n",
"df1.drop(labels=[\"Chine\"], inplace=True) # suppression d'une ligne\n",
"display(df1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Aperçu des données"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Créons d'abord un DataFrame un peu plus richement rempli (il pourrait tout aussi bien provenir d'un fichier CSV, comme vu plus haut) :"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.965386Z",
"iopub.status.busy": "2026-10-30T13:14:17.965232Z",
"iopub.status.idle": "2026-10-30T13:14:17.971261Z",
"shell.execute_reply": "2026-10-30T13:14:17.970768Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
2
\n",
"
one
\n",
"
B
\n",
"
3
\n",
"
z
\n",
"
\n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y\n",
"2 one B 3 z\n",
"3 two A 4 q\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data = pd.DataFrame( { \"foo\" : [\"one\", \"one\", \"one\", \"two\", \"two\", \"two\"],\n",
" \"bar\" : [\"A\", \"A\", \"B\", \"A\", \"B\", \"B\"],\n",
" \"baz\" : [1, 2, 3, 4, 5, 6], \n",
" \"zoo\" : [\"x\", \"y\", \"z\", \"q\", \"w\", 't'] } )\n",
"\n",
"data"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Afficher les premières/dernières lignes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Un bon réflexe à adopter après la création/l’importation d'un DataFrale, et après toute transformation importante, est de visualiser le jeu de données, ou du moins quelques lignes, afin de vérifier que tout s’est correctement déroulé. Pour cela, il existe deux méthodes principales :\n",
"\n",
"- la méthode `.head()` permettant de sélectionner par défaut les 5 premières lignes du data frame. Il est possible de préciser entre parenthèses le nombre de lignes à afficher ;\n",
"- la méthode `.tail()` permettant de sélectionner par défaut les 5 dernières lignes du data frame. Il est également possible de préciser entre parenthèses le nombre de lignes à afficher.\n",
"\n",
"Il n’est pas possible (par défaut) d’afficher plus de 60 lignes d’un data frame, afin de ne pas surcharger inutilement le notebook. De façon plus globale, chercher à visualiser l’ensemble d’un data frame n’est généralement pas une bonne pratique. Si cela est tout à fait envisageable avec quelques dizaines de lignes, ça devient vite impossible avec plusieurs millions de lignes !\n",
"Si vous cherchez à afficher plus de 60 lignes, vous aurez finalement comme résultat les 5 premières et dernières lignes du data frame."
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.972907Z",
"iopub.status.busy": "2026-10-30T13:14:17.972752Z",
"iopub.status.idle": "2026-10-30T13:14:17.977963Z",
"shell.execute_reply": "2026-10-30T13:14:17.977523Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
2
\n",
"
one
\n",
"
B
\n",
"
3
\n",
"
z
\n",
"
\n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y\n",
"2 one B 3 z\n",
"3 two A 4 q\n",
"4 two B 5 w"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# afficher les 5 premières lignes\n",
"display(data.head())"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.979587Z",
"iopub.status.busy": "2026-10-30T13:14:17.979440Z",
"iopub.status.idle": "2026-10-30T13:14:17.984576Z",
"shell.execute_reply": "2026-10-30T13:14:17.984098Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# afficher les 2 dernières lignes\n",
"display(data.tail(2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Attributs d'un DataFrame"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Combien de lignes comporte le DataFrame ? Et combien de colonnes ? Tout comme avec les arrays NumPy, il est possible de répondre à ces questions via l’attribut `.shape`. Le résultat est un tuple : le premier élément correspond au nombre de lignes, et le second au nombre de colonnes. On peut naturellement stocker le résultat de cet attribut dans une variable pour réutiliser ces éléments ultérieurement."
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.986221Z",
"iopub.status.busy": "2026-10-30T13:14:17.986071Z",
"iopub.status.idle": "2026-10-30T13:14:17.997632Z",
"shell.execute_reply": "2026-10-30T13:14:17.997156Z"
}
},
"outputs": [
{
"data": {
"text/markdown": [
"**`ndim` : nombre de dimensions (2 pour un DataFrame)**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"2"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"**`shape` : (nombre de lignes, nombre de colonnes)**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"(6, 4)"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"**`size` : nombre total d'éléments (lignes * colonnes)**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"24"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"**`axes` : liste des axes (index des lignes, index des colonnes)**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"[RangeIndex(start=0, stop=6, step=1),\n",
" Index(['foo', 'bar', 'baz', 'zoo'], dtype='object')]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"**`index`, `columns`, `values` : accès aux composants du DataFrame**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"RangeIndex(start=0, stop=6, step=1)"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"Index(['foo', 'bar', 'baz', 'zoo'], dtype='object')"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"array([['one', 'A', 1, 'x'],\n",
" ['one', 'A', 2, 'y'],\n",
" ['one', 'B', 3, 'z'],\n",
" ['two', 'A', 4, 'q'],\n",
" ['two', 'B', 5, 'w'],\n",
" ['two', 'B', 6, 't']], dtype=object)"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"display(Markdown(\"**`ndim` : nombre de dimensions (2 pour un DataFrame)**\"))\n",
"display( data.ndim)\n",
"\n",
"display(Markdown(\"**`shape` : (nombre de lignes, nombre de colonnes)**\"))\n",
"display( data.shape )\n",
"\n",
"display(Markdown(\"**`size` : nombre total d'éléments (lignes * colonnes)**\"))\n",
"display( data.size )\n",
"\n",
"display(Markdown(\"**`axes` : liste des axes (index des lignes, index des colonnes)**\"))\n",
"display( data.axes)\n",
"\n",
"display(Markdown(\"**`index`, `columns`, `values` : accès aux composants du DataFrame**\"))\n",
"display( data.index ) \n",
"display( data.columns ) \n",
"display( data.values ) # tableau numpy 2D des valeurs\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut avoir envie de connaître les types de chacune de nos variables (un type par colonne). On peut accéder à cela très simplement à partir de l’attribut `.dtypes`. On obtient un objet Series :les index de cette série sont les étiquettes des colonnes, et les valeurs de cette série sont les types de données. Vous noterez que le type de `foo` est `objet`, alors que nous avons pourtant des chaînes de caractères. C’est une chose à connaître, mais le type objet de Pandas correspond en fait à une colonne de type chaîne de caractères. "
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:17.999276Z",
"iopub.status.busy": "2026-10-30T13:14:17.999127Z",
"iopub.status.idle": "2026-10-30T13:14:18.002863Z",
"shell.execute_reply": "2026-10-30T13:14:18.002395Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"foo object\n",
"bar object\n",
"baz int64\n",
"zoo object\n",
"dtype: object"
]
},
"execution_count": 57,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data.dtypes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Les jeux de données réels sont rarement complets. Les valeurs manquantes sont affichées `NaN` et repérées par la méthode `.isnull()`, qui renvoie un tableau de booléens de même forme que le DataFrame.\n",
"\n",
"Ici, le DataFrame `data` est complet : toutes les cases valent `False`. Nous verrons un peu plus bas, dans la section [Les valeurs manquantes](#les-valeurs-manquantes), comment les compter, les supprimer ou les remplacer."
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.004453Z",
"iopub.status.busy": "2026-10-30T13:14:18.004308Z",
"iopub.status.idle": "2026-10-30T13:14:18.009803Z",
"shell.execute_reply": "2026-10-30T13:14:18.009359Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
False
\n",
"
False
\n",
"
False
\n",
"
False
\n",
"
\n",
"
\n",
"
1
\n",
"
False
\n",
"
False
\n",
"
False
\n",
"
False
\n",
"
\n",
"
\n",
"
2
\n",
"
False
\n",
"
False
\n",
"
False
\n",
"
False
\n",
"
\n",
"
\n",
"
3
\n",
"
False
\n",
"
False
\n",
"
False
\n",
"
False
\n",
"
\n",
"
\n",
"
4
\n",
"
False
\n",
"
False
\n",
"
False
\n",
"
False
\n",
"
\n",
"
\n",
"
5
\n",
"
False
\n",
"
False
\n",
"
False
\n",
"
False
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 False False False False\n",
"1 False False False False\n",
"2 False False False False\n",
"3 False False False False\n",
"4 False False False False\n",
"5 False False False False"
]
},
"execution_count": 58,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data.isnull()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ces informations peuvent être combinées pour obtenir un résumé complet des données avec la méthode `.info()`."
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.011518Z",
"iopub.status.busy": "2026-10-30T13:14:18.011363Z",
"iopub.status.idle": "2026-10-30T13:14:18.017245Z",
"shell.execute_reply": "2026-10-30T13:14:18.016757Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"RangeIndex: 6 entries, 0 to 5\n",
"Data columns (total 4 columns):\n",
" # Column Non-Null Count Dtype \n",
"--- ------ -------------- ----- \n",
" 0 foo 6 non-null object\n",
" 1 bar 6 non-null object\n",
" 2 baz 6 non-null int64 \n",
" 3 zoo 6 non-null object\n",
"dtypes: int64(1), object(3)\n",
"memory usage: 324.0+ bytes\n"
]
}
],
"source": [
"data.info()"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.018914Z",
"iopub.status.busy": "2026-10-30T13:14:18.018760Z",
"iopub.status.idle": "2026-10-30T13:14:18.022071Z",
"shell.execute_reply": "2026-10-30T13:14:18.021665Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"3.5"
]
},
"execution_count": 60,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data['baz'].mean()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Les valeurs manquantes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Les jeux de données réels sont rarement complets. Une valeur manquante peut recouvrir des réalités très différentes : information non collectée, question sans objet pour cet individu, erreur de saisie, perte lors d'un transfert. Pandas les représente toutes de la même façon, par `NaN` (*Not a Number*).\n",
"\n",
"Le DataFrame `data` utilisé jusqu'ici n'en contient aucune. Construisons-en un qui en contient :"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.023664Z",
"iopub.status.busy": "2026-10-30T13:14:18.023516Z",
"iopub.status.idle": "2026-10-30T13:14:18.030401Z",
"shell.execute_reply": "2026-10-30T13:14:18.030016Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
station
\n",
"
temperature
\n",
"
humidite
\n",
"
vent
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
Toulon
\n",
"
18.2
\n",
"
65.0
\n",
"
12.0
\n",
"
\n",
"
\n",
"
1
\n",
"
Nice
\n",
"
NaN
\n",
"
70.0
\n",
"
8.0
\n",
"
\n",
"
\n",
"
2
\n",
"
Marseille
\n",
"
21.0
\n",
"
NaN
\n",
"
15.0
\n",
"
\n",
"
\n",
"
3
\n",
"
Ajaccio
\n",
"
19.5
\n",
"
58.0
\n",
"
NaN
\n",
"
\n",
"
\n",
"
4
\n",
"
Bastia
\n",
"
NaN
\n",
"
62.0
\n",
"
20.0
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" station temperature humidite vent\n",
"0 Toulon 18.2 65.0 12.0\n",
"1 Nice NaN 70.0 8.0\n",
"2 Marseille 21.0 NaN 15.0\n",
"3 Ajaccio 19.5 58.0 NaN\n",
"4 Bastia NaN 62.0 20.0"
]
},
"execution_count": 61,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"releve = pd.DataFrame({\n",
" \"station\" : [\"Toulon\", \"Nice\", \"Marseille\", \"Ajaccio\", \"Bastia\"],\n",
" \"temperature\" : [18.2, np.nan, 21.0, 19.5, np.nan],\n",
" \"humidite\" : [65, 70, np.nan, 58, 62],\n",
" \"vent\" : [12, 8, 15, np.nan, 20] })\n",
"\n",
"releve"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Repérer les valeurs manquantes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`.isnull()` (ou son alias `.isna()`) renvoie un DataFrame de booléens de même forme. Combiné à `.sum()` il donne le **nombre** de valeurs manquantes par colonne ; combiné à `.mean()`, leur **proportion**."
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.032077Z",
"iopub.status.busy": "2026-10-30T13:14:18.031893Z",
"iopub.status.idle": "2026-10-30T13:14:18.045944Z",
"shell.execute_reply": "2026-10-30T13:14:18.045586Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" station temperature humidite vent\n",
"1 Nice NaN 70.0 8.0\n",
"2 Marseille 21.0 NaN 15.0\n",
"3 Ajaccio 19.5 58.0 NaN\n",
"4 Bastia NaN 62.0 20.0"
]
},
"execution_count": 64,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"masque = releve.isnull().any(axis=1) # au moins une valeur manquante sur la ligne\n",
"releve[masque]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"**`NaN` n'est égal à rien, pas même à lui-même.** Un test `== np.nan` renvoie toujours `False`, et ne détecte donc jamais rien. Utilisez toujours `.isnull()` / `.isna()`.\n",
"\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.063690Z",
"iopub.status.busy": "2026-10-30T13:14:18.063530Z",
"iopub.status.idle": "2026-10-30T13:14:18.069746Z",
"shell.execute_reply": "2026-10-30T13:14:18.069235Z"
}
},
"outputs": [
{
"data": {
"text/markdown": [
"np.nan == np.nan : **False**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"0 False\n",
"1 False\n",
"2 False\n",
"3 False\n",
"4 False\n",
"Name: temperature, dtype: bool"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"0 False\n",
"1 True\n",
"2 False\n",
"3 False\n",
"4 True\n",
"Name: temperature, dtype: bool"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"display(Markdown(f\"np.nan == np.nan : **{np.nan == np.nan}**\"))\n",
"\n",
"display(releve[\"temperature\"] == np.nan) # que des False : inutilisable\n",
"display(releve[\"temperature\"].isnull()) # la bonne façon de faire"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Comment les calculs les traitent"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Les fonctions d'agrégation **ignorent** les valeurs manquantes. Ce n'est pas anodin : la moyenne est calculée sur les seules valeurs disponibles, et le dénominateur n'est donc pas celui que vous croyez."
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.071516Z",
"iopub.status.busy": "2026-10-30T13:14:18.071351Z",
"iopub.status.idle": "2026-10-30T13:14:18.076842Z",
"shell.execute_reply": "2026-10-30T13:14:18.076395Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"19.566666666666666"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"58.7"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"3"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"display(releve[\"temperature\"].mean()) # moyenne sur 3 valeurs, pas sur 5\n",
"display(releve[\"temperature\"].sum()) # somme des 3 valeurs présentes\n",
"display(releve[\"temperature\"].count()) # nombre de valeurs NON manquantes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"En revanche, une opération arithmétique **propage** le `NaN` : dès qu'une des deux valeurs manque, le résultat manque."
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.078611Z",
"iopub.status.busy": "2026-10-30T13:14:18.078449Z",
"iopub.status.idle": "2026-10-30T13:14:18.082646Z",
"shell.execute_reply": "2026-10-30T13:14:18.082105Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"0 30.2\n",
"1 NaN\n",
"2 36.0\n",
"3 NaN\n",
"4 NaN\n",
"dtype: float64"
]
},
"execution_count": 67,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"releve[\"temperature\"] + releve[\"vent\"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Supprimer : `dropna`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Par défaut, `.dropna()` supprime toute **ligne** comportant au moins une valeur manquante. Les arguments utiles :\n",
"\n",
"| Argument | Effet |\n",
"|---|---|\n",
"| `axis=1` | supprimer les **colonnes** plutôt que les lignes |\n",
"| `how=\"all\"` | ne supprimer que si **toutes** les valeurs manquent |\n",
"| `subset=[...]` | n'examiner que certaines colonnes |\n",
"| `thresh=n` | conserver les lignes ayant au moins `n` valeurs renseignées |"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.084598Z",
"iopub.status.busy": "2026-10-30T13:14:18.084396Z",
"iopub.status.idle": "2026-10-30T13:14:18.098358Z",
"shell.execute_reply": "2026-10-30T13:14:18.097868Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" station temperature humidite vent\n",
"0 Toulon 18.2 65.0 12.0\n",
"1 Nice 21.0 70.0 8.0\n",
"2 Marseille 21.0 58.0 15.0\n",
"3 Ajaccio 19.5 58.0 20.0\n",
"4 Bastia NaN 62.0 20.0"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"display(releve.ffill()) # forward fill : on reprend la valeur du dessus\n",
"display(releve.bfill()) # backward fill : on reprend la valeur du dessous"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"**Traiter les valeurs manquantes n'est pas un choix technique, c'est un choix méthodologique.**\n",
"\n",
"- **Supprimer** les lignes incomplètes biaise l'échantillon dès que les données ne manquent pas « au hasard » : si les personnes à hauts revenus refusent plus souvent de répondre, les supprimer fait baisser artificiellement le revenu moyen.\n",
"- **Remplacer par la moyenne** préserve cette moyenne, mais écrase la variance et invente des observations qui n'ont jamais été faites.\n",
"\n",
"Il n'existe pas de bonne réponse générique. La seule règle vraiment solide : **regarder combien de lignes sont concernées avant de décider**, puis **dire explicitement ce que vous avez fait et pourquoi**.\n",
"\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"count 6 6 6.000000 6\n",
"unique 2 2 NaN 6\n",
"top one A NaN x\n",
"freq 3 3 NaN 1\n",
"mean NaN NaN 3.500000 NaN\n",
"std NaN NaN 1.870829 NaN\n",
"min NaN NaN 1.000000 NaN\n",
"25% NaN NaN 2.250000 NaN\n",
"50% NaN NaN 3.500000 NaN\n",
"75% NaN NaN 4.750000 NaN\n",
"max NaN NaN 6.000000 NaN"
]
},
"execution_count": 74,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data.describe(include=\"all\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut modifier le type de données d'une colonne avec la méthode `.astype()` et demander à Pandas d'y associer des codes numériques.\n",
"Si on ne veut pas ecraser le DataFrame initial, on peut utiliser la méthode `.copy()`."
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.179857Z",
"iopub.status.busy": "2026-10-30T13:14:18.179704Z",
"iopub.status.idle": "2026-10-30T13:14:18.190489Z",
"shell.execute_reply": "2026-10-30T13:14:18.189895Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
2
\n",
"
one
\n",
"
B
\n",
"
3
\n",
"
z
\n",
"
\n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y\n",
"2 one B 3 z\n",
"3 two A 4 q\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"count 6.000000 6.000000 6.000000 6.000000\n",
"mean 0.500000 0.500000 3.500000 2.500000\n",
"std 0.547723 0.547723 1.870829 1.870829\n",
"min 0.000000 0.000000 1.000000 0.000000\n",
"25% 0.000000 0.000000 2.250000 1.250000\n",
"50% 0.500000 0.500000 3.500000 2.500000\n",
"75% 1.000000 1.000000 4.750000 3.750000\n",
"max 1.000000 1.000000 6.000000 5.000000"
]
},
"execution_count": 77,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data_bis.describe()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Comptage : valeurs uniques, dénombrement de valeurs et appartenance"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Une autre catégorie de méthodes connexes permet d’extraire des informations sur les valeurs contenues dans une série unidimensionnelle. \n",
"Il s'agit des méthodes `.count()`, `.unique()`, `.nunique()` et `.value_counts()`."
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.212639Z",
"iopub.status.busy": "2026-10-30T13:14:18.212483Z",
"iopub.status.idle": "2026-10-30T13:14:18.217578Z",
"shell.execute_reply": "2026-10-30T13:14:18.217092Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
2
\n",
"
one
\n",
"
B
\n",
"
3
\n",
"
z
\n",
"
\n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y\n",
"2 one B 3 z\n",
"3 two A 4 q\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"execution_count": 78,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data"
]
},
{
"cell_type": "code",
"execution_count": 79,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.219302Z",
"iopub.status.busy": "2026-10-30T13:14:18.219151Z",
"iopub.status.idle": "2026-10-30T13:14:18.222366Z",
"shell.execute_reply": "2026-10-30T13:14:18.221931Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 79,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Combien de valuers : ici , on peut également utiliser .size(), puisqu'il n'y a pas de valeurs manquantes \n",
"data['foo'].count()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour déterminer le nombre de valeurs uniques d’une variable, plutôt que chercher à écrire soi-même une fonction, on utilise la méthode `nunique`."
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.224040Z",
"iopub.status.busy": "2026-10-30T13:14:18.223882Z",
"iopub.status.idle": "2026-10-30T13:14:18.227684Z",
"shell.execute_reply": "2026-10-30T13:14:18.227373Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"foo 2\n",
"bar 2\n",
"baz 6\n",
"zoo 6\n",
"dtype: int64"
]
},
"execution_count": 80,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# On affiche combien de valeurs uniques par colonne :\n",
"data.nunique()"
]
},
{
"cell_type": "code",
"execution_count": 81,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.229328Z",
"iopub.status.busy": "2026-10-30T13:14:18.229175Z",
"iopub.status.idle": "2026-10-30T13:14:18.232365Z",
"shell.execute_reply": "2026-10-30T13:14:18.232019Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Valeurs uniques dans la colonne foo :\n",
"['one' 'two']\n",
"\n",
"Valeurs uniques dans la colonne bar :\n",
"['A' 'B']\n",
"\n",
"Valeurs uniques dans la colonne baz :\n",
"[1 2 3 4 5 6]\n",
"\n",
"Valeurs uniques dans la colonne zoo :\n",
"['x' 'y' 'z' 'q' 'w' 't']\n"
]
}
],
"source": [
"# Pour chaque colonne selectionnée, on affiche les valeurs uniques :\n",
"for col in data.columns:\n",
" print((f\"\\nValeurs uniques dans la colonne {col} :\"))\n",
" print(data[col].unique())"
]
},
{
"cell_type": "code",
"execution_count": 82,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.234042Z",
"iopub.status.busy": "2026-10-30T13:14:18.233874Z",
"iopub.status.idle": "2026-10-30T13:14:18.238672Z",
"shell.execute_reply": "2026-10-30T13:14:18.238226Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Valeurs et occurrences dans la colonne foo :\n",
"foo\n",
"one 3\n",
"two 3\n",
"Name: count, dtype: int64\n",
"\n",
"Valeurs et occurrences dans la colonne bar :\n",
"bar\n",
"A 3\n",
"B 3\n",
"Name: count, dtype: int64\n",
"\n",
"Valeurs et occurrences dans la colonne baz :\n",
"baz\n",
"1 1\n",
"2 1\n",
"3 1\n",
"4 1\n",
"5 1\n",
"6 1\n",
"Name: count, dtype: int64\n",
"\n",
"Valeurs et occurrences dans la colonne zoo :\n",
"zoo\n",
"x 1\n",
"y 1\n",
"z 1\n",
"q 1\n",
"w 1\n",
"t 1\n",
"Name: count, dtype: int64\n"
]
}
],
"source": [
"# On peut obtenir ces deux informations en une seule instruction :\n",
"for col in data.columns:\n",
" print((f\"\\nValeurs et occurrences dans la colonne {col} :\"))\n",
" print(data[col].value_counts())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Filtres et opérations "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"L’opération de sélection de lignes s’appelle Filtrer. Elle s’utilise en fonction d’une condition logique, on sélectionne les données sur une condition logique.\n",
"\n",
"Il existe plusieurs méthodes en Pandas. La plus simple est d’utiliser les boolean mask, déjà vus en numpy.\n",
"\n",
"La plupart de ce qu’on a pu voir avec les arrays de NumPy est applicable aux objets Series et DataFrames de Pandas. On peut par exemple effectuer des opérations arithmétiques sur les objets, ou encore appliquer des fonctions mathématiques."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Opérations sur les DataFrames\n",
"\n",
"On peut appliquer des opérations arithmétiques sur les DataFrames, de la même manière que pour les Series. Les opérations sont effectuées élément par élément, en alignant les lignes et les colonnes par leurs étiquettes respectives."
]
},
{
"cell_type": "code",
"execution_count": 83,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.240359Z",
"iopub.status.busy": "2026-10-30T13:14:18.240204Z",
"iopub.status.idle": "2026-10-30T13:14:18.247429Z",
"shell.execute_reply": "2026-10-30T13:14:18.246978Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
Population
\n",
"
Area
\n",
"
Density
\n",
"
NewCol1
\n",
"
NewCol2
\n",
"
\n",
" \n",
" \n",
"
\n",
"
Suisse
\n",
"
8.516
\n",
"
41285.0
\n",
"
0.000206
\n",
"
17.032
\n",
"
0.000206
\n",
"
\n",
"
\n",
"
France
\n",
"
67.060
\n",
"
551695.0
\n",
"
0.000122
\n",
"
134.120
\n",
"
0.000122
\n",
"
\n",
"
\n",
"
USA
\n",
"
328.200
\n",
"
3796742.0
\n",
"
0.000086
\n",
"
656.400
\n",
"
0.000086
\n",
"
\n",
"
\n",
"
Italie
\n",
"
60.360
\n",
"
301338.0
\n",
"
0.000200
\n",
"
120.720
\n",
"
0.000200
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" Population Area Density NewCol1 NewCol2\n",
"Suisse 8.516 41285.0 0.000206 17.032 0.000206\n",
"France 67.060 551695.0 0.000122 134.120 0.000122\n",
"USA 328.200 3796742.0 0.000086 656.400 0.000086\n",
"Italie 60.360 301338.0 0.000200 120.720 0.000200"
]
},
"execution_count": 83,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df1['NewCol1'] = df1['Population'] * 2\n",
"df1['NewCol2'] = df1['Population']/df1['Area']\n",
"df1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Filtrer un DataFrame : masque booléen *vs* `query()`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pandas propose deux façons principales de filtrer un DataFrame : les masques booléens “à la NumPy”, très flexibles, et la méthode `query()`, plus lisible et proche du SQL.\n",
"\n",
"Voici un exemple de DataFrame que nous allons utiliser pour illustrer ces deux approches :"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.249145Z",
"iopub.status.busy": "2026-10-30T13:14:18.248946Z",
"iopub.status.idle": "2026-10-30T13:14:18.254143Z",
"shell.execute_reply": "2026-10-30T13:14:18.253815Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
2
\n",
"
one
\n",
"
B
\n",
"
3
\n",
"
z
\n",
"
\n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y\n",
"2 one B 3 z\n",
"3 two A 4 q\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"execution_count": 84,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Filtre \"à la NumPy\" (masques booléens)\n",
"\n",
"Avec cette méthode, on crée un masque booléen en appliquant une condition logique sur une ou plusieurs colonnes du DataFrame. On utilise ensuite ce masque pour sélectionner les lignes correspondantes.\n",
"\n",
"\n",
"- Avantages\n",
" - Très flexible (méthodes pandas/NumPy, fonctions Python).\n",
" - Compatible avec tous les noms de colonnes.\n",
"- Inconvénients\n",
" - Syntaxe moins intuitive car `& | ~` au lieu de `and or not` et parenthèses obligatoires."
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.255779Z",
"iopub.status.busy": "2026-10-30T13:14:18.255594Z",
"iopub.status.idle": "2026-10-30T13:14:18.259725Z",
"shell.execute_reply": "2026-10-30T13:14:18.259173Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"0 True\n",
"1 True\n",
"2 False\n",
"3 True\n",
"4 False\n",
"5 False\n",
"Name: bar, dtype: bool"
]
},
"execution_count": 85,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mask = data[\"bar\"]==\"A\"\n",
"mask"
]
},
{
"cell_type": "code",
"execution_count": 86,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.261465Z",
"iopub.status.busy": "2026-10-30T13:14:18.261277Z",
"iopub.status.idle": "2026-10-30T13:14:18.266961Z",
"shell.execute_reply": "2026-10-30T13:14:18.266577Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y\n",
"3 two A 4 q"
]
},
"execution_count": 86,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data[mask]"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.268552Z",
"iopub.status.busy": "2026-10-30T13:14:18.268396Z",
"iopub.status.idle": "2026-10-30T13:14:18.274341Z",
"shell.execute_reply": "2026-10-30T13:14:18.273910Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"1 one A 2 y\n",
"3 two A 4 q"
]
},
"execution_count": 87,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# `&` pour le `and` \n",
"# `|` pour le `or` \n",
"# `~` pour le `not` \n",
"# parenthèses obligatoires\n",
"mask = (data[\"bar\"]==\"A\") & (data[\"baz\"]>=2) \n",
"data[mask]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Remarque : dans l'exemple ci-dessous, on utilise la méthode `str.startswith('t')` pour vérifier si les chaînes de caractères de la colonne 'foo' commencent par la lettre 't'. `.str.` est une méthode particulière qui permet de traiter chaque valeur d’une colonne comme un string natif en Python sur lequel appliquer une méthode ultérieure (en l’occurrence `startswith`)."
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.276142Z",
"iopub.status.busy": "2026-10-30T13:14:18.275946Z",
"iopub.status.idle": "2026-10-30T13:14:18.281816Z",
"shell.execute_reply": "2026-10-30T13:14:18.281424Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"3 two A 4 q\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"execution_count": 88,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mask = data['foo'].str.startswith('t')\n",
"data[mask]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Filtre avec `query()`\n",
"\n",
"- Avantages\n",
" - Syntaxe type SQL : plus lisible.\n",
" - Pas de parenthèses autour des conditions.\n",
"- Inconvénients \n",
" - Limitations si noms de colonnes avec espaces ou fonctions Python complexes.\n",
" - Expression passée en chaîne de caractères."
]
},
{
"cell_type": "code",
"execution_count": 89,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.283451Z",
"iopub.status.busy": "2026-10-30T13:14:18.283299Z",
"iopub.status.idle": "2026-10-30T13:14:18.290442Z",
"shell.execute_reply": "2026-10-30T13:14:18.290021Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y\n",
"3 two A 4 q"
]
},
"execution_count": 89,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data.query(\"bar=='A'\")"
]
},
{
"cell_type": "code",
"execution_count": 90,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.292161Z",
"iopub.status.busy": "2026-10-30T13:14:18.291963Z",
"iopub.status.idle": "2026-10-30T13:14:18.299615Z",
"shell.execute_reply": "2026-10-30T13:14:18.299160Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"1 one A 2 y\n",
"3 two A 4 q"
]
},
"execution_count": 90,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data.query(\"bar=='A' & baz>=2\") \n",
"# idem que \n",
"# data[(data[\"bar\"]==\"A\") & (data[\"baz\"]>=2)]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Aggregations"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## `groupby` : analyse par groupes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La méthode `groupby` permet de grouper les données suivant certains critères."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Commençons par un exemple simple :"
]
},
{
"cell_type": "code",
"execution_count": 91,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.301880Z",
"iopub.status.busy": "2026-10-30T13:14:18.301689Z",
"iopub.status.idle": "2026-10-30T13:14:18.312188Z",
"shell.execute_reply": "2026-10-30T13:14:18.311761Z"
}
},
"outputs": [
{
"data": {
"text/markdown": [
"**DataFrame initial**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
key
\n",
"
data
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
A
\n",
"
0
\n",
"
\n",
"
\n",
"
1
\n",
"
B
\n",
"
1
\n",
"
\n",
"
\n",
"
2
\n",
"
C
\n",
"
2
\n",
"
\n",
"
\n",
"
3
\n",
"
A
\n",
"
3
\n",
"
\n",
"
\n",
"
4
\n",
"
B
\n",
"
4
\n",
"
\n",
"
\n",
"
5
\n",
"
C
\n",
"
5
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" key data\n",
"0 A 0\n",
"1 B 1\n",
"2 C 2\n",
"3 A 3\n",
"4 B 4\n",
"5 C 5"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"**GroupBy sum sur la colonne 'key'**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" key data toto\n",
"0 A 0 a\n",
"1 B 1 a\n",
"2 C 2 b\n",
"3 A 3 b\n",
"4 B 4 a\n",
"5 C 5 b"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"**GroupBy sum sur la colonne 'key'**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
data
\n",
"
toto
\n",
"
\n",
"
\n",
"
key
\n",
"
\n",
"
\n",
"
\n",
" \n",
" \n",
"
\n",
"
A
\n",
"
3
\n",
"
ab
\n",
"
\n",
"
\n",
"
B
\n",
"
5
\n",
"
aa
\n",
"
\n",
"
\n",
"
C
\n",
"
7
\n",
"
bb
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" data toto\n",
"key \n",
"A 3 ab\n",
"B 5 aa\n",
"C 7 bb"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"df = pd.DataFrame({'key': ['A', 'B', 'C', 'A', 'B', 'C'],\n",
" 'data': range(6),\n",
" 'toto': ['a','a','b','b','a','b']}, \n",
" columns=['key', 'data', 'toto'])\n",
"\n",
"display(Markdown(\"**DataFrame initial**\"))\n",
"display(df)\n",
"display(Markdown(\"**GroupBy sum sur la colonne 'key'**\"))\n",
"display(df.groupby('key').sum())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"C'est ce que l'on appelle le paradigme « split-apply-combine » (diviser-appliquer-combiner) : d'abord on génère un groupe de DataFrame en fonction de la valeur de la clé spécifiée. À chaque groupe, on applique ensuite une fonction d'agrégation (ici la somme) pour obtenir une seule ligne. Enfin on fusionne les lignes obtenues dans un nouveau DataFrame.\n",
"\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Passons à un exemple plus riche."
]
},
{
"cell_type": "code",
"execution_count": 93,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.326474Z",
"iopub.status.busy": "2026-10-30T13:14:18.326323Z",
"iopub.status.idle": "2026-10-30T13:14:18.332535Z",
"shell.execute_reply": "2026-10-30T13:14:18.332101Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
2
\n",
"
one
\n",
"
B
\n",
"
3
\n",
"
z
\n",
"
\n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y\n",
"2 one B 3 z\n",
"3 two A 4 q\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"execution_count": 93,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data = pd.DataFrame( { \"foo\" : [\"one\", \"one\", \"one\", \"two\", \"two\", \"two\"],\n",
" \"bar\" : [\"A\", \"A\", \"B\", \"A\", \"B\", \"B\"],\n",
" \"baz\" : [1, 2, 3, 4, 5, 6], \n",
" \"zoo\" : [\"x\", \"y\", \"z\", \"q\", \"w\", 't'] } )\n",
"\n",
"data"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On va regrouper les données en fonction de la colonne `foo`. "
]
},
{
"cell_type": "code",
"execution_count": 94,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.334247Z",
"iopub.status.busy": "2026-10-30T13:14:18.334094Z",
"iopub.status.idle": "2026-10-30T13:14:18.337571Z",
"shell.execute_reply": "2026-10-30T13:14:18.337182Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 94,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data_gbfoo = data.groupby(\"foo\")\n",
"data_gbfoo"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On obtient un objet `DataFrameGroupBy`, c'est-à-dire **une sorte de dictionnaire de DatFrame dont les clés sont les valeurs uniques de la colonne `foo` et les valeurs sont les DataFrame correspondant à chaque groupe** :"
]
},
{
"cell_type": "code",
"execution_count": 95,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.339214Z",
"iopub.status.busy": "2026-10-30T13:14:18.339052Z",
"iopub.status.idle": "2026-10-30T13:14:18.349181Z",
"shell.execute_reply": "2026-10-30T13:14:18.348745Z"
}
},
"outputs": [
{
"data": {
"text/markdown": [
"**Nom du groupe : one**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
2
\n",
"
one
\n",
"
B
\n",
"
3
\n",
"
z
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y\n",
"2 one B 3 z"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"**Nom du groupe : two**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"3 two A 4 q\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"for name, group in data_gbfoo:\n",
" display(Markdown(f\"**Nom du groupe : {name}**\"))\n",
" display(group)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut regrouper les données en fonction de plusieurs colonnes. Par exemple, on peut regrouper les données en fonction des colonnes `foo` et `bar` :"
]
},
{
"cell_type": "code",
"execution_count": 96,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.350912Z",
"iopub.status.busy": "2026-10-30T13:14:18.350726Z",
"iopub.status.idle": "2026-10-30T13:14:18.368429Z",
"shell.execute_reply": "2026-10-30T13:14:18.368016Z"
}
},
"outputs": [
{
"data": {
"text/markdown": [
"**Nom du groupe : ('one', 'A')**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"**Nom du groupe : ('one', 'B')**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
2
\n",
"
one
\n",
"
B
\n",
"
3
\n",
"
z
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"2 one B 3 z"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"**Nom du groupe : ('two', 'A')**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"3 two A 4 q"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"**Nom du groupe : ('two', 'B')**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"data_gbfoobar = data.groupby(['foo', 'bar'])\n",
"for name, group in data_gbfoobar:\n",
" display(Markdown(f\"**Nom du groupe : {name}**\"))\n",
" display(group)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut appliquer une même opération sur chaque groupe en même temps. Par exemple, on peut extraire une seule colonne de cet objet, et on obtient un objet `SeriesGroupBy` :"
]
},
{
"cell_type": "code",
"execution_count": 97,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.370215Z",
"iopub.status.busy": "2026-10-30T13:14:18.370047Z",
"iopub.status.idle": "2026-10-30T13:14:18.373557Z",
"shell.execute_reply": "2026-10-30T13:14:18.373091Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 97,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data_gbfoo_baz = data_gbfoo[\"baz\"]\n",
"data_gbfoo_baz"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On obtient ainsi un objet `SeriesGroupBy`, qui est une sorte de dictionnaire de Series. Chaque Series correspond à un groupe."
]
},
{
"cell_type": "code",
"execution_count": 98,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.375349Z",
"iopub.status.busy": "2026-10-30T13:14:18.375201Z",
"iopub.status.idle": "2026-10-30T13:14:18.381709Z",
"shell.execute_reply": "2026-10-30T13:14:18.381234Z"
}
},
"outputs": [
{
"data": {
"text/markdown": [
"**Nom du groupe : one**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"0 1\n",
"1 2\n",
"2 3\n",
"Name: baz, dtype: int64"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"**Nom du groupe : two**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"3 4\n",
"4 5\n",
"5 6\n",
"Name: baz, dtype: int64"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"for name, group in data_gbfoo_baz:\n",
" display(Markdown(f\"**Nom du groupe : {name}**\"))\n",
" display(group)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour ne pas itérer sur les groupes mais juste connaître des informations sur les groupes, on peut utiliser :\n",
"\n",
"- `ngroups` permet de connaître le nombre de groupes obtenus (ici 2 car on a deux valeurs uniques dans la colonne `foo`) \n",
"- `size` combien d'éléments sont dans chaque groupe\n",
"- `groups` les indices des lignes de chaque groupe avec la méthode."
]
},
{
"cell_type": "code",
"execution_count": 99,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.383531Z",
"iopub.status.busy": "2026-10-30T13:14:18.383345Z",
"iopub.status.idle": "2026-10-30T13:14:18.389654Z",
"shell.execute_reply": "2026-10-30T13:14:18.389185Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"foo\n",
"one 3\n",
"two 3\n",
"dtype: int64"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"{'one': [0, 1, 2], 'two': [3, 4, 5]}"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Combien de groupes ?\n",
"nb_groupe = data_gbfoo.ngroups\n",
"display(nb_groupe)\n",
"\n",
"# Combien d'éléments par groupe ?\n",
"nb_element_par_groupe = data_gbfoo.size()\n",
"display(nb_element_par_groupe)\n",
"\n",
"# Quelles sont les indices des lignes de chaque groupe ?\n",
"group_indices = data_gbfoo.groups\n",
"display(group_indices)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"L'object `DataFrameGroupBy` peut être immaginé comme un dictionnaire de DataFrames où chaque clé est un nom de groupe et chaque valeur est le DataFrame correspondant à ce groupe. Cependant, ce c'est pas un vrai dictionnaire, en particulier on ne peut pas accéder aux groupes avec la syntaxe des dictionnaires `data_gbfoo['one']`. \n",
"\n",
"Pour récuperer les dataframes on doit utiliser la méthode `get_group()` :"
]
},
{
"cell_type": "code",
"execution_count": 100,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.391341Z",
"iopub.status.busy": "2026-10-30T13:14:18.391173Z",
"iopub.status.idle": "2026-10-30T13:14:18.400313Z",
"shell.execute_reply": "2026-10-30T13:14:18.399789Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
2
\n",
"
one
\n",
"
B
\n",
"
3
\n",
"
z
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y\n",
"2 one B 3 z"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"3 two A 4 q\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"data_one = data_gbfoo.get_group(\"one\") # les lignes du groupe \"one\" constitue un dataframe\n",
"data_two = data_gbfoo.get_group(\"two\") # les lignes du groupe \"two\" constitue un dataframe\n",
"display(data_one, data_two)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"L'utilisation principale de `groupby` nest pas la simple création de sous-DataFrames. Généralement **on applique des fonctions d'agrégation** sur les groupes obtenus. **On obtient un unique DataFrame** avec une ligne par groupe.\n",
"\n",
"Par exemple, on peut calculer la somme des éléments de chaque groupe (on se rappelle que l'operation \"somme\" entre chaînes de caractères correspond à la concaténation de ces chaînes) :"
]
},
{
"cell_type": "code",
"execution_count": 101,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.402071Z",
"iopub.status.busy": "2026-10-30T13:14:18.401865Z",
"iopub.status.idle": "2026-10-30T13:14:18.407586Z",
"shell.execute_reply": "2026-10-30T13:14:18.407164Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
"
\n",
"
foo
\n",
"
\n",
"
\n",
"
\n",
"
\n",
" \n",
" \n",
"
\n",
"
one
\n",
"
AAB
\n",
"
6
\n",
"
xyz
\n",
"
\n",
"
\n",
"
two
\n",
"
ABB
\n",
"
15
\n",
"
qwt
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" bar baz zoo\n",
"foo \n",
"one AAB 6 xyz\n",
"two ABB 15 qwt"
]
},
"execution_count": 101,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data_gbfoo.sum()"
]
},
{
"cell_type": "code",
"execution_count": 102,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.409465Z",
"iopub.status.busy": "2026-10-30T13:14:18.409275Z",
"iopub.status.idle": "2026-10-30T13:14:18.413378Z",
"shell.execute_reply": "2026-10-30T13:14:18.412885Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"foo\n",
"one 6\n",
"two 15\n",
"Name: baz, dtype: int64"
]
},
"execution_count": 102,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data_gbfoo['baz'].sum()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut aussi **regrouper par plusieurs colonnes**, puis appliquer une fonction d'agrégation.\n",
"\n",
"Exemple : regroupons les données de `data` en utilisant les colonnes `foo` et `bar`, puis calculons la somme de la colonne `baz` pour chaque groupe unique de `foo` et `bar`.\n",
"\n",
"Voici les étapes décomposées :\n",
"\n",
"1. **`data_grfoobar = data.groupby(['foo', 'bar'])`** : regroupe le DataFrame par les colonnes `foo` et `bar`, en obtenant autant de groupes que de couples différents ; \n",
"2. **`data_grfoobar['baz'].sum()`** : calcule la somme de `baz` pour chaque groupe.\n",
"3. Facultatif : **`.unstack()`** qui transforme le résultat en une table pivotée, en déplaçant les valeurs uniques de `bar` en colonnes. Ainsi, pour chaque valeur de `foo`, on obtient les sommes de `baz` réparties par les différentes valeurs de `bar`.\n",
"\n",
"Le résultat est un DataFrame avec les valeurs de `foo` en index et celles de `bar` en colonnes, où chaque cellule contient la somme correspondante de `baz`."
]
},
{
"cell_type": "code",
"execution_count": 103,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.415097Z",
"iopub.status.busy": "2026-10-30T13:14:18.414902Z",
"iopub.status.idle": "2026-10-30T13:14:18.429645Z",
"shell.execute_reply": "2026-10-30T13:14:18.429170Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
2
\n",
"
one
\n",
"
B
\n",
"
3
\n",
"
z
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"2 one B 3 z"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"3 two A 4 q"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# on regroupe les couples (foo, bar) \n",
"data_grfoobar = data.groupby(['foo', 'bar'])\n",
"\n",
"display(data_grfoobar.get_group(('one', 'A'))) # df pour qui foo == 'one' et bar == 'A'\n",
"display(data_grfoobar.get_group(('one', 'B'))) # df pour qui foo == 'one' et bar == 'B'\n",
"display(data_grfoobar.get_group(('two', 'A'))) # df pour qui foo == 'two' et bar == 'A'\n",
"display(data_grfoobar.get_group(('two', 'B'))) # df pour qui foo == 'two' et bar == 'B'\n"
]
},
{
"cell_type": "code",
"execution_count": 104,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.431405Z",
"iopub.status.busy": "2026-10-30T13:14:18.431217Z",
"iopub.status.idle": "2026-10-30T13:14:18.435957Z",
"shell.execute_reply": "2026-10-30T13:14:18.435633Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"foo bar\n",
"one A 3\n",
" B 3\n",
"two A 4\n",
" B 11\n",
"Name: baz, dtype: int64"
]
},
"execution_count": 104,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Pour chaque groupe, on somme les valeurs de la colonne \"baz\"\n",
"data_gbfoobarbaz = data_grfoobar['baz'].sum() \n",
"data_gbfoobarbaz # c'est une Series avec un MultiIndex"
]
},
{
"cell_type": "code",
"execution_count": 105,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.437751Z",
"iopub.status.busy": "2026-10-30T13:14:18.437609Z",
"iopub.status.idle": "2026-10-30T13:14:18.441076Z",
"shell.execute_reply": "2026-10-30T13:14:18.440740Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"MultiIndex([('one', 'A'),\n",
" ('one', 'B'),\n",
" ('two', 'A'),\n",
" ('two', 'B')],\n",
" names=['foo', 'bar'])"
]
},
"execution_count": 105,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data_gbfoobarbaz.index"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Avec `.unstack()`, on peut transformer la Series MultiIndex en DataFrame pour une meilleure lisibilité :"
]
},
{
"cell_type": "code",
"execution_count": 106,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.442611Z",
"iopub.status.busy": "2026-10-30T13:14:18.442465Z",
"iopub.status.idle": "2026-10-30T13:14:18.448293Z",
"shell.execute_reply": "2026-10-30T13:14:18.447783Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
bar
\n",
"
A
\n",
"
B
\n",
"
\n",
"
\n",
"
foo
\n",
"
\n",
"
\n",
"
\n",
" \n",
" \n",
"
\n",
"
one
\n",
"
3
\n",
"
3
\n",
"
\n",
"
\n",
"
two
\n",
"
4
\n",
"
11
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
"bar A B\n",
"foo \n",
"one 3 3\n",
"two 4 11"
]
},
"execution_count": 106,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data_gbfoobarbaz.unstack()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## `pivot_table` : tableaux croisés"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"Le résultat obtenu avec l’instruction : \n",
"\n",
"`data.groupby(['col1', 'col2'])['col3'].sum().unstack()`\n",
"\n",
"est un **tableau croisé dynamique** : à chaque couple `(col1, col2)`, on associe la **somme des valeurs de `col3`**.\n",
"\n",
"Si le DataFrame `data` contient les colonnes `col1`, `col2` et `col3`, on peut imaginer que chaque ligne du DataFrame correspond à un triplet `(x_i, y_i, z_i)`. On peut alors representer cela comme un point en 3D : \n",
"\n",
"- `col1` est la coordonnée `x_i`\n",
"- `col2` est la coordonnée `y_i`\n",
"- `col3` est la coordonnée `z_i`\n",
"\n",
"On peut imaginer que l’on cherche à représenter une fonction de deux variables $z = f(x,y)$, où $x$ et $y$ sont les coordonnées dans le plan horizontal, et $z$ est la hauteur associée à chaque point $(x,y)$. **Problème** : si le couple `(x_i, y_i)` est unique dans le DataFrame, on a un seul point pour cette position. Mais si plusieurs lignes $j$ ont le même couple `(x_i, y_i)` mais des valeurs différentes `(z_i)_j`, cela correspond à plusieurs point empilés verticalement, ce qui ne représente plus une fonction de $\\mathbb R^2$ vers $\\mathbb R$. Dans ce cas, pour obtenir une valeur unique $\\tilde z_i$, il faut **agréger** ces différentes valeurs. C’est là qu’intervient l’agrégation (ici la somme) :\n",
"\n",
"$$\n",
"(x_i, y_i) \\mapsto \\tilde z_i = \\sum_{j} (z_i)_j\n",
"$$\n",
"\n",
"On pourrait également utiliser d’autres fonctions d’agrégation comme `mean`, `max`, `min`, etc.\n",
"\n",
"\n",
"C’est une opération très courante en analyse de données. Pandas propose donc une méthode dédiée : `pivot_table`.\n",
"\n",
"```python\n",
"pivot = data.pivot_table(\n",
" index='col1',\n",
" columns='col2',\n",
" values='col3',\n",
" aggfunc='sum'\n",
")\n",
"```\n",
"\n",
"On applique la méthode `pivot_table` sur le DataFrame `data` en précisant :\n",
"\n",
"* `index` : le nom de la colonne dans de DataFrame qui sera la ligne du nouveau tableau\n",
"* `columns` : le nom de la colonne dans le DataFrame qui sera la colonne du nouveau tableau\n",
"* `values` : le nom de la colonne sur laquelle appliquer l’agrégation\n",
"* `aggfunc` : la fonction d’agrégation (`sum`, `mean`, `count`, `min`, `max`, etc.). Si ce n'est pas spécifié, par défaut on calcule la moyenne (mean) des valeurs.\n",
"\n",
"Avec `pivot_table`, on obtient un résultat équivalent à \n",
"\n",
"`groupby(...).agg(...).unstack()`\n",
"\n",
"mais plus lisible et directement structuré sous forme de tableau croisé.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
""
]
},
{
"cell_type": "code",
"execution_count": 107,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.450090Z",
"iopub.status.busy": "2026-10-30T13:14:18.449900Z",
"iopub.status.idle": "2026-10-30T13:14:18.455219Z",
"shell.execute_reply": "2026-10-30T13:14:18.454864Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
2
\n",
"
one
\n",
"
B
\n",
"
3
\n",
"
z
\n",
"
\n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y\n",
"2 one B 3 z\n",
"3 two A 4 q\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"execution_count": 107,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data"
]
},
{
"cell_type": "code",
"execution_count": 108,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.456899Z",
"iopub.status.busy": "2026-10-30T13:14:18.456722Z",
"iopub.status.idle": "2026-10-30T13:14:18.465861Z",
"shell.execute_reply": "2026-10-30T13:14:18.465446Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
"bar A B All\n",
"foo \n",
"one 3 3 6\n",
"two 4 11 15\n",
"All 7 14 21"
]
},
"execution_count": 109,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data.pivot_table(index='foo', \n",
" columns='bar', \n",
" values='baz', \n",
" aggfunc='sum', \n",
" margins=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## `crosstab` : tableaux croisés"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`crosstab` est une fonction principalement utilisée pour **compter les occurrences ou les fréquences** des combinaisons de valeurs de deux colonnes.\n",
"\n",
"```python\n",
"pd.crosstab(data['col1'], data['col2'])\n",
"```\n",
"\n",
"Cette fonction crée un tableau croisé indipendamment d'un DataFrame, en utilisant deux séries ou colonnes comme entrées :\n",
"\n",
"* `index` : les données stockées dans une séries ou une colonne d'un DataFrame qui sera la ligne du nouveau tableau\n",
"* `columns` : les données stockées dans une séries ou une colonne d'un DataFrame qui sera la colonne du nouveau tableau\n",
"\n",
"Pour chaque combinaison unique de valeurs dans `col1` et `col2`, `crosstab` compte le nombre d'occurrences et remplit le tableau avec ces comptes.\n",
"\n",
"`crosstab` peut également agréger les valeurs d'une colonne supplémentaire, mais la syntaxe est différente de `pivot_table` :\n",
"\n",
"```python\n",
"pd.crosstab(\n",
" index=data['col1'],\n",
" columns=data['col2'],\n",
" values=data['col3'],\n",
" aggfunc=sum\n",
")\n",
"```\n",
"\n",
"* `index` et `columns` : comme précédemment\n",
"* `values` : les données stockées dans une séries ou une colonne d'un DataFrame qui sera la colonne à agréger\n",
"* `aggfunc` : fonction d’agrégation (par défaut `count` pour compter les occurrences, mais on peut utiliser `sum`, `mean`, etc.)\n",
"\n",
"Enfin, `crosstab` propose un argument très pratique, `normalize`, qui permet d'afficher les résultats en pourcentages (par rapport à la somme totale, aux lignes ou aux colonnes) en une seule instruction, sans calcul supplémentaire."
]
},
{
"cell_type": "code",
"execution_count": 110,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.488326Z",
"iopub.status.busy": "2026-10-30T13:14:18.488172Z",
"iopub.status.idle": "2026-10-30T13:14:18.493511Z",
"shell.execute_reply": "2026-10-30T13:14:18.493106Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
foo
\n",
"
bar
\n",
"
baz
\n",
"
zoo
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
one
\n",
"
A
\n",
"
1
\n",
"
x
\n",
"
\n",
"
\n",
"
1
\n",
"
one
\n",
"
A
\n",
"
2
\n",
"
y
\n",
"
\n",
"
\n",
"
2
\n",
"
one
\n",
"
B
\n",
"
3
\n",
"
z
\n",
"
\n",
"
\n",
"
3
\n",
"
two
\n",
"
A
\n",
"
4
\n",
"
q
\n",
"
\n",
"
\n",
"
4
\n",
"
two
\n",
"
B
\n",
"
5
\n",
"
w
\n",
"
\n",
"
\n",
"
5
\n",
"
two
\n",
"
B
\n",
"
6
\n",
"
t
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" foo bar baz zoo\n",
"0 one A 1 x\n",
"1 one A 2 y\n",
"2 one B 3 z\n",
"3 two A 4 q\n",
"4 two B 5 w\n",
"5 two B 6 t"
]
},
"execution_count": 110,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"data"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La commande `pd.crosstab(data['foo'], data['bar'])` crée un tableau croisé (ou \"contingence\") en comptant les occurrences de chaque combinaison unique de valeurs dans les colonnes `foo` et `bar` du DataFrame `data`.\n",
"\n",
"1. **`pd.crosstab(data['foo'], data['bar'])`** : compte le nombre de fois que chaque paire de valeurs (`foo`,`bar`) apparaît dans le DataFrame.\n",
"2. Le résultat est un nouveau DataFrame avec :\n",
" - Les valeurs uniques de `foo` comme index (lignes).\n",
" - Les valeurs uniques de `bar` comme colonnes.\n",
" - Les cellules contiennent le nombre d'occurrences de chaque combinaison `(foo, bar)`."
]
},
{
"cell_type": "code",
"execution_count": 111,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.495767Z",
"iopub.status.busy": "2026-10-30T13:14:18.495537Z",
"iopub.status.idle": "2026-10-30T13:14:18.505148Z",
"shell.execute_reply": "2026-10-30T13:14:18.504770Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
"bar A B\n",
"foo \n",
"one 2 1\n",
"two 1 2"
]
},
"execution_count": 112,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# idem que\n",
"data.pivot_table(values='baz', index='foo', columns='bar', aggfunc='count')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"C'est utile pour obtenir une vue d'ensemble des fréquences d'association entre les deux variables. Pour obtenir les fréquences au lieu des comptes bruts dans un tableau croisé de pandas, on ajoute l'argument `normalize=True`, chaque valeur est alors divisée par le total de toutes les combinaisons. Cela affichera chaque valeur comme une proportion du total, ce qui correspond aux fréquences relatives."
]
},
{
"cell_type": "code",
"execution_count": 113,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.516809Z",
"iopub.status.busy": "2026-10-30T13:14:18.516654Z",
"iopub.status.idle": "2026-10-30T13:14:18.526221Z",
"shell.execute_reply": "2026-10-30T13:14:18.525872Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
bar
\n",
"
A
\n",
"
B
\n",
"
\n",
"
\n",
"
foo
\n",
"
\n",
"
\n",
"
\n",
" \n",
" \n",
"
\n",
"
one
\n",
"
0.333333
\n",
"
0.166667
\n",
"
\n",
"
\n",
"
two
\n",
"
0.166667
\n",
"
0.333333
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
"bar A B\n",
"foo \n",
"one 0.333333 0.166667\n",
"two 0.166667 0.333333"
]
},
"execution_count": 113,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pd.crosstab(data['foo'], data['bar'], normalize=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut aussi normaliser par ligne ou par colonne :\n",
"\n",
"- Par ligne (chaque ligne totalisera 1): `normalize='index'`\n",
"- Par colonne (chaque colonne totalisera 1): `normalize='columns'`"
]
},
{
"cell_type": "code",
"execution_count": 114,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.527831Z",
"iopub.status.busy": "2026-10-30T13:14:18.527679Z",
"iopub.status.idle": "2026-10-30T13:14:18.537253Z",
"shell.execute_reply": "2026-10-30T13:14:18.536912Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
bar
\n",
"
A
\n",
"
B
\n",
"
\n",
"
\n",
"
foo
\n",
"
\n",
"
\n",
"
\n",
" \n",
" \n",
"
\n",
"
one
\n",
"
0.666667
\n",
"
0.333333
\n",
"
\n",
"
\n",
"
two
\n",
"
0.333333
\n",
"
0.666667
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
"bar A B\n",
"foo \n",
"one 0.666667 0.333333\n",
"two 0.333333 0.666667"
]
},
"execution_count": 114,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pd.crosstab(data['foo'], data['bar'], normalize='index')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Bonus : `melt`, du format large au format long"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"**Bonus : hors séance.** Cette section n'est pas nécessaire pour la suite du cours, mais elle vous servira dès que vous voudrez tracer des données groupées avec Seaborn ou Plotly.\n",
"\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`pivot_table` transforme un tableau **long** (une observation par ligne) en tableau **large** (une modalité par colonne). `melt` réalise l'opération **inverse**.\n",
"\n",
"Pourquoi en aurait-on besoin ? Parce que Seaborn et Plotly attendent presque toujours le format **long** : une colonne qui dit *de quelle variable il s'agit*, une colonne qui dit *quelle en est la valeur*."
]
},
{
"cell_type": "code",
"execution_count": 115,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:18.538870Z",
"iopub.status.busy": "2026-10-30T13:14:18.538719Z",
"iopub.status.idle": "2026-10-30T13:14:18.544055Z",
"shell.execute_reply": "2026-10-30T13:14:18.543690Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
"matiere algebre analyse\n",
"etudiant \n",
"Alice 12.0 14.0\n",
"Bob 15.0 8.0\n",
"Chloé 9.0 16.0"
]
},
"execution_count": 118,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"notes_long.pivot_table(index=\"etudiant\", columns=\"matiere\", values=\"note\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Arithmétique et alignement des données : différences avec `Numpy`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Il existe une différence très importante : lorsque vous faites une opération entre deux objets Series, **l’opération se fait terme à terme, mais les termes sont identifiés par leur index.** Si les index ne correspondent pas, le résultat sera un objet Series avec un index qui est l’union des deux index initiaux. Les valeurs correspondant à des index qui n’étaient pas présents dans les deux objets initiaux seront des valeurs manquantes, notées `NaN` (pour Not a Number)."
]
},
{
"cell_type": "code",
"execution_count": 119,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:19.384832Z",
"iopub.status.busy": "2026-10-30T13:14:19.384642Z",
"iopub.status.idle": "2026-10-30T13:14:19.392532Z",
"shell.execute_reply": "2026-10-30T13:14:19.392036Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"A -0.405428\n",
"B -0.741871\n",
"C -0.080453\n",
"D 0.626063\n",
"E -1.865330\n",
"dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"A 0.286204\n",
"B 0.812590\n",
"C 0.220832\n",
"F -0.737247\n",
"dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"A -0.119224\n",
"B 0.070718\n",
"C 0.140379\n",
"D NaN\n",
"E NaN\n",
"F NaN\n",
"dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"ma_serie4 = pd.Series( np.random.randn(5), index=[\"A\",\"B\",\"C\",\"D\",\"E\"] )\n",
"display(ma_serie4)\n",
"ma_serie5 = pd.Series( np.random.randn(4), index=[\"A\",\"B\",\"C\",\"F\"] )\n",
"display(ma_serie5)\n",
"ma_serie_somme = ma_serie4 + ma_serie5\n",
"display(ma_serie_somme)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On voit ici que les deux Series ont en commun A, B et C. La somme donne bien une valeur qui est la somme des deux objets Series. Pour D, E et F, on obtient une valeur manquante car l’un des deux objets Series ne comprend pas d’index D, E ou F. On a donc la somme d’une valeur manquante et d’une valeur présente qui logiquement donne une valeur manquante. Si vous voulez faire une somme en supposant que les données manquantes sont équivalentes à 0, il faut utiliser : `s1.add(s2, fill_value=0)`:"
]
},
{
"cell_type": "code",
"execution_count": 120,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:19.394311Z",
"iopub.status.busy": "2026-10-30T13:14:19.394122Z",
"iopub.status.idle": "2026-10-30T13:14:19.398529Z",
"shell.execute_reply": "2026-10-30T13:14:19.398183Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"A -0.119224\n",
"B 0.070718\n",
"C 0.140379\n",
"D 0.626063\n",
"E -1.865330\n",
"F -0.737247\n",
"dtype: float64"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"ma_serie_somme_BIS = ma_serie4.add(ma_serie5, fill_value=0)\n",
"display(ma_serie_somme_BIS)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## L’indexation des DataFrames\n",
"\n",
"Vous pouvez avoir besoin de modifier les index de vos données. Pour cela, différentes options s’offrent à vous :"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `.reindex()` permet de sélectionner des colonnes et de réordonner les colonnes et les lignes. Si une colonne ou une ligne n’est pas présente dans le DataFrame initial, elle sera ajoutée avec des valeurs manquantes."
]
},
{
"cell_type": "code",
"execution_count": 121,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:19.400286Z",
"iopub.status.busy": "2026-10-30T13:14:19.400098Z",
"iopub.status.idle": "2026-10-30T13:14:19.405804Z",
"shell.execute_reply": "2026-10-30T13:14:19.405339Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"**Bonus : hors séance,** mais très utile en pratique : `groupby` produit constamment des index qu'il faut ensuite remettre en colonnes.\n",
"\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- `.set_index(\"col\")` promeut une **colonne** au rang d'index ;\n",
"- `.reset_index()` fait l'inverse : il remet l'index **dans une colonne** et renumérote les lignes."
]
},
{
"cell_type": "code",
"execution_count": 126,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:19.436425Z",
"iopub.status.busy": "2026-10-30T13:14:19.436237Z",
"iopub.status.idle": "2026-10-30T13:14:19.444724Z",
"shell.execute_reply": "2026-10-30T13:14:19.444227Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" ville dep population\n",
"0 Nice 06 342669\n",
"1 Marseille 13 873076"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"filtre = villes[ villes[\"population\"] > 200_000 ]\n",
"\n",
"display(filtre) # les index 1 et 2 d'origine ont été conservés\n",
"display(filtre.reset_index(drop=True)) # renumérotation de 0 à n-1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Copie *vs* vue"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Lorsqu'on crée un objet à partir d'un autre : `df2 = df1`, `df2 = df1[[\"col\"]]`, ou un DataFrame construit sur un tableau NumPy : pandas ne duplique pas systématiquement les données. Tantôt vous obtenez une **copie** indépendante, tantôt une **vue** qui partage la même zone mémoire que l'original : modifier l'une modifie alors l'autre, parfois à votre insu."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"**La règle à retenir.** Si vous voulez un objet réellement indépendant de l'original, dites-le explicitement :\n",
"\n",
"```python\n",
"df2 = df1.copy()\n",
"```\n",
"\n",
"
"
],
"text/plain": [
" 0 1\n",
"0 0 1\n",
"1 2 22\n",
"2 4 5"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"array([[ 0, 1],\n",
" [ 2, 22],\n",
" [ 4, 5]])"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"arr1 = np.arange(6).reshape(3, 2)\n",
"df1 = pd.DataFrame(arr1)\n",
"\n",
"print(\"Avant modification\")\n",
"display(arr1)\n",
"display(df1)\n",
"\n",
"df1.iloc[1, 1] = 22\n",
"\n",
"print(\"Après modification d'une valeur du DataFrame\")\n",
"display(df1)\n",
"display(arr1) # ici, l'array a été modifié lui aussi"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Le même phénomène explique l'avertissement `SettingWithCopyWarning`, que vous rencontrerez tôt ou tard : pandas vous prévient qu'il ne sait pas si l'objet que vous modifiez est une vue ou une copie, et donc si votre modification atteindra l'original ou se perdra."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Ce qui change avec le *Copy-on-Write*"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Depuis pandas 2.0, un mode appelé **Copy-on-Write** (CoW) est disponible ; il devient le comportement **par défaut à partir de pandas 3.0**. Sa règle est simple et uniforme : *toute opération se comporte comme si elle renvoyait une copie*. Le partage de mémoire continue d'exister en interne, pour la performance, mais il n'est plus jamais observable : et l'avertissement `SettingWithCopyWarning` disparaît.\n",
"\n",
"Activons-le le temps d'une démonstration, avec `pd.option_context` qui restaure automatiquement le réglage à la sortie du bloc :"
]
},
{
"cell_type": "code",
"execution_count": 132,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:19.492573Z",
"iopub.status.busy": "2026-10-30T13:14:19.492383Z",
"iopub.status.idle": "2026-10-30T13:14:19.499592Z",
"shell.execute_reply": "2026-10-30T13:14:19.499133Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
0
\n",
"
1
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
0
\n",
"
1
\n",
"
\n",
"
\n",
"
1
\n",
"
2
\n",
"
22
\n",
"
\n",
"
\n",
"
2
\n",
"
4
\n",
"
5
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" 0 1\n",
"0 0 1\n",
"1 2 22\n",
"2 4 5"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"array([[0, 1],\n",
" [2, 3],\n",
" [4, 5]])"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"Copy-on-Write actif en dehors du bloc ? **False**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"with pd.option_context(\"mode.copy_on_write\", True):\n",
"\n",
" arr2 = np.arange(6).reshape(3, 2)\n",
" df2 = pd.DataFrame(arr2)\n",
" df2.iloc[1, 1] = 22\n",
"\n",
" display(df2) # le DataFrame est bien modifié\n",
" display(arr2) # ici, en revanche, l'array n'est PLUS modifié\n",
"\n",
"display(Markdown(f\"Copy-on-Write actif en dehors du bloc ? **{pd.options.mode.copy_on_write}**\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"| | pandas 2.x (comportement actuel) | Copy-on-Write (défaut en pandas 3.0) |\n",
"|---|---|---|\n",
"| Modification « à distance » | possible, et silencieuse | impossible |\n",
"| `SettingWithCopyWarning` | fréquent | n'existe plus |\n",
"| Rôle de `.copy()` | **indispensable** pour s'isoler | explicite votre intention |\n",
"\n",
"Dans les deux cas, la règle du début de section reste la bonne : **si vous voulez une copie, écrivez `.copy()`.**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Combiner des tables"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Jusqu'ici nous avons travaillé sur un seul DataFrame. En pratique, l'information est presque toujours répartie dans **plusieurs tables** qu'il faut rapprocher. Deux situations, très différentes, se présentent.\n",
"\n",
"- **Empiler** des tables qui décrivent *les mêmes variables* pour *des individus différents* : les ventes de janvier et celles de février, les étudiants du groupe A et ceux du groupe B. C'est le rôle de `pd.concat`.\n",
"- **Joindre** des tables qui décrivent *des variables différentes* pour *les mêmes individus*, en s'appuyant sur une colonne commune appelée **clé** : une table des communes et une table des départements, reliées par le code du département. C'est le rôle de `pd.merge`.\n",
"\n",
"Retenez la distinction : **empiler ajoute des lignes, joindre ajoute des colonnes.**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Empiler des tables : `pd.concat`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`pd.concat` prend une **liste** de DataFrame et les empile. Par défaut l'empilement est vertical (`axis=0`) : les lignes du second viennent sous celles du premier, et les colonnes sont appariées **par leur nom**."
]
},
{
"cell_type": "code",
"execution_count": 133,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:19.501433Z",
"iopub.status.busy": "2026-10-30T13:14:19.501245Z",
"iopub.status.idle": "2026-10-30T13:14:19.508964Z",
"shell.execute_reply": "2026-10-30T13:14:19.508580Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"**Attention :** `pd.concat(..., axis=1)` apparie les lignes **par leur index**, et non par leur ordre d'apparition. Si les index ne coïncident pas, vous obtiendrez des `NaN` sans le moindre message d'erreur.\n",
"\n",
"
"
],
"text/plain": [
" prix stock\n",
"stylo 1.2 300.0\n",
"cahier 2.5 NaN\n",
"gomme 0.6 NaN\n",
"règle NaN 150.0"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"stock_desordre = pd.DataFrame({ \"stock\" : [80, 300, 150] }, index=[\"gomme\", \"stylo\", \"cahier\"])\n",
"\n",
"# L'ordre des lignes diffère, mais l'appariement se fait sur l'index : le résultat est correct\n",
"display(pd.concat([prix, stock_desordre], axis=1))\n",
"\n",
"stock_partiel = pd.DataFrame({ \"stock\" : [300, 150] }, index=[\"stylo\", \"règle\"])\n",
"\n",
"# Ici \"cahier\" et \"gomme\" n'ont pas de stock, \"règle\" n'a pas de prix : des NaN apparaissent\n",
"display(pd.concat([prix, stock_partiel], axis=1))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Joindre deux tables : `pd.merge`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Changeons de situation. Nous disposons maintenant de deux tables qui décrivent **des choses différentes** :\n",
"\n",
"- une table des **communes**, avec leur population et le code de leur département ;\n",
"- une table des **départements**, qui donne le nom du département et sa région.\n",
"\n",
"La colonne `dep` est présente dans les deux : c'est la **clé** de la jointure."
]
},
{
"cell_type": "code",
"execution_count": 140,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:19.558671Z",
"iopub.status.busy": "2026-10-30T13:14:19.558521Z",
"iopub.status.idle": "2026-10-30T13:14:19.567373Z",
"shell.execute_reply": "2026-10-30T13:14:19.566956Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" commune dep population nom_departement region\n",
"0 Toulon 83 176198 Var PACA\n",
"1 Hyères 83 57635 Var PACA\n",
"2 Nice 06 342669 Alpes-Maritimes PACA\n",
"3 Marseille 13 873076 Bouches-du-Rhône PACA\n",
"4 Lyon 69 522250 Rhône Auvergne-Rhône-Alpes"
]
},
"execution_count": 141,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pd.merge(communes, departements, on=\"dep\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Que s'est-il passé ? Pour **chaque ligne** de la table de gauche, pandas a cherché dans la table de droite les lignes ayant la **même valeur de clé**, puis a recollé les colonnes. La table des départements comptait 4 lignes, celle des communes 5 ; le résultat en compte 5, car plusieurs communes partagent le même département.\n",
"\n",
"On peut écrire indifféremment `pd.merge(communes, departements, on=\"dep\")` ou `communes.merge(departements, on=\"dep\")`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Les quatre types de jointure : l'argument `how`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Que faire des lignes qui **n'ont aucune correspondance** dans l'autre table ? C'est tout l'objet de l'argument `how` :\n",
"\n",
"| `how` | Lignes conservées | Équivalent SQL |\n",
"|---|---|---|\n",
"| `\"inner\"` *(défaut)* | seulement les clés présentes **dans les deux** tables | `INNER JOIN` |\n",
"| `\"left\"` | **toutes** celles de la table de gauche | `LEFT JOIN` |\n",
"| `\"right\"` | **toutes** celles de la table de droite | `RIGHT JOIN` |\n",
"| `\"outer\"` | **toutes**, des deux côtés | `FULL OUTER JOIN` |\n",
"\n",
"Les colonnes sans correspondance sont remplies par des `NaN`."
]
},
{
"cell_type": "code",
"execution_count": 142,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:19.578668Z",
"iopub.status.busy": "2026-10-30T13:14:19.578472Z",
"iopub.status.idle": "2026-10-30T13:14:19.587604Z",
"shell.execute_reply": "2026-10-30T13:14:19.587227Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" commune dep population nom_departement region\n",
"0 Nice 06 342669.0 Alpes-Maritimes PACA\n",
"1 Marseille 13 873076.0 Bouches-du-Rhône PACA\n",
"2 Lyon 69 522250.0 Rhône Auvergne-Rhône-Alpes\n",
"3 Toulon 83 176198.0 Var PACA\n",
"4 Hyères 83 57635.0 Var PACA\n",
"5 NaN 75 NaN Paris Île-de-France"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"**`how = \"outer\"`**"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
commune
\n",
"
dep
\n",
"
population
\n",
"
nom_departement
\n",
"
region
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
Toulon
\n",
"
83
\n",
"
176198.0
\n",
"
Var
\n",
"
PACA
\n",
"
\n",
"
\n",
"
1
\n",
"
Hyères
\n",
"
83
\n",
"
57635.0
\n",
"
Var
\n",
"
PACA
\n",
"
\n",
"
\n",
"
2
\n",
"
Nice
\n",
"
06
\n",
"
342669.0
\n",
"
Alpes-Maritimes
\n",
"
PACA
\n",
"
\n",
"
\n",
"
3
\n",
"
Marseille
\n",
"
13
\n",
"
873076.0
\n",
"
Bouches-du-Rhône
\n",
"
PACA
\n",
"
\n",
"
\n",
"
4
\n",
"
Lyon
\n",
"
69
\n",
"
522250.0
\n",
"
Rhône
\n",
"
Auvergne-Rhône-Alpes
\n",
"
\n",
"
\n",
"
5
\n",
"
Ajaccio
\n",
"
2A
\n",
"
71361.0
\n",
"
NaN
\n",
"
NaN
\n",
"
\n",
"
\n",
"
6
\n",
"
NaN
\n",
"
75
\n",
"
NaN
\n",
"
Paris
\n",
"
Île-de-France
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" commune dep population nom_departement region\n",
"0 Toulon 83 176198.0 Var PACA\n",
"1 Hyères 83 57635.0 Var PACA\n",
"2 Nice 06 342669.0 Alpes-Maritimes PACA\n",
"3 Marseille 13 873076.0 Bouches-du-Rhône PACA\n",
"4 Lyon 69 522250.0 Rhône Auvergne-Rhône-Alpes\n",
"5 Ajaccio 2A 71361.0 NaN NaN\n",
"6 NaN 75 NaN Paris Île-de-France"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"for methode in [\"inner\", \"left\", \"right\", \"outer\"]:\n",
" display(Markdown(f\"**`how = \\\"{methode}\\\"`**\"))\n",
" display(pd.merge(communes2, departements2, on=\"dep\", how=methode))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Comparez attentivement ces quatre tableaux :\n",
"\n",
"- `inner` **supprime silencieusement** Ajaccio (département inconnu) *et* Paris (aucune commune) ;\n",
"- `left` conserve Ajaccio, avec `NaN` pour le nom du département et la région ;\n",
"- `right` conserve Paris, avec `NaN` pour la commune et la population ;\n",
"- `outer` conserve les deux.\n",
"\n",
"Le choix n'est pas anodin : `inner`, la valeur **par défaut**, est précisément celle qui perd des données sans prévenir."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Quand les colonnes clés n'ont pas le même nom"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Les deux tables ne nomment pas toujours la clé de la même façon. On précise alors `left_on` et `right_on` :"
]
},
{
"cell_type": "code",
"execution_count": 144,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:19.616419Z",
"iopub.status.busy": "2026-10-30T13:14:19.616264Z",
"iopub.status.idle": "2026-10-30T13:14:19.623723Z",
"shell.execute_reply": "2026-10-30T13:14:19.623301Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" commune dep population nom_departement region\n",
"0 Toulon 83 176198 Var PACA\n",
"1 Hyères 83 57635 Var PACA\n",
"2 Nice 06 342669 Alpes-Maritimes PACA\n",
"3 Marseille 13 873076 Bouches-du-Rhône PACA\n",
"4 Lyon 69 522250 Rhône Auvergne-Rhône-Alpes"
]
},
"execution_count": 145,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pd.merge(communes, departements_bis,\n",
" left_on=\"dep\", right_on=\"code_departement\").drop(columns=\"code_departement\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Vérifier une jointure"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Une jointure **réussit toujours** : y compris quand elle ne fait pas ce que vous croyez. Deux réflexes :\n",
"\n",
"1. comparer le **nombre de lignes** avant et après ;\n",
"2. utiliser `indicator=True`, qui ajoute une colonne `_merge` indiquant l'origine de chaque ligne."
]
},
{
"cell_type": "code",
"execution_count": 146,
"metadata": {
"execution": {
"iopub.execute_input": "2026-10-30T13:14:19.634213Z",
"iopub.status.busy": "2026-10-30T13:14:19.634018Z",
"iopub.status.idle": "2026-10-30T13:14:19.648781Z",
"shell.execute_reply": "2026-10-30T13:14:19.648246Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
commune
\n",
"
dep
\n",
"
population
\n",
"
nom_departement
\n",
"
region
\n",
"
_merge
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
Toulon
\n",
"
83
\n",
"
176198.0
\n",
"
Var
\n",
"
PACA
\n",
"
both
\n",
"
\n",
"
\n",
"
1
\n",
"
Hyères
\n",
"
83
\n",
"
57635.0
\n",
"
Var
\n",
"
PACA
\n",
"
both
\n",
"
\n",
"
\n",
"
2
\n",
"
Nice
\n",
"
06
\n",
"
342669.0
\n",
"
Alpes-Maritimes
\n",
"
PACA
\n",
"
both
\n",
"
\n",
"
\n",
"
3
\n",
"
Marseille
\n",
"
13
\n",
"
873076.0
\n",
"
Bouches-du-Rhône
\n",
"
PACA
\n",
"
both
\n",
"
\n",
"
\n",
"
4
\n",
"
Lyon
\n",
"
69
\n",
"
522250.0
\n",
"
Rhône
\n",
"
Auvergne-Rhône-Alpes
\n",
"
both
\n",
"
\n",
"
\n",
"
5
\n",
"
Ajaccio
\n",
"
2A
\n",
"
71361.0
\n",
"
NaN
\n",
"
NaN
\n",
"
left_only
\n",
"
\n",
"
\n",
"
6
\n",
"
NaN
\n",
"
75
\n",
"
NaN
\n",
"
Paris
\n",
"
Île-de-France
\n",
"
right_only
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" commune dep population nom_departement region \\\n",
"0 Toulon 83 176198.0 Var PACA \n",
"1 Hyères 83 57635.0 Var PACA \n",
"2 Nice 06 342669.0 Alpes-Maritimes PACA \n",
"3 Marseille 13 873076.0 Bouches-du-Rhône PACA \n",
"4 Lyon 69 522250.0 Rhône Auvergne-Rhône-Alpes \n",
"5 Ajaccio 2A 71361.0 NaN NaN \n",
"6 NaN 75 NaN Paris Île-de-France \n",
"\n",
" _merge \n",
"0 both \n",
"1 both \n",
"2 both \n",
"3 both \n",
"4 both \n",
"5 left_only \n",
"6 right_only "
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"_merge\n",
"both 5\n",
"left_only 1\n",
"right_only 1\n",
"Name: count, dtype: int64"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"resultat = pd.merge(communes2, departements2, on=\"dep\", how=\"outer\", indicator=True)\n",
"\n",
"display(resultat)\n",
"display(resultat[\"_merge\"].value_counts())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"**Les deux pièges classiques de `merge`**\n",
"\n",
"1. **Des lignes disparaissent.** Avec `how=\"inner\"` (le défaut), toute clé absente d'un côté fait disparaître la ligne, sans message. Vérifiez systématiquement le nombre de lignes avant et après.\n",
"2. **Des lignes se dupliquent.** Si la clé n'est **pas unique** dans la table de droite, chaque ligne de gauche est répétée autant de fois qu'il y a de correspondances : et tous les totaux calculés ensuite sont faux.\n",
"\n",
"