SUPPORT DE COURS

PYTHON POUR LA DATA ANALYSE

ET L'INTELLIGENCE ARTIFICIELLE
Du premier programme au projet d'analyse de données

Filière : Data Analyse et Intelligence Artificielle

Niveau : Débutant, aucune expérience préalable en programmation requise

Par M. Boris ADJAHE

Année académique 2026 – 2027

 Python pour la Data Analyse et l'IA

Table des matières

Table des matières ............................................................................................................................................................. 2
Avant-propos ...................................................................................................................................................................... 7
Comment utiliser ce support ? ....................................................................................................................................... 7
Chapitre 1 — Introduction à Python .................................................................................................................................. 8
1.1 Histoire de Python .................................................................................................................................................... 8
1.2 Pourquoi Python est le langage de référence en Data Analyse et IA ..................................................................... 8
1.3 Domaines d'application............................................................................................................................................ 8
1.4 Les métiers utilisant Python ..................................................................................................................................... 8
Résumé du chapitre........................................................................................................................................................ 8
Mots-clés à retenir ......................................................................................................................................................... 8
Erreurs fréquentes des débutants ................................................................................................................................. 8
Exercices d'application ................................................................................................................................................... 8
Chapitre 2 — Installation de l'environnement ................................................................................................................ 10
2.1 Installation de Python ............................................................................................................................................ 10
2.2 Installation de Visual Studio Code ......................................................................................................................... 10
2.3 Installation des extensions Python ........................................................................................................................ 10
2.4 Utilisation du terminal ........................................................................................................................................... 10
2.5 Création d'un premier projet ................................................................................................................................. 10
Résumé du chapitre...................................................................................................................................................... 10
Mots-clés à retenir ....................................................................................................................................................... 10
Erreurs fréquentes des débutants ............................................................................................................................... 10
Exercices d'application ................................................................................................................................................. 11
Chapitre 3 — Les bases de Python ................................................................................................................................... 12
3.1 Syntaxe ................................................................................................................................................................... 12
3.2 Les commentaires................................................................................................................................................... 12
3.3 Les variables ........................................................................................................................................................... 12
3.4 Les constantes ........................................................................................................................................................ 12
3.5 Les types de données ............................................................................................................................................. 12
3.6 Conversion de types ............................................................................................................................................... 12
3.7 Les opérateurs ........................................................................................................................................................ 12
3.8 Les entrées et sorties.............................................................................................................................................. 12
Résumé du chapitre...................................................................................................................................................... 13
Mots-clés à retenir ....................................................................................................................................................... 13
Erreurs fréquentes des débutants ............................................................................................................................... 13
Exercices d'application ................................................................................................................................................. 13
Chapitre 4 — Structures de contrôle ............................................................................................................................... 14
4.1 Condition if ............................................................................................................................................................. 14
4.2 if...else .................................................................................................................................................................... 14
4.3 if...elif...else ............................................................................................................................................................ 14
4.4 L'instruction match (présentation) ........................................................................................................................ 14
4.5 Boucle for................................................................................................................................................................ 14
Page 2 / 43
 Python pour la Data Analyse et l'IA
4.6 Boucle while ........................................................................................................................................................... 14
4.7 break, continue et pass .......................................................................................................................................... 14
Résumé du chapitre...................................................................................................................................................... 14
Mots-clés à retenir ....................................................................................................................................................... 14
Erreurs fréquentes des débutants ............................................................................................................................... 15
Exercices d'application ................................................................................................................................................. 15
Chapitre 5 — Les structures de données ......................................................................................................................... 16
5.1 Les listes .................................................................................................................................................................. 16
5.2 Les tuples ................................................................................................................................................................ 16
5.3 Les dictionnaires ..................................................................................................................................................... 16
5.4 Les ensembles (set) ................................................................................................................................................ 16
5.5 Manipulation et parcours des collections ............................................................................................................. 16
Résumé du chapitre...................................................................................................................................................... 16
Mots-clés à retenir ....................................................................................................................................................... 16
Erreurs fréquentes des débutants ............................................................................................................................... 16
Exercices d'application ................................................................................................................................................. 16
Chapitre 6 — Les fonctions .............................................................................................................................................. 18
6.1 Déclaration d'une fonction .................................................................................................................................... 18
6.2 Les paramètres ....................................................................................................................................................... 18
6.3 Les valeurs de retour .............................................................................................................................................. 18
6.4 Variables locales et globales .................................................................................................................................. 18
6.5 Documentation d'une fonction .............................................................................................................................. 18
Résumé du chapitre...................................................................................................................................................... 18
Mots-clés à retenir ....................................................................................................................................................... 18
Erreurs fréquentes des débutants ............................................................................................................................... 18
Exercices d'application ................................................................................................................................................. 18
Chapitre 7 — Les chaînes de caractères .......................................................................................................................... 20
7.1 Manipulation de base ............................................................................................................................................ 20
7.2 Découpage (slicing) ................................................................................................................................................ 20
7.3 Recherche dans une chaîne.................................................................................................................................... 20
7.4 Remplacement........................................................................................................................................................ 20
7.5 Formatage des chaînes ........................................................................................................................................... 20
Résumé du chapitre...................................................................................................................................................... 20
Mots-clés à retenir ....................................................................................................................................................... 20
Erreurs fréquentes des débutants ............................................................................................................................... 20
Exercices d'application ................................................................................................................................................. 20
Chapitre 8 — Gestion des exceptions .............................................................................................................................. 22
8.1 Pourquoi gérer les erreurs ?................................................................................................................................... 22
8.2 try et except............................................................................................................................................................ 22
8.3 else .......................................................................................................................................................................... 22
8.4 finally ...................................................................................................................................................................... 22
8.5 raise......................................................................................................................................................................... 22
Page 3 / 43
 Python pour la Data Analyse et l'IA
Résumé du chapitre...................................................................................................................................................... 22
Mots-clés à retenir ....................................................................................................................................................... 22
Erreurs fréquentes des débutants ............................................................................................................................... 22
Exercices d'application ................................................................................................................................................. 22
Chapitre 9 — Modules et bibliothèques .......................................................................................................................... 24
9.1 L'instruction import ................................................................................................................................................ 24
9.2 Le module math...................................................................................................................................................... 24
9.3 Le module random ................................................................................................................................................. 24
9.4 Le module datetime ............................................................................................................................................... 24
9.5 Le module os........................................................................................................................................................... 24
9.6 Le module statistics ................................................................................................................................................ 24
Résumé du chapitre...................................................................................................................................................... 24
Mots-clés à retenir ....................................................................................................................................................... 24
Erreurs fréquentes des débutants ............................................................................................................................... 24
Exercices d'application ................................................................................................................................................. 24
Chapitre 10 — Manipulation des fichiers ........................................................................................................................ 26
10.1 Lecture de fichiers texte ....................................................................................................................................... 26
10.2 Écriture de fichiers................................................................................................................................................ 26
10.3 Introduction au format CSV ................................................................................................................................. 26
Résumé du chapitre...................................................................................................................................................... 26
Mots-clés à retenir ....................................................................................................................................................... 26
Erreurs fréquentes des débutants ............................................................................................................................... 26
Exercices d'application ................................................................................................................................................. 26
Chapitre 11 — Introduction à NumPy.............................................................................................................................. 28
11.1 Installation ............................................................................................................................................................ 28
11.2 Les tableaux NumPy (array) ................................................................................................................................. 28
11.3 Calculs vectoriels .................................................................................................................................................. 28
11.4 Fonctions statistiques essentielles ...................................................................................................................... 28
Résumé du chapitre...................................................................................................................................................... 28
Mots-clés à retenir ....................................................................................................................................................... 28
Erreurs fréquentes des débutants ............................................................................................................................... 28
Exercices d'application ................................................................................................................................................. 28
Chapitre 12 — Introduction à Pandas .............................................................................................................................. 30
12.1 Installation ............................................................................................................................................................ 30
12.2 Le DataFrame........................................................................................................................................................ 30
12.3 Lecture d'un fichier CSV ....................................................................................................................................... 30
12.4 Sélection des colonnes ......................................................................................................................................... 30
12.5 Filtrage des données ............................................................................................................................................ 30
12.6 Calculs statistiques simples .................................................................................................................................. 30
Résumé du chapitre...................................................................................................................................................... 30
Mots-clés à retenir ....................................................................................................................................................... 30
Erreurs fréquentes des débutants ............................................................................................................................... 30
Page 4 / 43
 Python pour la Data Analyse et l'IA
Exercices d'application ................................................................................................................................................. 30
Chapitre 13 — Visualisation des données ....................................................................................................................... 32
13.1 Introduction à Matplotlib .................................................................................................................................... 32
13.2 Diagramme en barres ........................................................................................................................................... 32
13.3 Courbe (line plot).................................................................................................................................................. 32
13.4 Histogramme ........................................................................................................................................................ 32
13.5 Camembert (pie chart) ......................................................................................................................................... 32
Résumé du chapitre...................................................................................................................................................... 32
Mots-clés à retenir ....................................................................................................................................................... 32
Erreurs fréquentes des débutants ............................................................................................................................... 32
Exercices d'application ................................................................................................................................................. 32
Chapitre 14 — Bonnes pratiques ..................................................................................................................................... 34
14.1 Indentation ........................................................................................................................................................... 34
14.2 Convention de nommage ..................................................................................................................................... 34
14.3 Commentaires utiles ............................................................................................................................................ 34
14.4 Organisation du code ........................................................................................................................................... 34
14.5 Débogage .............................................................................................................................................................. 34
Résumé du chapitre...................................................................................................................................................... 34
Mots-clés à retenir ....................................................................................................................................................... 34
Erreurs fréquentes des débutants ............................................................................................................................... 34
Exercices d'application ................................................................................................................................................. 34
Chapitre 15 — Exercices ................................................................................................................................................... 36
Niveau facile ................................................................................................................................................................. 36
Niveau intermédiaire ................................................................................................................................................... 36
Niveau avancé .............................................................................................................................................................. 37
Résumé du chapitre...................................................................................................................................................... 38
Conseil pédagogique .................................................................................................................................................... 38
Chapitre 16 — Travaux pratiques .................................................................................................................................... 39
TP 1 — Calculatrice ....................................................................................................................................................... 39
TP 2 — Gestion des notes d'une classe........................................................................................................................ 39
TP 3 — Analyse des ventes d'une boutique ................................................................................................................ 39
TP 4 — Analyse d'un fichier CSV .................................................................................................................................. 40
TP 5 — Analyse des résultats d'un examen ................................................................................................................. 40
Résumé du chapitre...................................................................................................................................................... 40
Chapitre 17 — Projet de fin de module ........................................................................................................................... 42
Analyse des performances académiques des étudiants ............................................................................................. 42
17.1 Objectifs du projet................................................................................................................................................ 42
17.2 Structure du fichier de données .......................................................................................................................... 42
17.3 Étape 1 : Lecture du fichier CSV ........................................................................................................................... 42
17.4 Étape 2 : Calcul des moyennes ............................................................................................................................. 42
17.5 Étape 3 : Détermination des meilleurs étudiants................................................................................................ 42
17.6 Étape 4 : Statistiques descriptives ....................................................................................................................... 42
Page 5 / 43
 Python pour la Data Analyse et l'IA
17.7 Étape 5 : Visualisation des résultats .................................................................................................................... 42
17.8 Étape 6 : Export du rapport de résultats ............................................................................................................. 43
17.9 Grille d'évaluation du projet ................................................................................................................................ 43
17.10 Pour aller plus loin.............................................................................................................................................. 43
Résumé du chapitre...................................................................................................................................................... 43

Page 6 / 43
 Python pour la Data Analyse et l'IA

Avant-propos
Ce support de cours a été conçu pour accompagner les étudiants de première année de la filière Data Analyse et Intelligence Artificielle
dans leurs tout premiers pas en programmation. Aucune connaissance préalable n'est nécessaire : chaque notion est expliquée simplement,
illustrée par des exemples concrets, et suivie d'exercices progressifs.
Le document est structuré en 17 chapitres, allant des bases du langage Python jusqu'à un projet complet d'analyse de données mobilisant
NumPy, Pandas et Matplotlib. Chaque chapitre se termine par un résumé, les mots-clés essentiels, les erreurs fréquentes des débutants,
ainsi que cinq exercices corrigés.
La meilleure façon d'apprendre à programmer est de pratiquer. Il est fortement recommandé d'exécuter soi-même chaque exemple de
code proposé dans ce document, puis de résoudre les exercices avant de consulter les corrigés.

Comment utiliser ce support ?

• Lire chaque chapitre dans l'ordre : les notions s'appuient les unes sur les autres.
• Recopier et exécuter systématiquement les exemples de code dans un éditeur (VS Code).
• Faire les exercices de fin de chapitre avant de regarder le corrigé.
• Réaliser les travaux pratiques du chapitre 16 en autonomie ou en binôme.
• Terminer par le projet de fin de module (chapitre 17), qui synthétise l'ensemble des compétences acquises.

Page 7 / 43
 Python pour la Data Analyse et l'IA
Chapitre 1 — Introduction à Python
1.1 Histoire de Python
Python est un langage de programmation créé en 1991 par Guido van Rossum, un développeur néerlandais. Son nom ne vient pas du
serpent, mais de la série télévisée britannique « Monty Python's Flying Circus », que son créateur appréciait. Dès le départ, Guido van
Rossum voulait un langage simple à lire, agréable à écrire et accessible à des personnes qui ne sont pas des experts en informatique.
Depuis sa création, Python n'a cessé d'évoluer : la version 2 est sortie en 2000, puis la version 3 en 2008, qui a apporté de nombreuses
améliorations. Aujourd'hui, c'est la version 3 qui est utilisée partout dans le monde, y compris dans ce cours.

1.2 Pourquoi Python est le langage de référence en Data Analyse et IA

Python est devenu, en quelques années, le langage préféré des data analystes et des spécialistes de l'intelligence artificielle, pour plusieurs
raisons :
• Une syntaxe simple et proche du langage humain, ce qui le rend facile à apprendre pour les débutants.
• Un très grand nombre de bibliothèques spécialisées (NumPy, Pandas, Matplotlib, Scikit-learn, TensorFlow, PyTorch, etc.).
• Une communauté immense qui partage des tutoriels, des solutions et des outils gratuits.
• Sa polyvalence : le même langage sert à analyser des données, créer des sites web, automatiser des tâches ou construire des
intelligences artificielles.
• Sa gratuité et sa compatibilité avec tous les systèmes d'exploitation (Windows, macOS, Linux).
1.3 Domaines d'application
Domaine Exemple d'utilisation
Analyse de données Nettoyer, explorer et visualiser de grands jeux de données
Intelligence artificielle Créer des modèles de machine learning et deep learning
Développement web Construire des sites avec Django ou Flask
Automatisation Créer des scripts qui exécutent des tâches répétitives
Science et recherche Simulations scientifiques, calcul numérique
Finance Analyse de risques, trading algorithmique

1.4 Les métiers utilisant Python

• Data Analyst : analyse et interprétation des données pour aider à la décision.
• Data Scientist : construction de modèles prédictifs et statistiques avancées.
• Ingénieur Machine Learning / IA : conception d'algorithmes d'apprentissage automatique.
• Développeur backend : création d'applications et de services web.
• Ingénieur DevOps : automatisation de l'infrastructure informatique.
• Chercheur scientifique : traitement de données expérimentales.
Résumé du chapitre
Python est un langage de programmation créé en 1991 par Guido van Rossum. Sa syntaxe simple, sa richesse en bibliothèques et sa grande
communauté en font aujourd'hui le langage de référence pour la Data Analyse et l'Intelligence Artificielle. Il est utilisé dans de nombreux
domaines et par de nombreux métiers du numérique.

Mots-clés à retenir
Python • Guido van Rossum • Data Analyse • Intelligence Artificielle • Bibliothèque

Erreurs fréquentes des débutants

• Confondre Python 2 et Python 3 : ce cours utilise exclusivement Python 3.
• Penser que Python est réservé aux experts en informatique : c'est au contraire un langage conçu pour les débutants.
• Croire qu'il faut tout maîtriser avant de commencer à pratiquer : on apprend Python en programmant, pas seulement en lisant.
Exercices d'application
Exercice 1 — Recherche
En une phrase, expliquez pourquoi le nom « Python » a été choisi par son créateur.
Corrigé :
Guido van Rossum a choisi ce nom en référence à la série comique « Monty Python's Flying Circus », qu'il
appréciait, et non au serpent.
Exercice 2 — Réflexion
Citez trois bibliothèques Python utilisées en Data Analyse ou en Intelligence Artificielle.
Page 8 / 43
 Python pour la Data Analyse et l'IA
Corrigé :
NumPy, Pandas et Matplotlib (ou Scikit-learn, TensorFlow, PyTorch).
Exercice 3 — Vrai ou Faux
« Python est un langage payant réservé aux grandes entreprises. » Vrai ou faux ? Justifiez.
Corrigé :
Faux. Python est un langage libre et gratuit, utilisable par tous, particuliers comme entreprises.
Exercice 4 — Association
Associez chaque métier à sa mission : (1) Data Analyst, (2) Data Scientist — (a) construire des modèles prédictifs, (b) analyser des données
pour aider à la décision.
Corrigé :
(1)-(b) Data Analyst : analyse des données pour la décision. (2)-(a) Data Scientist : construction de modèles
prédictifs.
Exercice 5 — Synthèse
En deux phrases maximum, résumez pourquoi Python convient particulièrement aux débutants en programmation.
Corrigé :
Python a une syntaxe proche du langage naturel, sans symboles complexes obligatoires, ce qui facilite la lecture
et l'écriture du code. Sa communauté propose aussi énormément de ressources pédagogiques gratuites pour
accompagner les débutants.

Page 9 / 43
 Python pour la Data Analyse et l'IA
Chapitre 2 — Installation de l'environnement
2.1 Installation de Python
Pour programmer en Python, il faut d'abord installer l'interpréteur Python sur son ordinateur. Voici les étapes générales :
1. Se rendre sur le site officiel : [Link]
2. Télécharger la dernière version stable de Python 3 correspondant à votre système d'exploitation.
3. Lancer l'installateur. Sur Windows, cocher impérativement la case « Add Python to PATH » avant de cliquer sur Install Now.
4. Vérifier l'installation en ouvrant un terminal et en tapant la commande python --version (ou python3 --version sur macOS/Linux).
$ python --version
Python 3.12.4

2.2 Installation de Visual Studio Code

Visual Studio Code (VS Code) est un éditeur de code gratuit, léger et très utilisé par les développeurs Python.
5. Télécharger VS Code depuis [Link]
6. Installer le logiciel en suivant les instructions à l'écran.
7. Ouvrir VS Code une fois l'installation terminée.
2.3 Installation des extensions Python
Une fois VS Code installé, il faut ajouter l'extension Python pour bénéficier de la coloration syntaxique, de l'autocomplétion et du débogueur
:
8. Ouvrir l'onglet Extensions (icône de carrés dans la barre latérale gauche, ou raccourci Ctrl+Shift+X).
9. Rechercher « Python » (extension publiée par Microsoft).
10. Cliquer sur Installer.
11. Redémarrer VS Code si nécessaire.
2.4 Utilisation du terminal
Le terminal (ou console) permet d'exécuter des commandes et des scripts Python. Dans VS Code, on l'ouvre avec le menu Terminal >
Nouveau terminal, ou le raccourci Ctrl+` (accent grave).
Commande Utilité
python nom_fichier.py Exécuter un script Python
cd nom_dossier Se déplacer dans un dossier
dir (Windows) / ls (macOS-Linux) Lister les fichiers d'un dossier
pip install nom_module Installer une bibliothèque Python
cls (Windows) / clear (macOS-Linux) Effacer le contenu du terminal

2.5 Création d'un premier projet

Un bon projet commence toujours par une organisation claire des fichiers et des dossiers.
12. Créer un dossier, par exemple mon_premier_projet.
13. Ouvrir ce dossier dans VS Code (Fichier > Ouvrir le dossier).
14. Créer un fichier nommé [Link].
15. Écrire une première instruction : print("Bonjour le monde")
16. Exécuter le script depuis le terminal avec la commande python [Link].
# [Link]
print("Bonjour le monde")
$ python [Link]
Bonjour le monde

Résumé du chapitre
L'environnement de développement Python se compose de l'interpréteur Python et d'un éditeur de code comme Visual Studio Code, enrichi
de l'extension Python. Le terminal permet d'exécuter des scripts et d'installer des bibliothèques avec pip. Un projet Python bien organisé
commence par un dossier dédié et un fichier principal, souvent nommé [Link].

Mots-clés à retenir
Interpréteur • PATH • VS Code • Extension • Terminal • pip

Erreurs fréquentes des débutants

• Oublier de cocher « Add Python to PATH » lors de l'installation sous Windows, ce qui empêche d'utiliser Python depuis le terminal.
• Confondre le terminal du système et la console intégrée de VS Code (les deux fonctionnent, mais il faut être dans le bon dossier).
Page 10 / 43
 Python pour la Data Analyse et l'IA
• Enregistrer un fichier sans l'extension .py, ce qui empêche son exécution en tant que script Python.
• Ne pas vérifier la version installée avant de commencer à coder.
Exercices d'application
Exercice 1 — Vérification
Quelle commande permet de vérifier la version de Python installée sur un ordinateur ?
Corrigé :
python --version (ou python3 --version selon le système).
Exercice 2 — Premier script
Créez un fichier [Link] qui affiche votre prénom à l'écran.
Corrigé :
print("Sarah")
Exercice 3 — Navigation
Quelle commande permet de se déplacer dans un dossier nommé projets depuis le terminal ?
Corrigé :
cd projets
Exercice 4 — Extension
Quelle extension faut-il installer dans VS Code pour développer en Python ?
Corrigé :
L'extension officielle « Python », publiée par Microsoft.
Exercice 5 — Exécution
Écrivez la commande terminal permettant d'exécuter un fichier nommé [Link].
Corrigé :
python [Link]

Page 11 / 43
 Python pour la Data Analyse et l'IA
Chapitre 3 — Les bases de Python
3.1 Syntaxe
La syntaxe de Python est réputée pour sa clarté. Contrairement à d'autres langages, Python n'utilise pas d'accolades { } pour délimiter les
blocs de code : il utilise l'indentation (les espaces en début de ligne).
if 5 > 2:
print("Cinq est plus grand que deux")
Chaque instruction s'écrit en général sur une seule ligne, sans point-virgule obligatoire à la fin.

3.2 Les commentaires

Un commentaire est une ligne de texte ignorée par l'interpréteur, utile pour expliquer le code. On utilise le symbole # pour un commentaire
sur une ligne, ou des triples guillemets pour un commentaire sur plusieurs lignes.
# Ceci est un commentaire sur une ligne
"""
Ceci est un commentaire
sur plusieurs lignes
"""

3.3 Les variables

Une variable est un espace mémoire nommé qui contient une valeur. En Python, il n'est pas nécessaire de déclarer le type d'une variable :
il est déduit automatiquement.
age = 20
prenom = "Awa"
moyenne = 14.5
Le nom d'une variable doit commencer par une lettre ou un underscore (_), ne doit pas contenir d'espace, et est sensible à la casse (age et
Age sont deux variables différentes).

3.4 Les constantes

Python ne possède pas de mot-clé pour créer une constante « verrouillée ». Par convention, on écrit les noms de constantes en majuscules
pour signaler qu'elles ne doivent pas être modifiées.
PI = 3.14159
TAUX_TVA = 0.18

3.5 Les types de données

Type Description Exemple
int Nombre entier 12
float Nombre décimal 12.5
str Chaîne de caractères (texte) "Bonjour"
bool Valeur booléenne (vrai/faux) True / False
list Liste ordonnée de valeurs [1, 2, 3]
dict Dictionnaire clé-valeur {"nom": "Awa"}

La fonction type() permet de connaître le type d'une variable.

age = 20
print(type(age)) # <class 'int'>

3.6 Conversion de types

On peut convertir une valeur d'un type vers un autre grâce aux fonctions int(), float(), str() et bool().
nombre_texte = "25"
nombre = int(nombre_texte)
print(nombre + 5) # 30

3.7 Les opérateurs

Catégorie Opérateurs Exemple
Arithmétiques + - * / // % ** 7 // 2 = 3 (division entière)
Comparaison == != > < >= <= 5 > 3 → True
Logiques and or not True and False → False
Affectation = += -= *= /= x += 1 équivaut à x = x + 1

3.8 Les entrées et sorties

Page 12 / 43
 Python pour la Data Analyse et l'IA
La fonction print() affiche un résultat à l'écran (sortie). La fonction input() permet de récupérer une valeur saisie par l'utilisateur (entrée).
Attention : input() renvoie toujours une chaîne de caractères (str).
nom = input("Quel est votre nom ? ")
print("Bonjour", nom)

Résumé du chapitre
Python utilise l'indentation pour structurer le code. Une variable stocke une valeur dont le type (entier, flottant, texte, booléen, liste,
dictionnaire...) est déduit automatiquement. Les opérateurs permettent d'effectuer des calculs, des comparaisons et des opérations
logiques. Les fonctions print() et input() gèrent respectivement les sorties et les entrées.

Mots-clés à retenir
Indentation • Variable • Type • Conversion • Opérateur • print() • input()

Erreurs fréquentes des débutants

• Oublier les deux-points ( : ) à la fin d'une ligne qui ouvre un bloc (if, for, while, def...).
• Mélanger espaces et tabulations dans l'indentation, ce qui provoque une erreur.
• Oublier que input() renvoie toujours du texte, même si l'utilisateur tape un nombre.
• Utiliser = (affectation) au lieu de == (comparaison) dans une condition.
• Nommer une variable avec un espace ou un chiffre en première position (interdit en Python).
Exercices d'application
Exercice 1 — Variables
Créez trois variables : votre prénom, votre âge et votre moyenne, puis affichez-les avec print().
Corrigé :
prenom = "Koffi"
age = 19
moyenne = 15.5
print(prenom, age, moyenne)
Exercice 2 — Types
Affichez le type de chacune des valeurs suivantes : 10, 10.5, "10", True.
Corrigé :
print(type(10)) # <class 'int'>
print(type(10.5)) # <class 'float'>
print(type("10")) # <class 'str'>
print(type(True)) # <class 'bool'>
Exercice 3 — Conversion
Demandez à l'utilisateur son âge avec input(), convertissez-le en entier, puis affichez son âge dans 10 ans.
Corrigé :
age = int(input("Votre âge : "))
print("Dans 10 ans, vous aurez", age + 10, "ans")
Exercice 4 — Opérateurs
Calculez et affichez le reste de la division de 17 par 4, ainsi que le résultat de 2 puissance 5.
Corrigé :
print(17 % 4) # 1
print(2 ** 5) # 32
Exercice 5 — Comparaison
Écrivez une expression qui vérifie si une variable note vaut au moins 10 ET au plus 20.
Corrigé :
note = 14
print(note >= 10 and note <= 20) # True

Page 13 / 43
 Python pour la Data Analyse et l'IA
Chapitre 4 — Structures de contrôle
4.1 Condition if
L'instruction if permet d'exécuter un bloc de code uniquement si une condition est vraie.
note = 12
if note >= 10:
print("Admis")

4.2 if...else
L'instruction else exécute un bloc alternatif lorsque la condition du if est fausse.
note = 8
if note >= 10:
print("Admis")
else:
print("Ajourné")

4.3 if...elif...else
elif (contraction de « else if ») permet de tester plusieurs conditions à la suite.
note = 14
if note >= 16:
print("Très bien")
elif note >= 14:
print("Bien")
elif note >= 10:
print("Passable")
else:
print("Insuffisant")

4.4 L'instruction match (présentation)

Depuis Python 3.10, l'instruction match permet de comparer une valeur à plusieurs motifs, un peu comme un aiguillage. Elle est utile
lorsqu'on doit tester une même variable par rapport à de nombreux cas.
jour = "lundi"
match jour:
case "samedi" | "dimanche":
print("Week-end")
case _:
print("Jour de semaine")

4.5 Boucle for

La boucle for permet de répéter un bloc de code pour chaque élément d'une séquence (liste, chaîne de caractères, plage de nombres...).
for i in range(5):
print(i) # affiche 0, 1, 2, 3, 4

4.6 Boucle while

La boucle while répète un bloc de code tant qu'une condition reste vraie.
compteur = 0
while compteur < 3:
print(compteur)
compteur += 1

4.7 break, continue et pass

Instruction Effet
break Arrête immédiatement la boucle en cours
continue Passe directement à l'itération suivante
pass Ne fait rien ; sert d'instruction « vide » (utile comme réservation de code)

for i in range(10):
if i == 5:
break # arrête la boucle à i = 5
if i % 2 == 0:
continue # saute les nombres pairs
print(i)

Résumé du chapitre
Les structures conditionnelles (if, elif, else, match) permettent d'exécuter du code selon des conditions. Les boucles for et while répètent
des instructions, respectivement pour un nombre défini d'éléments ou tant qu'une condition est vraie. Les instructions break, continue et
pass affinent le comportement des boucles.

Mots-clés à retenir
Page 14 / 43
 Python pour la Data Analyse et l'IA
if • elif • else • match • for • while • break • continue • pass

Erreurs fréquentes des débutants

• Oublier les deux-points après la condition d'un if, for ou while.
• Mal indenter le bloc de code, ce qui change sa signification ou provoque une erreur.
• Créer une boucle while infinie en oubliant de modifier la variable de la condition.
• Confondre break (arrête toute la boucle) et continue (passe seulement à l'itération suivante).
Exercices d'application
Exercice 1 — Condition simple
Écrivez un programme qui affiche « Majeur » si l'âge est supérieur ou égal à 18, sinon « Mineur ».
Corrigé :
age = 16
if age >= 18:
print("Majeur")
else:
print("Mineur")
Exercice 2 — elif
Écrivez un programme qui affiche la mention d'une note (Excellent ≥ 16, Bien ≥ 14, Passable ≥ 10, Insuffisant sinon).
Corrigé :
note = 15
if note >= 16:
print("Excellent")
elif note >= 14:
print("Bien")
elif note >= 10:
print("Passable")
else:
print("Insuffisant")
Exercice 3 — Boucle for
Affichez les nombres de 1 à 10 grâce à une boucle for.
Corrigé :
for i in range(1, 11):
print(i)
Exercice 4 — Boucle while
Affichez le compte à rebours de 5 à 1 avec une boucle while.
Corrigé :
n = 5
while n >= 1:
print(n)
n -= 1
Exercice 5 — break et continue
Parcourez les nombres de 1 à 20 : arrêtez la boucle dès que vous atteignez 15, et sautez les multiples de 3.
Corrigé :
for i in range(1, 21):
if i == 15:
break
if i % 3 == 0:
continue
print(i)

Page 15 / 43
 Python pour la Data Analyse et l'IA
Chapitre 5 — Les structures de données
5.1 Les listes
Une liste est une collection ordonnée et modifiable de valeurs, définie entre crochets [].
fruits = ["pomme", "banane", "orange"]
print(fruits[0]) # pomme
[Link]("mangue") # ajoute un élément
fruits[1] = "kiwi" # modifie un élément

5.2 Les tuples

Un tuple ressemble à une liste, mais il est immuable : une fois créé, il ne peut plus être modifié. On le définit entre parenthèses ().
coordonnees = (6.37, 2.43)
print(coordonnees[0]) # 6.37

5.3 Les dictionnaires

Un dictionnaire associe des clés à des valeurs, entre accolades {}. Il permet de retrouver rapidement une information à partir de son nom.
etudiant = {"nom": "Fatou", "age": 20, "moyenne": 15.5}
print(etudiant["nom"]) # Fatou
etudiant["age"] = 21 # modifie une valeur

5.4 Les ensembles (set)

Un ensemble est une collection non ordonnée d'éléments uniques (sans doublons), définie entre accolades {}.
notes = {12, 15, 12, 18, 15}
print(notes) # {12, 15, 18} — les doublons disparaissent

5.5 Manipulation et parcours des collections

Structure Ordonnée Modifiable Doublons autorisés Syntaxe
Liste Oui Oui Oui []
Tuple Oui Non Oui ()
Dictionnaire Oui (depuis Python 3.7) Oui Clés uniques {clé: valeur}
Ensemble (set) Non Oui Non {}

On parcourt une collection avec une boucle for :

for fruit in fruits:
print(fruit)

for cle, valeur in [Link]():

print(cle, ":", valeur)

Résumé du chapitre
Python propose quatre structures de données principales : la liste (ordonnée, modifiable), le tuple (ordonné, immuable), le dictionnaire
(paires clé-valeur) et l'ensemble (éléments uniques, non ordonnés). Chacune se parcourt facilement avec une boucle for et convient à des
usages différents selon les besoins du programme.

Mots-clés à retenir
Liste • Tuple • Dictionnaire • Ensemble • append() • items() • immuable

Erreurs fréquentes des débutants

• Essayer de modifier un tuple comme une liste (erreur, car le tuple est immuable).
• Confondre les crochets [ ], les parenthèses ( ) et les accolades { } propres à chaque structure.
• Accéder à une clé de dictionnaire qui n'existe pas, ce qui provoque une erreur KeyError.
• Croire qu'un ensemble (set) conserve l'ordre d'ajout des éléments.
Exercices d'application
Exercice 1 — Liste
Créez une liste de 5 notes d'étudiants, puis affichez la troisième note de la liste.
Corrigé :
notes = [12, 15, 9, 18, 14]
print(notes[2]) # 9
Exercice 2 — Tuple
Créez un tuple contenant les coordonnées GPS (latitude, longitude) de votre ville, puis affichez-le.
Corrigé :
coordonnees = (6.3703, 2.3912)
Page 16 / 43
 Python pour la Data Analyse et l'IA
print(coordonnees)
Exercice 3 — Dictionnaire
Créez un dictionnaire représentant un étudiant (nom, âge, filière) et affichez sa filière.
Corrigé :
etudiant = {"nom": "Ali", "age": 19, "filiere": "Data & IA"}
print(etudiant["filiere"])
Exercice 4 — Ensemble
À partir de la liste [1, 2, 2, 3, 4, 4, 4, 5], créez un ensemble pour supprimer les doublons.
Corrigé :
nombres = [1, 2, 2, 3, 4, 4, 4, 5]
uniques = set(nombres)
print(uniques) # {1, 2, 3, 4, 5}
Exercice 5 — Parcours
Parcourez la liste ["Data", "IA", "Python"] avec une boucle for et affichez chaque mot en majuscules.
Corrigé :
mots = ["Data", "IA", "Python"]
for mot in mots:
print([Link]())

Page 17 / 43
 Python pour la Data Analyse et l'IA
Chapitre 6 — Les fonctions
6.1 Déclaration d'une fonction
Une fonction est un bloc de code réutilisable, défini avec le mot-clé def, qui réalise une tâche précise.
def saluer():
print("Bonjour et bienvenue !")

saluer() # appel de la fonction

6.2 Les paramètres

Une fonction peut recevoir des paramètres, c'est-à-dire des valeurs d'entrée qui personnalisent son comportement.
def saluer(prenom):
print("Bonjour", prenom)

saluer("Emma") # Bonjour Emma

On peut définir des valeurs par défaut pour un paramètre :
def saluer(prenom="visiteur"):
print("Bonjour", prenom)

saluer() # Bonjour visiteur

saluer("Yao") # Bonjour Yao

6.3 Les valeurs de retour

Le mot-clé return permet à une fonction de renvoyer un résultat au programme qui l'a appelée.
def addition(a, b):
return a + b

resultat = addition(3, 4)
print(resultat) # 7

6.4 Variables locales et globales

Une variable déclarée à l'intérieur d'une fonction est locale : elle n'existe que dans cette fonction. Une variable déclarée en dehors de toute
fonction est globale et accessible partout dans le script.
compteur = 0 # variable globale

def incrementer():
x = 1 # variable locale, existe uniquement ici
return x

6.5 Documentation d'une fonction

On documente une fonction avec une docstring, une chaîne de texte placée juste après la ligne def, entre triples guillemets. Elle explique
le rôle de la fonction, ses paramètres et sa valeur de retour.
def addition(a, b):
"""
Additionne deux nombres et retourne le résultat.
Paramètres : a (int/float), b (int/float)
Retour : la somme de a et b
"""
return a + b

Résumé du chapitre
Une fonction, définie avec def, regroupe des instructions réutilisables. Elle peut recevoir des paramètres (avec ou sans valeur par défaut)
et renvoyer un résultat grâce à return. Les variables déclarées dans une fonction sont locales, contrairement aux variables globales. Une
bonne fonction est toujours documentée par une docstring.

Mots-clés à retenir
def • paramètre • return • variable locale • variable globale • docstring

Erreurs fréquentes des débutants

• Oublier les parenthèses lors de l'appel d'une fonction (saluer au lieu de saluer()).
• Confondre un paramètre (défini dans la fonction) et un argument (valeur transmise à l'appel).
• Oublier return et croire que la fonction renvoie automatiquement un résultat.
• Essayer d'utiliser une variable locale en dehors de sa fonction.
Exercices d'application
Exercice 1 — Fonction simple
Créez une fonction carre(n) qui retourne le carré d'un nombre.

Page 18 / 43
 Python pour la Data Analyse et l'IA
Corrigé :
def carre(n):
return n ** 2

print(carre(5)) # 25
Exercice 2 — Paramètre par défaut
Créez une fonction puissance(base, exposant=2) qui retourne base élevé à exposant.
Corrigé :
def puissance(base, exposant=2):
return base ** exposant

print(puissance(3)) # 9
print(puissance(2, 5)) # 32
Exercice 3 — Plusieurs paramètres
Créez une fonction moyenne(a, b, c) qui retourne la moyenne de trois notes.
Corrigé :
def moyenne(a, b, c):
return (a + b + c) / 3

print(moyenne(12, 15, 18)) # 15.0

Exercice 4 — Portée des variables
Expliquez pourquoi le code suivant provoque une erreur : def f(): x = 5 \n print(x) (à l'extérieur de la fonction).
Corrigé :
La variable x est locale à la fonction f : elle n'existe pas en dehors de celle-ci. Y accéder à l'extérieur
provoque une erreur NameError.
Exercice 5 — Documentation
Ajoutez une docstring à une fonction est_pair(n) qui retourne True si n est pair.
Corrigé :
def est_pair(n):
"""Retourne True si n est un nombre pair, sinon False."""
return n % 2 == 0

Page 19 / 43
 Python pour la Data Analyse et l'IA
Chapitre 7 — Les chaînes de caractères
7.1 Manipulation de base
Une chaîne de caractères (str) représente du texte. On peut la concaténer, mesurer sa longueur et accéder à ses caractères par leur position
(index), en commençant à 0.
texte = "Data Science"
print(len(texte)) # 12 (nombre de caractères)
print(texte[0]) # D
print(texte + " IA") # Data Science IA

7.2 Découpage (slicing)

Le découpage permet d'extraire une portion d'une chaîne grâce à la syntaxe [debut:fin].
texte = "Intelligence Artificielle"
print(texte[0:12]) # Intelligence
print(texte[13:]) # Artificielle

7.3 Recherche dans une chaîne

Méthode Effet
in Vérifie si un texte est présent
find() Renvoie l'index de la première occurrence (ou -1)
count() Compte le nombre d'occurrences
startswith() / endswith() Vérifie le début ou la fin d'une chaîne

texte = "Python pour la Data"

print("Data" in texte) # True
print([Link]("pour")) # 7
print([Link]("a")) # 3

7.4 Remplacement
texte = "J'aime Java"
nouveau = [Link]("Java", "Python")
print(nouveau) # J'aime Python

7.5 Formatage des chaînes

Les f-strings (chaînes formatées) permettent d'insérer facilement des variables dans du texte, avec le préfixe f devant les guillemets.
prenom = "Léa"
age = 20
print(f"{prenom} a {age} ans") # Léa a 20 ans
print(f"Moyenne : {14.6666:.2f}") # Moyenne : 14.67
Autres méthodes utiles : .upper() (majuscules), .lower() (minuscules), .strip() (supprime les espaces inutiles), .split() (découpe en liste).
phrase = " Python Data Analyse "
print([Link]()) # 'Python Data Analyse'
print([Link]().split(" ")) # ['Python', 'Data', 'Analyse']

Résumé du chapitre
Les chaînes de caractères se manipulent grâce à l'indexation, au découpage (slicing), et à de nombreuses méthodes intégrées : recherche
(in, find, count), remplacement (replace) et transformation (upper, lower, strip, split). Les f-strings offrent un moyen simple et lisible de
formater du texte avec des variables.

Mots-clés à retenir
str • slicing • find() • replace() • f-string • split() • strip()

Erreurs fréquentes des débutants

• Oublier que l'indexation commence à 0, et non à 1.
• Oublier le préfixe f devant une chaîne formatée (f"...").
• Croire que les méthodes comme replace() ou upper() modifient la chaîne d'origine : elles renvoient une nouvelle chaîne, il faut la
stocker.
• Confondre find() (renvoie -1 si absent) avec in (renvoie True/False).
Exercices d'application
Exercice 1 — Longueur et index
Affichez la longueur du mot « Programmation » ainsi que sa première et sa dernière lettre.
Corrigé :
mot = "Programmation"
print(len(mot)) # 13
Page 20 / 43
 Python pour la Data Analyse et l'IA
print(mot[0]) # P
print(mot[-1]) # n
Exercice 2 — Découpage
À partir de la chaîne "Data Analyse et IA", extrayez uniquement le mot « Analyse ».
Corrigé :
texte = "Data Analyse et IA"
print(texte[5:12]) # Analyse
Exercice 3 — Recherche
Vérifiez si le mot « Python » est contenu dans la phrase « J'apprends Python pour la Data ».
Corrigé :
phrase = "J'apprends Python pour la Data"
print("Python" in phrase) # True
Exercice 4 — Remplacement
Remplacez le mot « lent » par « rapide » dans la phrase « Cet algorithme est lent ».
Corrigé :
phrase = "Cet algorithme est lent"
print([Link]("lent", "rapide"))
Exercice 5 — Formatage
Avec une f-string, affichez : « L'étudiant Awa a obtenu 15.5 de moyenne » à partir des variables nom et moyenne.
Corrigé :
nom = "Awa"
moyenne = 15.5
print(f"L'étudiant {nom} a obtenu {moyenne} de moyenne")

Page 21 / 43
 Python pour la Data Analyse et l'IA
Chapitre 8 — Gestion des exceptions
8.1 Pourquoi gérer les erreurs ?
Un programme peut rencontrer des erreurs à l'exécution (division par zéro, fichier introuvable, saisie invalide...). Sans gestion des erreurs,
le programme s'arrête brutalement. Python propose le bloc try/except pour anticiper et gérer ces situations.

8.2 try et except

try:
resultat = 10 / 0
except ZeroDivisionError:
print("Erreur : division par zéro impossible")
On peut capturer plusieurs types d'erreurs différentes :
try:
nombre = int(input("Entrez un nombre : "))
except ValueError:
print("Erreur : ce n'est pas un nombre valide")

8.3 else
Le bloc else s'exécute uniquement si aucune erreur ne s'est produite dans le bloc try.
try:
resultat = 10 / 2
except ZeroDivisionError:
print("Erreur")
else:
print("Calcul réussi :", resultat)

8.4 finally
Le bloc finally s'exécute toujours, qu'une erreur se soit produite ou non. Il sert souvent à libérer des ressources (fermer un fichier, une
connexion...).
try:
fichier = open("[Link]")
except FileNotFoundError:
print("Fichier introuvable")
finally:
print("Fin du traitement")

8.5 raise
L'instruction raise permet de déclencher volontairement une exception, par exemple pour signaler une valeur incorrecte.
def calculer_moyenne(notes):
if len(notes) == 0:
raise ValueError("La liste de notes est vide")
return sum(notes) / len(notes)

Résumé du chapitre
La gestion des exceptions avec try/except permet d'éviter qu'une erreur n'arrête brutalement un programme. Le bloc else s'exécute si tout
s'est bien passé, et finally s'exécute toujours. L'instruction raise permet de déclencher soi-même une exception pour signaler une situation
anormale.

Mots-clés à retenir
try • except • else • finally • raise • exception • ValueError • ZeroDivisionError

Erreurs fréquentes des débutants

• Utiliser un except général (except:) qui masque toutes les erreurs, y compris les vraies erreurs de programmation.
• Oublier que le code après une erreur non gérée dans try ne s'exécute pas.
• Confondre else (s'exécute si pas d'erreur) et finally (s'exécute toujours).
• Ne pas préciser le type d'exception attendu, ce qui rend le débogage plus difficile.
Exercices d'application
Exercice 1 — Division sécurisée
Écrivez un programme qui demande deux nombres et affiche leur division, en gérant l'erreur de division par zéro.
Corrigé :
try:
a = float(input("Numérateur : "))
b = float(input("Dénominateur : "))
print(a / b)
except ZeroDivisionError:
print("Division par zéro impossible")
Exercice 2 — Saisie valide

Page 22 / 43
 Python pour la Data Analyse et l'IA
Demandez un âge à l'utilisateur et gérez le cas où il ne saisit pas un nombre entier.
Corrigé :
try:
age = int(input("Votre âge : "))
print("Âge enregistré :", age)
except ValueError:
print("Veuillez entrer un nombre entier")
Exercice 3 — else
Ajoutez un bloc else au programme précédent pour afficher un message de succès.
Corrigé :
try:
age = int(input("Votre âge : "))
except ValueError:
print("Erreur de saisie")
else:
print("Âge valide :", age)
Exercice 4 — finally
Écrivez un bloc try/except/finally qui affiche toujours « Traitement terminé », même en cas d'erreur.
Corrigé :
try:
resultat = 10 / 0
except ZeroDivisionError:
print("Erreur")
finally:
print("Traitement terminé")
Exercice 5 — raise
Écrivez une fonction verifier_note(note) qui déclenche une exception si la note n'est pas comprise entre 0 et 20.
Corrigé :
def verifier_note(note):
if note < 0 or note > 20:
raise ValueError("La note doit être comprise entre 0 et 20")
return note

Page 23 / 43
 Python pour la Data Analyse et l'IA
Chapitre 9 — Modules et bibliothèques
9.1 L'instruction import
Un module est un fichier Python contenant des fonctions prêtes à l'emploi. On l'utilise avec le mot-clé import.
import math
print([Link](16)) # 4.0

from math import pi

print(pi) # 3.141592653589793

9.2 Le module math

Fonction Rôle
[Link](x) Racine carrée de x
[Link](x, y) x puissance y
[Link](x) / [Link](x) Arrondi inférieur / supérieur
[Link] Valeur de π

9.3 Le module random

Le module random permet de générer des nombres aléatoires, très utile pour les simulations.
import random
print([Link](1, 10)) # entier aléatoire entre 1 et 10
print([Link](["a", "b", "c"])) # choix aléatoire dans une liste

9.4 Le module datetime

Le module datetime gère les dates et les heures.
from datetime import datetime
maintenant = [Link]()
print(maintenant)
print([Link]) # année actuelle

9.5 Le module os
Le module os permet d'interagir avec le système d'exploitation : fichiers, dossiers, chemins.
import os
print([Link]()) # dossier courant
print([Link]()) # liste les fichiers du dossier

9.6 Le module statistics

Le module statistics fournit des fonctions statistiques de base, complémentaires à NumPy.
import statistics
notes = [12, 15, 9, 18, 14]
print([Link](notes)) # moyenne
print([Link](notes)) # médiane
print([Link](notes)) # écart-type

Résumé du chapitre
Les modules Python offrent des fonctions prêtes à l'emploi que l'on importe avec import. Le module math gère les calculs mathématiques,
random génère des valeurs aléatoires, datetime manipule les dates, os interagit avec le système de fichiers, et statistics propose des calculs
statistiques simples.

Mots-clés à retenir
import • module • math • random • datetime • os • statistics

Erreurs fréquentes des débutants

• Oublier d'importer un module avant d'utiliser ses fonctions (NameError).
• Écrire sqrt(16) au lieu de [Link](16) après un simple import math.
• Confondre randint (borne incluse) avec random() (nombre décimal entre 0 et 1).
• Modifier le système de fichiers avec os sans vérifier le chemin courant ([Link]()).
Exercices d'application
Exercice 1 — math
Calculez la racine carrée de 81 et l'arrondi supérieur de 4.2 à l'aide du module math.
Corrigé :
import math
print([Link](81)) # 9.0
Page 24 / 43
 Python pour la Data Analyse et l'IA
print([Link](4.2)) # 5
Exercice 2 — random
Simulez un lancer de dé à six faces avec le module random.
Corrigé :
import random
print([Link](1, 6))
Exercice 3 — datetime
Affichez l'année, le mois et le jour actuels avec le module datetime.
Corrigé :
from datetime import datetime
aujourdhui = [Link]()
print([Link], [Link], [Link])
Exercice 4 — os
Affichez le dossier de travail courant et la liste des fichiers qu'il contient.
Corrigé :
import os
print([Link]())
print([Link]())
Exercice 5 — statistics
Calculez la moyenne et la médiane de la liste [10, 12, 14, 16, 18].
Corrigé :
import statistics
notes = [10, 12, 14, 16, 18]
print([Link](notes)) # 14
print([Link](notes)) # 14

Page 25 / 43
 Python pour la Data Analyse et l'IA
Chapitre 10 — Manipulation des fichiers
10.1 Lecture de fichiers texte
La fonction open() ouvre un fichier. Le mode "r" (read) sert à la lecture. Il est recommandé d'utiliser with, qui referme automatiquement le
fichier après usage.
with open("[Link]", "r") as fichier:
contenu = [Link]()
print(contenu)
D'autres méthodes de lecture existent : readline() (une ligne), readlines() (toutes les lignes sous forme de liste).

10.2 Écriture de fichiers

Le mode "w" (write) crée un nouveau fichier ou écrase un fichier existant. Le mode "a" (append) ajoute du contenu à la fin d'un fichier
existant.
with open("[Link]", "w") as fichier:
[Link]("Moyenne générale : 14.5\n")
[Link]("Nombre d'étudiants : 30\n")

Mode Effet
"r" Lecture seule (le fichier doit exister)
"w" Écriture (crée ou écrase le fichier)
"a" Ajout à la fin du fichier
"r+" Lecture et écriture

10.3 Introduction au format CSV

CSV (Comma-Separated Values) est un format de fichier texte très répandu pour stocker des données tabulaires, où chaque ligne représente
un enregistrement et chaque valeur est séparée par une virgule (ou un point-virgule).
nom,age,moyenne
Awa,20,15.5
Koffi,19,12.0
Léa,21,17.8
Le module intégré csv permet de lire ce type de fichier facilement :
import csv
with open("[Link]", "r") as fichier:
lecteur = [Link](fichier)
for ligne in lecteur:
print(ligne)
Dans les chapitres suivants, nous utiliserons Pandas, une bibliothèque bien plus puissante pour manipuler des fichiers CSV dans le cadre de
l'analyse de données.

Résumé du chapitre
La lecture et l'écriture de fichiers texte se font avec open(), en précisant le mode (r, w, a) ; l'usage du bloc with est recommandé pour fermer
automatiquement le fichier. Le format CSV, largement utilisé en Data Analyse, stocke des données tabulaires sous forme de texte séparé
par des virgules, et peut être lu avec le module csv ou, plus tard, avec Pandas.

Mots-clés à retenir
open() • with • mode r/w/a • read() • write() • CSV • [Link]

Erreurs fréquentes des débutants

• Ouvrir un fichier en mode "w" alors qu'on veut seulement le lire : cela efface son contenu existant.
• Oublier de fermer un fichier ouvert sans with ([Link]() est alors obligatoire).
• Essayer de lire un fichier qui n'existe pas sans gérer l'exception FileNotFoundError.
• Oublier que readlines() renvoie les lignes avec le caractère de fin de ligne \n inclus.
Exercices d'application
Exercice 1 — Écriture
Créez un fichier [Link] contenant trois notes d'étudiants, une par ligne.
Corrigé :
with open("[Link]", "w") as f:
[Link]("12\n15\n18\n")
Exercice 2 — Lecture
Lisez le contenu du fichier [Link] créé précédemment et affichez-le.
Corrigé :

Page 26 / 43
 Python pour la Data Analyse et l'IA
with open("[Link]", "r") as f:
print([Link]())
Exercice 3 — Ajout
Ajoutez une nouvelle note (14) à la fin du fichier [Link] sans effacer son contenu.
Corrigé :
with open("[Link]", "a") as f:
[Link]("14\n")
Exercice 4 — Lecture ligne par ligne
Lisez le fichier [Link] ligne par ligne et affichez chaque note précédée de « Note : ».
Corrigé :
with open("[Link]", "r") as f:
for ligne in f:
print("Note :", [Link]())
Exercice 5 — CSV
Créez un fichier CSV contenant les colonnes nom et note pour deux étudiants, puis lisez-le avec le module csv.
Corrigé :
import csv
with open("[Link]", "w") as f:
[Link]("nom,note\nAwa,15\nKoffi,12\n")

with open("[Link]", "r") as f:

lecteur = [Link](f)
for ligne in lecteur:
print(ligne)

Page 27 / 43
 Python pour la Data Analyse et l'IA
Chapitre 11 — Introduction à NumPy
11.1 Installation
NumPy (Numerical Python) est la bibliothèque de référence pour le calcul numérique en Python. Elle s'installe via pip :
$ pip install numpy
On l'importe ensuite généralement avec l'alias np :
import numpy as np

11.2 Les tableaux NumPy (array)

Un tableau NumPy (ndarray) ressemble à une liste, mais il est bien plus rapide et optimisé pour les calculs mathématiques sur de grandes
quantités de données.
import numpy as np
notes = [Link]([12, 15, 9, 18, 14])
print(notes)
print(type(notes)) # <class '[Link]'>

11.3 Calculs vectoriels

NumPy permet d'effectuer une opération sur tous les éléments d'un tableau en une seule instruction, sans boucle explicite : c'est ce qu'on
appelle la vectorisation.
notes = [Link]([12, 15, 9, 18, 14])
notes_sur_100 = notes * 5
print(notes_sur_100) # [60 75 45 90 70]
print(notes + 1) # ajoute 1 point à chaque note

11.4 Fonctions statistiques essentielles

Fonction Rôle
[Link](tableau) Calcule la moyenne
[Link](tableau) Calcule la somme
[Link](tableau) Trouve la valeur maximale
[Link](tableau) Trouve la valeur minimale
[Link](tableau) Calcule l'écart-type

notes = [Link]([12, 15, 9, 18, 14])

print([Link](notes)) # 13.6
print([Link](notes)) # 68
print([Link](notes)) # 18
print([Link](notes)) # 9

Résumé du chapitre
NumPy est la bibliothèque fondamentale du calcul numérique en Python. Elle introduit le tableau (ndarray), une structure optimisée qui
permet des calculs vectorisés très rapides, sans boucle explicite. Ses fonctions statistiques (mean, sum, max, min, std) sont largement
utilisées en Data Analyse.

Mots-clés à retenir
NumPy • ndarray • [Link]() • vectorisation • mean() • sum() • max() • min()

Erreurs fréquentes des débutants

• Oublier d'installer NumPy avant de l'importer (pip install numpy).
• Confondre une liste Python classique et un tableau NumPy : leurs opérations (+ , *) ne se comportent pas de la même façon.
• Utiliser une boucle for pour parcourir un tableau NumPy alors que la vectorisation est plus rapide et plus simple.
• Oublier l'alias np conventionnel, ce qui rend le code moins lisible pour les autres.
Exercices d'application
Exercice 1 — Création
Créez un tableau NumPy contenant les températures [21, 24, 19, 26, 23] et affichez-le.
Corrigé :
import numpy as np
temperatures = [Link]([21, 24, 19, 26, 23])
print(temperatures)
Exercice 2 — Calcul vectoriel
Convertissez le tableau de températures précédent de Celsius en Fahrenheit (F = C * 9/5 + 32).
Corrigé :
fahrenheit = temperatures * 9/5 + 32
Page 28 / 43
 Python pour la Data Analyse et l'IA
print(fahrenheit)
Exercice 3 — Moyenne
Calculez la moyenne des températures.
Corrigé :
print([Link](temperatures))
Exercice 4 — Min et max
Affichez la température minimale et maximale de la semaine.
Corrigé :
print([Link](temperatures))
print([Link](temperatures))
Exercice 5 — Somme
Un tableau contient les ventes journalières [120, 340, 210, 180, 400]. Calculez le total des ventes de la semaine.
Corrigé :
ventes = [Link]([120, 340, 210, 180, 400])
print([Link](ventes))

Page 29 / 43
 Python pour la Data Analyse et l'IA
Chapitre 12 — Introduction à Pandas
12.1 Installation
Pandas est la bibliothèque de référence pour manipuler des données tabulaires (comme des feuilles Excel) en Python. Elle s'installe avec
pip et s'importe généralement sous l'alias pd :
$ pip install pandas

import pandas as pd

12.2 Le DataFrame
Un DataFrame est un tableau à deux dimensions, composé de lignes et de colonnes, similaire à une feuille de calcul.
import pandas as pd
donnees = {
"nom": ["Awa", "Koffi", "Léa"],
"note": [15.5, 12.0, 17.8],
}
df = [Link](donnees)
print(df)

12.3 Lecture d'un fichier CSV

La fonction pd.read_csv() permet de charger un fichier CSV directement dans un DataFrame.
df = pd.read_csv("[Link]")
print([Link]()) # affiche les 5 premières lignes

12.4 Sélection des colonnes

print(df["nom"]) # sélectionne une colonne
print(df[["nom", "note"]]) # sélectionne plusieurs colonnes

12.5 Filtrage des données

On peut filtrer les lignes d'un DataFrame en appliquant une condition, comme pour une liste.
admis = df[df["note"] >= 10]
print(admis)

12.6 Calculs statistiques simples

Méthode Rôle
[Link]() Statistiques descriptives complètes
df["note"].mean() Moyenne d'une colonne
df["note"].max() / .min() Valeur maximale / minimale
df.sort_values("note") Trie le DataFrame selon une colonne

print(df["note"].mean())
print(df.sort_values("note", ascending=False))

Résumé du chapitre
Pandas est la bibliothèque incontournable pour manipuler des données tabulaires en Python grâce au DataFrame. Elle permet de charger
un fichier CSV (read_csv), de sélectionner des colonnes, de filtrer des lignes selon une condition, et de réaliser rapidement des statistiques
descriptives (mean, describe, sort_values).

Mots-clés à retenir
Pandas • DataFrame • read_csv() • filtrage • describe() • sort_values()

Erreurs fréquentes des débutants

• Oublier les doubles crochets pour sélectionner plusieurs colonnes (df[["a","b"]] et non df["a","b"]).
• Confondre [Link]() (moyenne de toutes les colonnes numériques) et df["col"].mean() (moyenne d'une seule colonne).
• Modifier un DataFrame filtré en pensant modifier l'original.
• Ne pas vérifier le chemin du fichier CSV, provoquant une erreur FileNotFoundError.
Exercices d'application
Exercice 1 — Création
Créez un DataFrame contenant les colonnes produit et prix pour trois produits.
Corrigé :
import pandas as pd
df = [Link]({"produit": ["Stylo", "Cahier", "Sac"], "prix": [200, 500, 5000]})
print(df)

Page 30 / 43
 Python pour la Data Analyse et l'IA
Exercice 2 — Lecture CSV
Chargez un fichier [Link] dans un DataFrame et affichez ses 5 premières lignes.
Corrigé :
df = pd.read_csv("[Link]")
print([Link]())
Exercice 3 — Sélection
À partir du DataFrame produit/prix, affichez uniquement la colonne prix.
Corrigé :
print(df["prix"])
Exercice 4 — Filtrage
Affichez uniquement les produits dont le prix est supérieur à 300.
Corrigé :
print(df[df["prix"] > 300])
Exercice 5 — Statistiques
Calculez le prix moyen et affichez les statistiques descriptives complètes du DataFrame.
Corrigé :
print(df["prix"].mean())
print([Link]())

Page 31 / 43
 Python pour la Data Analyse et l'IA
Chapitre 13 — Visualisation des données
13.1 Introduction à Matplotlib
Matplotlib est la bibliothèque la plus utilisée pour créer des graphiques en Python. Elle s'installe avec pip et s'importe généralement ainsi :
$ pip install matplotlib

import [Link] as plt

Un graphique s'affiche toujours avec [Link]() à la fin du script.

13.2 Diagramme en barres

Utile pour comparer des catégories entre elles.
matieres = ["Maths", "Info", "Anglais"]
moyennes = [14.5, 16.2, 12.8]
[Link](matieres, moyennes)
[Link]("Moyenne par matière")
[Link]("Matière")
[Link]("Moyenne")
[Link]()

13.3 Courbe (line plot)

Idéale pour observer une évolution dans le temps.
mois = ["Jan", "Fév", "Mar", "Avr"]
ventes = [1200, 1500, 1100, 1800]
[Link](mois, ventes, marker="o")
[Link]("Évolution des ventes")
[Link]()

13.4 Histogramme
Permet de visualiser la répartition (distribution) d'une variable numérique.
notes = [8, 12, 14, 9, 15, 18, 11, 13, 16, 10]
[Link](notes, bins=5)
[Link]("Répartition des notes")
[Link]()

13.5 Camembert (pie chart)

Utile pour visualiser des proportions ou des parts d'un ensemble.
filieres = ["Data & IA", "Réseaux", "Génie logiciel"]
effectifs = [45, 30, 25]
[Link](effectifs, labels=filieres, autopct="%1.1f%%")
[Link]("Répartition des étudiants par filière")
[Link]()

Résumé du chapitre
Matplotlib est la bibliothèque de référence pour la visualisation de données en Python. Le diagramme en barres compare des catégories,
la courbe montre une évolution, l'histogramme illustre une distribution, et le camembert représente des proportions. Chaque graphique
se personnalise avec un titre et des légendes d'axes.

Mots-clés à retenir
Matplotlib • [Link]() • [Link]() • [Link]() • [Link]() • [Link]()

Erreurs fréquentes des débutants

• Oublier [Link]() à la fin du script, ce qui empêche l'affichage du graphique.
• Utiliser un diagramme en barres pour montrer une évolution dans le temps (préférer une courbe).
• Oublier de nommer les axes et le titre, rendant le graphique difficile à interpréter.
• Créer un camembert avec trop de catégories, ce qui le rend illisible.
Exercices d'application
Exercice 1 — Barres
Créez un diagramme en barres comparant les ventes de 3 produits : ["A", "B", "C"] avec les valeurs [340, 210, 480].
Corrigé :
import [Link] as plt
[Link](["A", "B", "C"], [340, 210, 480])
[Link]("Ventes par produit")
[Link]()
Exercice 2 — Courbe
Tracez l'évolution des températures [20, 22, 19, 25, 23] sur 5 jours.
Corrigé :
Page 32 / 43
 Python pour la Data Analyse et l'IA
jours = [1, 2, 3, 4, 5]
temperatures = [20, 22, 19, 25, 23]
[Link](jours, temperatures, marker="o")
[Link]("Évolution de la température")
[Link]()
Exercice 3 — Histogramme
Affichez l'histogramme des notes suivantes : [5, 8, 12, 14, 9, 15, 18, 11, 13, 16, 10, 7].
Corrigé :
notes = [5, 8, 12, 14, 9, 15, 18, 11, 13, 16, 10, 7]
[Link](notes, bins=4)
[Link]("Distribution des notes")
[Link]()
Exercice 4 — Camembert
Représentez la répartition de 3 filières avec des effectifs de 50, 30 et 20 étudiants.
Corrigé :
[Link]([50, 30, 20], labels=["Filière A", "Filière B", "Filière C"], autopct="%1.1f%%")
[Link]("Répartition des étudiants")
[Link]()
Exercice 5 — Personnalisation
Reprenez le graphique en barres de l'exercice 1 en ajoutant un titre et des légendes pour les deux axes.
Corrigé :
[Link](["A", "B", "C"], [340, 210, 480])
[Link]("Ventes par produit")
[Link]("Produit")
[Link]("Ventes (unités)")
[Link]()

Page 33 / 43
 Python pour la Data Analyse et l'IA
Chapitre 14 — Bonnes pratiques
14.1 Indentation
L'indentation structure le code Python : elle doit toujours être cohérente, avec 4 espaces par niveau (jamais de mélange
espaces/tabulations). La plupart des éditeurs, dont VS Code, insèrent automatiquement 4 espaces lorsqu'on appuie sur Tab.

14.2 Convention de nommage

Élément Convention Exemple
Variable / fonction snake_case (minuscules, underscore) nombre_etudiants
Constante MAJUSCULES_AVEC_UNDERSCORE TAUX_TVA
Classe PascalCase GestionnaireNotes
Nom de fichier minuscules_avec_underscore.py analyse_ventes.py

14.3 Commentaires utiles

Un bon commentaire explique le pourquoi, pas seulement le comment. Il vaut mieux nommer clairement ses variables et fonctions plutôt
que de multiplier les commentaires inutiles.
# Mauvais : commentaire inutile
x = x + 1 # ajoute 1 à x

# Bon : le nom de variable est explicite

nombre_tentatives += 1

14.4 Organisation du code

• Séparer le code en fonctions claires, chacune avec une seule responsabilité.
• Regrouper les imports en haut du fichier.
• Utiliser des noms de variables explicites plutôt que des lettres isolées (sauf pour les compteurs simples comme i).
• Éviter la duplication de code : si un bloc se répète, en faire une fonction.
• Structurer un projet en plusieurs fichiers lorsque le code devient volumineux.
14.5 Débogage
Déboguer consiste à trouver et corriger les erreurs d'un programme. Quelques techniques essentielles :
• Lire attentivement le message d'erreur : Python indique le type d'erreur et la ligne concernée.
• Utiliser print() pour afficher la valeur des variables à différentes étapes du programme.
• Utiliser le débogueur intégré de VS Code (points d'arrêt, exécution pas à pas).
• Tester son code avec des cas simples avant de l'appliquer à des données complexes.

Résumé du chapitre
Écrire du code Python propre repose sur une indentation cohérente, des conventions de nommage claires (snake_case, PascalCase,
MAJUSCULES), des commentaires pertinents, une bonne organisation en fonctions, et des techniques de débogage efficaces (lecture des
erreurs, print(), débogueur).

Mots-clés à retenir
snake_case • PascalCase • convention de nommage • débogage • print() de contrôle

Erreurs fréquentes des débutants

• Nommer les variables x, y, z sans signification, rendant le code illisible.
• Ignorer les messages d'erreur au lieu de les lire attentivement.
• Écrire des fonctions trop longues qui font plusieurs tâches à la fois.
• Copier-coller du code au lieu de créer une fonction réutilisable.
Exercices d'application
Exercice 1 — Nommage
Corrigez le nom de variable suivant selon les conventions Python : NombreEtudiants = 30.
Corrigé :
nombre_etudiants = 30
Exercice 2 — Constante
Écrivez correctement une constante représentant le taux de TVA de 18 %.
Corrigé :

Page 34 / 43
 Python pour la Data Analyse et l'IA
TAUX_TVA = 0.18
Exercice 3 — Refactorisation
Transformez ce code dupliqué en une fonction réutilisable : print(12*2) puis print(15*2) puis print(9*2).
Corrigé :
def doubler(n):
return n * 2

for note in [12, 15, 9]:

print(doubler(note))
Exercice 4 — Débogage
Le code suivant provoque une erreur : print(resultat) sans avoir défini resultat avant. Corrigez-le.
Corrigé :
resultat = 10 + 5
print(resultat)
Exercice 5 — Bonnes pratiques
Citez trois bonnes pratiques à respecter pour écrire un code Python lisible.
Corrigé :
Utiliser des noms explicites, respecter l'indentation à 4 espaces, et éviter la duplication de code en créant
des fonctions.

Page 35 / 43
 Python pour la Data Analyse et l'IA
Chapitre 15 — Exercices
Ce chapitre rassemble 20 exercices classés par niveau de difficulté, permettant de consolider l'ensemble des notions vues dans les chapitres
précédents. Chaque exercice est accompagné de son corrigé.

Niveau facile
Exercice 1
Affichez « Bonjour, je découvre Python ! » à l'écran.
Corrigé :
print("Bonjour, je découvre Python !")
Exercice 2
Créez deux variables a et b valant 8 et 3, puis affichez leur somme, différence et produit.
Corrigé :
a = 8
b = 3
print(a + b, a - b, a * b)
Exercice 3
Demandez l'âge de l'utilisateur et affichez « Vous êtes majeur » ou « Vous êtes mineur ».
Corrigé :
age = int(input("Votre âge : "))
if age >= 18:
print("Vous êtes majeur")
else:
print("Vous êtes mineur")
Exercice 4
Affichez les nombres pairs de 0 à 20 grâce à une boucle for.
Corrigé :
for i in range(0, 21, 2):
print(i)
Exercice 5
Créez une liste de 5 fruits et affichez-la triée par ordre alphabétique.
Corrigé :
fruits = ["mangue", "kiwi", "banane", "orange", "ananas"]
print(sorted(fruits))
Exercice 6
Calculez le périmètre d'un rectangle à partir de sa longueur et de sa largeur saisies au clavier.
Corrigé :
longueur = float(input("Longueur : "))
largeur = float(input("Largeur : "))
print("Périmètre :", 2 * (longueur + largeur))
Exercice 7
Écrivez une fonction est_majeur(age) qui retourne True ou False.
Corrigé :
def est_majeur(age):
return age >= 18

print(est_majeur(16))

Niveau intermédiaire
Exercice 8
Écrivez un programme qui calcule la somme des nombres de 1 à 100 sans utiliser la fonction sum().
Corrigé :
total = 0
for i in range(1, 101):
total += i
print(total) # 5050
Exercice 9
Créez un dictionnaire représentant un produit (nom, prix, quantité) et calculez le total (prix × quantité).
Corrigé :
produit = {"nom": "Cahier", "prix": 500, "quantite": 4}
total = produit["prix"] * produit["quantite"]

Page 36 / 43
 Python pour la Data Analyse et l'IA
print(f"Total : {total} F")
Exercice 10
Écrivez une fonction qui retourne le plus grand nombre parmi trois nombres donnés.
Corrigé :
def plus_grand(a, b, c):
return max(a, b, c)

print(plus_grand(4, 9, 7))
Exercice 11
À partir d'une liste de notes, comptez combien d'étudiants ont eu la moyenne (note >= 10).
Corrigé :
notes = [8, 12, 15, 9, 17, 6, 11]
admis = 0
for note in notes:
if note >= 10:
admis += 1
print(admis)
Exercice 12
Écrivez un programme qui vérifie si un mot donné est un palindrome (se lit pareil dans les deux sens).
Corrigé :
mot = "radar"
print(mot == mot[::-1])
Exercice 13
Créez un dictionnaire des effectifs par filière et affichez la filière ayant le plus d'étudiants.
Corrigé :
effectifs = {"Data & IA": 45, "Réseaux": 30, "Logiciel": 38}
filiere_max = max(effectifs, key=[Link])
print(filiere_max)
Exercice 14
Gérez avec try/except la conversion d'une saisie utilisateur en nombre décimal.
Corrigé :
try:
valeur = float(input("Entrez un nombre : "))
print("Valeur valide :", valeur)
except ValueError:
print("Saisie invalide")
Exercice 15
Écrivez une fonction qui retourne la liste des diviseurs d'un nombre entier.
Corrigé :
def diviseurs(n):
resultat = []
for i in range(1, n + 1):
if n % i == 0:
[Link](i)
return resultat

print(diviseurs(12)) # [1, 2, 3, 4, 6, 12]

Niveau avancé
Exercice 16
Avec NumPy, créez un tableau de 10 notes aléatoires entre 0 et 20 et calculez leur moyenne et écart-type.
Corrigé :
import numpy as np
notes = [Link](0, 21, 10)
print(notes)
print("Moyenne :", [Link](notes))
print("Écart-type :", [Link](notes))
Exercice 17
Avec Pandas, chargez un fichier CSV de ventes et affichez le produit qui a généré le plus de chiffre d'affaires.
Corrigé :
import pandas as pd
df = pd.read_csv("[Link]")
ligne = [Link][df["chiffre_affaires"].idxmax()]
print(ligne["produit"])
Exercice 18
Page 37 / 43
 Python pour la Data Analyse et l'IA
Écrivez une fonction récursive qui calcule la factorielle d'un nombre.
Corrigé :
def factorielle(n):
if n <= 1:
return 1
return n * factorielle(n - 1)

print(factorielle(5)) # 120
Exercice 19
Créez un programme qui lit un fichier texte et compte le nombre d'occurrences de chaque mot.
Corrigé :
from collections import Counter
with open("[Link]", "r") as f:
mots = [Link]().split()
compteur = Counter(mots)
print(compteur)
Exercice 20
Avec Matplotlib, tracez sur un même graphique l'évolution des ventes de deux produits sur 6 mois.
Corrigé :
import [Link] as plt
mois = [1, 2, 3, 4, 5, 6]
produit_a = [100, 120, 90, 150, 170, 160]
produit_b = [80, 95, 100, 110, 130, 140]
[Link](mois, produit_a, label="Produit A")
[Link](mois, produit_b, label="Produit B")
[Link]()
[Link]("Comparaison des ventes")
[Link]()
Exercice 21
Écrivez une fonction qui prend une liste de dictionnaires « étudiant » et retourne le nom de celui qui a la meilleure moyenne.
Corrigé :
def meilleur_etudiant(etudiants):
return max(etudiants, key=lambda e: e["moyenne"])["nom"]

etudiants = [{"nom": "Awa", "moyenne": 15}, {"nom": "Koffi", "moyenne": 17.5}]

print(meilleur_etudiant(etudiants))

Résumé du chapitre
Ces 20 exercices progressifs permettent de vérifier la maîtrise des bases de Python (variables, conditions, boucles, fonctions), des structures
de données, de la gestion des erreurs, ainsi qu'une première utilisation de NumPy, Pandas et Matplotlib.

Conseil pédagogique
Il est recommandé de résoudre chaque exercice seul avant de consulter le corrigé, puis de comparer sa solution à celle proposée : il existe
souvent plusieurs façons correctes d'écrire un même programme.

Page 38 / 43
 Python pour la Data Analyse et l'IA
Chapitre 16 — Travaux pratiques
Ce chapitre propose cinq travaux pratiques complets, à réaliser en autonomie ou en petits groupes, afin de mettre en pratique l'ensemble
des notions du cours dans des situations proches de la réalité professionnelle.

TP 1 — Calculatrice
Objectif : créer une calculatrice en ligne de commande capable d'effectuer les quatre opérations de base.
Cahier des charges
• Demander deux nombres à l'utilisateur.
• Proposer un menu d'opérations : addition, soustraction, multiplication, division.
• Gérer l'erreur de division par zéro avec try/except.
• Afficher le résultat formaté avec deux décimales.
Solution proposée
def calculatrice():
a = float(input("Premier nombre : "))
b = float(input("Deuxième nombre : "))
print("1. Addition\n2. Soustraction\n3. Multiplication\n4. Division")
choix = input("Choisissez une opération (1-4) : ")

try:
if choix == "1":
print(f"Résultat : {a + b:.2f}")
elif choix == "2":
print(f"Résultat : {a - b:.2f}")
elif choix == "3":
print(f"Résultat : {a * b:.2f}")
elif choix == "4":
print(f"Résultat : {a / b:.2f}")
else:
print("Choix invalide")
except ZeroDivisionError:
print("Erreur : division par zéro impossible")

calculatrice()

TP 2 — Gestion des notes d'une classe

Objectif : gérer une liste d'étudiants et de leurs notes, avec calcul de moyenne et classement.
Cahier des charges
• Stocker les étudiants dans une liste de dictionnaires (nom, note).
• Calculer la moyenne de la classe.
• Afficher les étudiants admis (note >= 10) et ceux ajournés.
• Afficher le meilleur étudiant de la classe.
Solution proposée
classe = [
{"nom": "Awa", "note": 15.5},
{"nom": "Koffi", "note": 8.0},
{"nom": "Léa", "note": 17.8},
{"nom": "Yao", "note": 9.5},
]

notes = [e["note"] for e in classe]

moyenne_classe = sum(notes) / len(notes)
print(f"Moyenne de la classe : {moyenne_classe:.2f}")

admis = [e["nom"] for e in classe if e["note"] >= 10]

ajournes = [e["nom"] for e in classe if e["note"] < 10]
print("Admis :", admis)
print("Ajournés :", ajournes)

meilleur = max(classe, key=lambda e: e["note"])

print(f"Meilleur étudiant : {meilleur['nom']} ({meilleur['note']})")

TP 3 — Analyse des ventes d'une boutique

Objectif : analyser les ventes hebdomadaires d'une boutique à l'aide de NumPy.
Cahier des charges
• Représenter les ventes des 7 jours de la semaine avec un tableau NumPy.
• Calculer le total, la moyenne, le jour de vente maximale et minimale.
• Afficher un diagramme en barres des ventes avec Matplotlib.
Page 39 / 43
 Python pour la Data Analyse et l'IA
Solution proposée
import numpy as np
import [Link] as plt

jours = ["Lun", "Mar", "Mer", "Jeu", "Ven", "Sam", "Dim"]

ventes = [Link]([1200, 1500, 900, 1100, 1800, 2200, 1700])

print("Total :", [Link](ventes))

print("Moyenne :", [Link](ventes))
print("Meilleur jour :", jours[[Link](ventes)])
print("Pire jour :", jours[[Link](ventes)])

[Link](jours, ventes, color="steelblue")

[Link]("Ventes hebdomadaires de la boutique")
[Link]("Montant (F CFA)")
[Link]()

TP 4 — Analyse d'un fichier CSV

Objectif : découvrir Pandas à travers l'analyse d'un fichier CSV contenant des données d'employés.
Cahier des charges
• Charger un fichier [Link] (colonnes : nom, departement, salaire).
• Afficher les statistiques descriptives des salaires.
• Calculer le salaire moyen par département.
• Identifier l'employé le mieux payé.
Solution proposée
import pandas as pd

df = pd.read_csv("[Link]")
print([Link]())

moyenne_par_departement = [Link]("departement")["salaire"].mean()
print(moyenne_par_departement)

meilleur_salaire = [Link][df["salaire"].idxmax()]
print("Employé le mieux payé :", meilleur_salaire["nom"])

TP 5 — Analyse des résultats d'un examen

Objectif : combiner Pandas, NumPy et Matplotlib pour analyser les résultats d'un examen de fin de module.
Cahier des charges
• Charger un fichier [Link] (colonnes : nom, note).
• Calculer la moyenne, la médiane, la note minimale et maximale.
• Ajouter une colonne « mention » selon la note obtenue.
• Afficher un histogramme de la distribution des notes.
Solution proposée
import pandas as pd
import [Link] as plt

df = pd.read_csv("[Link]")
print("Moyenne :", df["note"].mean())
print("Médiane :", df["note"].median())
print("Min :", df["note"].min(), "| Max :", df["note"].max())

def mention(note):
if note >= 16:
return "Très bien"
elif note >= 14:
return "Bien"
elif note >= 10:
return "Passable"
return "Insuffisant"

df["mention"] = df["note"].apply(mention)
print(df)

[Link](df["note"], bins=6, color="seagreen", edgecolor="black")

[Link]("Distribution des notes de l'examen")
[Link]("Note")
[Link]("Nombre d'étudiants")
[Link]()

Résumé du chapitre
Page 40 / 43
 Python pour la Data Analyse et l'IA
Ces cinq travaux pratiques couvrent un large éventail de situations réelles : calcul interactif, gestion de collections d'étudiants, analyse de
ventes avec NumPy, exploration d'un fichier CSV et analyse complète de résultats d'examen combinant Pandas, NumPy et Matplotlib.

Page 41 / 43
 Python pour la Data Analyse et l'IA
Chapitre 17 — Projet de fin de module
Analyse des performances académiques des étudiants
Ce projet de synthèse mobilise l'ensemble des compétences acquises durant le module : manipulation de fichiers, NumPy, Pandas et
Matplotlib. Il consiste à analyser les résultats académiques d'une promotion d'étudiants à partir d'un fichier CSV.

17.1 Objectifs du projet

• Lire un fichier CSV contenant les notes des étudiants dans plusieurs matières.
• Calculer la moyenne générale de chaque étudiant.
• Déterminer les meilleurs étudiants de la promotion.
• Produire des statistiques descriptives globales (moyenne, médiane, écart-type, min, max).
• Afficher plusieurs graphiques pour visualiser les résultats.
• Exporter un rapport final au format texte et CSV.
17.2 Structure du fichier de données
Le fichier [Link] contient une ligne par étudiant, avec les colonnes suivantes :
Colonne Description
nom Nom complet de l'étudiant
maths Note en mathématiques (/20)
python Note en programmation Python (/20)
statistiques Note en statistiques (/20)
anglais Note en anglais (/20)

nom,maths,python,statistiques,anglais
Awa Diallo,15,18,14,16
Koffi Mensah,9,12,11,10
Léa Fontaine,17,16,18,15
Yao Kouassi,12,10,13,11
Sarah Bamba,18,19,17,18
Ali Traoré,7,9,8,10

17.3 Étape 1 : Lecture du fichier CSV

import pandas as pd
import numpy as np
import [Link] as plt

df = pd.read_csv("[Link]")
print([Link]())

17.4 Étape 2 : Calcul des moyennes

On ajoute une colonne moyenne, calculée à partir des quatre matières, grâce à NumPy pour illustrer le calcul vectoriel.
matieres = ["maths", "python", "statistiques", "anglais"]
df["moyenne"] = [Link](df[matieres].values, axis=1)
print(df[["nom", "moyenne"]])

17.5 Étape 3 : Détermination des meilleurs étudiants

classement = df.sort_values("moyenne", ascending=False).reset_index(drop=True)
top3 = [Link](3)
print("Top 3 des étudiants :")
print(top3[["nom", "moyenne"]])

17.6 Étape 4 : Statistiques descriptives

moyenne_generale = df["moyenne"].mean()
mediane = df["moyenne"].median()
ecart_type = df["moyenne"].std()
note_max = df["moyenne"].max()
note_min = df["moyenne"].min()

print(f"Moyenne générale de la promotion : {moyenne_generale:.2f}")

print(f"Médiane : {mediane:.2f}")
print(f"Écart-type : {ecart_type:.2f}")
print(f"Note la plus haute : {note_max:.2f}")
print(f"Note la plus basse : {note_min:.2f}")

17.7 Étape 5 : Visualisation des résultats

Trois graphiques permettent d'illustrer les résultats sous des angles complémentaires.

Page 42 / 43
 Python pour la Data Analyse et l'IA
a) Histogramme des moyennes
[Link](df["moyenne"], bins=5, color="cornflowerblue", edgecolor="black")
[Link]("Distribution des moyennes de la promotion")
[Link]("Moyenne générale")
[Link]("Nombre d'étudiants")
[Link]()
b) Diagramme en barres du top 3
[Link](top3["nom"], top3["moyenne"], color="seagreen")
[Link]("Top 3 des meilleurs étudiants")
[Link]("Moyenne générale")
[Link]()
c) Moyenne par matière (camembert des contributions)
moyennes_matieres = df[matieres].mean()
[Link](moyennes_matieres, labels=matieres, autopct="%1.1f%%")
[Link]("Poids relatif des moyennes par matière")
[Link]()

17.8 Étape 6 : Export du rapport de résultats

Pour finaliser le projet, un rapport texte et un export CSV du classement complet sont générés automatiquement.
classement.to_csv("classement_final.csv", index=False)

with open("rapport_resultats.txt", "w") as rapport:

[Link]("RAPPORT D'ANALYSE DES PERFORMANCES ACADÉMIQUES\n")
[Link]("=" * 50 + "\n")
[Link](f"Nombre d'étudiants : {len(df)}\n")
[Link](f"Moyenne générale : {moyenne_generale:.2f}\n")
[Link](f"Médiane : {mediane:.2f}\n")
[Link](f"Écart-type : {ecart_type:.2f}\n")
[Link]("\nTop 3 des étudiants :\n")
for i, row in [Link]():
[Link](f"{i+1}. {row['nom']} — {row['moyenne']:.2f}/20\n")

print("Rapport exporté avec succès !")

17.9 Grille d'évaluation du projet

Critère Points
Lecture correcte du fichier CSV 3
Calcul correct des moyennes (NumPy) 4
Classement et identification des meilleurs étudiants 4
Statistiques descriptives complètes 4
Qualité et pertinence des graphiques 3
Export du rapport (CSV + texte) 2
Total 20

17.10 Pour aller plus loin

• Ajouter une pondération différente par matière (coefficients).
• Détecter automatiquement les étudiants en difficulté (moyenne < 10) et proposer un plan de soutien.
• Comparer les résultats de plusieurs promotions.
• Créer un tableau de bord interactif avec une bibliothèque comme Streamlit.
Résumé du chapitre
Ce projet de fin de module a permis de mobiliser l'ensemble des compétences du cours : lecture de fichiers CSV, manipulation de données
avec Pandas, calculs vectorisés avec NumPy, visualisation avec Matplotlib, et génération d'un rapport final. Il constitue une première
expérience complète d'un projet de Data Analyse, du chargement des données jusqu'à la restitution des résultats.

Page 43 / 43