Ce support de cours est destiné aux étudiants du Master Intelligence Artificielle et Génie Informatique de la Faculté Polydisciplinaire de Khouribga (FPK), relevant de l’Université Sultan Moulay Slimane (USMS). Il s’inscrit dans le cadre du module Python pour les sciences de données et vise à fournir une maîtrise progressive et pratique de la bibliothèque Pandas, pilier fondamental de la manipulation et de l’analyse de données tabulaires en Python. Le document couvre l’ensemble des concepts essentiels de Pandas, depuis les bases jusqu’aux usages avancés, notamment : - la découverte des structures de données Series et DataFrame ; l’importation, l’exploration et le nettoyage de jeux de données réels (CSV, Excel, JSON, etc.) ; - les opérations de transformation, d’agrégation et de combinaison des données (groupby, pivot tables, jointures, concaténations) ; - la gestion des données temporelles et des index avancés ; - la préparation des datasets pour les applications en Machine Learning et Intelligence Artificielle, avec une intégration naturelle vers Scikit-learn. Les exemples et études de cas s’appuient principalement sur le dataset Titanic, permettant une approche concrète et pédagogique, orientée vers les usages réels en Data Science. Ce support se veut à la fois : - un cours structuré pour l’apprentissage académique, - un guide pratique pour les travaux dirigés et projets, - et une référence pour la préparation des données dans les projets d’IA et de Data Science.

1. © 2025
Support de cours
YOUSSOUF EL ALLIOUI
Université Sultan Moulay Slimane
y.elallioui@usms.ma
2025
Introduction à Pandas
MANIPULATION ET ANALYSE DE DONNÉES EN PYTHON

2. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 1 / 34
Table des matières
TABLE DES MATIÈRES __________________________________________________________1
AVANT-PROPOS_________________________________________________________________4
INTRODUCTION GÉNÉRALE _____________________________________________________5
CHAPITRE 1 : INTRODUCTION À PANDAS ET STRUCTURES DE DONNÉES__________6
INTRODUCTION À PANDAS___________________________________________________________6
POURQUOI UTILISER PANDAS ? ________________________________________________________6
COMPLÉMENTARITÉ AVEC LES AUTRES BIBLIOTHÈQUES ____________________________________7
EXEMPLE INTRODUCTIF______________________________________________________________7
RÉSUMÉ__________________________________________________________________________8
STRUCTURES DE DONNÉES DE PANDAS : SERIES ET DATAFRAME_____________________________8
OBJECTIF _________________________________________________________________________8
SERIES PANDAS ____________________________________________________________________8
DATAFRAME PANDAS _______________________________________________________________8
RAPPEL ET LIENS AVEC NUMPY _______________________________________________________9
RÉSUMÉ__________________________________________________________________________9
CONCLUSION _____________________________________________________________________9
CHAPITRE 2 : MANIPULATION ET PRÉPARATION DES DONNÉES _________________11
IMPORTATION DES DONNÉES ET PREMIERS PAS AVEC UN DATAFRAME _____________________11
OBJECTIF ________________________________________________________________________11
LECTURE DE FICHIERS TABULAIRES ___________________________________________________11
APERÇU ET INFORMATIONS DU DATAFRAME ____________________________________________12
ACCÈS RAPIDE AUX DONNÉES ________________________________________________________13
Sélection de colonnes ______________________________________________________________13
Sélection de lignes_________________________________________________________________13
Filtrage par conditions______________________________________________________________13
EXEMPLE FIL ROUGE : TITANIC _______________________________________________________14
MANIPULATION DE BASE DES DONNÉES _______________________________________________14
OBJECTIF ________________________________________________________________________14
MODIFICATION ET CRÉATION DE COLONNES ____________________________________________14
Ajouter une colonne calculée ________________________________________________________14
Modifier une colonne existante_______________________________________________________15
Renommer des colonnes ____________________________________________________________15
Réordonner les colonnes ____________________________________________________________15
GESTION DES VALEURS MANQUANTES _________________________________________________15
Détection ________________________________________________________________________15
Suppression ______________________________________________________________________15
Imputation (remplissage) ___________________________________________________________15

3. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 2 / 34
AUTRES NETTOYAGES ET TRANSFORMATIONS SIMPLES ____________________________________15
Doublons ________________________________________________________________________15
Remplacer des valeurs______________________________________________________________16
Conversion de type ________________________________________________________________16
Trier les données __________________________________________________________________16
EXEMPLE FIL ROUGE : TITANIC _______________________________________________________16
CONCLUSION ____________________________________________________________________16
CHAPITRE 3 : ANALYSE ET TRANSFORMATION AVANCÉES______________________17
ANALYSE EXPLORATOIRE AVANCÉE : GROUPEMENTS ET PIVOTEMENTS ____________________17
OBJECTIF ________________________________________________________________________17
GROUPBY ET AGRÉGATIONS _________________________________________________________17
Fonctions utiles avec groupby________________________________________________________18
TABLEAUX CROISÉS (PIVOT TABLES) ET RESHAPING ______________________________________18
Autres paramètres utiles ____________________________________________________________19
Reshaping avec melt _______________________________________________________________19
AUTRES OPÉRATIONS PAR GROUPES (OPTIONNEL) ________________________________________19
EXEMPLE FIL ROUGE : TITANIC _______________________________________________________20
FUSION ET COMBINAISON DE DONNÉES _______________________________________________20
OBJECTIF ________________________________________________________________________20
JOINTURES ENTRE DATAFRAMES (MERGE / JOIN)_________________________________________20
Types de jointures _________________________________________________________________20
Jointure sur index (join) ____________________________________________________________21
CONCATÉNATION ET APPEND ________________________________________________________22
Concaténation verticale (lignes, axis=0) ______________________________________________22
Concaténation horizontale (colonnes, axis=1) _________________________________________22
append (déprécié) ________________________________________________________________23
AUTRES OPÉRATIONS DE COMBINAISON ________________________________________________23
combine_first ________________________________________________________________23
compare _______________________________________________________________________23
Multi-joins (plus de deux tables)______________________________________________________23
Exemple fil rouge : Titanic __________________________________________________________23
1) Fusion de tables “Passagers” et “Billets” _____________________________________________23
2) Concaténation de nouvelles lignes __________________________________________________24
Check-list pratique ________________________________________________________________24
DONNÉES TEMPORELLES ET INDEX AVANCÉS __________________________________________25
OBJECTIF ________________________________________________________________________25
INDEX DE DATES ET SÉRIES CHRONOLOGIQUES __________________________________________25
Génération d’intervalles réguliers_____________________________________________________25
Resample (ré-échantillonnage) _______________________________________________________25
Accès aux composants avec .dt _____________________________________________________26
DÉCALAGES TEMPORELS ET FENÊTRES GLISSANTES_______________________________________26
Décalage (shift)___________________________________________________________________26
Fenêtres glissantes (rolling) _________________________________________________________26
INDEX MULTI-NIVEAUX (MULTIINDEX) ________________________________________________26
Exemple IA ______________________________________________________________________27
EXEMPLE D’APPLICATION ___________________________________________________________27
CONCLUSION ____________________________________________________________________27
CHAPITRE 4 : PANDAS ET L’INTELLIGENCE ARTIFICIELLE______________________28

4. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 3 / 34
VERS L’UTILISATION DE PANDAS EN IA/ML : BONNES PRATIQUES ET CAS D’USAGE___________28
OBJECTIF ________________________________________________________________________28
PRÉPARATION DES DONNÉES POUR LE MACHINE LEARNING_________________________________28
Encodage des variables catégorielles __________________________________________________28
Feature engineering________________________________________________________________29
Détection d’outliers________________________________________________________________29
INTÉGRATION AVEC LES BIBLIOTHÈQUES DE ML/DL______________________________________29
Avec scikit-learn __________________________________________________________________29
Avec la vision par ordinateur ________________________________________________________29
Avec le deep learning ______________________________________________________________29
BONNES PRATIQUES DE CODE PANDAS _________________________________________________30
Utiliser les opérations vectorisées_____________________________________________________30
Method chaining (chaînage de méthodes)_______________________________________________30
Documentation et aide______________________________________________________________30
Reproductibilité___________________________________________________________________30
CAS D’USAGE FINAL : PRÉPARATION D’UN DATASET ______________________________________30
Scénario : prédiction de revenus ______________________________________________________30
CONCLUSION _____________________________________________________________________31
PANDAS – FICHE RÉCAPITULATIVE __________________________________________________31
IMPORTATION ____________________________________________________________________31
STRUCTURES DE DONNÉES __________________________________________________________31
EXPLORATION RAPIDE______________________________________________________________31
SÉLECTIONS______________________________________________________________________31
MANIPULATION DE COLONNES _______________________________________________________32
NETTOYAGE _____________________________________________________________________32
GROUPBY ET PIVOT _______________________________________________________________32
FUSION ET CONCATÉNATION_________________________________________________________32
DONNÉES TEMPORELLES ____________________________________________________________32
BONNES PRATIQUES _______________________________________________________________33
CAS D’USAGE IA/ML ______________________________________________________________33
CONCLUSION ____________________________________________________________________33
CONCLUSION GÉNÉRALE ______________________________________________________34

5. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 4 / 34
Avant-propos
Ce support de cours est destiné aux étudiants du Master Intelligence Artificielle et Génie
Informatique, dispensé à la Faculté Polydisciplinaire de Khouribga (FPK) relevant de
l’Université Sultan Moulay Slimane de Béni Mellal (USMS).
Il s’inscrit dans la continuité du module Python pour les sciences de données, qui constitue
l’un des fondements de la formation en Data Science et en Intelligence Artificielle.
L’objectif de ce document est de fournir une base solide pour la maîtrise de la bibliothèque
Pandas, considérée comme l’un des outils centraux de la manipulation et de l’analyse de
données tabulaires en Python.
Pandas joue un rôle clé dans le traitement, la préparation et la transformation des données avant
toute modélisation.
Elle repose sur la puissance de NumPy et interagit étroitement avec des bibliothèques comme
Matplotlib, Seaborn et SciPy, tout en préparant le terrain pour Scikit-learn, dédié à
l’apprentissage automatique.
Les exemples et démonstrations présentés dans ce document s’appuient principalement sur le
dataset Titanic (fichiers titanic.csv et titanic.xls), accessible librement sur GitHub à l’adresse
suivante :
https://github.com/yelallioui/Python-DataScience-Master-IA-GI.git
La démarche adoptée dans ce support est volontairement progressive et pédagogique. Chaque
chapitre introduit les concepts de manière claire, les illustre à travers des exemples concrets et
en propose une synthèse afin de faciliter leur assimilation.
L’ambition est de permettre à l’étudiant non seulement de comprendre les mécanismes internes
de Pandas, mais aussi d’acquérir les compétences nécessaires pour manipuler efficacement des
jeux de données réels dans le cadre de projets en Data Science et en Intelligence Artificielle.
Ce document se veut à la fois un guide de référence et un outil de travail pratique, destiné à
renforcer les acquis des étudiants et à les préparer aux prochaines étapes de leur parcours
académique, notamment l’apprentissage des techniques de modélisation et de prédiction avec
Scikit-learn.

6. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 5 / 34
Introduction générale
Dans la continuité de l’apprentissage des bibliothèques fondamentales du langage Python pour
la Data Science, Pandas occupe une place essentielle.
Conçue pour faciliter la manipulation et l’analyse de données tabulaires, cette bibliothèque
s’impose comme un pilier incontournable dans le traitement des données avant toute application
en Machine Learning ou en Intelligence Artificielle.
Dans le cadre du module Python pour les sciences de données du Master Intelligence
Artificielle et Génie Informatique, ce support de cours consacré à Pandas constitue une étape
charnière.
Il vient après l’étude de NumPy, Matplotlib, SciPy et Seaborn, et précède l’introduction à
Scikit-learn, bibliothèque dédiée à la modélisation et à l’apprentissage automatique.
Pandas s’appuie directement sur les performances de NumPy pour offrir des structures de
données puissantes et des outils de manipulation intuitifs, capables de gérer aussi bien des
données numériques que textuelles, temporelles ou catégorielles.
L’objectif de ce support est double :
• acquérir une maîtrise pratique des Series et des DataFrames, les deux structures
principales de Pandas ;
• apprendre à importer, explorer, nettoyer et transformer des jeux de données réels afin
de les préparer aux étapes de modélisation.
Au fil des chapitres, l’étudiant découvrira progressivement :
• Chapitre 1 : Introduction à Pandas et structures de données – présentation de la
bibliothèque et découverte des objets Series et DataFrame.
• Chapitre 2 : Manipulation et préparation des données – lecture, exploration,
nettoyage et mise en forme des données réelles.
• Chapitre 3 : Analyse et transformations avancées – groupements, tableaux croisés,
jointures, gestion du temps et transformation de structures complexes.
• Chapitre 4 : Pandas et l’intelligence artificielle – préparation des datasets pour le
machine learning, intégration avec Scikit-learn et bonnes pratiques de code.
Ce parcours permettra à l’étudiant de comprendre non seulement la logique de Pandas, mais
aussi son rôle central comme outil de préparation et d’analyse de données dans tout projet
d’intelligence artificielle.
.

7. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 6 / 34
Chapitre 1 : Introduction à Pandas et structures de
données
Dans le domaine de la data science, la première étape consiste à
manipuler efficacement les données. La bibliothèque Pandas est un
outil essentiel pour cela.
Construite au-dessus de NumPy, elle fournit des structures de données
puissantes et flexibles qui facilitent le traitement des tableaux, des
fichiers et des jeux de données complexes.
Dans ce chapitre, nous allons découvrir les deux structures principales
de Pandas : Series et DataFrame.
Nous apprendrons à les créer, les comprendre et les manipuler à
travers des exemples simples.
Ces bases nous permettront ensuite d’aborder sereinement la
préparation et le nettoyage des données.
Introduction à Pandas
Pandas est une bibliothèque Python essentielle pour la data science.
Elle repose sur NumPy et fournit des structures de données puissantes et faciles à utiliser.
Avec Pandas, nous travaillons principalement avec deux objets :
• Series : un tableau 1D étiqueté.
• DataFrame : un tableau 2D étiqueté, proche d’une table SQL ou d’une feuille Excel.
Ces structures rendent la manipulation de données simple et rapide.
Elles sont idéales pour explorer, nettoyer, transformer et analyser des données.
Pourquoi utiliser Pandas ?
Avant Pandas, traiter un fichier CSV ou Excel nécessitait beaucoup de code.
Avec Pandas, quelques lignes suffisent pour :
• Lire un fichier (CSV, Excel, JSON, SQL, …).

8. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 7 / 34
• Afficher un aperçu des données.
• Calculer des statistiques descriptives.
• Filtrer ou sélectionner des lignes et colonnes précises.
Exemple simple :
import pandas as pd
# Lire un fichier CSV
df = pd.read_csv("students.csv")
# Afficher les 5 premières lignes
print(df.head())
# Obtenir des infos sur le DataFrame
print(df.info())
# Statistiques de base
print(df.describe())
En quelques instructions, nous explorons un dataset complet.
Complémentarité avec les autres bibliothèques
Pandas n’est pas isolé.
Il s’intègre naturellement avec :
• NumPy : calcul numérique (vecteurs, matrices).
• Matplotlib et Seaborn : visualisation des données.
• SciPy : outils scientifiques avancés.
Exemple : charger des données avec Pandas, puis tracer un graphique avec Matplotlib ou
Seaborn.
Exemple introductif
Imaginons un petit dataset d’étudiants :
data = {
"Nom": ["Ali", "Sara", "Youssouf"],
"Âge": [21, 23, 20],
"Note": [14.5, 16.0, 12.0]
}
df = pd.DataFrame(data)
print(df)
Sortie :
Nom Âge Note
0 Ali 21 14.5
1 Sara 23 16.0
2 Youssouf 20 12.0
Avec ce DataFrame, nous pouvons :
• Calculer la moyenne des notes : df["Note"].mean()
• Sélectionner les étudiants de plus de 21 ans : df[df["Âge"] > 21]

9. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 8 / 34
Résumé
• Pandas est un outil central de la data science.
• Il facilite l’exploration et la préparation des données.
• Ces compétences sont indispensables pour la suite : machine learning, vision par
ordinateur, deep learning.
Structures de données de Pandas : Series et DataFrame
Objectif
• Découvrir les deux structures principales de Pandas.
• Elles sont à la base de toutes les manipulations de données.
Series Pandas
Une Series est un tableau 1D étiqueté.
Elle contient :
• des valeurs (les données),
• un index (les étiquettes des lignes).
Une Serie peut contenir des nombres, du texte ou des booléens.
Exemple simple :
import pandas as pd
# Création d'une Series à partir d'une liste
s = pd.Series([15, 20, 57], index = ["Fes", "Meknes", "Khouribga"])
print(s)
Sortie :
Fes 15
Meknes 20
Khouribga 57
dtype: int64
Ici, les valeurs sont les immatriculations.
L’index correspond aux villes.
On peut accéder à une valeur grâce à son label :
print(s["Fes"]) # Sortie : 15
DataFrame Pandas
• Un DataFrame est un tableau 2D avec lignes et colonnes.
• Chaque colonne est une Serie.
• C’est l’équivalent d’une table SQL ou d’une feuille Excel.
• Un DataFrame peut mélanger plusieurs types : nombres, texte, booléens, catégories.
Exemple simple :

10. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 9 / 34
data = {
"Nom": ["Ali", "Sara", "Driss"],
"Âge": [21, 23, 20],
"Note": [14.5, 16.0, 12.0]
}
students_df = pd.DataFrame(data)
print(students_df)
Sortie :
Nom Âge Note
0 Ali 21 14.5
1 Sara 23 16.0
2 Driss 20 12.0
Chaque colonne (Nom, Âge, Note) est une Serie.
Un DataFrame est donc une collection ordonnée de Series.
Rappel et liens avec NumPy
Derrière chaque Series ou DataFrame, il y a un array NumPy.
C’est ce qui rend Pandas rapide et efficace.
Différence clé : Pandas garde les étiquettes (index, colonnes).
Cela permet d’aligner automatiquement les données.
Exemple :
s1 = pd.Series([10, 20, 30], index=["a", "b", "c"])
s2 = pd.Series([100, 200, 300], index=["b", "c", "d"])
print(s1 + s2)
Sortie :
a NaN
b 120.0
c 230.0
d NaN
dtype: float64
Les valeurs sont additionnées seulement quand les index correspondent.
Les index absents donnent un NaN (valeur manquante).
Résumé
• Series : tableau 1D avec index.
• DataFrame : tableau 2D, collection de Series.
• Les deux reposent sur NumPy, avec un système d’index puissant.
Ces bases sont essentielles pour explorer et manipuler des données réelles.
Conclusion
À ce stade, vous savez ce qu’est Pandas, ses avantages et ses deux structures fondamentales.

11. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 10 / 34
Vous avez compris comment les Series et les DataFrames permettent de représenter et
d’explorer les données de manière simple et rapide.
Dans le chapitre suivant, nous allons passer à l’étape suivante : apprendre à importer,
explorer et préparer les données pour les rendre prêtes à l’analyse.

12. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 11 / 34
Chapitre 2 : Manipulation et préparation des données
Une fois que l’on connaît les structures de base de Pandas, il est temps de
travailler sur des données réelles.
En data science, les données brutes contiennent souvent des erreurs, des
valeurs manquantes ou des doublons.
Pandas nous offre des outils simples pour importer, explorer et nettoyer ces
données avant toute analyse.
Dans ce chapitre, nous verrons comment charger des fichiers (CSV, Excel,
JSON...), visualiser rapidement leur contenu, sélectionner certaines lignes
ou colonnes, et corriger les problèmes les plus courants.
Nous utiliserons un exemple concret, le dataset Titanic, pour illustrer
chaque étape.
Importation des données et premiers pas avec un DataFrame
Objectif
• Apprendre à charger des données externes dans Pandas.
• Découvrir comment obtenir un premier aperçu d’un DataFrame.
Lecture de fichiers tabulaires
Pandas offre plusieurs fonctions pour lire des fichiers :
• pd.read_csv() pour les fichiers CSV (le plus courant),
• pd.read_excel() pour Excel,
• pd.read_json() pour JSON,
• pd.read_sql() pour SQL.
Toutes ces fonctions suivent le même schéma : pd.read_***.
L’écriture se fait avec DataFrame.to_***.
Exemple avec un fichier CSV :
import pandas as pd
# Lecture d'un fichier CSV
titanic_df = pd.read_csv("titanic.csv")
# Sauvegarde dans un nouveau fichier CSV
titanic_df.to_csv("titanic_copy.csv", index=False)

13. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 12 / 34
Ce code effectue deux opérations simples avec Pandas :
• Lecture : il lit le fichier CSV titanic.csv et charge son contenu dans un
DataFrame titanic_df.
• Écriture : il enregistre ce DataFrame dans un nouveau fichier CSV
nommé titanic_copy.csv, sans inclure l’index des lignes (index=False).
Autrement dit, il crée une copie exacte du fichier titanic.csv sous le nom
titanic_copy.csv.
Les autres paramètres utiles de read_csv sont :
• sep=";" → séparateur (par défaut ,).
• header=0 → ligne des noms de colonnes.
• encoding="utf-8" → encodage du fichier.
• nrows=10 → lire seulement 10 lignes.
Aperçu et informations du DataFrame
Une fois les données chargées, on doit explorer leur structure.
Fonctions principales :
• df.head(n) : affiche les n premières lignes (par défaut 5).
• df.tail(n) : affiche les n dernières lignes.
• df.shape : dimensions (lignes, colonnes).
• len(df) : nombre de lignes.
• df.columns : noms des colonnes.
• df.index : index des lignes.
• df.info() : résumé (taille, types, valeurs non-nulles).
• df.describe() : statistiques sur les colonnes numériques.
Exemple avec Titanic :
print(titanic_df.head())
print(titanic_df.info())
print(titanic_df.describe())
ce code permet d’explorer rapidement le contenu du DataFrame titanic_df :
• titanic_df.head() → affiche les 5 premières lignes du tableau.
• titanic_df.info() → donne des informations générales : nombre de
lignes/colonnes, noms des colonnes, types de données, valeurs manquantes.
• titanic_df.describe() → fournit des statistiques descriptives (moyenne, écart-
type, min, max, quartiles) pour les colonnes numériques.
C’est donc un aperçu global et statistique des données du Titanic.
On peut aussi voir la distribution d’une variable :
print(titanic_df["Sex"].value_counts())

14. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 13 / 34
Cela donne le nombre d’hommes et de femmes.
Sortie :
Sex
male 577
female 314
Name: count, dtype: int64
Accès rapide aux données
Sélection de colonnes
• Une seule colonne → df["col"] (Series).
• Plusieurs colonnes → df[["col1","col2"]] (DataFrame).
Sélection de lignes
• Par label (index) → df.loc[label].
• Par position → df.iloc[pos].
Exemple :
# Âge du 5ème passager (index 4)
print(titanic_df.iloc[4, titanic_df.columns.get_loc("Age")])
# Les 4 premiers noms et âges
print(titanic_df.loc[0:3, ["Name", "Age"]])
Sortie :
35.0
Name Age
0 Braund, Mr. Owen Harris 22.0
1 Cumings, Mrs. John Bradley (Florence Briggs Th... 38.0
2 Heikkinen, Miss. Laina 26.0
3 Futrelle, Mrs. Jacques Heath (Lily May Peel) 35.0
Filtrage par conditions
On peut extraire les lignes qui respectent une condition.
# Passagers mineurs (<18 ans)
print(titanic_df[titanic_df["Age"] < 18])
# Femmes en 1ère classe
print(titanic_df[(titanic_df["Sex"]=="female") &
(titanic_df["Pclass"]==1)])
Ce code filtre les données du Titanic selon deux conditions :
• Affiche toutes les lignes où l’âge est inférieur à 18 (donc uniquement les passagers
enfants/adolescents).
• Affiche toutes les passagères de sexe féminin (Sex == "female") qui voyagent en 1ʳᵉ
classe (Pclass == 1).
Autrement dit, ce code permet de sélectionner des sous-groupes spécifiques de passagers à
partir des critères donnés.

15. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 14 / 34
Exemple fil rouge : Titanic
À ce stade, on peut répondre à des questions simples :
• Combien de passagers ?
titanic_df.shape[0]
• Quelles colonnes disponibles ?
titanic_df.columns
• Quelle proportion a survécu ?
titanic_df["Survived"].mean()
• Âge moyen des survivants vs non survivants ?
print(titanic_df.groupby("Survived")["Age"].mean())
Sortie : deux moyennes, une pour les survivants, une pour les non survivants.
Avec ces bases, on peut déjà explorer n’importe quel dataset.
Manipulation de base des données
Objectif
• Savoir modifier la structure d’un DataFrame.
• Créer ou supprimer des colonnes, traiter les données manquantes, trier et nettoyer.
• Préparer le dataset avant des analyses plus complexes.
Modification et création de colonnes
Ajouter une colonne calculée
On peut créer une nouvelle colonne en affectant une valeur. Souvent, c’est le résultat d’un calcul
sur d’autres colonnes.
Exemple : taille de la famille dans Titanic.
titanic_df["FamilySize"] = titanic_df["SibSp"] + titanic_df["Parch"] + 1
print(titanic_df[["SibSp","Parch","FamilySize"]].head())
Sortie :
SibSp Parch FamilySize
0 1 0 2
1 1 0 2
2 0 0 1
3 1 0 2
4 0 0 1
Ce code :
• crée une nouvelle colonne FamilySize qui calcule la taille de la famille de chaque
passager (frères/sœurs + parents/enfants + lui-même).
• affiche les 5 premières lignes avec les colonnes SibSp, Parch et FamilySize.
Chaque ligne est calculée d’un coup, sans boucle. C’est une opération vectorisée.

16. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 15 / 34
Modifier une colonne existante
titanic_df["Age"] = titanic_df["Age"] * 2
Toutes les valeurs de Age sont multipliées par 2. Encore une fois, c’est vectorisé et donc très
rapide.
Renommer des colonnes
titanic_df = titanic_df.rename(columns={"SibSp": "Siblings/Spouses"})
Avec inplace=True, le renommage est appliqué directement au DataFrame d’origine, sans
créer de copie.
Réordonner les colonnes
cols = ["Name","Age","Sex","Pclass","Survived"]
titanic_df = titanic_df[cols]
On affiche ou on organise les colonnes dans un ordre logique.
Gestion des valeurs manquantes
Les données réelles contiennent souvent des NaN (Not a Number). Pandas les repère et les traite
facilement.
Détection
print(titanic_df["Age"].isnull().sum()) # Sortie : 177
On obtient le nombre de valeurs manquantes pour Age.
Suppression
# Supprimer toutes les lignes avec NaN
titanic_df.dropna()
# Supprimer les lignes où Age est manquant
titanic_df.dropna(subset=["Age"])
Imputation (remplissage)
# Remplacer par la moyenne
titanic_df["Age"].fillna(titanic_df["Age"].mean(), inplace=True)
# Remplissage avec la valeur précédente
titanic_df["Age"].fillna(method="ffill", inplace=True)
NB : Chaque stratégie a des conséquences. En machine learning, un mauvais choix peut créer
du biais.
Autres nettoyages et transformations simples
Doublons
print(titanic_df.duplicated().sum()) # 0
titanic_df = titanic_df.drop_duplicates()
La méthode drop_duplicates() supprime les lignes en double.

17. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 16 / 34
Remplacer des valeurs
titanic_df["Sex"] = titanic_df["Sex"].replace({"male":"M","female":"F"})
Utile pour uniformiser les données.
Conversion de type
titanic_df["Pclass"] = titanic_df["Pclass"].astype("category")
Ce code convertit la colonne Pclass en type catégoriel (au lieu d’un entier), ce qui permet de
la traiter comme une variable qualitative (classe de voyage).
NB : Changer le type peut réduire la mémoire utilisée.
Trier les données
# Trier par âge
titanic_df.sort_values(by="Age", inplace=True)
# Trier par classe puis âge
titanic_df.sort_values(by=["Pclass","Age"], inplace=True)
Le tri rend le dataset plus lisible et logique.
Exemple fil rouge : Titanic
• Supprimer les doublons.
• Renommer SibSp en Siblings/Spouses.
• Remplir les âges manquants avec la médiane.
• Créer une colonne FamilySize.
Après nettoyage :
print(titanic_df.info())
Le DataFrame est prêt pour des analyses plus avancées.
Conclusion
Nous savons désormais comment lire un fichier, examiner sa structure et effectuer les premières
corrections sur un dataset. Ces manipulations constituent la base de tout travail en data science.
Dans le chapitre suivant, nous irons plus loin : nous apprendrons à analyser, regrouper et
transformer les données pour en extraire des informations utiles et préparer nos futures
analyses statistiques.

18. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 17 / 34
Chapitre 3 : Analyse et transformation avancées
Maintenant que nous savons manipuler et nettoyer nos données, nous allons
apprendre à en tirer des enseignements.
Pandas met à notre disposition des fonctions puissantes pour analyser,
regrouper et transformer les jeux de données.
Grâce à des opérations comme groupby(), pivot_table(), ou merge(),
nous pouvons obtenir des statistiques par catégorie, combiner plusieurs
sources et créer des vues structurées adaptées à nos besoins.
Ce chapitre nous permettra aussi de découvrir la gestion des données
temporelles et des index avancés, indispensables pour les séries
chronologiques et les données complexes.
Analyse exploratoire avancée : groupements et pivotements
Objectif
• Aller plus loin dans l’analyse des données.
• Apprendre à regrouper des observations et à créer des tableaux croisés.
• Ces techniques aident à trouver des patterns cachés et préparent les données pour le
machine learning.
GroupBy et agrégations
La méthode groupby() suit le principe split-apply-combine :
• Split → diviser les données en groupes.
• Apply → appliquer une fonction (moyenne, somme, etc.).
• Combine → recomposer le résultat.
Exemple : taux de survie par classe (Titanic).
titanic_df.groupby("Pclass")["Survived"].mean()
Ce code calcule le taux moyen de survie (Survived) pour chaque classe de voyage (Pclass).
Sortie :
Survived
Pclass

19. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 18 / 34
1 0.629630
2 0.472826
3 0.242363
dtype: float64
Explication :
• Classe 1 → environ 62% de survie.
• Classe 2 → environ 47% de survie.
• Classe 3 → environ 25% de survie.
On peut aussi grouper par plusieurs colonnes.
titanic_df.groupby(["Embarked","Pclass"]).size()
Ici, on obtient le nombre de passagers pour chaque combinaison de port d’embarquement
(Embarked) et de classe (Pclass).
Fonctions utiles avec groupby
• mean() → moyenne
• sum() → somme
• count() → nombre d’éléments
• min() / max() → min et max
• median() → médiane
On peut appliquer plusieurs fonctions d’un coup :
titanic_df.groupby("Pclass").agg({"Age":"mean", "Fare":"median"})
Ce code calcule pour chaque classe (Pclass) :
• la moyenne d’âge (Age),
• la médiane du prix du billet (Fare).
Tableaux croisés (Pivot tables) et reshaping
Un pivot table est une forme de groupby. Il organise les résultats sous forme de table 2D :
• une variable en lignes,
• une autre en colonnes,
• une statistique dans les cellules.
Exemple : taux de survie par classe et sexe.
pd.pivot_table(
titanic_df,
values="Survived",
index="Pclass",
columns="Sex",
aggfunc="mean"
)
Sortie :
Sex F M

20. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 19 / 34
Pclass
1 0.968085 0.368852
2 0.921053 0.157407
3 0.500000 0.135447
Explication :
• Femmes → survie bien plus élevée que les hommes dans chaque classe.
Autres paramètres utiles
• aggfunc="sum" → somme au lieu de la moyenne.
• margins=True → ajoute les totaux.
Exemple :
pd.pivot_table(
titanic_df,
values="Survived",
index="Pclass",
columns="Sex",
aggfunc="sum",
margins=True
)
Sortie :
Sex F M All
Pclass
1 91 45 136
2 70 17 87
3 72 47 119
All 233 109 342
Reshaping avec melt
Parfois, il faut passer d’un tableau large à un tableau long. C’est ce que fait pd.melt().
Exemple :
pd.melt(titanic_df, id_vars="Name", value_vars=["Age","Fare"])
Sortie :
Name variable value
0 Braund, Mr. Owen Harris Age 22.0
1 Cumings, Mrs. John Bradley (Florence Briggs Th... Age 38.0
2 Heikkinen, Miss. Laina Age 26.0
… … … …
1781 Dooley, Mr. Patrick Fare 7.75
Ce code transforme le DataFrame en format « long » :
• Name reste une colonne d’identifiant,
• Age et Fare deviennent des valeurs dans une seule colonne, avec une colonne
indiquant à quelle variable elles appartiennent.
Ce format est souvent plus pratique pour certains algorithmes.
Autres opérations par groupes (optionnel)
• Filtrer : garder seulement certains groupes.

21. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 20 / 34
titanic_df.groupby("Pclass").filter(lambda x: len(x) > 100)
Ce code garde uniquement les classes (Pclass) ayant plus de 100 passagers, en
filtrant le DataFrame en conséquence.
• Transform : appliquer une fonction et garder la même taille.
titanic_df.groupby("Pclass")["Age"].transform(lambda x: x - x.mean())
Ce code calcule pour chaque classe (Pclass) la différence entre l’âge de chaque
passager et la moyenne d’âge de sa classe. Autrement dit, il centre les âges par classe.
• Sample : échantillonner dans chaque groupe.
titanic_df.groupby("Pclass").sample(2)
Ce code prend au hasard 2 passagers dans chaque classe (Pclass) du DataFrame.
Exemple fil rouge : Titanic
Quelques questions et réponses avec Pandas :
• Prix moyen du billet (Fare) par port d’embarquement (Embarked) ?
titanic_df.groupby("Embarked")["Fare"].mean()
• Nombre de passagers par port (Embarked) et par classe (Pclass) ?
titanic_df.groupby(["Embarked","Pclass"]).size()
• Taux de survie par tranche d’âge ?
titanic_df["AgeGroup"] = pd.cut(titanic_df["Age"], [0,12,18,60,80],
labels=["Enfant","Adolescent","Adulte","Senior"])
titanic_df.groupby("AgeGroup")["Survived"].mean()
Ce code crée une nouvelle colonne AgeGroup qui classe les passagers en tranches
d’âge : Enfant, Adolescent, Adulte, Senior.
Ces quelques lignes donnent déjà des insights puissants. On comprend mieux la structure des
données et on se rapproche de la modélisation prédictive.
Fusion et combinaison de données
Objectif
• Combiner des DataFrames venant de sources différentes.
• Préparer un tableau unique, propre, et prêt pour l’analyse ou le machine learning.
Jointures entre DataFrames (merge / join)
Les jointures ressemblent à SQL. On utilise pd.merge() pour assembler deux DataFrames sur
une clé commune.
Types de jointures
• inner : garde seulement les correspondances.
• left : garde toutes les lignes du DataFrame de gauche.

22. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 21 / 34
• right : garde toutes les lignes du DataFrame de droite.
• outer : garde tout, et met NaN quand ça ne matche pas.
Exemple
import pandas as pd
clients_df = pd.DataFrame({
"id": [1, 2, 3],
"nom": ["Ali", "Sara", "Driss"],
"ville": ["Rabat", "Casa", "Fès"]
})
achats_df = pd.DataFrame({
"client_id": [1, 1, 3, 4],
"produit": ["Livre", "Stylo", "PC", "Souris"],
"montant": [120, 10, 7000, 100]
})
# Jointure style SQL
merged = pd.merge(
clients_df, achats_df,
left_on="id", right_on="client_id",
how="inner" # "left", "right", "outer" possibles
)
print(merged)
Ce code fusionne les deux DataFrames clients_df et achats_df comme une jointure
SQL :
• left_on="id" et right_on="client_id" → correspondance entre id du client
et client_id des achats.
• how="inner" → ne garde que les clients ayant au moins un achat.
Le résultat merged contient donc les colonnes des deux DataFrames pour les clients présents
dans les deux tables.
Sortie :
id nom ville client_id produit montant
0 1 Ali Rabat 1 Livre 120
1 1 Ali Rabat 1 Stylo 10
2 3 Driss Fès 3 PC 7000
Remarques utiles :
• left_on / right_on pour des noms de colonnes différents.
• indicator=True pour voir l’origine de chaque ligne.
• validate="one_to_one" (ou "one_to_many", "many_to_one") pour détecter les
erreurs de cardinalité.
Jointure sur index (join)
Le code suivant, joint le DataFrame infos_df à clients_df en utilisant la
colonne id de clients_df pour faire correspondre l’index de infos_df.
• Chaque client reçoit la valeur de classe correspondant à son id.
• La méthode join ajoute la colonne classe au DataFrame clients_df.

23. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 22 / 34
Exemple: joindre sur l'index du DataFrame de droite
infos_df = pd.DataFrame({
"classe": ["A", "B", "C"]
}, index=[1, 2, 3])
out = clients_df.join(infos_df, on="id")
print(out)
Le résultat out contient donc id, nom, ville et classe.
Rappel :
• df.join() est pratique pour des jointures sur index.
• pd.merge() est plus général (colonnes ou index).
Concaténation et append
pd.concat() assemble des DataFrames sans clé. Il empile (vertical) ou aligne (horizontal)
selon l’axe.
Concaténation verticale (lignes, axis=0)
# Deux échantillons de Titanic simulés
titanic_part1 = titanic_df.sample(400, random_state=0)
titanic_part2 = titanic_df.drop(titanic_part1.index)
# Recréer le DataFrame global
titanic_all = pd.concat([titanic_part1, titanic_part2], axis=0,
ignore_index=True)
print(titanic_all.shape)
Ce code divise le DataFrame titanic_df en deux parties aléatoires, puis recombine ces
deux parties pour recréer un DataFrame complet titanic_all.
• axis=0 → concaténation par lignes.
• ignore_index=True → réindexe les lignes de 0 à n-1.
• Le print(titanic_all.shape) affiche la taille finale du DataFrame, qui doit être
identique à l’original.
• Utile pour réunir des fichiers “part1/part2/part3…”.
Concaténation horizontale (colonnes, axis=1)
df_features = titanic_df[["Age","Fare"]]
df_predictions = pd.DataFrame({"Pred": [0]*len(titanic_df)},
index=titanic_df.index)
# Aligner par index
out = pd.concat([df_features, df_predictions], axis=1, join="outer")
print(out.head())
Ce code combine deux DataFrames (df_features et df_predictions) côte à côte (par
colonnes) :
• df_features contient les colonnes Age et Fare.
• df_predictions contient une colonne Pred remplie de zéros.

24. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 23 / 34
• axis=1 → concaténation par colonnes.
• join="outer" → assure que tous les index sont conservés, même s’il y avait des
différences (ici, les index sont alignés).
• Le print(out.head()) affiche les 5 premières lignes du DataFrame résultant.
NB :
• Par défaut, concat fait l’union des index (comme un outer join).
• Utilisez join="inner" si vous voulez l’intersection uniquement.
append (déprécié)
df1.append(df2) a existé. Aujourd’hui, on préfère pd.concat([df1, df2]).
Autres opérations de combinaison
combine_first
Comble les NaN d’un DataFrame par les valeurs de l’autre (mêmes index/colonnes).
a = pd.DataFrame({"x": [1, None, 3]}, index=[0,1,2])
b = pd.DataFrame({"x": [10, 20, None]}, index=[0,1,2])
a_filled = a.combine_first(b)
print(a_filled)
Résultat : on remplace les vides de a par ce que b possède.
compare
Compare deux DataFrames similaires. Pratique pour valider une transformation.
before = titanic_df.copy()
after = titanic_df.copy()
after.loc[after["Age"].notna(), "Age"] = after["Age"] + 1
diff = after.compare(before)
print(diff.head())
Vous voyez ce qui change, colonne par colonne.
Multi-joins (plus de deux tables)
• Faites des merges successifs étape par étape.
• Vérifiez les tailles après chaque jointure.
• Cela garde le code lisible et traçable.
Exemple fil rouge : Titanic
1) Fusion de tables “Passagers” et “Billets”
Imaginons deux tables relationnelles :
• passagers_df (infos démographiques)
• billets_df (tarif, cabine, port)

25. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 24 / 34
titanic_full = pd.merge(
passagers_df, billets_df,
on="PassengerId", how="left", indicator=True
)
print(titanic_full[["_merge"]].value_counts())
titanic_full.drop(columns=["_merge"], inplace=True)
• On obtient un dataset complet.
• On vérifie les correspondances avec _merge.
• On traite ensuite les NaN s’il manque des infos de billets.
2) Concaténation de nouvelles lignes
On ajoute des “nouveaux passagers” (exercice fictif).
new_people = pd.DataFrame({
"PassengerId": [9991, 9992],
"Name": ["Test A", "Test B"],
"Age": [30, 28],
"Sex": ["male", "female"],
"Pclass": [2, 1]
})
titanic_extended = pd.concat([titanic_df, new_people], ignore_index=True)
print(titanic_extended.tail())
• concat aligne les colonnes.
• Les colonnes manquantes reçoivent des NaN.
• Pratique pour enrichir un dataset.
Check-list pratique
• Avant merge :
o nettoyer les doublons de clé,
o vérifier les types des colonnes de jointure,
o choisir le bon how (inner/left/right/outer),
o optionnel : validate et indicator.
• Pour concat :
o vertical (axis=0) pour empiler,
o horizontal (axis=1) pour ajouter des features,
o ignore_index=True si vous voulez réindexer.
• Pour combler/valider :
o combine_first pour compléter les manques,
o compare pour auditer les différences.
Avec ces techniques, vous pouvez unifier des jeux de données variés.
C’est une étape clé avant toute modélisation en IA/ML.
Prochaine étape : données temporelles et index avancés ?

26. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 25 / 34
Données temporelles et index avancés
Objectif
• Apprendre à manipuler des données chronologiques avec Pandas.
• Découvrir les index avancés (datetime, multi-index).
• Ces outils sont essentiels pour les séries temporelles, l’IA séquentielle et les données
hiérarchiques.
Index de dates et séries chronologiques
Pandas sait gérer les dates de façon native. On peut convertir une colonne en datetime avec
pd.to_datetime. Puis, on l’utilise comme index avec set_index().
Exemple :
import pandas as pd
# Exemple de ventes journalières
sales_df = pd.DataFrame({
"Date": pd.date_range("2021-01-01", periods=10, freq="D"),
"Ventes": [10, 12, 9, 15, 18, 20, 17, 19, 22, 25]
})
# Conversion en index temps
sales_df = sales_df.set_index("Date")
print(sales_df)
Avec un DateTimeIndex, on peut :
• Extraire une année : sales_df["2021"]
• Extraire une période : sales_df["2021-01-03":"2021-01-06"]
• Sélectionner par attribut : sales_df[sales_df.index.month == 1]
Génération d’intervalles réguliers
pd.date_range(start="2021-01-01", periods=5, freq="M")
→ crée une série de 5 mois consécutifs.
Resample (ré-échantillonnage)
resample() regroupe par période.
# Ventes par mois
monthly = sales_df.resample("M").sum()
print(monthly)
Fréquences courantes :
• D = jour,
• W = semaine,
• M = mois,
• A = année,

27. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 26 / 34
• H = heure.
Exemple IA : données IoT captées chaque seconde → resample("1min").mean() pour
obtenir la moyenne par minute.
Accès aux composants avec .dt
dates = pd.to_datetime(["2021-01-01", "2021-06-15"])
df = pd.DataFrame({"date": dates})
print(df["date"].dt.year)
print(df["date"].dt.month)
Décalages temporels et fenêtres glissantes
Décalage (shift)
Permet de créer des lags (valeurs précédentes).
sales_df["Lag1"] = sales_df["Ventes"].shift(1)
On obtient la valeur du jour précédent.
Très utile pour construire des features séquentielles.
Fenêtres glissantes (rolling)
rolling(window) calcule des statistiques mobiles.
# Moyenne mobile sur 3 jours
sales_df["Moyenne3"] = sales_df["Ventes"].rolling(3).mean()
Applications :
• Températures : tendance hebdo .rolling(7).mean().
• Données financières : volatilité .rolling(30).std().
• Variation jour à jour : .pct_change().
Ces transformations sont très utilisées en RNN/LSTM ou pour lisser les séries.
Index multi-niveaux (MultiIndex)
Un MultiIndex permet d’organiser les données par plusieurs clés.
Il apparaît souvent après un groupby multiple ou un pivot.
Exemple :
data = {
"Ville": ["Paris","Paris","Lyon","Lyon"],
"Année": [2020, 2021, 2020, 2021],
"Temp": [15.1, 14.8, 16.2, 15.5]
}
df = pd.DataFrame(data)
df = df.set_index(["Ville","Année"])
print(df)
On peut :
• Sélectionner toutes les années d’une ville : df.loc["Paris"]
• Inverser les niveaux : df.swaplevel()

28. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 27 / 34
• Passer d’un format large à long : .stack() / .unstack().
Exemple IA
Données de pollution indexées par (Ville, Date).
On peut calculer :
• moyenne annuelle par ville (groupby(level=0).mean()),
• comparer les villes côte à côte avec .unstack().
Exemple d’application
Imaginons des données de capteurs sur un véhicule autonome.
• On calcule la moyenne par minute avec resample().
• On crée des lags avec shift() pour modéliser les dépendances temporelles.
• On ajoute des fenêtres glissantes pour extraire des tendances.
• Si plusieurs capteurs → un MultiIndex (capteur, temps) permet d’analyser chaque
capteur séparément ou ensemble.
En quelques lignes Pandas, on obtient des features prêtes pour un modèle séquentiel (RNN,
LSTM, Transformer).
Conclusion
Nous avons appris à réaliser des analyses plus poussées, à regrouper des données et à
restructurer des tables complexes.
Nous avons vu comment fusionner plusieurs sources et gérer des données chronologiques.
Dans le dernier chapitre, nous verrons comment ces compétences s’intègrent dans le monde
de l’intelligence artificielle : préparation des données pour le machine learning, intégration
avec scikit-learn et TensorFlow, et bonnes pratiques de code.

29. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 28 / 34
Chapitre 4 : Pandas et l’intelligence artificielle
Les outils et techniques que nous avons découverts jusqu’ici trouvent toute
leur utilité lorsqu’ils sont appliqués à l’intelligence artificielle.
Avant de pouvoir entraîner un modèle de machine learning ou de deep
learning, les données doivent être soigneusement préparées : il faut les
nettoyer, les transformer, les fusionner et les convertir en variables
exploitables par un algorithme.
Dans ce dernier chapitre, nous verrons comment Pandas s’intègre dans
cette chaîne de traitement.
Nous apprendrons à encoder les variables, à créer de nouvelles features et
à exporter un dataset prêt pour l’apprentissage automatique.
Nous terminerons par quelques bonnes pratiques pour écrire un code
Pandas efficace et réutilisable.
Vers l’utilisation de Pandas en IA/ML : bonnes pratiques et cas
d’usage
Objectif
• Relier les compétences Pandas aux futures applications en machine learning, vision
par ordinateur et deep learning.
• Montrer comment Pandas s’intègre dans la chaîne IA.
• Donner quelques bonnes pratiques pour un code efficace et lisible.
Préparation des données pour le machine learning
Avant d’entraîner un modèle, il faut des données propres et numériques. Pandas est l’outil
central de ce prétraitement.
Encodage des variables catégorielles
• One-hot encoding :
pd.get_dummies(titanic_df["Sex"])
Cela produit deux colonnes : male et female.

30. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 29 / 34
• Label encoding simple :
titanic_df["Embarked"] = titanic_df["Embarked"].replace({"C":0,
"Q":1, "S":2})
Feature engineering
Créer de nouvelles caractéristiques :
titanic_df["FamilySize"] = titanic_df["SibSp"] + titanic_df["Parch"] + 1
titanic_df["Year"] = titanic_df["Date"].dt.year
Détection d’outliers
outliers = titanic_df[titanic_df["Fare"] >
titanic_df["Fare"].quantile(0.99)]
print(outliers.head())
Ces valeurs extrêmes peuvent être traitées ou exclues avant modélisation.
Intégration avec les bibliothèques de ML/DL
Avec scikit-learn
Un DataFrame peut être directement utilisé.
X = titanic_df.drop("Survived", axis=1).to_numpy()
y = titanic_df["Survived"].to_numpy()
scikit-learn accepte numpy.array, mais garde souvent les colonnes Pandas pour plus de clarté.
Avec la vision par ordinateur
Un DataFrame peut stocker les annotations d’images.
images_df = pd.DataFrame({
"filepath": ["img1.jpg","img2.jpg"],
"label": ["cat","dog"]
})
print(images_df["label"].value_counts())
On peut compter le nombre d’images par classe, faire un split train/test avec sample(), ou
fusionner avec des métadonnées (conditions de prise de vue, attributs…).
Avec le deep learning
Après entraînement d’un modèle, Pandas sert à analyser les résultats.
results_df = pd.DataFrame({
"y_true": [1,0,1,1,0],
"y_pred": [1,0,0,1,1]
})
print(results_df.groupby("y_true")["y_pred"].mean())
On obtient des métriques par sous-groupe, utiles pour détecter les classes où le modèle échoue.

31. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 30 / 34
Bonnes pratiques de code Pandas
Utiliser les opérations vectorisées
df["col"] = df["col"] + 1 # rapide
NB : Éviter les boucles for ligne par ligne.
Method chaining (chaînage de méthodes)
df_clean = (
titanic_df
.dropna()
.assign(FamilySize = titanic_df["SibSp"] + titanic_df["Parch"] + 1)
.groupby("Pclass")
.mean()
)
C’est compact, lisible, et proche d’une pipeline.
Documentation et aide
• help(pd.DataFrame)
• Documentation officielle Pandas
• Cheatsheets (rapides et efficaces)
Reproductibilité
• Écrire du code clair dans un notebook Jupyter.
• Éviter les modifications manuelles.
• Toujours garder une trace des étapes de nettoyage.
Cas d’usage final : préparation d’un dataset
Scénario : prédiction de revenus
On dispose de plusieurs fichiers :
• données démographiques,
• historiques d’achats,
• attributs socio-professionnels.
Avec Pandas :
1. Lire les fichiers CSV.
2. Nettoyer : supprimer NaN, traiter outliers.
3. Fusionner les tables avec merge sur l’ID.
4. Créer des features : dépenses totales par catégorie (groupby), encodage de catégories
(get_dummies).
5. Exporter le DataFrame final en CSV.
Résultat : un dataset propre, prêt pour l’entraînement.

32. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 31 / 34
Conclusion
Pandas est plus qu’un outil de manipulation, c’est le pont entre les données brutes et les modèles
IA.
Les techniques vues ici préparent aux modules futurs de :
• machine learning,
• vision par ordinateur,
• deep learning.
Pandas – Fiche récapitulative
Importation
import pandas as pd
Structures de données
• Series : tableau 1D étiqueté.
s = pd.Series([23, 19, 21], index=["Fès","Casa","Khouribga"])
• DataFrame : tableau 2D étiqueté.
df = pd.DataFrame({"Nom":["Ali","Sara"], "Âge":[21,23]})
Import / Export
• Lire CSV : pd.read_csv("file.csv")
• Lire Excel : pd.read_excel("file.xlsx")
• Écrire : df.to_csv("file.csv", index=False)
Exploration rapide
• df.head() / df.tail() → aperçu
• df.shape → dimensions
• df.info() → résumé (types, NaN)
• df.describe() → stats descriptives
• df["col"].value_counts() → distribution
Sélections
• Colonne : df["col"]
• Plusieurs colonnes : df[["col1","col2"]]
• Ligne par index : df.loc[5]
• Ligne par position : df.iloc[5]
• Cellule : df.loc[5,"col"] ou df.iat[5,2]
• Filtrage : df[df["Age"]>20]

33. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 32 / 34
Manipulation de colonnes
• Créer : df["New"] = df["A"] + df["B"]
• Modifier : df["Age"] *= 2
• Renommer : df.rename(columns={"old":"new"})
• Réordonner : df = df[["col1","col2"]]
Nettoyage
• Détection NaN : df.isnull().sum()
• Supprimer : df.dropna()
• Remplir : df.fillna(df["Age"].mean())
• Doublons : df.drop_duplicates()
• Remplacer : df.replace({"M":"Male"})
• Changer type : df["col"].astype("category")
GroupBy et Pivot
• Groupement :
df.groupby("Pclass")["Survived"].mean()
• Plusieurs clés :
df.groupby(["Sex","Pclass"]).size()
• Pivot table :
pd.pivot_table(df, values="Survived", index="Pclass", columns="Sex",
aggfunc="mean")
Fusion et concaténation
• Merge :
pd.merge(df1, df2, left_on="id", right_on="client_id", how="inner")
• Concat vertical :
pd.concat([df1, df2], axis=0, ignore_index=True)
• Concat horizontal :
pd.concat([df1, df2], axis=1)
Données temporelles
• Conversion : pd.to_datetime(df["date"])
• Index temps : df.set_index("date")
• Resample : df.resample("M").mean()
• Décalage : df.shift(1)
• Rolling : df.rolling(7).mean()

34. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 33 / 34
Bonnes pratiques
• Préférer les opérations vectorisées aux boucles.
• Utiliser le method chaining pour plus de lisibilité.
• Garder le code reproductible dans un notebook.
• Bien documenter les étapes de nettoyage et de transformation.
Cas d’usage IA/ML
• Prétraitement: nettoyage, encodage, création de features.
• Split train/test :
df.sample(frac=0.8)
• Export vers ML/DL :
X = df.drop("target",1).to_numpy() / y = df["target"].to_numpy()
• Vision : gérer les chemins et labels d’images.
• Analyse post-modèle : grouper les résultats pour détecter des biais.
Conclusion
Nous arrivons au terme de notre parcours sur Pandas. Vous avez maintenant toutes les bases
nécessaires pour manipuler, nettoyer et transformer des données en vue d’un projet
d’intelligence artificielle.
Les outils que vous avez découverts ici seront les fondations des prochains modules : Machine
Learning, Vision par Ordinateur et Deep Learning.
Dans la suite de votre formation, vous verrez comment utiliser ces données préparées pour
entraîner des modèles intelligents capables de prédire, classifier ou reconnaître des formes dans
des images.

35. Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 34 / 34
Conclusion générale
Ce support de cours a permis d’explorer les fonctionnalités essentielles de Pandas, depuis la
création des structures de données de base jusqu’à la préparation de datasets complets pour
l’intelligence artificielle.
L’étudiant a pu constater que Pandas n’est pas seulement une bibliothèque de manipulation de
données, mais un véritable écosystème d’analyse, combinant simplicité d’utilisation et
puissance de traitement.
Grâce aux compétences acquises, il est désormais capable de :
• manipuler efficacement des Series et des DataFrames,
• importer et explorer des jeux de données réels,
• nettoyer et transformer des données de manière structurée,
• réaliser des analyses avancées par regroupement, fusion ou pivotement,
• préparer des datasets exploitables par des modèles de Machine Learning.
Ces connaissances constituent une base indispensable pour aborder la suite du module,
notamment :
• Scikit-learn, qui utilise les données préparées sous Pandas pour l’apprentissage
automatique,
• ainsi que les bibliothèques de Deep Learning et de Vision par Ordinateur qui
s’appuient sur les mêmes principes de structuration et de prétraitement des données.
En conclusion, la maîtrise de Pandas offre à l’étudiant une compétence clé pour transformer
des données brutes en informations exploitables.
Elle établit le lien naturel entre l’analyse exploratoire et la modélisation, ouvrant la voie à une
utilisation efficace des outils de l’intelligence artificielle.
Dans le support suivant, consacré à Scikit-learn, nous mettrons en pratique ces connaissances
pour entraîner et évaluer des modèles prédictifs à partir de données préparées avec Pandas.