Apprendre la Programmation Python

en Résolvant des Problèmes Africains

Regis N’guessan

Date de Publication : 30 septembre 2023

@Regis
LinkedIn
YouTube
2
Programmation Python pour Résoudre des Problèmes
Africains

Regis N’guessan

30 septembre 2023
ii
Table des matières

Préambule 1

1 Installation de Python 3
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Installation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 Téléchargement de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.2 Installation de Python sur Windows . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.3 Installation de Python sur macOS . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.4 Installation de Python sur Linux . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.5 Vérification de l’installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Les Bases de Python 5

2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Variables et Types de Données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2.1 Variables et assignation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2.2 Types de données de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2.3 Conversion de types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2.4 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 Opérations et Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3.1 Opérations mathématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3.2 Opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.3.3 Opérateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 Structures de Contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4.1 Conditionnelles (if, elif, else) . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4.2 Boucles (for, while) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4.3 Break et continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.5 Exemple d’application : Gestion des Stocks Alimentaires dans un village en Afrique . 6
2.5.1 Code Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.5.2 Explication du Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3 Les Fonctions 9
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2 Définition de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2.1 Création de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2.2 Paramètres et arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2.3 Fonctions intégrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.3 Utilisation de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.3.1 Appel de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.3.2 Valeurs de retour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.4 Documentation de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.5 Exemple d’application : Calcul du PIB par habitant au Bénin . . . . . . . . . . . . . 10
3.5.1 Code Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.5.2 Explications du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

iii
iv TABLE DES MATIÈRES

4 Les Listes et les Dictionnaires 13

4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.2 Les Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.2.1 Création de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.2.2 Accès aux éléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.2.3 Modification de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.2.4 Opérations sur les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.2.5 Boucle for avec des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.3 Les Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.3.1 Création de dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.3.2 Accès aux valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.3.3 Modification de dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.3.4 Opérations sur les dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.4 Exemple d’application : Gestion des Stocks de Médicaments au Senegal . . . . . . . 14
4.4.1 Code Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.4.2 Explication du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

5 Les Fonctions Avancées 17

5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5.2 Fonctions Récursives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5.2.1 Qu’est-ce qu’une fonction récursive ? . . . . . . . . . . . . . . . . . . . . . . . 17
5.2.2 Structure d’une fonction récursive . . . . . . . . . . . . . . . . . . . . . . . . 17
5.2.3 Exemple : Calcul du Factoriel . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5.3 Fonctions Lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5.3.1 Qu’est-ce qu’une fonction lambda ? . . . . . . . . . . . . . . . . . . . . . . . . 17
5.3.2 Syntaxe d’une fonction lambda . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.3.3 Utilisation de fonctions lambda . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.4 Portée des Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.4.1 Variables locales et variables globales . . . . . . . . . . . . . . . . . . . . . . . 18
5.4.2 L’instruction global . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.5 Exemple d’application : Résolution d’un Problème Éducatif au Burkina Faso avec
Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.6 Problème : Calcul du Nombre d’Étudiants Inscrits . . . . . . . . . . . . . . . . . . . 18
5.6.1 Contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.6.2 Objectif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.6.3 Solution en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

6 Les Modules et les Packages 21

6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
6.2 Les Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
6.2.1 Importation de modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
6.2.2 Utilisation de fonctions et de variables de module . . . . . . . . . . . . . . . . 21
6.2.3 Création de modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
6.3 Les Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
6.3.1 Création de packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
6.3.2 Importation de modules depuis un package . . . . . . . . . . . . . . . . . . . 22
6.3.3 Utilisation de fonctions et de variables de modules dans un package . . . . . 22
6.4 Importation avec des alias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
6.5 Exemple d’application : Gestion de la Production Agricole en Côte d’Ivoire . . . . . 22
6.5.1 Code Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
6.5.2 Utilisation du Package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
6.5.3 Explication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Regis N’guessan v

7 La Manipulation des Fichiers et des Données 25

7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.2 Lecture de Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.2.1 Ouverture de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.2.2 Lecture de contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.2.3 Fermeture de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.3 Écriture dans des Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.3.1 Écriture de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
7.4 Travailler avec des Fichiers CSV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
7.4.1 Le module CSV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
7.4.2 Lecture de fichiers CSV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
7.4.3 Écriture dans des fichiers CSV . . . . . . . . . . . . . . . . . . . . . . . . . . 26

8 Les Graphiques et la Visualisation de Données 29

8.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.2 Introduction à Matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.2.1 Installation de Matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.2.2 Importation de Matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.3 Création de Graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.3.1 Graphique linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.3.2 Diagramme à barres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.4 Personnalisation des Graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.4.1 Couleurs, styles et légendes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.4.2 Sous-graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.4.3 Exportation des graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.5 Visualisation de Données avec Seaborn . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.6 Exemple d’application : Visualisation des Tendances du Chomage au Cameroun . . . 30
8.6.1 Étape 1 : Collecte des Données . . . . . . . . . . . . . . . . . . . . . . . . . . 30
8.6.2 Étape 2 : Préparation des Données . . . . . . . . . . . . . . . . . . . . . . . . 30
8.6.3 Étape 3 : Création du Graphique . . . . . . . . . . . . . . . . . . . . . . . . . 31
8.6.4 Explication du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

9 Les Bases de Données 33

9.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
9.2 Bases de Données Relationnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
9.2.1 Qu’est-ce qu’une base de données relationnelle ? . . . . . . . . . . . . . . . . . 33
9.2.2 SQL (Structured Query Language) . . . . . . . . . . . . . . . . . . . . . . . . 33
9.3 Utilisation de SQLite en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
9.3.1 Installation de SQLite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
9.3.2 Création d’une base de données . . . . . . . . . . . . . . . . . . . . . . . . . . 33
9.3.3 Création de tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
9.3.4 Insertion, Mise à Jour et Suppression de Données . . . . . . . . . . . . . . . . 34
9.3.5 Interrogation de Données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
9.3.6 Fermeture de la Base de Données . . . . . . . . . . . . . . . . . . . . . . . . . 34
9.4 Utilisation de SQLAlchemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
9.4.1 Installation de SQLAlchemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
9.4.2 Utilisation de SQLAlchemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
9.5 Exemple : Gestion des Données Agricoles au Ghana avec une Base de Données . . . 34
9.5.1 Code Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
9.5.2 Explication du Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
vi TABLE DES MATIÈRES

10 La Programmation Orientée Objet 37

10.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
10.2 Classes et Objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
10.2.1 Qu’est-ce qu’une classe ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
10.2.2 Création d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
10.3 Attributs et Méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
10.3.1 Attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
10.3.2 Méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
10.4 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
10.5 Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
10.6 Exemple : Modélisation d’un Système Bancaire en POO au Congo . . . . . . . . . . 39
10.6.1 Code Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
10.6.2 Explication du Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

11 Projets Python pour l’Afrique 41

11.1 Projet 1 : Calcul de la Croissance Économique au Nigeria . . . . . . . . . . . . . . . 41
11.2 Projet 2 : Suivi de la Population en Éthiopie . . . . . . . . . . . . . . . . . . . . . . 41
11.3 Projet 3 : Convertisseur de Devises pour le Kenya . . . . . . . . . . . . . . . . . . . 41
11.4 Projet 4 : Prédiction de la Récolte d’Arachides au Sénégal . . . . . . . . . . . . . . . 41
11.5 Projet 5 : Calculateur de Taux de Change en Afrique du Sud . . . . . . . . . . . . . 41

12 Des Approches de Solutions aux Projets Python pour l’Afrique 43

12.1 Solution au Projet 1 : Calcul de la Croissance Économique au Nigeria . . . . . . . . 43
12.2 Solution au Projet 2 : Suivi de la Population en Éthiopie . . . . . . . . . . . . . . . . 43
12.3 Solution au Projet 3 : Convertisseur de Devises pour le Kenya . . . . . . . . . . . . . 44
12.4 Solution au Projet 4 : Prédiction de la Récolte d’Arachides au Sénégal . . . . . . . . 44
12.5 Solution au Projet 5 : Calculateur de Taux de Change en Afrique du Sud . . . . . . 45
12.6 Épilogue : Python, l’Aventure sans Fin . . . . . . . . . . . . . . . . . . . . . . . . . . 46
12.6.1 Python, un Ami Fidèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
12.6.2 Les Joies des Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
12.6.3 Les Énigmes de la Portée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
12.6.4 La Créativité sans Limite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
12.6.5 Le Futur Brillant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
12.6.6 Ce Livre est Gratuit et Open Source ! . . . . . . . . . . . . . . . . . . . . . . 46
12.6.7 Vos Contributions Sont les Bienvenues ! . . . . . . . . . . . . . . . . . . . . . 46
12.6.8 Restons Connectés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Préambule

Bienvenue dans ce livre sur la programmation Python dédié à l’Afrique. Ce livre est conçu pour
tous ceux qui souhaitent acquérir des compétences en programmation tout en abordant les problèmes
réels de l’environnement africain. Que vous soyez un étudiant, un professionnel ou simplement quel-
qu’un désireux d’apprendre à coder, ce livre est destiné à vous aider à développer votre expertise en
programmation tout en relevant les défis auxquels l’Afrique est confrontée.

Pourquoi ce livre ?
L’Afrique est un continent dynamique et en pleine croissance, qui fait face à une multitude de
défis et d’opportunités. Dans ce contexte, la programmation informatique offre un outil puissant
pour résoudre des problèmes concrets et contribuer au développement durable de l’Afrique. Ce livre
vise à :
— Autonomiser les Apprenants : La programmation donne aux apprenants africains la
possibilité de créer des solutions innovantes à des problèmes locaux, favorisant ainsi l’auto-
nomisation et l’initiative individuelle.
— Développer des Compétences Incontournables : La maîtrise de la programmation est
devenue une compétence clé dans l’économie mondiale. Elle offre des opportunités de carrière
dans divers domaines, de la technologie à la finance en passant par la santé.
— Résoudre des Problèmes Locaux : En abordant des problèmes spécifiques à l’Afrique,
ce livre montre comment la programmation peut être utilisée pour résoudre des défis tels
que la gestion des ressources naturelles, le suivi de la santé publique et le développement
économique.
— Promouvoir la Créativité : La programmation encourage la créativité en permettant aux
apprenants de concevoir des applications, des sites Web, des systèmes automatisés et bien
plus encore.

Pour qui est-ce ?

Ce livre s’adresse à un public diversifié, des débutants complets aux programmeurs intermédiaires.
Vous n’avez pas besoin d’une expérience préalable en programmation pour commencer. Les ressources
et les projets présentés sont conçus pour s’adapter à différents niveaux de compétence. Que vous
soyez un étudiant d’une école africaine, un professionnel en quête de nouvelles compétences, ou
simplement un curieux désireux de comprendre le monde de la programmation, ce livre est conçu
pour vous.

Structure du Livre
Ce livre est structuré en une série de chapitres, chacun se concentrant sur un aspect spécifique
de la programmation Python. Nous commençons par les bases et progressons vers des concepts plus
avancés, tout en abordant des problèmes réels rencontrés en Afrique. Chaque chapitre comprend des
exemples de code, des exercices pratiques et des projets concrets pour renforcer votre apprentissage.

1
2 TABLE DES MATIÈRES

Comment Utiliser ce Livre

Ce livre est conçu pour être interactif et pratique. Pour tirer le meilleur parti de votre appren-
tissage, je vous encourage à suivre ces recommandations :
— Pratiquez : La programmation s’apprend en pratiquant. Essayez les exemples de code, ré-
solvez les exercices et réalisez les projets pour renforcer votre compréhension.
— Expérimentez : Ne craignez pas de tester de nouvelles idées. La créativité est essentielle
en programmation. Essayez de personnaliser les projets pour les adapter à des problèmes
spécifiques de votre région.
— Collaborez : La programmation est souvent un effort collaboratif. Partagez vos idées, tra-
vaillez avec d’autres apprenants et soyez ouvert aux commentaires et aux suggestions.
— Restez Curieux : La technologie évolue rapidement. Restez à l’affût des dernières tendances
et des nouvelles technologies pour continuer à développer vos compétences.
En fin de compte, ce livre est un point de départ pour votre voyage dans le monde passionnant
de la programmation. Nous espérons qu’il vous inspirera à relever les défis de l’Afrique en utilisant
la puissance de la programmation.
Bonne lecture et bon apprentissage !

Regis N’guessan
Chapitre 1

Installation de Python

1.1 Introduction
Dans ce premier chapitre, nous allons vous guider à travers le processus d’installation de Python
sur votre ordinateur. Python est un langage de programmation puissant et polyvalent, largement
utilisé pour résoudre une variété de problèmes, y compris ceux auxquels l’Afrique est confrontée.
Nous allons également explorer quelques exemples de problèmes africains qui peuvent être abordés
avec Python.

1.2 Installation de Python

Python est un langage open-source, ce qui signifie que vous pouvez le télécharger et l’installer
gratuitement. Voici les étapes à suivre pour l’installer sur différentes plateformes.

1.2.1 Téléchargement de Python

Rendez-vous sur le site officiel de Python à l’adresse https://www.python.org/downloads/
pour télécharger la dernière version de Python.

1.2.2 Installation de Python sur Windows

Téléchargement de l’installeur
Téléchargez l’installeur Python pour Windows à partir du site officiel.

Lancement de l’installeur
Double-cliquez sur le fichier d’installation téléchargé. Cochez la case "Add Python to PATH"
lors de l’installation pour rendre Python accessible depuis n’importe quel répertoire.

Installation
Suivez les instructions à l’écran pour terminer l’installation.

1.2.3 Installation de Python sur macOS

Téléchargement de l’installeur
Téléchargez l’installeur Python pour macOS à partir du site officiel.

3
4 CHAPITRE 1. INSTALLATION DE PYTHON

Lancement de l’installeur
Ouvrez le fichier d’installation téléchargé.

Installation
Suivez les instructions à l’écran pour terminer l’installation.

1.2.4 Installation de Python sur Linux

Python est généralement préinstallé sur la plupart des distributions Linux. Pour vérifier si Python
est déjà installé, ouvrez un terminal et exécutez la commande suivante :
python3 −−v e r s i o n
Si Python n’est pas installé, vous pouvez l’installer à partir du gestionnaire de paquets de votre
distribution Linux. Par exemple, sur Ubuntu, vous pouvez utiliser la commande suivante :
sudo apt−g e t i n s t a l l python3

1.2.5 Vérification de l’installation

Après avoir installé Python, vous pouvez vérifier que tout fonctionne correctement en ouvrant
un terminal (ou l’invite de commande sous Windows) et en tapant la commande suivante :
python −−v e r s i o n
Vous devriez voir la version de Python que vous venez d’installer s’afficher à l’écran.
Félicitations ! Vous avez maintenant installé Python sur votre ordinateur. Vous êtes prêt à com-
mencer à programmer en Python et à résoudre des problèmes africains à l’aide de ce puissant langage.
Chapitre 2

Les Bases de Python

2.1 Introduction
Dans ce chapitre, nous allons explorer les bases de la programmation Python. Vous apprendrez
les concepts fondamentaux, y compris les variables, les opérateurs, les structures de contrôle, et les
fonctions. Ces concepts sont essentiels pour résoudre les problèmes africains que nous aborderons
plus tard dans ce livre.

2.2 Variables et Types de Données

2.2.1 Variables et assignation
En Python, les variables sont des espaces de mémoire que vous pouvez utiliser pour stocker des
données. Pour assigner une valeur à une variable, utilisez le signe égal (=). Par exemple :

nom = "John"
age = 30

2.2.2 Types de données de base

Python prend en charge plusieurs types de données de base, notamment :
— Entiers (integers) : par exemple, 5, -2, 100
— Flottants (floats) : par exemple, 3.14, -0.5, 2.0
— Chaînes de caractères (strings) : par exemple, "Bonjour", ’Python’
— Booléens (booleans) : True (Vrai) ou False (Faux)

2.2.3 Conversion de types

Vous pouvez convertir des valeurs d’un type à un autre. Par exemple :

nombre = 42
texte = str(nombre) % Convertit le nombre en une chaîne de caractères

2.2.4 Commentaires
Les commentaires sont des annotations dans le code Python qui ne sont pas exécutées. Ils com-
mencent par le symbole "# " et sont utiles pour expliquer le code. Par exemple :

# Ceci est un commentaire

5
6 CHAPITRE 2. LES BASES DE PYTHON

2.3 Opérations et Opérateurs

2.3.1 Opérations mathématiques
Python prend en charge les opérations mathématiques de base, telles que l’addition (+), la
soustraction (-), la multiplication (*), la division (/), et d’autres opérations plus avancées.

2.3.2 Opérateurs de comparaison

Les opérateurs de comparaison vous permettent de comparer des valeurs. Les opérations de
comparaison courantes incluent "==", " !=", "<", ">", "<=", ">=".

2.3.3 Opérateurs logiques

Les opérateurs logiques ("and", "or", "not") sont utilisés pour combiner des expressions boo-
léennes.

2.4 Structures de Contrôle

2.4.1 Conditionnelles (if, elif, else)
Les structures conditionnelles permettent d’exécuter des blocs de code en fonction de conditions.
Par exemple :

age = 18
if age < 18:
print("Vous êtes mineur.")
else:
print("Vous êtes majeur.")

2.4.2 Boucles (for, while)

Les boucles vous permettent de répéter des blocs de code. Par exemple, une boucle "for" permet
de parcourir des éléments d’une liste.

nombres = [1, 2, 3, 4, 5]
for nombre in nombres:
print(nombre)

2.4.3 Break et continue

Les instructions "break" et "continue" permettent de contrôler le flux d’une boucle. "break"
arrête complètement une boucle, tandis que "continue" passe à l’itération suivante.

2.5 Exemple d’application : Gestion des Stocks Alimentaires

dans un village en Afrique
Dans cet exemple, nous allons utiliser Python pour résoudre un problème lié à la gestion des
stocks alimentaires dans un village d’Afrique.
Regis N’guessan 7

2.5.1 Code Python

Voici le code Python pour résoudre ce problème :
# Exemple d ’ application : Gestion des Stocks Alimentaires en Afrique

# Definitions des variables

stock_alimentaire = 1000 # Quantite initiale de nourriture en kilogrammes
c o n s ommat ion_pa r_jou r = 20 # Consommation quotidienne en kilogrammes
jours_a_nourrir = 30 # Nombre de jours a nourrir la communaute

# Calcul de la quantite de nourriture necessaire

n o u r ritur e_nece ssair e = consom matio n_par_ jour * jours_a_nourrir

# Verification de la disponibilite de la nourriture

if stock_alimentaire >= nourr iture _neces saire :
print ( " La ␣ quantite ␣ de ␣ nourriture ␣ est ␣ suffisante . " )
print ( f " Stock ␣ restant ␣ : ␣ { stock_alimentaire ␣ -␣ nourri ture_ necess aire } ␣ kg " )
else :
print ( " La ␣ quantite ␣ de ␣ nourriture ␣ est ␣ insuffisante . " )
print ( f " Il ␣ manque ␣ { nour riture _nece ssaire ␣ -␣ stock_alimentaire } ␣ kg ␣ de ␣
nourriture . " )

2.5.2 Explication du Code

— Nous définissons initialement la quantité de nourriture disponible dans le stock (stock_alimentaire),
la consommation quotidienne moyenne par personne (consommation_par_jour), et le nombre
de jours pour lesquels nous devons nourrir la communauté (jours_a_nourrir).
— Nous calculons la quantité totale de nourriture nécessaire en multipliant la consommation
quotidienne par le nombre de jours (nourriture_necessaire).
— Ensuite, nous vérifions si la quantité de nourriture dans le stock est suffisante pour nourrir la
communauté pendant la période spécifiée. Si le stock est suffisant, nous affichons un message
indiquant qu’il y a suffisamment de nourriture et affichons le stock restant. Sinon, nous
indiquons combien de kilogrammes de nourriture supplémentaires sont nécessaires.
8 CHAPITRE 2. LES BASES DE PYTHON
Chapitre 3

Les Fonctions

3.1 Introduction
Les fonctions sont des éléments essentiels de la programmation Python. Elles vous permettent de
regrouper des blocs de code en une unité logique et réutilisable. Dans ce chapitre, nous explorerons
en détail la création et l’utilisation des fonctions, ainsi que leur rôle dans la résolution de problèmes
africains.

3.2 Définition de fonctions

3.2.1 Création de fonctions
En Python, vous pouvez définir une fonction à l’aide du mot-clé def. Par exemple :

def saluer():
print("Bonjour, comment ça va ?")

3.2.2 Paramètres et arguments

Les fonctions peuvent accepter des paramètres, qui sont des valeurs que vous fournissez lors de
l’appel de la fonction. Les paramètres permettent à une fonction de prendre en compte des données
variables. Par exemple :

def dire_bonjour(nom):
print("Bonjour, " + nom + " !")

3.2.3 Fonctions intégrées

Python dispose de nombreuses fonctions intégrées, telles que print(), len(), range(), etc. Vous
pouvez les utiliser directement sans avoir à les définir.

3.3 Utilisation de fonctions

3.3.1 Appel de fonctions
Pour appeler une fonction que vous avez définie, utilisez son nom suivi de parenthèses contenant
les arguments. Par exemple :

saluer() # Appel de la fonction saluer

dire_bonjour("Alice") # Appel de la fonction dire_bonjour avec un argument

9
10 CHAPITRE 3. LES FONCTIONS

3.3.2 Valeurs de retour

Les fonctions peuvent renvoyer des valeurs à l’aide du mot-clé return. Par exemple :

def addition(a, b):

resultat = a + b
return resultat

3.4 Documentation de fonctions

Il est recommandé de documenter vos fonctions en fournissant des commentaires explicatifs (docs-
trings) pour expliquer ce que fait la fonction, quels sont ses paramètres, et ce qu’elle renvoie. Par
exemple :

def calculer_surface(longueur, largeur):

"""
Cette fonction calcule la surface d’un rectangle.

:param longueur: La longueur du rectangle.

:param largeur: La largeur du rectangle.
:return: La surface du rectangle.
"""
return longueur * largeur

3.5 Exemple d’application : Calcul du PIB par habitant au

Bénin
Dans cet exemple, nous allons utiliser Python pour calculer le PIB par habitant au Bénin en
utilisant des données factices.

3.5.1 Code Python

Voici le code Python qui effectue le calcul :

# Fonction pour calculer le PIB par habitant

def calculer_pib_par_habitant(pib_total, population):
pib_par_habitant = pib_total / population
return pib_par_habitant

# Données du Bénin
pib_benin = 12209 # En millions de dollars
population_benin = 12209 # En millions d’habitants

# Appel de la fonction pour calculer le PIB par habitant

pib_par_habitant_benin = calculer_pib_par_habitant(pib_benin, population_benin)

# Affichage du résultat
print("Le PIB par habitant au Bénin est de", pib_par_habitant_benin, "dollars par habitant.")

3.5.2 Explications du code

Nous avons créé une fonction Python nommée calculerp ibp arh abitantquiprendleP IBtotaletlapopulationentantqu′ argum
Ensuite, nous avons utilisé cette fonction pour calculer le PIB par habitant du Bénin
en utilisant des données factices. Le PIB total du Bénin est de 12 209 millions de dollars,
Regis N’guessan 11

et sa population est également de 12 209 millions d’habitants (ce sont des données factices
à des fins d’exemple).
Enfin, nous avons affiché le résultat à l’aide de la fonction print().
Ce code Python peut être exécuté dans un environnement Python pour obtenir le résultat
du calcul du PIB par habitant.
12 CHAPITRE 3. LES FONCTIONS
Chapitre 4

Les Listes et les Dictionnaires

4.1 Introduction
Les listes et les dictionnaires sont des structures de données essentielles en Python.
Dans ce chapitre, nous allons les explorer en profondeur et apprendre comment les utiliser
pour résoudre des problèmes africains.

4.2 Les Listes

4.2.1 Création de listes
En Python, une liste est une collection ordonnée d’éléments. Vous pouvez créer une
liste en utilisant des crochets [] et en séparant les éléments par des virgules. Par
exemple :

fruits = ["pomme", "banane", "orange"]

4.2.2 Accès aux éléments

Vous pouvez accéder aux éléments d’une liste en utilisant leur indice (index) à l’intérieur
des crochets. Les indices commencent à 0. Par exemple :

premier_fruit = fruits[0] % Accède au premier élément de la liste

4.2.3 Modification de listes

Les listes sont mutables, ce qui signifie que vous pouvez modifier leurs éléments.
Par exemple :

fruits[1] = "kiwi" % Remplace "banane" par "kiwi"

4.2.4 Opérations sur les listes

Vous pouvez effectuer diverses opérations sur les listes, notamment :
— Ajout d’éléments avec append() ou insert().
— Suppression d’éléments avec remove() ou pop().
— Concaténation de listes avec +.
— Trouver la longueur d’une liste avec len().

13
14 CHAPITRE 4. LES LISTES ET LES DICTIONNAIRES

4.2.5 Boucle for avec des listes

Les boucles for sont couramment utilisées pour parcourir les éléments d’une liste.
Par exemple :

for fruit in fruits:

print(fruit)

4.3 Les Dictionnaires

4.3.1 Création de dictionnaires
Un dictionnaire est une collection de paires clé-valeur. Vous pouvez créer un dictionnaire
en utilisant des accolades {} et en spécifiant des paires clé-valeur. Par exemple :

capitales = {"France": "Paris", "États-Unis": "Washington, D.C.", "Nigeria": "Abuja"}

4.3.2 Accès aux valeurs

Vous pouvez accéder aux valeurs d’un dictionnaire en utilisant la clé correspondante.
Par exemple :

capitale_france = capitales["France"] % Accède à la valeur associée à la clé "France"

4.3.3 Modification de dictionnaires

Les dictionnaires sont mutables, ce qui signifie que vous pouvez ajouter, mettre
à jour ou supprimer des paires clé-valeur.

capitales["Allemagne"] = "Berlin" % Ajoute une nouvelle paire clé-valeur

capitales["France"] = "Lyon" % Met à jour la valeur associée à la clé "France"
del capitales["Nigeria"] % Supprime la paire clé-valeur associée à la clé "Nigeria"

4.3.4 Opérations sur les dictionnaires

Vous pouvez vérifier si une clé existe dans un dictionnaire avec l’opérateur in,
et obtenir la liste des clés ou des valeurs avec les méthodes keys() et values().

4.4 Exemple d’application: Gestion des Stocks de Médicaments

au Senegal
Supposons que vous travaillez dans une clinique médicale rurale au Sénégal. La clinique
a besoin d’un système informatisé pour gérer son stock de médicaments. Vous allez créer
un programme Python simple pour suivre les médicaments en stock et en commander de nouveaux
lorsque le stock est faible.

4.4.1 Code Python

# Initialisation de la liste des médicaments en stock
stock_medicaments = {
"Paracétamol": 100,
"Amoxicilline": 50,
"Aspirine": 75,
"Ibuprofène": 30,
}
Regis N’guessan 15

# Fonction pour vérifier la quantité en stock d’un médicament

def verifier_stock(medicament):
if medicament in stock_medicaments:
quantite = stock_medicaments[medicament]
return f"Il reste {quantite} {medicament} en stock."
else:
return "Ce médicament n’est pas en stock."

# Fonction pour commander des médicaments

def commander_medicaments(medicament, quantite):
if medicament in stock_medicaments:
stock_medicaments[medicament] += quantite
else:
stock_medicaments[medicament] = quantite

# Fonction pour vendre un médicament

def vendre_medicament(medicament, quantite):
if medicament in stock_medicaments and stock_medicaments[medicament] >= quantite:
stock_medicaments[medicament] -= quantite
return f"{quantite} {medicament}(s) vendu(s)."
else:
return "Stock insuffisant pour cette vente."

# Utilisation du programme
print(verifier_stock("Paracétamol")) # Vérifier la quantité de Paracétamol en stock
commander_medicaments("Vitamine C", 20) # Commander 20 comprimés de Vitamine C
print(verifier_stock("Vitamine C")) # Vérifier la quantité de Vitamine C en stock
print(vendre_medicament("Paracétamol", 10)) # Vendre 10 comprimés de Paracétamol
print(verifier_stock("Paracétamol")) # Vérifier la quantité de Paracétamol en stock

4.4.2 Explication du code

Dans ce code Python :
— Nous initialisons une liste appelée stock_medicaments qui stocke les médicaments
disponibles et leur quantité en stock sous forme de dictionnaire.
— Nous définissons trois fonctions : verifier_stock, commander_medicaments, et vendre_medicam
qui sont utilisées pour vérifier le stock d’un médicament, commander des médicaments
et vendre des médicaments, respectivement.
— Nous utilisons ces fonctions pour effectuer des opérations de gestion de stock,
telles que la vérification du stock de Paracétamol, la commande de Vitamine C,
la vérification du stock de Vitamine C, la vente de Paracétamol et la vérification
du stock de Paracétamol.
Ce code simule la gestion des stocks de médicaments dans une clinique médicale au
Sénégal. Il montre comment les listes (utilisées sous forme de dictionnaire) peuvent
être utilisées pour stocker et mettre à jour des informations sur les médicaments en
stock, et comment des fonctions peuvent être utilisées pour effectuer des opérations
de gestion de stock. Ce type d’approche peut être utile pour résoudre des problèmes
de gestion de stock dans de nombreuses situations en Afrique.
16 CHAPITRE 4. LES LISTES ET LES DICTIONNAIRES
Chapitre 5

Les Fonctions Avancées

5.1 Introduction
Dans ce chapitre, nous allons explorer des concepts avancés liés aux fonctions en
Python. Vous découvrirez comment créer des fonctions récursives, utiliser des fonctions
lambda, et comprendre la portée des variables.

5.2 Fonctions Récursives

5.2.1 Qu’est-ce qu’une fonction récursive ?
Une fonction récursive est une fonction qui s’appelle elle-même dans sa propre définition.
Cette technique est utile pour résoudre des problèmes qui peuvent être décomposés en
des sous-problèmes similaires.

5.2.2 Structure d’une fonction récursive

Une fonction récursive comporte généralement deux parties : le cas de base (base
case) et la récursion. Le cas de base est la condition qui détermine quand la récursion
doit s’arrêter, évitant ainsi une boucle infinie.

5.2.3 Exemple : Calcul du Factoriel

Un exemple classique de fonction récursive est le calcul du factoriel d’un nombre.
Le cas de base est lorsque le nombre est égal à 0, le résultat est alors 1. Sinon, le
factoriel est calculé en multipliant le nombre par le factoriel du nombre précédent.
def factoriel ( n ) :
if n == 0:
return 1
else :
return n * factoriel (n -1)

5.3 Fonctions Lambda

5.3.1 Qu’est-ce qu’une fonction lambda ?
Une fonction lambda, également appelée fonction anonyme, est une petite fonction
sans nom. Elles sont souvent utilisées pour créer des fonctions simples et ponctuelles.

17
18 CHAPITRE 5. LES FONCTIONS AVANCÉES

5.3.2 Syntaxe d’une fonction lambda

Une fonction lambda est définie à l’aide du mot-clé lambda, suivi des paramètres
et de l’expression à évaluer. Par exemple :
carre = lambda x : x **2

5.3.3 Utilisation de fonctions lambda

Les fonctions lambda sont souvent utilisées en combinaison avec des fonctions telles
que map(), filter(), et reduce(), pour appliquer des opérations à des collections de
données.

5.4 Portée des Variables

5.4.1 Variables locales et variables globales
En Python, il existe deux types de variables : les variables locales, définies à
l’intérieur d’une fonction et limitées à cette fonction, et les variables globales,
définies en dehors de toutes les fonctions et accessibles partout dans le code.

5.4.2 L’instruction global

Si vous devez modifier une variable globale à l’intérieur d’une fonction, vous pouvez
utiliser l’instruction global pour indiquer que vous faites référence à une variable
globale.

5.5 Exemple d’application : Résolution d’un Problème Édu-

catif au Burkina Faso avec Python
5.6 Problème : Calcul du Nombre d’Étudiants Inscrits
5.6.1 Contexte
Au Burkina Faso, il est essentiel de suivre le nombre d’étudiants inscrits dans les
écoles pour garantir un accès à l’éducation de qualité. Cependant, le calcul du nombre
total d’étudiants dans tout le pays peut être complexe en raison de la diversité des
niveaux d’enseignement.

5.6.2 Objectif
Créer un programme Python qui calcule le nombre total d’étudiants inscrits dans tout
le Burkina Faso en fonction des données de chaque région et de ses écoles primaires,
secondaires et supérieures.

5.6.3 Solution en Python

Fonctions Récursives pour le Calcul
Les fonctions récursives sont utilisées pour calculer le nombre d’étudiants à chaque
niveau d’enseignement. Chaque fonction prend en compte les niveaux inférieurs et s’arrête
lorsque le cas de base est atteint.
 Regis N’guessan 19

1 def n o m b r e _ e t u d i a n t s _ p r i m a i r e ( n ) :
2 if n == 0:
3 return 0 # Cas de base : aucune cole primaire
4 else :
5 return 500 + n o m b r e _ e t u d i a n t s _ p r i m a i r e ( n - 1)
6
7 def n o m b r e _ e t u d i a n t s _ s e c o n d a i r e ( n ) :
8 if n == 0:
9 return 0 # Cas de base : aucune cole secondaire
10 else :
11 return 300 + n o m b r e _ e t u d i a n t s _ s e c o n d a i r e ( n - 1)
12
13 def n o m b r e _ e t u d i a n t s _ s u p e r i e u r ( n ) :
14 if n == 0:
15 return 0 # Cas de base : aucune cole sup rieure
16 else :
17 return 100 + n o m b r e _ e t u d i a n t s _ s u p e r i e u r ( n - 1)

Utilisation de Fonctions Lambda

Nous définissons une liste de régions avec le nombre d’écoles primaires, secondaires
et supérieures dans chaque région. Ensuite, nous utilisons des fonctions lambda pour
appliquer nos fonctions récursives aux données de chaque région.
1 regions = [
2 { " nom " : " Ouagadougou " , " primaire " : 20 , " secondaire " : 15 ,
" superieur " : 8} ,
3 { " nom " : " Bobo - Dioulasso " , " primaire " : 15 , " secondaire " : 10 ,
" superieur " : 5} ,
4 % Ajoutez d ’ autres ␣ r g i o n s ␣ avec ␣ leurs ␣ d o n n e s
5 ]
6
7 c a l c u l e r _ t o t a l _ r e g i o n ␣ = ␣ lambda ␣ region : ␣ (
8 ␣ ␣ ␣ ␣ n o m b r e _ e t u d i a n t s _ p r i m a i r e ( region [" primaire "]) ␣ +
9 ␣ ␣ ␣ ␣ n o m b r e _ e t u d i a n t s _ s e c o n d a i r e ( region [" secondaire "]) ␣ +
10 ␣ ␣ ␣ ␣ n o m b r e _ e t u d i a n t s _ s u p e r i e u r ( region [" superieur "])
11 )

Agrégation des Résultats

Nous utilisons la fonction map() pour appliquer notre fonction lambda à chaque région
et agréger les résultats pour obtenir le nombre total d’étudiants au Burkina Faso.
1 total_national = sum ( map ( calculer_total_region , regions ) )
2 print ( " Nombre ␣ total ␣ d ’ tudiants ␣ au ␣ Burkina ␣ Faso ␣ : " , total_national )
20 CHAPITRE 5. LES FONCTIONS AVANCÉES
Chapitre 6

Les Modules et les Packages

6.1 Introduction
Dans ce chapitre, nous allons découvrir comment organiser notre code en utilisant
des modules et des packages en Python. Les modules sont des fichiers Python contenant
des fonctions et des variables que vous pouvez réutiliser, tandis que les packages sont
des répertoires contenant plusieurs modules.

6.2 Les Modules

6.2.1 Importation de modules
Pour utiliser un module dans votre code, vous devez l’importer à l’aide de l’instruction
import. Par exemple :
import math % Importe le module math

6.2.2 Utilisation de fonctions et de variables de module

Une fois un module importé, vous pouvez utiliser ses fonctions et variables en les
précédant du nom du module. Par exemple :
resultat = math.sqrt(25) % Utilise la fonction sqrt() du module math

6.2.3 Création de modules

Vous pouvez également créer vos propres modules en créant des fichiers Python avec
des fonctions et des variables que vous souhaitez réutiliser dans d’autres parties de
votre code.

6.3 Les Packages

6.3.1 Création de packages
Un package est un répertoire contenant plusieurs modules Python, ainsi qu’un fichier
spécial nommé __init__.py. La présence de ce fichier indique à Python que le répertoire
est un package. Par exemple :
mon_package/
__init__.py
module1.py
module2.py

21
 22 CHAPITRE 6. LES MODULES ET LES PACKAGES

6.3.2 Importation de modules depuis un package

Pour importer des modules à partir d’un package, vous utilisez l’instruction import
avec la structure du package et le nom du module. Par exemple :

import mon_package.module1

6.3.3 Utilisation de fonctions et de variables de modules dans un package

Une fois que vous avez importé un module depuis un package, vous pouvez utiliser
ses fonctions et variables de la même manière que pour les modules simples.

6.4 Importation avec des alias

Vous pouvez également importer des modules ou des fonctions avec des alias pour simplifier
leur utilisation. Par exemple :

import mon_module as mm

6.5 Exemple d’application: Gestion de la Production Agricole

en Côte d’Ivoire
Dans ce document, nous allons explorer un exemple d’application Python pour la gestion
de la production agricole en Côte d’Ivoire en utilisant des modules et des packages.

6.5.1 Code Python

Voici le code Python qui gère la collecte et l’analyse des données de production
agricole en Côte d’Ivoire :
1 # c o t e d i v oi r e_ ag r ic ul tu r e / production . py
2
3 def coll ecter_donnees () :
4 """ Simule la collecte de donnees sur la production agricole . """
5 donnees = {
6 ’ cacao ’: 50000 ,
7 ’ cafe ’: 30000 ,
8 ’ huile ␣ de ␣ palme ’: 75000 ,
9 }
10 return donnees
11
12 # c o t e d i v oi r e_ ag r ic ul tu r e / analyse . py
13
14 def c a l c u l e r _ p r o d u c t i o n _ t o t a l e ( donnees ) :
15 """ Calcule la production agricole totale en Cote dIvoire . """
16 produ ction_totale = sum ( donnees . values () )
17 return production_totale
18
19 def p r o d u i t _l e_ pl u s_ pr o du it ( donnees ) :
20 """ Trouve le produit agricole le plus produit . """
21 produit = max ( donnees , key = donnees . get )
22 return produit
 Regis N’guessan 23

6.5.2 Utilisation du Package

Nous utilisons le package et les modules dans notre code principal pour effectuer
des opérations sur les données de production :
1 # main . py
2
3 # Importation du package
4 import c ot ed i vo ir e _a gr ic u lt ur e . production as production
5 import c ot ed i vo ir e _a gr ic u lt ur e . analyse as analyse
6
7 # Collecte des donnees de production
8 donnees_agricoles = production . collecter_donnees ()
9
10 # Calcul de la production totale
11 production_totale = analyse . c a l c u l e r _ p r o d u c t i o n _ t o t a l e ( donnees_agricoles )
12
13 # Trouver le produit le plus produit
14 p r o duit_plus_produit = analyse . p ro du it _ le _p lu s _p ro d ui t ( donnees_agricoles )
15
16 # Affichage des resultats
17 print ( " Donnees ␣ de ␣ production ␣ agricole ␣ en ␣ Cote ␣ dIvoire ␣ : " )
18 print ( donnees_agricoles )
19 print ( " Production ␣ agricole ␣ totale ␣ en ␣ Cote ␣ dIvoire ␣ : " , production_totale )
20 print ( " Produit ␣ le ␣ plus ␣ produit ␣ en ␣ Cote ␣ dIvoire ␣ : " , produit_plus_produit )

6.5.3 Explication
Dans cet exemple, nous avons créé un système simple de gestion de la production agricole
en Côte d’Ivoire en utilisant Python. Voici comment cela fonctionne :

Organisation du Code
Nous avons structuré notre code en utilisant des modules et un package Python appelé
cotedivoire_agriculture. Voici comment les fichiers sont organisés :
— cotedivoire_agriculture/ : Le répertoire du package contenant nos modules.
— __init__.py : Un fichier spécial indiquant que ce répertoire est un package.
— production.py : Le module de collecte de données.
— analyse.py : Le module d’analyse de données.

Module production.py
Dans ce module, nous simulons la collecte de données sur la production agricole en
Côte d’Ivoire. Nous stockons ces données dans un dictionnaire avec des valeurs fictives
pour trois produits agricoles : cacao, café et huile de palme. La fonction collecter_donnees()
renvoie ce dictionnaire.

Module analyse.py
Ce module contient deux fonctions pour analyser les données de production :
— calculer_production_totale(donnees) : Cette fonction prend le dictionnaire de
données de production et calcule la production totale en additionnant les valeurs.
— produit_le_plus_produit(donnees) : Cette fonction trouve le produit agricole le
plus produit en Côte d’Ivoire en recherchant la clé associée à la valeur maximale
dans le dictionnaire.
24 CHAPITRE 6. LES MODULES ET LES PACKAGES

Utilisation du Package et des Modules

Dans notre fichier principal main.py, nous utilisons le package et les modules pour
effectuer des opérations sur les données de production :
— Nous importons le package cotedivoire_agriculture et ses modules correspondants.
— Nous collectons les données de production à l’aide de la fonction collecter_donnees().
— Nous calculons la production totale à l’aide de la fonction calculer_production_totale().
— Nous trouvons le produit le plus produit en utilisant la fonction produit_le_plus_produit().
— Enfin, nous affichons les résultats à l’écran.
Ce modèle d’organisation du code avec des modules et des packages facilite la gestion
et la réutilisation du code, ce qui est essentiel pour résoudre des problèmes complexes
en programmation.
Chapitre 7

La Manipulation des Fichiers et des

Données

7.1 Introduction
Dans ce chapitre, nous allons explorer la manipulation des fichiers et des données
en Python. Vous apprendrez comment lire, écrire et manipuler des fichiers, ainsi que
travailler avec des données structurées, telles que les fichiers CSV, pour résoudre
des problèmes liés à l’économie africaine.

7.2 Lecture de Fichiers

7.2.1 Ouverture de fichiers
Vous pouvez ouvrir un fichier en Python à l’aide de la fonction open(). Il est important
de spécifier le mode d’ouverture, tel que "lecture" (’r’), "écriture" (’w’), ou "ajout"
(’a’).

fichier = open(’mon_fichier.txt’, ’r’) # Ouvre le fichier en mode lecture

7.2.2 Lecture de contenu

Vous pouvez lire le contenu d’un fichier ligne par ligne ou dans son intégralité.

ligne = fichier.readline() # Lit une ligne

contenu = fichier.read() # Lit tout le contenu

7.2.3 Fermeture de fichiers

Il est important de fermer un fichier après l’avoir lu ou écrit à l’aide de la méthode
close().

7.3 Écriture dans des Fichiers

7.3.1 Écriture de fichiers
Pour écrire dans un fichier, ouvrez-le en mode d’écriture (’w’) ou d’ajout (’a’)
et utilisez la méthode write() pour écrire des données dans le fichier.

25
 26 CHAPITRE 7. LA MANIPULATION DES FICHIERS ET DES DONNÉES

fichier = open(’nouveau_fichier.txt’, ’w’) # Ouvre le fichier en mode écriture

fichier.write("Hello, monde !")
fichier.close() # Ferme le fichier

7.4 Travailler avec des Fichiers CSV

7.4.1 Le module CSV
Python offre un module csv pour travailler avec des fichiers CSV. Vous pouvez l’importer
avec import csv.

7.4.2 Lecture de fichiers CSV

Vous pouvez lire des fichiers CSV à l’aide de la fonction csv.reader().
import csv

with open(’donnees.csv’, ’r’) as fichier_csv:

lecteur = csv.reader(fichier_csv)
for ligne in lecteur:
print(ligne)

7.4.3 Écriture dans des fichiers CSV

Pour écrire des données dans un fichier CSV, vous pouvez utiliser la fonction csv.writer().
import csv

donnees = [[’nom’, ’age’], [’Alice’, 25], [’Bob’, 30]]

with open(’nouvelles_donnees.csv’, ’w’, newline=’’) as fichier_csv:

ecrivain = csv.writer(fichier_csv)
ecrivain.writerows(donnees)

Exemple d’Application : Analyse de la Production de Cacao en

Côte d’Ivoire
Code Python

1 import csv
2
3 # Etape 0 : Creation du fichier CSV ( optionnel , si le fichier n ’ existe pas
encore )
4 donnees = [
5 [ " Annee " , " Production ␣ ( en ␣ tonnes ) " ] ,
6 [2010 , 1500000] ,
7 [2011 , 1550000] ,
8 [2012 , 1600000] ,
9 [2013 , 1620000] ,
10 [2014 , 1650000]
11 ]
12
13 nom_fichier = " production_cacao_ci . csv "
14
15 with open ( nom_fichier , ’w ’ , newline = ’ ’) as fichier_csv :
 Regis N’guessan 27

16 ecrivain = csv . writer ( fichier_csv )

17 ecrivain . writerows ( donnees )
18
19 # Etape 1 : Ouverture du fichier CSV en mode lecture
20 nom_fichier = " production_cacao_ci . csv "
21
22 with open ( nom_fichier , ’r ’) as fichier_csv :
23 lecteur = csv . reader ( fichier_csv )
24
25 # Etape 2 : Lecture des en - tetes ( premiere ligne )
26 en_tetes = next ( lecteur )
27 print ( " Les ␣ en - tetes ␣ du ␣ fichier ␣ sont ␣ : " , en_tetes )
28
29 # Etape 3 : Initialisation des listes pour stocker les donnees
30 annees = []
31 productions = []
32
33 # Etape 4 : Lecture des donnees du fichier
34 for ligne in lecteur :
35 annee = int ( ligne [0])
36 production = int ( ligne [1])
37
38 annees . append ( annee )
39 productions . append ( production )
40
41 # Etape 5 : Calcul de la production totale
42 production_totale = sum ( productions )
43 print ( " La ␣ production ␣ totale ␣ de ␣ cacao ␣ en ␣ Cote ␣ dIvoire ␣ est ␣ de " ,
production_totale , " tonnes . " )
44
45 # Etape 6 : Calcul de la moyenne de production
46 moyenne_production = sum ( productions ) / len ( productions )
47 print ( " La ␣ moyenne ␣ de ␣ production ␣ de ␣ cacao ␣ en ␣ Cote ␣ dIvoire ␣ est ␣ de " ,
moyenne_production , " tonnes ␣ par ␣ an . " )
48
49 # Etape 7 : Annee de production maximale
50 annee_max = annees [ productions . index ( max ( productions ) ) ]
51 print ( " L ’ annee ␣ de ␣ production ␣ maximale ␣ etait ␣ en " , annee_max )

Explication du Code
1. Nous importons le module csv pour travailler avec des fichiers CSV.
2. Nous ouvrons le fichier CSV en mode lecture (’r’) à l’aide d’une clause with pour
garantir que le fichier est correctement fermé après utilisation.
3. Nous utilisons csv.reader() pour lire les lignes du fichier CSV.
4. Nous lisons les en-têtes (première ligne) du fichier pour comprendre quelles données
nous avons.
5. Nous initialisons des listes (annees et productions) pour stocker les données
à partir du fichier.
6. Nous parcourons le fichier ligne par ligne et extrayons les années et les productions,
que nous stockons dans les listes correspondantes.
7. Nous calculons la production totale et la moyenne de production en utilisant les
données de la liste productions.
8. Nous déterminons l’année de production maximale en cherchant l’indice de la production
maximale dans la liste productions et en utilisant cet indice pour extraire l’année
correspondante de la liste annees.
28 CHAPITRE 7. LA MANIPULATION DES FICHIERS ET DES DONNÉES
Chapitre 8

Les Graphiques et la Visualisation de

Données

8.1 Introduction
Dans ce chapitre, nous allons explorer comment créer des graphiques et visualiser
des données en Python. La visualisation de données est essentielle pour présenter des
informations de manière claire et convaincante. Nous utiliserons principalement la bibliothèque
Matplotlib, l’une des bibliothèques les plus populaires pour la visualisation de données
en Python.

8.2 Introduction à Matplotlib

8.2.1 Installation de Matplotlib
Si vous n’avez pas déjà installé Matplotlib, vous pouvez le faire en utilisant pip,
le gestionnaire de paquets de Python.

pip install matplotlib

8.2.2 Importation de Matplotlib

Pour utiliser Matplotlib, importez-le dans votre script Python.

import matplotlib.pyplot as plt

8.3 Création de Graphiques

8.3.1 Graphique linéaire
Un graphique linéaire est utilisé pour représenter des relations linéaires entre
deux variables. Par exemple, le PIB en fonction du temps.

8.3.2 Diagramme à barres

Un diagramme à barres est utilisé pour comparer différentes catégories. Par exemple,
la comparaison du PIB de plusieurs pays.

29
 30 CHAPITRE 8. LES GRAPHIQUES ET LA VISUALISATION DE DONNÉES

8.4 Personnalisation des Graphiques

8.4.1 Couleurs, styles et légendes
Vous pouvez personnaliser la couleur, le style des lignes et ajouter des légendes
à vos graphiques pour les rendre plus informatifs.

8.4.2 Sous-graphiques
Matplotlib permet de créer des sous-graphiques pour afficher plusieurs graphiques
dans une même figure.

8.4.3 Exportation des graphiques

Vous pouvez exporter vos graphiques au format image (PNG, JPG, etc.) pour les partager
ou les intégrer dans des rapports.

8.5 Visualisation de Données avec Seaborn

Seaborn est une autre bibliothèque de visualisation de données qui s’intègre bien
avec Matplotlib et simplifie la création de graphiques esthétiques. Vous pouvez l’installer
avec pip.

8.6 Exemple d’application : Visualisation des Tendances du

Chomage au Cameroun
Nous allons faire la visualisation de données en utilisant Python pour comprendre
les tendances du taux de chômage au Cameroun au fil du temps. Nous utiliserons Matplotlib
pour créer un graphique linéaire montrant l’évolution du taux de chômage au cours des
dernières années.

8.6.1 Étape 1 : Collecte des Données

La première étape consiste à collecter les données du taux de chômage au Cameroun
au fil du temps. Vous pouvez obtenir ces données auprès d’organismes gouvernementaux
ou de sources fiables. Supposons que nous avons collecté ces données et les avons stockées
dans un fichier CSV nommé "chomagecameroun.csv". Le fichier CSV devrait contenir deux
colonnes : "Annee" et "Taux de Chomage".

8.6.2 Étape 2 : Préparation des Données

Nous allons utiliser la bibliothèque Pandas pour lire et manipuler les données à
partir du fichier CSV. Assurez-vous d’installer Pandas avec pip install pandas.
1 import pandas as pd
2
3 # Lecture des d o n n e s depuis le fichier CSV
4 data = pd . read_csv ( ’ chomage_cameroun . csv ’)
5
6 # Affichage des p r e m i r e s lignes du DataFrame
7 print ( data . head () )
 Regis N’guessan 31

8.6.3 Étape 3 : Création du Graphique

Maintenant que nous avons nos données, nous pouvons créer un graphique pour visualiser
les tendances du taux de chomage au Cameroun.
1 import matplotlib . pyplot as plt
2
3 # Extraction des d o n n e s d ’ a n n e et de taux de c h m a g e
4 annees = data [ ’ Annee ’]
5 taux_chomage = data [ ’ Taux ␣ de ␣ Chomage ’]
6
7 # C r a t i o n du graphique
8 plt . figure ( figsize =(10 , 6) ) # D f i n i t la taille du graphique
9 plt . plot ( annees , taux_chomage , marker = ’o ’ , linestyle = ’ - ’) # C r e un
graphique l i n a i r e avec des points
10 plt . xlabel ( ’ Annee ’)
11 plt . ylabel ( ’ Taux ␣ de ␣ Chomage ␣ (%) ’)
12 plt . title ( ’ Taux ␣ de ␣ Chomage ␣ au ␣ Cameroun ␣ (2010 -2020) ’)
13
14 # Ajout de grilles
15 plt . grid ( True )
16
17 # Affichage du graphique
18 plt . show ()

8.6.4 Explication du code

— Nous utilisons Pandas pour lire les données à partir du fichier CSV et stocker
les colonnes "Annee" et "Taux de Chomage" dans des variables distinctes.
— Ensuite, nous utilisons Matplotlib pour créer un graphique linéaire. Nous spécifions
les années sur l’axe des x et les taux de chômage sur l’axe des y. Le paramètre
marker=’o’ ajoute des points aux valeurs de données pour les rendre plus visibles,
et linestyle=’-’ spécifie une ligne continue.
— Nous ajoutons des étiquettes d’axe, un titre et activons les grilles pour rendre
le graphique plus lisible.
— Enfin, nous utilisons plt.show() pour afficher le graphique.
Ce code générera un graphique linéaire montrant l’évolution du taux de chômage au
Cameroun de 2010 à 2020. Vous pouvez ensuite analyser les tendances et les variations
du taux de chômage au fil des ans pour mieux comprendre la situation économique du pays.
32 CHAPITRE 8. LES GRAPHIQUES ET LA VISUALISATION DE DONNÉES
Chapitre 9

Les Bases de Données

9.1 Introduction
Dans ce chapitre, nous allons explorer comment interagir avec des bases de données
en utilisant Python. Les bases de données sont des outils essentiels pour stocker, organiser
et récupérer des données, ce qui les rend indispensables pour la gestion de données
dans de nombreux domaines, y compris l’économie africaine.

9.2 Bases de Données Relationnelles

9.2.1 Qu’est-ce qu’une base de données relationnelle ?
Une base de données relationnelle est un système de gestion de base de données qui
utilise des tables pour stocker des données. Les tables sont liées les unes aux autres
par des relations.

9.2.2 SQL (Structured Query Language)

SQL est le langage standard pour interagir avec les bases de données relationnelles.
Vous pouvez utiliser Python pour exécuter des requêtes SQL et manipuler des données
de bases de données.

9.3 Utilisation de SQLite en Python

SQLite est une base de données relationnelle légère et autonome qui peut être utilisée
en Python sans nécessiter d’installation de logiciel de gestion de base de données externe.

9.3.1 Installation de SQLite

SQLite est généralement inclus dans les installations Python par défaut, il n’est
donc pas nécessaire de l’installer séparément.

9.3.2 Création d’une base de données

Vous pouvez créer une nouvelle base de données SQLite en utilisant la bibliothèque
SQLite3 de Python.

import sqlite3

connexion = sqlite3.connect(’ma_base_de_donnees.db’)

33
34 CHAPITRE 9. LES BASES DE DONNÉES

9.3.3 Création de tables

Après avoir établi une connexion à la base de données, vous pouvez créer des tables
pour stocker des données en utilisant SQL.

9.3.4 Insertion, Mise à Jour et Suppression de Données

Vous pouvez insérer, mettre à jour et supprimer des données dans la base de données
en utilisant SQL.

9.3.5 Interrogation de Données

Utilisez SQL pour interroger la base de données et extraire des données.

curseur = connexion.cursor()
curseur.execute("SELECT * FROM ma_table WHERE colonne = ’valeur’")
resultats = curseur.fetchall()

9.3.6 Fermeture de la Base de Données

N’oubliez pas de fermer la connexion à la base de données lorsque vous avez terminé
de l’utiliser.

connexion.close()

9.4 Utilisation de SQLAlchemy

SQLAlchemy est une bibliothèque Python populaire qui facilite l’interaction avec
les bases de données relationnelles en fournissant une interface de haut niveau pour
créer, interroger et gérer des bases de données.

9.4.1 Installation de SQLAlchemy

Vous pouvez installer SQLAlchemy à l’aide de pip.

pip install sqlalchemy

9.4.2 Utilisation de SQLAlchemy

Utilisez SQLAlchemy pour définir des modèles de données, interagir avec la base de
données et effectuer des opérations de manière plus abstraite.

9.5 Exemple : Gestion des Données Agricoles au Ghana avec

une Base de Données
Dans cet exemple, nous allons créer une base de données SQLite en Python pour suivre
les informations sur le secteur agricole au Ghana. Cela comprendra des données sur les
cultures, les rendements, les agriculteurs et les prix des produits agricoles.
 Regis N’guessan 35

9.5.1 Code Python

Voici le code Python utilisé pour créer la base de données et effectuer des opérations
de base.
1 # Importation de la b i b l i o t h q u e SQLite3
2 import sqlite3
3
4 # C r a t i o n de la base de d o n n e s et d ’ une connexion
5 connexion = sqlite3 . connect ( ’ ghana_agriculture . db ’)
6
7 # C r a t i o n de la table " cultures "
8 curseur = connexion . cursor ()
9 curseur . execute ( ’’’
10 CREATE TABLE IF NOT EXISTS cultures (
11 id INTEGER PRIMARY KEY AUTOINCREMENT ,
12 nom TEXT ,
13 superficie REAL ,
14 rendement REAL
15 )
16 ’’’)
17
18 # Insertion de d o n n e s dans la table " cultures "
19 curseur . execute ( ’’’
20 INSERT INTO cultures ( nom , superficie , rendement )
21 VALUES
22 ( ’ M a s ’, 5000 , 2.5) ,
23 ( ’ Riz ’, 3500 , 3.0) ,
24 ( ’ Cacao ’, 2000 , 1.8)
25 ’’’)
26
27 # Interrogation de d o n n e s
28 curseur . execute ( ’ SELECT ␣ * ␣ FROM ␣ cultures ’)
29 donnees = curseur . fetchall ()
30
31 print ( " D o n n e s ␣ sur ␣ les ␣ cultures ␣ au ␣ Ghana ␣ : " )
32 for ligne in donnees :
33 print ( f " ID ␣ : ␣ { ligne [0]} , ␣ Nom ␣ : ␣ { ligne [1]} , ␣ Superficie ␣ : ␣ { ligne [2]} ␣
hectares , ␣ Rendement ␣ : ␣ { ligne [3]} ␣ tonnes ␣ par ␣ hectare " )
34
35 # Fermeture de la base de d o n n e s
36 connexion . close ()

9.5.2 Explication du Code

Voici une explication détaillée du code Python :
— Nous importons la bibliothèque SQLite3 pour travailler avec SQLite en Python.
— Nous créons une base de données nommée "ghana_agriculture.db" et établissons une
connexion à cette base de données. Si la base de données n’existe pas, elle sera
créée.
— Nous définissons une table "cultures" pour stocker des informations sur les cultures,
y compris le nom de la culture, la superficie cultivée et les rendements. Nous
utilisons SQL pour créer cette table.
— Nous insérons quelques données initiales dans la table "cultures" pour représenter
les cultures au Ghana.
— Nous effectuons une requête SQL pour extraire les données sur les cultures et
les afficher.
36 CHAPITRE 9. LES BASES DE DONNÉES

— Enfin, nous fermons la connexion à la base de données lorsque nous avons terminé
de l’utiliser.
Chapitre 10

La Programmation Orientée Objet

10.1 Introduction
Dans ce chapitre, nous allons plonger dans la programmation orientée objet (POO)
en Python. La POO est un paradigme de programmation qui repose sur la création d’objets,
des instances de classes, pour organiser et structurer votre code. La POO est largement
utilisée pour résoudre des problèmes complexes et est un concept fondamental en développement
logiciel.

10.2 Classes et Objets

10.2.1 Qu’est-ce qu’une classe ?
Une classe est un modèle ou un plan pour créer des objets. Elle définit les attributs
(variables) et les méthodes (fonctions) que les objets de cette classe auront.

10.2.2 Création d’objets

Un objet est une instance d’une classe spécifique. Vous créez des objets en utilisant
le nom de la classe suivi de parenthèses.

class Voiture:
def __init__(self, marque, modele):
self.marque = marque
self.modele = modele

ma_voiture = Voiture("Toyota", "Camry")

10.3 Attributs et Méthodes

10.3.1 Attributs
Les attributs sont des variables qui définissent les caractéristiques d’un objet.
Les attributs peuvent être définis dans le constructeur de classe (__init__) et peuvent
être accessibles via l’objet.

class Voiture:
def __init__(self, marque, modele):
self.marque = marque
self.modele = modele

37
38 CHAPITRE 10. LA PROGRAMMATION ORIENTÉE OBJET

ma_voiture = Voiture("Toyota", "Camry")

print(ma_voiture.marque) # Accès à l’attribut ’marque’

10.3.2 Méthodes
Les méthodes sont des fonctions qui définissent les comportements d’un objet. Les
méthodes sont définies à l’intérieur de la classe et peuvent être appelées via l’objet.

class Voiture:
def __init__(self, marque, modele):
self.marque = marque
self.modele = modele

def demarrer(self):
print("La voiture démarre.")

ma_voiture = Voiture("Toyota", "Camry")

ma_voiture.demarrer() # Appel de la méthode ’demarrer’

10.4 Héritage
L’héritage est un concept clé de la POO qui permet de créer de nouvelles classes
en utilisant des classes existantes comme modèle. Les nouvelles classes héritent des
attributs et des méthodes de la classe parente.

class Vehicule:
def __init__(self, marque, modele):
self.marque = marque
self.modele = modele

def demarrer(self):
print("Le véhicule démarre.")

class Voiture(Vehicule):
def __init__(self, marque, modele, couleur):
super().__init__(marque, modele)
self.couleur = couleur

ma_voiture = Voiture("Toyota", "Camry", "bleue")

ma_voiture.demarrer()

10.5 Encapsulation
L’encapsulation est un principe qui consiste à cacher les détails d’implémentation
d’une classe et à ne permettre l’accès qu’aux parties nécessaires. En Python, l’encapsulation
est souvent réalisée en utilisant des attributs privés et des méthodes d’accès (getters
et setters).
 Regis N’guessan 39

10.6 Exemple : Modélisation d’un Système Bancaire en POO

au Congo
Nous allons modéliser un système bancaire congolais simple en utilisant la POO en
Python. Cela nous permettra de comprendre comment la POO peut être utilisée pour structurer
un système complexe.

10.6.1 Code Python

Voici le code Python correspondant à l’exemple de gestion de comptes bancaires :

1 class Client :
2 def __init__ ( self , nom , prenom , adresse , num_telephone ) :
3 self . nom = nom
4 self . prenom = prenom
5 self . adresse = adresse
6 self . num_telephone = num_telephone
7 self . comptes = []
8
9 def ouvrir_compte ( self , solde_initial ) :
10 if solde_initial >= 0:
11 nouveau_compte = Compte ( solde_initial )
12 self . comptes . append ( nouveau_compte )
13 print ( f " Compte ␣ c r ␣ pour ␣ { self . prenom } ␣ { self . nom } " )
14 else :
15 print ( " Le ␣ solde ␣ initial ␣ doit ␣ tre ␣ positif . " )
16
17 # ... ( Autres m t h o d e s de la classe Client )
18
19 class Compte :
20 numero_compte = 0 # Un compteur pour attribuer des n u m r o s de compte
uniques
21
22 def __init__ ( self , solde_initial ) :
23 Compte . numero_compte += 1
24 self . numero = Compte . numero_compte
25 self . solde = solde_initial
26
27 # ... ( Autres m t h o d e s de la classe Compte )
28
29 # Exemple d ’ utilisation
30 client1 = Client ( " Mukendi " , " Jean " , " Kinshasa " , " 123456789 " )
31 client1 . ouvrir_compte (50000)
32 client1 . ouvrir_compte (10000)
33 client1 . afficher_comptes ()
34
35 # ... ( O p r a t i o n s s u p p l m e n t a i r e s sur les comptes )

10.6.2 Explication du Code

Classes et Objets

Nous avons créé deux classes principales : Client et Compte. La classe Client représente
un client de la banque avec ses informations personnelles et une liste de comptes. La
classe Compte représente un compte bancaire avec un numéro de compte unique et un solde.
40 CHAPITRE 10. LA PROGRAMMATION ORIENTÉE OBJET

Attributs et Méthodes
Les attributs sont des variables qui définissent les caractéristiques d’un objet.
Les méthodes sont des fonctions qui définissent les comportements d’un objet.

Héritage
L’héritage est utilisé pour créer une classe dérivée (Voiture) à partir d’une classe
parente (Vehicule). La classe dérivée hérite des attributs et des méthodes de la classe
parente.

Encapsulation
L’encapsulation est un principe de la POO qui consiste à cacher les détails d’implémentation
d’une classe. Nous avons utilisé des méthodes pour accéder aux attributs privés, par
exemple, client1.ouvrir_compte(50000).
Chapitre 11

Projets Python pour l’Afrique

11.1 Projet 1 : Calcul de la Croissance Économique au Nigeria

Problème : Le Nigeria souhaite suivre sa croissance économique. Vous avez les données
du PIB pour plusieurs années. Calculez le taux de croissance économique annuel moyen
sur cette période.

11.2 Projet 2 : Suivi de la Population en Éthiopie

Problème : L’Éthiopie souhaite suivre sa croissance démographique. Vous avez les
données de la population pour plusieurs années. Calculez le taux de croissance démographique
annuel moyen sur cette période.

11.3 Projet 3 : Convertisseur de Devises pour le Kenya

Problème : Créez un convertisseur de devises en ligne de commandes pour le Kenya.
Les utilisateurs doivent pouvoir entrer un montant en monnaie locale (shillings kényans)
et choisir la devise de destination. Le programme doit retourner le montant équivalent
dans la devise choisie.

11.4 Projet 4 : Prédiction de la Récolte d’Arachides au Séné-

gal
Problème : Le Sénégal souhaite prédire sa récolte d’arachides pour l’année à venir.
Utilisez les données historiques de récolte et créez un modèle de prédiction simple
en utilisant la régression linéaire.

11.5 Projet 5 : Calculateur de Taux de Change en Afrique du

Sud
Problème : Créez un calculateur de taux de change pour l’Afrique du Sud. Les utilisateurs
doivent pouvoir entrer un montant en rand sud-africain (ZAR) et choisir une autre devise.
Le programme doit retourner le montant équivalent dans la devise choisie, en utilisant
les taux de change actuels.
Ces mini-projets sont conçus pour illustrer comment Python peut être utilisé pour
résoudre des problèmes concrets en Afrique, qu’il s’agisse de calculs économiques, de
suivi de la population ou de conversion de devises. Vous pouvez les développer davantage

41
42 CHAPITRE 11. PROJETS PYTHON POUR L’AFRIQUE

en ajoutant des fonctionnalités supplémentaires ou en les adaptant à des problèmes spécifiques

de chaque pays.
Chapitre 12

Des Approches de Solutions aux

Projets Python pour l’Afrique

Dans ce chapitre, nous allons examiner les solutions pour les cinq projets Python
conçus pour résoudre des problèmes spécifiques en Afrique. Les solutions fournies sont
des exemples de code Python qui illustrent comment aborder chaque problème. Vous pouvez
les utiliser comme point de départ pour développer davantage ces projets ou pour résoudre
des problèmes similaires.

12.1 Solution au Projet 1 : Calcul de la Croissance Écono-

mique au Nigeria
Solution : Pour calculer le taux de croissance économique au Nigeria, vous pouvez
utiliser la formule suivante :
(P IBF inal − P IBInitial)
T auxdeCroissance = × 100
P IBInitial
Vous pouvez implémenter cela en Python en demandant à l’utilisateur de saisir les
valeurs du PIB initial et final, puis en calculant le taux de croissance.

# Solution au Projet 1 : Calcul de la Croissance Économique au Nigeria

# Saisie du PIB initial et final

pib_initial = float(input("Entrez le PIB initial en milliards de dollars : "))
pib_final = float(input("Entrez le PIB final en milliards de dollars : "))

# Calcul du taux de croissance

taux_croissance = ((pib_final - pib_initial) / pib_initial) * 100

# Affichage du résultat
print(f"Le taux de croissance économique annuel moyen est de {taux_croissance:.2f}%")

12.2 Solution au Projet 2 : Suivi de la Population en Éthiopie

Solution : Pour suivre la croissance démographique en Éthiopie, vous pouvez utiliser
la formule suivante :
(P opulationF inale − P opulationInitiale)
T auxdeCroissanceDmographique = × 100
P opulationInitiale

43
 CHAPITRE 12. DES APPROCHES DE SOLUTIONS AUX PROJETS PYTHON POUR
44 L’AFRIQUE

Vous pouvez implémenter cela en Python en demandant à l’utilisateur de saisir les

valeurs de la population initiale et finale, puis en calculant le taux de croissance
démographique.

# Solution au Projet 2 : Suivi de la Population en Éthiopie

# Saisie de la population initiale et finale

population_initiale = float(input("Entrez la population initiale : "))
population_finale = float(input("Entrez la population finale : "))

# Calcul du taux de croissance démographique

taux_croissance_demographique = ((population_finale - population_initiale) / population_initiale) * 100

# Affichage du résultat
print(f"Le taux de croissance démographique annuel moyen est de {taux_croissance_demographique:.2f}%")

12.3 Solution au Projet 3 : Convertisseur de Devises pour le

Kenya
Solution : Vous pouvez créer un convertisseur de devises en Python en utilisant des
taux de change prédéfinis. Demandez à l’utilisateur de saisir un montant en shillings
kényans, puis choisissez une devise de destination. Utilisez un dictionnaire de taux
de change pour effectuer la conversion.

# Solution au Projet 3 : Convertisseur de Devises pour le Kenya

# Définition des taux de change (par rapport au shilling kényan)

taux_de_change = {
"USD": 0.009, # Taux de change en dollars américains
"EUR": 0.007, # Taux de change en euros
"GBP": 0.006 # Taux de change en livres sterling
}

# Saisie du montant en shillings kényans

montant_en_shillings = float(input("Entrez le montant en shillings kényans : "))

# Saisie de la devise de destination

devise_destination = input("Choisissez une devise de destination (USD, EUR, GBP) : ")

# Conversion du montant
montant_converti = montant_en_shillings * taux_de_change[devise_destination]

# Affichage du résultat
print(f"{montant_en_shillings} KES équivaut à {montant_converti} {devise_destination}")

12.4 Solution au Projet 4 : Prédiction de la Récolte d’Ara-

chides au Sénégal
Solution : Vous pouvez utiliser la bibliothèque scikit-learn en Python pour créer
un modèle de régression linéaire. Utilisez les données historiques de récolte d’arachides
comme jeu de données d’entraînement et entraînez le modèle pour prédire la récolte future
en fonction de variables telles que les précipitations, la température, etc.
Regis N’guessan 45

# Solution au Projet 4 : Prédiction de la Récolte d’Arachides au Sénégal

# Importation des bibliothèques nécessaires

import numpy as np
from sklearn.linear_model import LinearRegression

# Données historiques de récolte d’arachides (exemples fictifs)

annees = np.array([2010, 2011, 2012, 2013, 2014, 2015])
recolte = np.array([5000, 5200, 4900, 5300, 5100, 5400]) # En tonnes

# Création du modèle de régression linéaire

modele = LinearRegression()

# Entraînement du modèle
modele.fit(annees.reshape(-1, 1), recolte)

# Prédiction de la récolte pour l’année à venir

annee_future = 2023
recolte_future = modele.predict(np.array([[annee_future]]))

# Affichage du résultat
print(f"Prédiction de la récolte d’arachides en {annee_future} : {recolte_future[0]:.2f} tonnes")

12.5 Solution au Projet 5 : Calculateur de Taux de Change en

Afrique du Sud
Solution : Vous pouvez créer un calculateur de taux de change en Python en utilisant
un dictionnaire de taux de change. Demandez à l’utilisateur de saisir un montant en
rand sud-africain (ZAR), puis choisissez une autre devise. Utilisez le dictionnaire
pour effectuer la conversion.
# Solution au Projet 5 : Calculateur de Taux de Change en Afrique du Sud

# Définition des taux de change (par rapport au rand sud-africain, ZAR)

taux_de_change = {
"USD": 0.069, # Taux de change en dollars américains
"EUR": 0.059, # Taux de change en euros
"GBP": 0.051 # Taux de change en livres sterling
}

# Saisie du montant en rand sud-africain (ZAR)

montant_en_zar = float(input("Entrez le montant en rand sud-africain (ZAR) : "))

# Saisie de la devise de destination

devise_destination = input("Choisissez une devise de destination (USD, EUR, GBP) : ")

# Conversion du montant
montant_converti = montant_en_zar * taux_de_change[devise_destination]

# Affichage du résultat
print(f"{montant_en_zar} ZAR équivaut à {montant_converti} {devise_destination}")
Ces solutions illustrent comment résoudre les problèmes spécifiques à chaque projet
en utilisant Python. Vous pouvez les personnaliser, les améliorer ou les étendre en
 CHAPITRE 12. DES APPROCHES DE SOLUTIONS AUX PROJETS PYTHON POUR
46 L’AFRIQUE

fonction de vos besoins ou des exigences spécifiques de chaque problème.

12.6 Épilogue : Python, l’Aventure sans Fin

Félicitations, cher lecteur, vous avez maintenant parcouru tout un livre sur la programmation
en Python, un langage puissant et polyvalent. Avant de tourner la dernière page, permettez-moi
de vous offrir un dernier regard sur ce que vous avez accompli.

12.6.1 Python, un Ami Fidèle

Python n’est pas seulement un langage de programmation, c’est votre ami fidèle dans
la résolution de problèmes. Qu’il s’agisse de calculer le nombre d’étudiants au Burkina
Faso ou de prédire les rendements agricoles en Afrique, Python est toujours là pour
vous donner un coup de main.

12.6.2 Les Joies des Boucles

Avez-vous déjà ressenti la satisfaction ultime lorsque votre boucle "for" a parfaitement
fonctionné ? Ou quand votre boucle "while" a atteint le cas de base d’une fonction récursive
? Les boucles en Python sont comme des montagnes russes de la programmation, et vous
êtes le maître de la piste.

12.6.3 Les Énigmes de la Portée

La portée des variables peut parfois sembler être un mystère, mais vous avez réussi
à décoder les énigmes et à faire en sorte que vos variables jouent bien ensemble. Les
variables locales et globales ne vous réservent plus de surprises.

12.6.4 La Créativité sans Limite

Python est un langage qui encourage la créativité. Vous pouvez créer des jeux, des
applications web, des robots, ou même résoudre des problèmes mondiaux. L’imagination
est votre seule limite, et Python est votre baguette magique.

12.6.5 Le Futur Brillant

Alors, que réserve l’avenir à un Pythoniste accompli comme vous ? Peut-être allez-vous
contribuer à des projets open source, enseigner la programmation à la prochaine génération,
ou résoudre des problèmes du monde réel en utilisant vos compétences en Python. Quoi
que vous fassiez, n’oubliez jamais que Python est là pour vous soutenir.

12.6.6 Ce Livre est Gratuit et Open Source !

Je tiens à souligner que ce livre est totalement gratuit et open source. Il est disponible
pour tous ceux qui souhaitent apprendre Python, que ce soit pour leur propre plaisir
ou pour résoudre des problèmes du monde réel. Vous pouvez le partager, le modifier et
l’utiliser comme bon vous semble.

12.6.7 Vos Contributions Sont les Bienvenues !

Ce livre est un projet en constante évolution. Les conseils, les suggestions et les
améliorations sont les bienvenues et feront partie des éditions futures. Si vous avez
des idées pour améliorer le contenu, des exemples supplémentaires à partager, ou des
corrections à apporter, n’hésitez pas à contribuer.
Regis N’guessan 47

12.6.8 Restons Connectés

Regis N’guessan,
Doctorant en Data Science, AIMS-QLA(African Institute for Mathematical
Sciences-Quantum Leap Africa)

Je vous invite également à me suivre sur mes différents réseaux sociaux pour rester
en contact. Vous pouvez me contacter, me poser des questions ou simplement discuter
de vos propres expériences en programmation Python. Vos réussites et vos défis sont
les bienvenus:
- @Mail

- LinkedIn

- YouTube

Je serais ravi d’entendre parler de vos projets, de vos réussites en Python, et de

toutes les aventures qui vous attendent dans le monde de la programmation.
Alors, prenez une profonde inspiration, souriez, et continuez à coder. Python vous
accompagnera tout au long de votre parcours, vous guidant vers de nouveaux sommets de
créativité et d’innovation.
Bonne programmation, Pythoniste, et que votre code soit toujours propre et vos erreurs
faciles à déboguer !