Pandas

La bibliothèque pandas permet de manipuler et d’analyser facilement des données, grâce à des outils rapides et efficaces. L’élément principal de pandas s’appelle le DataFrame. On peut imaginer le DataFrame comme un tableau à deux dimensions, similaire à une feuille de calcul Excel, avec des noms de colonnes et des indices de lignes.

Grâce à pandas, on peut faire beaucoup de choses que l’on fait habituellement dans Excel :

• créer des tableaux croisés dynamiques,

• faire des calculs sur des colonnes,

• créer des graphiques,

• regrouper les données selon les valeurs d’une colonne,

• ou encore rassembler plusieurs tableaux comme dans les bases de données (SQL).

Pandas est aussi très pratique pour travailler avec des séries temporelles (des données organisées par dates, par exemple).

À savoir avant de commencer : Pandas fonctionne très souvent avec une autre bibliothèque nommée NumPy. Si tu ne connais pas NumPy, il est conseillé de jeter un œil à son tutoriel avant de commencer.

Mise en place¶

Pour commencer, il faut importer la bibliothèque pandas. On la renomme souvent pd pour aller plus vite :

Les objets Series¶

La bibliothèque pandas propose plusieurs types de structures de données très pratiques :

• Les objets Series : On va en parler tout de suite. Une Series, c’est comme une colonne dans un tableau Excel : une liste de valeurs (une seule dimension), avec un nom de colonne et des étiquettes pour les lignes.

• Les objets DataFrame : C’est un tableau à deux dimensions, donc plusieurs colonnes et plusieurs lignes, comme un tableau Excel complet.

• Les objets Panel : Ce sont comme des dictionnaires de DataFrame. Ils sont très peu utilisés, donc on n’en parle pas ici.

Créer une Series¶

Voyons comment créer notre première Series :

Ici, on crée une liste de nombres : 2, -1, 3 et 5. C’est tout ! Tu peux imaginer ça comme une colonne de chiffres dans Excel.

Presque comme un tableau NumPy¶

Les objets Series ressemblent beaucoup aux tableaux de la bibliothèque NumPy (qu’on appelle ndarray). On peut donc souvent utiliser des fonctions NumPy sur une Series :

On peut aussi faire des calculs directement : Quand tu ajoutes des listes ou des nombres, ça s’applique à chaque élément, automatiquement :

Si tu ajoutes un seul nombre, il sera ajouté à tous les éléments : C’est ce qu’on appelle la diffusion (“broadcasting”).

C’est pareil pour toutes les opérations : multiplication, division, ou même des conditions :

Les étiquettes d’index (index labels)¶

Chaque valeur d’une Series a un identifiant unique appelé étiquette d’index. Par défaut, ce sont juste des numéros (0, 1, 2, …). Mais tu peux choisir des étiquettes personnalisées :

Ici, chaque valeur correspond à un nom (par exemple, “Wome”).

Tu peux alors utiliser la Series comme un dictionnaire :

Pour être sûr de ne pas te tromper, il vaut mieux utiliser :

• .loc pour accéder à une valeur par son étiquette

• .iloc pour accéder par son numéro d’ordre

Exemples :

Tu peux aussi “découper” une Series (on appelle ça “slicing”) pour prendre une partie des valeurs. Les étiquettes suivront le découpage :

Mais fais attention quand tu utilises les indices numériques : Regarde cet exemple :

Ici, la première valeur du découpage a pour étiquette “2”, car on a commencé à la troisième valeur de la liste de base.

Si tu essaies d’accéder à surprise_slice[0], tu obtiens une erreur, car il n’y a plus d’étiquette “0” dans cette nouvelle liste :

Mais tu peux toujours accéder aux éléments par leur position avec .iloc :

C’est pour ça qu’il est toujours recommandé d’utiliser .loc et .iloc pour accéder aux valeurs d’une Series.

Créer une Series à partir d’un dictionnaire¶

On peut créer un objet Series directement à partir d’un dictionnaire. Les clés deviendront les étiquettes (index) :

Ici, chaque personne (par exemple, “Brice”) a son poids associé.

On peut aussi choisir quels éléments on veut inclure, et dans quel ordre, en précisant les index souhaités :

Alignement automatique¶

Quand tu fais des opérations avec plusieurs objets Series, pandas aligne automatiquement les éléments en utilisant les étiquettes d’index.

Exemple :

Le résultat va contenir toutes les étiquettes présentes dans au moins une des deux Series. Si une personne est absente dans une Series, le résultat sera “NaN” (c’est-à-dire “Non défini”, “donnée manquante”).

Fais attention : Si les étiquettes n’ont rien à voir, le résultat sera une Series remplie de “NaN” :

Ici, pandas n’a pas pu faire correspondre les index, donc tout est “NaN”.

Initialiser une Series avec un seul nombre¶

On peut aussi créer une Series où toutes les valeurs sont identiques, en utilisant un nombre et une liste d’index :

Ajouter un nom à une Series¶

On peut donner un nom à notre Series pour savoir ce qu’elle représente :

Tracer une Series (créer un graphique)¶

Pandas permet de tracer facilement des graphiques à partir d’une Series. Il suffit d’utiliser matplotlib et d’appeler la méthode plot() :

Il existe plein de façons d’afficher tes données (histogrammes, camemberts, etc.). Pour découvrir toutes les options, regarde la documentation officielle de pandas : Documentation sur la visualisation

Gérer le temps avec pandas¶

Très souvent, les données comportent des dates et heures. Pandas est très pratique pour tout ce qui touche aux séries temporelles :

• gérer les périodes (par exemple : “2023Q3” = troisième trimestre 2023),

• convertir des périodes en dates exactes et inversement,

• regrouper ou “ré-échantillonner” des données (par semaine, par mois, etc.),

• gérer les fuseaux horaires.

Créer une série temporelle¶

On peut facilement créer une liste de dates avec pd.date_range() :

Ici, on crée une suite de 12 heures à partir de 6h du matin le 14 juin 2023.

On peut ensuite utiliser ces dates comme index dans une Series :

Pour voir l’évolution sur un graphique :

Ré-échantillonnage (Resampling)¶

Supposons que tu veuilles résumer ces températures toutes les 2 heures au lieu d’avoir une valeur par heure. On utilise la méthode resample() :

On peut aussi afficher ce résultat :

On aurait aussi pu calculer, par exemple, le minimum pour chaque bloc de 2 heures :

Ou utiliser une fonction personnalisée :

Sur-échantillonnage et interpolation¶

Tout à l’heure, on a vu comment réduire la fréquence des mesures (par exemple, regrouper par 2 heures). Mais on peut aussi augmenter la fréquence (par exemple, passer de toutes les heures à toutes les 15 minutes). Cela crée des « trous » dans les données : il n’y a pas de valeur pour les heures intermédiaires.

Pour remplir les trous, on peut utiliser l’interpolation : pandas va « deviner » les valeurs manquantes. Par défaut, il utilise l’interpolation linéaire (en ligne droite), mais tu peux choisir d’autres méthodes, comme “cubic” (plus lisse) :

On peut afficher les deux séries sur un graphique pour voir la différence :

Les fuseaux horaires¶

Par défaut, les dates et heures dans pandas ne précisent pas le fuseau horaire. Par exemple, “2023-06-14 08:00” peut vouloir dire 8h à Douala ou 8h à Paris. On peut rendre ces dates “conscientes” du fuseau en utilisant tz_localize :

On voit alors le décalage UTC : pour Douala, c’est souvent “+01:00”.

On peut convertir cette série à l’heure de Paris :

Si tu enlèves le fuseau horaire, les heures deviennent à nouveau “ambiguës” :

Si tu essaies de remettre le fuseau, parfois pandas te prévient qu’il y a ambiguïté (comme lors des changements d’heure été/hiver) :

Mais on peut dire à pandas de deviner le bon sens avec ambiguous="infer" :

Les périodes¶

La fonction pd.period_range() permet de créer une liste de périodes (par exemple, les trimestres ou les mois) au lieu de dates précises.

Par exemple, on peut lister tous les trimestres sur 2 ans :

On peut “décaler” toutes les périodes :

Avec asfreq(), on change la “précision” des périodes : Par exemple, transformer chaque trimestre en mois (on « zoome » dans la période) :

On peut aussi demander le premier mois avec how="start" :

Ou encore “dézoomer” pour voir l’année :

On peut créer une Series avec ces périodes : Supposons qu’on ait les revenus trimestriels d’une petite entreprise au Cameroun :

On peut les tracer :

On peut transformer ces périodes en dates précises avec to_timestamp() : (par défaut, ça donne le premier jour de chaque période, mais on peut demander le dernier)

Et on peut revenir à une périodicité avec to_period() :

Pandas propose beaucoup d’autres fonctions liées au temps : Par exemple, pour obtenir le dernier jour ouvré (jour travaillé) de chaque mois à 8h du matin en 2022 :

Les objets DataFrame¶

Un objet DataFrame représente un tableau, un peu comme une feuille Excel :

• Il a des valeurs dans des cases (cellules),

• des noms de colonnes (ex : “poids”, “année de naissance”),

• et des étiquettes de lignes (ex : noms des personnes).

Avec un DataFrame, tu peux facilement faire des calculs, créer des tableaux croisés, grouper les lignes, tracer des graphiques, etc. On peut voir un DataFrame comme un dictionnaire de Series (chaque colonne est une Series).

Créer un DataFrame¶

Pour créer un DataFrame, on peut passer un dictionnaire de Series :

À retenir :

• Les Series sont automatiquement alignées grâce aux noms (Brice, Estelle, etc.).

• Les valeurs manquantes sont indiquées par NaN.

• Le nom de la Series (“année”) est ignoré.

• Dans les notebooks (comme Jupyter), les DataFrame s’affichent très bien.

Tu peux accéder à une colonne simplement comme ceci :

Pour avoir plusieurs colonnes à la fois :

Si tu veux t’assurer que seules certaines colonnes ou lignes existent (dans un certain ordre), tu peux les préciser lors de la création :

Autre manière de créer un DataFrame : En passant une liste de listes ou un tableau NumPy, et en précisant les noms de colonnes et de lignes :

Ici, None indique une valeur manquante.

Tu peux aussi utiliser les “masked arrays” de NumPy pour indiquer des valeurs absentes :

Tu peux créer un DataFrame à partir d’un autre DataFrame :

Ou même à partir d’un dictionnaire de dictionnaires :

Multi-index¶

Si toutes les colonnes sont des tuples de la même taille, pandas comprend qu’il s’agit d’un multi-index (plusieurs niveaux de colonnes/indices). Par exemple :

On peut alors récupérer facilement toutes les colonnes “public” :

Supprimer un niveau¶

On peut supprimer un niveau de colonnes avec droplevel() :

Transposer¶

On peut inverser colonnes et lignes avec .T :

“Stack” et “Unstack”¶

• stack() regroupe les colonnes vers les lignes (on “empile” un niveau de colonne vers l’index).

• unstack() fait l’inverse.

À retenir : La plupart des méthodes pandas (comme stack et unstack) ne modifient pas l’objet original, mais renvoient une nouvelle copie modifiée.

Accéder aux lignes¶

Revenons à notre DataFrame personnes :

Pour accéder à une ligne par son nom (étiquette), utilise loc :

Pour accéder par la position (numéro de la ligne), utilise iloc :

Pour obtenir plusieurs lignes à la fois :

Tu peux aussi utiliser des conditions pour filtrer :

Ajouter et supprimer des colonnes¶

Un DataFrame fonctionne comme un dictionnaire de Series. Voici quelques exemples :

Ajouter une colonne « âge » calculée automatiquement (exemple avec l’année 2024) :

Retirer une colonne et la stocker ailleurs :

Supprimer une colonne simplement :

Ajouter une colonne, même si certains noms sont absents ou en trop : (Les lignes manquantes auront NaN, les lignes en trop sont ignorées.)

Pour insérer une colonne à une position précise (par exemple en 2ème colonne) :

Créer de nouvelles colonnes avec assign¶

On peut créer de nouvelles colonnes sans modifier le DataFrame original :

Attention, tu ne peux pas utiliser une colonne que tu viens tout juste de créer dans la même commande :

Il faut séparer les deux :

Pour éviter les variables intermédiaires, tu peux utiliser des fonctions (lambda) dans assign :

Évaluer une expression¶

Pandas permet aussi d’utiliser la méthode eval pour faire des calculs sur les colonnes, un peu comme dans Excel :

On peut même utiliser des variables Python dans l’expression avec @ :

Explication du symbole @ dans ce code¶

En Python, le symbole @ a différentes significations selon le contexte.

personnes.eval("surpoids = imc > @seuil_surpoids", inplace=True)

Rôle du @ dans pandas.eval() :¶

Ici, @ est utilisé pour référencer une variable Python (seuil_surpoids) à l’intérieur de l’expression évaluée par pandas.eval().

• Sans @, eval() chercherait une colonne appelée seuil_surpoids dans le DataFrame.

• Avec @, eval() comprend qu’il faut utiliser la variable externe seuil_surpoids (qui vaut 28 dans votre exemple).

import pandas as pd

# Exemple de DataFrame
personnes = pd.DataFrame({"imc": [25, 30, 22, 28.5]})

# Variable externe (seuil personnalisé)
seuil_surpoids = 28

# Utilisation de eval() avec @ pour référencer la variable
personnes.eval("surpoids = imc > @seuil_surpoids", inplace=True)

Résultat :¶

Filtrer un DataFrame avec query¶

Pour ne garder que certaines lignes selon une condition :

Trier un DataFrame¶

Pour trier selon l’index (les noms), par ordre décroissant :

Pour modifier le DataFrame directement, on peut ajouter inplace=True, et pour trier les colonnes au lieu des lignes, ajoute axis=1 :

Pour trier selon les valeurs d’une colonne (ex : “age”) :

Tracer un DataFrame¶

Comme pour les Series, tu peux tracer rapidement des courbes :

Créer un nuage de points (scatter plot) avec taille différente pour chaque personne :

Il y a plein d’options, va voir la page visualisation pandas pour tout découvrir !

Opérations sur les DataFrames¶

Même si un DataFrame ne fonctionne pas exactement comme un tableau NumPy, on peut appliquer des fonctions mathématiques à toutes ses valeurs.

Exemple avec des notes d’examen :

Prendre la racine carrée de toutes les notes :

Ajouter 1 point à tout le monde :

Comparer toutes les notes à 10 (True ou False) :

Calculer la moyenne de chaque colonne :

Savoir dans quels mois tout le monde a eu plus de 10 :

Savoir qui a eu au moins une note de 15 :

On peut aussi soustraire la moyenne de chaque colonne à chaque note :

Si tu veux soustraire la moyenne globale :

Alignement automatique¶

Quand tu fais des opérations avec plusieurs DataFrames, pandas aligne automatiquement les noms de lignes et de colonnes. Par exemple, pour ajouter un tableau de bonus aux notes :

Certaines cases sont vides (NaN) car il n’y avait pas la même personne ou le même mois dans les deux tableaux.

Gérer les valeurs manquantes¶

Dans la vie réelle, il manque souvent des données. Avec pandas, tu peux remplacer toutes les valeurs manquantes (NaN) par la valeur de ton choix avec fillna :

Gérer les valeurs manquantes de façon équitable¶

C’est un peu injuste de remplacer toutes les notes manquantes par zéro ! Imaginons plutôt que les notes absentes sont vraiment absentes, mais que les bonus absents doivent être considérés comme zéro.

Comme ça, on a ajouté des bonus là où il en manque, sans inventer de notes là où on n’en a pas.

Interpoler les données manquantes¶

Une autre solution pour compléter les données manquantes est l’interpolation. Par exemple, si un élève a eu 0 bonus en janvier et 2 en mars, pandas peut “deviner” combien il a eu en février en faisant la moyenne.

Mais s’il manque une valeur au tout début (par exemple, janvier), l’interpolation ne fonctionne pas. On peut régler ça en ajoutant d’abord une colonne avec zéro pour janvier :

Maintenant, toutes les valeurs sont raisonnables. On peut calculer les notes finales :

Nettoyer les données¶

Si une colonne entière ou une ligne entière est vide (NaN), on peut l’enlever pour clarifier les résultats.

Pour enlever les lignes sans aucune note :

Pour enlever les colonnes totalement vides :

Grouper et agréger (GroupBy)¶

Comme en SQL, pandas permet de regrouper les données selon une colonne, puis d’effectuer des calculs pour chaque groupe. Par exemple, ajoutons les loisirs de chaque élève :

On groupe par loisir :

Calculer la moyenne par loisir :

Les valeurs manquantes (NaN) sont ignorées pour la moyenne.

Tableaux croisés dynamiques (Pivot Table)¶

Pandas gère très bien les tableaux croisés, comme dans Excel. Imaginons ce DataFrame simplifié :

Créer une table croisée avec la moyenne des notes et bonus par élève :

Changer la fonction d’agrégation, par exemple prendre le maximum :

Afficher les notes par élève et par mois, avec le total :

Créer une table avec plusieurs niveaux d’index :

Fonctions pour explorer un DataFrame¶

Quand tu as beaucoup de données, c’est utile de voir rapidement le contenu.

Créons un grand DataFrame de test :

Afficher les 5 premières lignes :

Ou les 2 dernières :

Avoir un résumé rapide de chaque colonne :

Avoir des statistiques descriptives (moyenne, min, max, etc.) :

• count : nombre de valeurs non manquantes

• mean : moyenne

• std : écart-type

• min : valeur minimale

• 25%, 50%, 75% : percentiles (quartiles)

• max : valeur maximale

Sauvegarder et charger des données avec pandas¶

Pandas permet de sauvegarder un DataFrame dans plusieurs formats : CSV, Excel, JSON, HTML, HDF5, ou même dans une base SQL.

Créons d’abord un petit DataFrame :

Sauvegarde¶

Enregistrer dans différents formats :

Le fichier CSV aura une colonne d’index (par défaut, sans nom). On peut la nommer avec infos.index.name = "prenom" avant la sauvegarde.

Pour Excel, il faut installer la bibliothèque openpyxl :

Chargement¶

Pour charger un fichier CSV en DataFrame :

On peut aussi charger du JSON, de l’Excel, du HTML, etc. grâce à pd.read_json, pd.read_excel, pd.read_html, etc.

On peut même charger des données sur Internet directement (par exemple, un CSV sur GitHub) :

Pour plus de détails sur tous les formats et options : voir la documentation pandas sur l’entrée/sortie.

Fusionner des DataFrames (jointures comme en SQL)¶

Pandas permet de “joindre” des tableaux comme dans les bases de données :

• “inner join” (intersection)

• “outer join” (union)

• “left/right join” (garder seulement les lignes du DataFrame de gauche/droite)

Exemple¶

Supposons deux DataFrames : villes camerounaises et leurs coordonnées, puis population.

Fusion simple sur la colonne “ville” :

Pour garder toutes les villes des deux tableaux (full outer join) :

Pour garder toutes les villes de gauche (“left join”) :

Fusion par l’index ou colonnes différentes¶

Si la clé de jointure se trouve dans l’index ou que les noms diffèrent :

Concaténer des DataFrames¶

Pour “empiler” (ajouter à la suite) plusieurs DataFrames :

Pour réinitialiser les indices :

Pour ne garder que les colonnes communes :

Les catégories¶

Il arrive qu’une colonne représente des catégories : par exemple, “1” pour femme et “2” pour homme, ou “A” (Bon), “B” (Moyen), “C” (Insuffisant). Pandas gère ça facilement :

Pour voir les catégories :

Pour renommer une catégorie :