INTRODUCTION GENERALE AU COURS

1
Table des matières

1. INTRODUCTION GENERALE AU COURS ................................................................... 1

1.1. Objectifs du cours.......................................................................................................... 3

1.2. Présentation de Python ................................................................................................. 3

1.2.1. Qu'est-ce que python ? ........................................................................................... 3

1.2.2. Caractéristiques principales .................................................................................. 3

1.2.3. Pourquoi apprendre Python ? ............................................................................... 4

1.2.4. Comment un code source est-il exécuté ? ............................................................. 4

1.3. Prérequis ........................................................................................................................ 5

1.4. Installation et premier programme ............................................................................. 5

1.4.1. Outils et configuration ........................................................................................... 5

1.4.2. Premier programme Python .................................................................................. 5

1.5. Structure du cours ......................................................................................................... 6

1.6. Conseils pour réussir ..................................................................................................... 6

1.7. Conclusion ...................................................................................................................... 6

2
1.1. Objectifs du cours
Ce cours est conçu pour initier les débutants à la programmation en Python. À la fin de ce cours,
les participants seront capables de :

- Comprendre les bases de la programmation informatique et le rôle des langages de

programmation.
- Manipuler Python pour développer de petits programmes fonctionnels.
- Résoudre des problèmes simples en utilisant une approche algorithmique.

1.2. Présentation de Python

1.2.1. Qu'est-ce que python ?

Python est un langage de programmation largement utilisé, interprété, orienté objet et de haut
niveau avec une sémantique dynamique, connu pour sa simplicité et utilisé pour la
programmation à usage général.

1.2.2. Caractéristiques principales

- «Open-source» : Son utilisation est gratuite et les fichiers sources sont disponibles et
modifiables
- Lisibilité : Une syntaxe proche de l’anglais, facile à apprendre
- Orienté objet
- Typage dynamique : Le typage (association à une variable de son type et allocation zone
mémoire en conséquence) est fait automatiquement lors de l’exécution du programme,
ce qui permet une grande flexibilité et rapidité de programmation mais qui se paye par
une surconsommation de mémoire et une perte de performance
- Multiplateforme : Compatible avec Windows, macOS et Linux
- Enorme bibliothèque standard : Prête à l’emploi pour diverses applications
- Communauté active : De nombreuses ressources d’aide

3
1.2.3. Pourquoi apprendre Python ?

Python est un langage :

- Facile à apprendre : Sa syntaxe claire et lisible en fait un choix idéal pour les débutants.
- Polyvalent : Utilisé dans des domaines variés comme Développement web (Django,
Flask), Science des données (NumPy, Pandas), Représentation graphique (Matplotlib,
VTK), Intelligence artificielle et machine learning (TensorFlow, PyTorch),
Automatisation de tâches, etc.
- Populaire : Il est largement utilisé dans l’industrie, avec une communauté active
fournissant des ressources et du support.

1.2.4. Comment un code source est-il exécuté ?

Pour qu’un programme écrit en langage de haut niveau puisse être compris par un ordinateur,
il doit être converti en langage machine. Deux méthodes principales permettent cette
transformation :

- La compilation : un programme spécifique, appelé compilateur, traduit l’ensemble du

code source en un fichier exécutable en langage machine. Ce fichier peut ensuite être
lancé directement. Toute modification du code impose une nouvelle compilation avant
exécution.
- L’interprétation : un interpréteur analyse et traduit le code instruction par instruction
au moment de l’exécution. Cette approche facilite les phases de développement et de
test, mais elle entraîne généralement des performances plus faibles que la compilation
directe.

Concernant Python, il est généralement présenté comme un langage interprété. En pratique, son
fonctionnement est hybride : le code est d’abord converti en un bytecode intermédiaire, puis
exécuté par une machine virtuelle. De plus, pour optimiser les traitements exigeants en calcul,
Python peut utiliser des bibliothèques écrites dans des langages compilés de bas niveau comme
le C, ce qui améliore significativement les performances.

4
1.3. Prérequis
Aucun prérequis technique n’est nécessaire pour ce cours. Cependant, il est utile d’avoir :

- Une connaissance de base de l’utilisation d’un ordinateur.

- Une motivation à apprendre et explorer.

1.4. Installation et premier programme

1.4.1. Outils et configuration

Pour suivre ce cours, vous aurez besoin de :

1. App Python : Téléchargez et installez la dernière version de Python (3.x) à partir du site
officiel : [Link]

2. IDE ou éditeur de code (recommandé) : VS Code ou Spyder...

3. Terminal ou console :

- Windows : PowerShell ou Command Prompt.

- macOS/Linux : Terminal intégré.
4. Bibliothèques additionnelles : pip (inclus avec Python) permettra d’installer des
bibliothèques supplémentaires si nécessaire.

Une fois prêt, testez votre installation en ouvrant un terminal et en tapant : python --version (Si
une version s'affiche, Python est bien installé.)

1.4.2. Premier programme Python

Créez un fichier premier_programme.py et ajoutez :

Nous n'allons pas expliquer la signification du programme pour le moment. Vous trouverez une
discussion détaillée dans la suite du cours.

Exécutez-le dans le terminal : python premier_programme.py

5
1.5. Structure du cours
Le cours est divisé en 6 grandes parties :

1. Bases de Python (syntaxe, variables et types de données, opérateurs).

2. Structures de contrôle (conditions, boucles).

3. Structures de données et manipulation (listes, dictionnaires, tuples et ensembles).

4. Fonctions et modularité.

5. Les notions avancées pour débutants (gestion des erreurs, fichiers, POO).

6. Les projets pratiques (mini-projets et un projet final).

Chaque partie comprend :

- Explications claires des concepts.

- Exemples pratiques pour illustrer l’utilisation.
- Exercices corrigés pour s’entraîner et valider les acquis.

1.6. Conseils pour réussir

- Pratiquez régulièrement : Essayez de coder un peu chaque jour pour mieux assimiler les
concepts.
- Posez des questions : Recherchez les réponses dans la documentation officielle ou
auprès de la communauté Python.
- Expérimentez : Ne vous limitez pas aux exemples donnés. Essayez de modifier les
programmes et d'explorer par vous-même.
- Ne vous découragez pas : La programmation peut être frustrante au début mais avec de
la persévérance, vous y arriverez.

1.7. Conclusion
Cette introduction marque le début d’un voyage passionnant dans l’univers de la
programmation. Python est un outil puissant et convivial pour démarrer, et ce cours vous
fournira les bases nécessaires pour explorer ses multiples possibilités. Soyez prêts à coder,
apprendre et créer !

6
PARTIE I : LES BASES DE PYTHON

7
Table des matières

2. PARTIE I : LES BASES DE PYTHON ............................................................................. 7

2.1. Concepts de base............................................................................................................ 9
2.1.1. Syntaxe de Python .................................................................................................. 9
2.1.2. Commentaires ......................................................................................................... 9
2.1.3. Affichage .................................................................................................................. 9
2.1.4. Entrée utilisateur .................................................................................................. 10
TP 1 .................................................................................................................................. 10
2.2. Variables et types de données ..................................................................................... 11
2.2.1. Qu'est-ce qu'une variable ? ................................................................................. 11
2.2.2. Déclaration et affectation ..................................................................................... 11
2.2.3. Types de données de base ..................................................................................... 12
2.2.4. Conversion de types ............................................................................................. 12
2.2.5. Constantes ............................................................................................................. 13
2.2.6. Bonnes pratiques .................................................................................................. 13
TP 2 .................................................................................................................................. 14
2.3. Opérateurs ................................................................................................................... 14
2.3.1. Opérateurs arithmétiques.................................................................................... 14
TP3 ................................................................................................................................... 15
2.3.2. Opérateurs de comparaison ................................................................................ 16
TP4 ................................................................................................................................... 16
2.3.3. Opérateurs logiques ............................................................................................. 17
TP5 ................................................................................................................................... 18

8
2.1. Concepts de base

2.1.1. Syntaxe de Python

Objectif : Comprendre les règles de base pour écrire du code Python.

- Chaque instruction s'écrit sur une ligne.

- Fin de ligne : Pas de point-virgule obligatoire (contrairement à d’autres langages).
- Sensibilité à la casse : Python distingue les majuscules et les minuscules. Exemple :
variable ≠ Variable
- Indentation : Les blocs de code sont définis par l’indentation (espaces ou tabulations).
- Mots-clés réservés : if, else, for, while, def, etc.

2.1.2. Commentaires

Objectif : Apprendre à ajouter des commentaires pour expliquer le code.

- Commentaire sur une ligne : Utilisez #.

- Commentaire sur plusieurs lignes : Utilisez ''' ou """.

2.1.3. Affichage

Objectif : Savoir afficher des informations à l’écran.

- Fonction print() : Affiche du texte ou des variables.

9
 - F-strings (Python 3.6+) : Permet d’insérer des variables dans une chaîne.

2.1.4. Entrée utilisateur

Objectif : Récupérer des informations saisies par l’utilisateur.

- Fonction input() : Permet de demander une entrée à l’utilisateur.

- Conversion de type : input() retourne toujours une chaîne de caractères. Utilisez int(),
float(), etc., pour convertir.

TP 1
Ecrivez un programme Python qui :

1. Affiche le message "Bienvenue dans ce TP Python !".

2. Demande à l’utilisateur de saisir son prénom et son âge.

3. Affiche un message personnalisé : "Bonjour [prénom], vous avez [âge] ans."

4. Ajoutez un commentaire pour expliquer chaque ligne de votre code.

10
Solution

2.2. Variables et types de données

2.2.1. Qu'est-ce qu'une variable ?

Une variable est un conteneur qui stocke une valeur en mémoire. Elle est caractérisée par :

- Un nom (exemple : age, nom).

- Une valeur (exemple : 25, "Junior").
- Un type (exemple : entier, chaîne de caractères).

2.2.2. Déclaration et affectation

Syntaxe : nom_variable = valeur

Nommage des variables

- Doit commencer par une lettre ou un underscore (_).

- Ne peut pas contenir d’espaces ni commencer par un chiffre.

11
2.2.3. Types de données de base

Type Description Exemple

int Nombre entier 18
float Nombre décimal 18.50
str Chaîne de caractères "Bonjour"
bool Booléen (True ou False) True

Important ! Utilisez type() pour afficher le type d’une variable :

2.2.4. Conversion de types

Pourquoi convertir ?

- Pour effectuer des opérations entre types compatibles.

- Pour adapter une entrée utilisateur (toujours de type str avec input()).

12
Fonctions de conversion :

Fonction Description Exemple

int() Convertit en entier int("25") → 25
float() Convertit en décimal float("3.14") → 3.14
str() Convertit en chaîne de caractères str(42) → "42"

2.2.5. Constantes

Python n’a pas de mot-clé spécifique pour les constantes mais par convention, elles sont
nommées en majuscules :

2.2.6. Bonnes pratiques

- Noms explicites : Utilisez des noms de variables clairs (exemple : nombre_etudiants

plutôt que n).
- Evitez les variables non initialisées : Toujours affecter une valeur à une variable avant
de l'utiliser.
- Respectez les conventions : Utilisez snake_case pour les noms de variables (exemple :
ma_variable).

13
TP 2

Ecrivez un programme qui :

1. Demande à l'utilisateur de saisir son prénom dans une variable prenom.

2. Demande à l'utilisateur de saisir son année de naissance dans une variable

annee_naissance.

3. Calcule et stocke son âge en 2026 dans une variable age.

4. Affiche un message utilisant ces variables : "Bonjour [prénom], vous aurez [âge] ans
en 2026."

Solution

2.3. Opérateurs

2.3.1. Opérateurs arithmétiques

Opérateur Description Exemple Résultat

+ Addition 5+3 8
- Soustraction 10 - 4 6
* Multiplication 3*4 12
/ Division 10 / 2 5.0
// Division entière 10 // 3 3
% Modulo 10 % 3 1
** Puissance 2 ** 3 8

14
Priorité des opérateurs

La règle de la priorité des opérations (PEMDAS) détermine l’ordre dans lequel chaque
opération doit être effectuée. PEMDAS est un acronyme pour les mots parenthèses, exposants,
multiplication, division, addition, soustraction. Etant donné qu’il y a au moins deux opérations
dans une équation, l’ordre des lettres dans PEMDAS vous indique quelle opération effectuer en
premier, deuxième, troisième et ainsi de suite jusqu’à ce que l’équation soit résolue.

Les calculs respectent les priorités classiques :

1. Parenthèses ()

2. Puissance **

3. Multiplication *, Division /, Division entière //, Modulo %

4. Addition +, Soustraction -

TP3

Ecrivez un programme qui :

1. Stocke deux nombres entiers dans les variables a et b.

2. Calcule et affiche :
- La somme de a et b.
- La différence entre a et b.
- Le produit de a et b.
- Le quotient de a divisé par b.
- Le reste de la division de a par b.

15
Solution

2.3.2. Opérateurs de comparaison

Opérateur Description Exemple Résultat

== Egal à 5 == 3 False
!= Différent de 5 != 3 True
> Supérieur à 5>3 True
< Inférieur à 5<3 False
>= Supérieur ou égal 5 >= 3 True
<= Inférieur ou égal 5 <= 3 False

TP4

Ecrivez un programme qui :

1. Stocke deux nombres dans les variables x et y.

2. Affiche le résultat des comparaisons suivantes :

- x est-il égal à y ?
- x est-il différent de y ?
- x est-il supérieur à y ?
- x est-il inférieur ou égal à y ?

16
2.3.3. Opérateurs logiques

Les opérateurs logiques permettent d’évaluer des conditions :

Opérateur Description Exemple Résultat

and ET 5+3 False
or OU True or False True
not NON not True False

Tables de vérité :

- and : True seulement si les deux opérandes sont True.

- or : True si au moins un opérande est True.
- not : Inverse la valeur booléenne.

17
TP5

Ecrivez un programme qui :

1. Stocke deux valeurs booléennes dans les variables a et b.

2. Affiche le résultat des opérations logiques suivantes :

- a AND b
- a OR b
- NOT a
- NOT (a AND b)

18
PARTIE II : STRUCTURES DE CONTROLE

19
Table des matières

3. Partie II : Structures de contrôle ...................................................................................... 19

3.1. Structures conditionnelles .......................................................................................... 21
3.1.1. L’instruction if ...................................................................................................... 21
TP 6 .................................................................................................................................. 21
3.1.2. L’instruction if/else ............................................................................................... 22
TP 7 .................................................................................................................................. 22
3.1.3. L’instruction if/elif/else ........................................................................................ 23
TP 8 .................................................................................................................................. 23
3.1.4. L’opérateur ternaire ............................................................................................. 24
TP 9 .................................................................................................................................. 25
3.2. Boucles .......................................................................................................................... 25
3.2.1. La boucle for ......................................................................................................... 25
TP 10 ................................................................................................................................ 25
3.2.2. La boucle while ..................................................................................................... 26
TP 11 ................................................................................................................................ 26
3.2.3. Instructions break et continue............................................................................. 27
TP 12 ................................................................................................................................ 27

20
3.1. Structures conditionnelles

3.1.1. L’instruction if

Objectif : Exécuter un bloc de code uniquement si une condition est vraie.

Syntaxe :

if condition:
# Bloc de code

Exemple :

TP 6

Ecrivez un programme qui :

1. Stocke un nombre dans une variable nombre.

2. Affiche "Le nombre est positif" uniquement si nombre est supérieur à 0.

Corrigé

21
3.1.2. L’instruction if/else

Objectif : Exécuter un bloc de code si la condition est vraie, sinon exécuter un autre bloc.

Syntaxe :

if condition:
# Bloc de code si condition vraie
else:
# Bloc de code si condition fausse

Exemple :

TP 7

Ecrivez un programme qui :

1. Stocke un nombre dans une variable nombre.

2. Affiche "Le nombre est positif" si nombre est supérieur à 0, sinon affiche "Le nombre
est négatif ou nul".

Corrigé

22
3.1.3. L’instruction if/elif/else

Objectif : Tester plusieurs conditions successives.

Syntaxe :

if condition1:
# Bloc de code si condition1 vraie
elif condition2:
# Bloc de code si condition2 vraie
else:
# Bloc de code si aucune condition vraie

Exemple :

TP 8

Ecrivez un programme qui :

1. Demande à l’utilisateur de saisir une note sur 20 (entier ou décimal).

2. Vérifie que la note est comprise entre 0 et 20 inclus. (Si la note est hors intervalle,
afficher : "Erreur : la note doit être comprise entre 0 et 20.")

3. Si la note est valide, afficher la mention correspondante :

- Excellent si note ≥ 18
- Très bien si 16 ≤ note < 18
- Bien si 14 ≤ note < 16

23
 - Assez bien si 12 ≤ note < 14
- Passable si 10 ≤ note < 12
- Insuffisant si note < 10

Les intervalles doivent être cohérents, sans chevauchement.

Corrigé

3.1.4. L’opérateur ternaire

Objectif : Ecrire une condition simple sur une seule ligne.

Syntaxe :

valeur_si_vrai if condition else valeur_si_faux

Exemple :

24
TP 9

Ecrivez un programme qui :

1. Stocke un nombre dans une variable nombre.

2. Utilise l’opérateur ternaire pour afficher "Pair" si nombre est pair, sinon affiche
"Impair".

Corrigé

3.2. Boucles

3.2.1. La boucle for

Objectif : Répéter un bloc de code un nombre connu de fois.

Syntaxe :

for variable in sequence:

# Bloc de code

Exemple :

TP 10

Ecrivez un programme qui affiche les nombres de 1 à 5 en utilisant une boucle for.

25
Corrigé

3.2.2. La boucle while

Objectif : Répéter un bloc de code tant qu’une condition est vraie.

Syntaxe :

while condition:
# Bloc de code

Exemple :

TP 11

Ecrivez un programme qui :

1. Stocke un compteur initialisé à 0 dans une variable compteur.

2. Utilise une boucle while pour afficher la valeur de compteur et l’incrémenter de 1, tant
que compteur est inférieur à 5.

26
Corrigé

3.2.3. Instructions break et continue

Objectif : Contrôler le flux d’exécution dans une boucle.

- break : Sort immédiatement de la boucle.

- continue : Passe à l’itération suivante.

Exemple :

TP 12

Ecrivez un programme qui :

1. Utilise une boucle for pour parcourir les nombres de 0 à 9.

2. Affiche uniquement les nombres pairs en utilisant continue.

3. Arrête la boucle dès que le nombre 6 est atteint en utilisant break.

27
Corrigé

28
PARTIE III : STRUCTURES DE DONNEES ET
MANIPULATION DES DONNEES

29
Table des matières

4. PARTIE III : STRUCTURES DE DONNEES ET MANIPULATION DES DONNEES

.................................................................................................................................................. 29

4.1. Listes et manipulation de données ............................................................................. 31

4.1.1. Introduction aux listes.......................................................................................... 31

4.1.2. Accéder et modifier des éléments ........................................................................ 31

4.1.3. Méthodes utiles pour les listes ............................................................................. 32

TP 13 ................................................................................................................................ 32

4.2. Dictionnaires ................................................................................................................ 33

4.2.1. Introduction aux dictionnaires ............................................................................ 33

4.2.2. Accéder et modifier des valeurs........................................................................... 33

4.2.3. Utilisation des dictionnaires pour stocker des données structurées ................ 34

TP 14 ................................................................................................................................ 34

4.3. Tuples et ensembles ..................................................................................................... 35

4.3.1. Introduction aux tuples ........................................................................................ 35

4.3.2. Introduction aux ensembles (set) ........................................................................ 35

4.3.3. Cas d'utilisation en Data Science ........................................................................ 35

TP 15 ................................................................................................................................ 36

30
4.1. Listes et manipulation de données

4.1.1. Introduction aux listes

Objectif : Comprendre comment stocker et organiser des collections de données.

Contenu :

- Une liste est une collection ordonnée et modifiable d'éléments.

- Les éléments peuvent être de types différents (entiers, chaînes, etc.).
- Les listes sont définies avec des crochets [].

Exemple :

4.1.2. Accéder et modifier des éléments

Objectif : Savoir manipuler les éléments d'une liste.

Contenu :

- Accéder à un élément : liste[index] (l'index commence à 0).

- Modifier un élément : liste[index] = nouvelle_valeur.
- Ajouter un élément : [Link](element).
- Supprimer un élément : [Link](element).

Exemple :

31
4.1.3. Méthodes utiles pour les listes

Objectif : Utiliser des méthodes pour trier, inverser ou obtenir des informations sur une liste.

Méthode Description Exemple

append() Ajoute un élément à la fin [Link]("kiwi")
remove() Supprime un élément [Link]("banane")
sort() Trie la liste [Link]()
len() Retourne la longueur de la liste len(fruits)
sum() Calcule la somme des éléments sum(notes)

Exemple :

TP 13

Ecrivez un programme qui :

1. Crée une liste de 5 notes d'étudiants.

2. Trie la liste.

3. Calcule et affiche la moyenne des notes.

Corrigé

32
4.2. Dictionnaires

4.2.1. Introduction aux dictionnaires

Objectif : Stocker des données sous forme de paires clé-valeur.

Contenu :

- Un dictionnaire est une collection non ordonnée de paires clé:valeur.

- Les dictionnaires sont définis avec des accolades {}.

Exemple :

4.2.2. Accéder et modifier des valeurs

Objectif : Manipuler les données dans un dictionnaire.

Contenu :

- Accéder à une valeur : dictionnaire[clé].

- Modifier une valeur : dictionnaire[clé] = nouvelle_valeur.
- Ajouter une paire : dictionnaire[nouvelle_clé] = valeur.

Exemple :

33
4.2.3. Utilisation des dictionnaires pour stocker des données structurées

Objectif : Organiser des données complexes.

Exemple :

TP 14

Ecrivez un programme qui :

1. Crée un dictionnaire pour stocker les informations d'un étudiant (nom, âge, liste de
notes).

2. Affiche la moyenne des notes de l'étudiant.

Corrigé

34
4.3. Tuples et ensembles

4.3.1. Introduction aux tuples

Objectif : Stocker des collections immuables (non modifiables).

Contenu :

- Un tuple est une collection ordonnée et immuable.

- Les tuples sont définis avec des parenthèses ().

Exemple :

4.3.2. Introduction aux ensembles (set)

Objectif : Stocker des éléments uniques et non ordonnés.

Contenu :

- Un ensemble est une collection non ordonnée d'éléments uniques.

- Les ensembles sont définis avec des accolades {} ou set().

Exemple :

4.3.3. Cas d'utilisation en Data Science

Objectif : Supprimer les doublons ou vérifier l'appartenance.

35
Exemple :

TP 15

Ecrivez un programme qui :

1. Crée une liste avec des doublons.

2. Utilise un ensemble pour supprimer les doublons.

3. Affiche la liste sans doublons.

Corrigé

36
PARTIE IV : FONCTIONS

37
Table des matières

5. PARTIE IV : FONCTIONS ............................................................................................... 37

5.1. Définition et appel de fonctions .................................................................................. 39

5.1.1. Syntaxe de base des fonctions .............................................................................. 39

5.1.2. Paramètres et arguments ..................................................................................... 39

TP 16 ................................................................................................................................ 39

5.2. Valeur de retour et portée des variables .................................................................... 40

5.2.1. Utilisation de return ............................................................................................. 40

5.2.2. Variables locales et globales ................................................................................. 40

TP 17 ................................................................................................................................ 41

5.3. Fonctions et Data Science ........................................................................................... 41

5.3.1. Ecrire des fonctions pour le prétraitement des données ................................... 41

5.3.2. Utilisation de fonctions dans des pipelines de données ..................................... 42

TP 18 ................................................................................................................................ 42

38
5.1. Définition et appel de fonctions

5.1.1. Syntaxe de base des fonctions

Objectif : Apprendre à définir et appeler une fonction en Python.

Contenu :

- Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique.
- Définition avec le mot-clé def.
- Appel d'une fonction avec son nom suivi de parenthèses ().

Exemple :

5.1.2. Paramètres et arguments

Objectif : Passer des informations à une fonction.

Contenu :

- Paramètres : Variables définies dans la déclaration de la fonction.

- Arguments : Valeurs passées à la fonction lors de l'appel.

Exemple :

TP 16

Ecrivez une fonction carre qui :

1. Prend un nombre en paramètre.

2. Affiche le carré de ce nombre.

39
Corrigé

5.2. Valeur de retour et portée des variables

5.2.1. Utilisation de return

Objectif : Renoyer un résultat depuis une fonction.

Contenu :

- return permet de renvoyer une valeur ou un résultat.

- Une fonction peut retourner un seul objet (mais cet objet peut être une collection).

Exemple :

5.2.2. Variables locales et globales

Objectif : Comprendre la portée des variables.

Contenu :

- Variable locale : Déclarée dans une fonction, accessible uniquement dans cette
fonction.
- Variable globale : Déclarée en dehors des fonctions, accessible partout.

Exemple :

40
TP 17

Ecrivez une fonction moyenne qui :

1. Prend deux nombres en paramètre.

2. Retourne la moyenne de ces deux nombres.

Corrigé

5.3. Fonctions et Data Science

5.3.1. Ecrire des fonctions pour le prétraitement des données

Objectif : Créer des fonctions pour nettoyer ou transformer des données.

Exemple :

41
5.3.2. Utilisation de fonctions dans des pipelines de données

Objectif : Chaîner des fonctions pour traiter des données.

Exemple :

TP 18

Ecrivez une fonction nettoyer_et_normaliser qui :

1. Prend une liste de nombres en paramètre.

2. Supprime les valeurs None et les doublons.

3. Normalise les valeurs entre 0 et 1 (en divisant par la valeur maximale).

4. Retourne la liste nettoyée et normalisée.

Corrigé

42
PARTIE V : MODULES

43
Table des matières

6. PARTIE IV : MODULES .................................................................................................. 43

6.1. Introduction aux modules en Python......................................................................... 45

6.1.1. Qu'est-ce qu'un module ? .................................................................................... 45

6.1.2. Importer un module ............................................................................................. 45

TP 19 ................................................................................................................................ 46

6.2. Modules courants en Python ...................................................................................... 46

6.2.1. Module math ......................................................................................................... 46

6.2.2. Module random .................................................................................................... 46

6.2.3. Module datetime ................................................................................................... 47

TP 20 ................................................................................................................................ 47

6.3. Modules spécifiques à l'IA et la Data Science ........................................................... 48

6.3.1. Introduction aux bibliothèques pour l'IA et la Data Science ........................... 48

6.3.2. Installation des bibliothèques .............................................................................. 48

6.3.3. Utilisation de numpy ............................................................................................ 48

TP 21 ................................................................................................................................ 49

6.3.4. Utilisation de pandas ............................................................................................ 49

TP 22 ................................................................................................................................ 49

6.3.5. Visualisation avec matplotlib............................................................................... 50

TP 23 ................................................................................................................................ 51

44
6.1. Introduction aux modules en Python

6.1.1. Qu'est-ce qu'un module ?

Objectif : Comprendre ce qu'est un module et son utilité.

Contenu :

- Un module est un fichier contenant du code Python (fonctions, classes, variables) qui
peut être réutilisé.
- Les modules permettent d'organiser le code en parties logiques et réutilisables.
- Exemple de modules intégrés : math, random, datetime.

Exemple :

6.1.2. Importer un module

Objectif : Apprendre à importer et utiliser un module.

Contenu :

- Importer un module entier : import nom_du_module.

- Importer des fonctions spécifiques : from nom_du_module import fonction.
- Utiliser un alias : import nom_du_module as alias.

Exemple :

45
TP 19

1. Utilisez le module math pour calculer la racine carrée de 25 et affichez le résultat.

2. Utilisez le module random pour générer un nombre entier aléatoire entre 1 et 100.

Corrigé

6.2. Modules courants en Python

6.2.1. Module math

Objectif : Utiliser des fonctions mathématiques de base.

Contenu :

- Fonctions courantes : sqrt, pow, sin, cos, log, etc.

Exemple :

6.2.2. Module random

Objectif : Générer des nombres aléatoires.

Contenu :

- Fonctions courantes : randint, random, choice, shuffle.

46
Exemple :

6.2.3. Module datetime

Objectif : Manipuler les dates et les heures.

Contenu :

- Fonctions courantes : [Link](), [Link](), timedelta.

Exemple :

TP 20

1. Utilisez le module math pour calculer le logarithme de 100 en base 10.

2. Utilisez le module random pour mélanger une liste de fruits.

3. Utilisez le module datetime pour afficher la date actuelle.

Corrigé :

47
6.3. Modules spécifiques à l'IA et la Data Science

6.3.1. Introduction aux bibliothèques pour l'IA et la Data Science

Objectif : Découvrir les bibliothèques essentielles pour l'IA et la Data Science.

Contenu :

- numpy : Calcul numérique et manipulation de tableaux.

- pandas : Manipulation et analyse de données tabulaires.
- matplotlib : Visualisation de données.
- scikit-learn : Apprentissage automatique.

6.3.2. Installation des bibliothèques

Objectif : Installer les bibliothèques nécessaires.

Contenu :

- Utiliser pip pour installer les bibliothèques.

Exemple :

pip install numpy pandas matplotlib scikit-learn

6.3.3. Utilisation de numpy

Objectif : Manipuler des tableaux numériques.

Contenu :

- Création de tableaux avec [Link]().

- Opérations sur les tableaux.

Exemple :

48
TP 21

1. Créez un tableau numpy contenant les valeurs [10, 20, 30, 40, 50].

2. Calculez la moyenne et l'écart-type de ce tableau.

Corrigé

6.3.4. Utilisation de pandas

Objectif : Manipuler des données tabulaires.

Contenu :

- Création de DataFrames avec [Link]().

- Lecture de fichiers CSV avec pd.read_csv().

Exemple :

TP 22

1. Créez un DataFrame pandas avec les données suivantes :

- Noms : ["Alice", "Bob", "Charlie"]

- Âges : [20, 22, 21]
- Notes : [15, 18, 12]

49
 2. Affichez les étudiants ayant une note supérieure à 15.

Corrigé

6.3.5. Visualisation avec matplotlib

Objectif : Créer des graphiques pour visualiser des données.

Contenu :

- Création de graphiques en lignes, barres, etc.

Exemple :

50
TP 23

1. Utilisez matplotlib pour tracer un graphique en barres représentant les notes des
étudiants suivants :

- Noms : ["Alice", "Bob", "Charlie"]

- Notes : [15, 18, 12]

2. Ajoutez un titre et des labels aux axes.

Corrigé

51
PROJET FINAL : ANALYSE DES DONNEES COVID-19

52
Table des matières

7. PROJET FINAL : ANALYSE DES DONNEES COVID-19 .......................................... 52

7.1. Préparation du projet ................................................................................................. 54

7.1.1. Téléchargement des données ............................................................................... 54

7.1.2. Charger les données avec pandas........................................................................ 54

7.2. Nettoyage des données ................................................................................................ 55

7.2.1. Vérifier les valeurs manquantes .......................................................................... 55

7.2.2. Supprimer les valeurs manquantes..................................................................... 55

7.2.3. Supprimer les doublons ....................................................................................... 55

7.3. Analyse des données .................................................................................................... 56

7.3.1. Statistiques de base............................................................................................... 56

7.3.2. Top 10 des pays avec le plus de cas confirmés ................................................... 56

7.4. Visualisation des données............................................................................................ 57

7.4.1. Graphique des cas confirmés par pays (Top 10)................................................ 57

7.4.2. Graphique du taux de mortalité par pays (Top 10)........................................... 57

7.4.3. Evolution des cas confirmés, décès et guérisons ................................................ 57

7.5. Projet final complet ..................................................................................................... 58

TP final : Analyse complète des données COVID-19 .................................................. 58

53
7.1. Préparation du projet

7.1.1. Téléchargement des données

Objectif : Récupérer les données COVID-19 depuis le dépôt GitHub de Johns Hopkins CSSE.

Contenu :

- Utilisez le lien suivant pour télécharger un fichier CSV de données quotidiennes : Dépôt
GitHub COVID-19
- Choisissez un fichier récent (exemple : [Link]).

7.1.2. Charger les données avec pandas

Objectif : Lire le fichier CSV et afficher les premières lignes.

Exemple :

54
7.2. Nettoyage des données

7.2.1. Vérifier les valeurs manquantes

Objectif : Identifier et gérer les valeurs manquantes.

Exemple :

7.2.2. Supprimer les valeurs manquantes

Objectif : Nettoyer le DataFrame en supprimant les lignes avec des valeurs manquantes.

Exemple :

7.2.3. Supprimer les doublons

Objectif : Vérifier et supprimer les doublons éventuels.

Exemple :

55
7.3. Analyse des données

7.3.1. Statistiques de base

Objectif : Calculer des statistiques de base pour les cas confirmés, décès et guérisons.

Exemple :

7.3.2. Top 10 des pays avec le plus de cas confirmés

Objectif : Identifier les pays les plus touchés.

Exemple :

7.3.3. Taux de mortalité par pays

Objectif : Calculer le taux de mortalité (décès / confirmés) pour chaque pays.

Exemple :

56
7.4. Visualisation des données

7.4.1. Graphique des cas confirmés par pays (Top 10)

Objectif : Visualiser les pays les plus touchés.

Exemple :

7.4.2. Graphique du taux de mortalité par pays (Top 10)

Objectif : Visualiser les pays avec le taux de mortalité le plus élevé.

Exemple :

7.4.3. Evolution des cas confirmés, décès et guérisons

Objectif : Visualiser l'évolution des cas confirmés, décès et guérisons pour un pays spécifique.

Exemple :

57
7.5. Projet final complet

TP final : Analyse complète des données COVID-19

Enoncé :

1. Chargez le fichier CSV des données COVID-19 dans un DataFrame pandas.

2. Nettoyez les données en supprimant les valeurs manquantes et les doublons.

3. Calculez les statistiques de base (moyenne, médiane, écart-type) pour les cas confirmés,
décès et guérisons.

4. Identifiez les 10 pays avec le plus de cas confirmés.

5. Calculez le taux de mortalité pour chaque pays et identifiez les 10 pays avec le taux de
mortalité le plus élevé.

6. Visualisez les 10 pays avec le plus de cas confirmés avec un graphique en barres.

7. Visualisez les 10 pays avec le taux de mortalité le plus élevé avec un graphique en
barres.

8. Choisissez un pays et visualisez l'évolution des cas confirmés, décès et guérisons.

58