Travaux Pratiques Python : Exercices Progressifs sur les Structures Alternatives et Répétitives

Ce document propose une série d’exercices en Python permettant de manipuler les conditions (if/elif/else) et les boucles (while/for). À travers des cas pratiques, l’étudiant apprend à rédiger des programmes simples et interactifs. L’objectif est d’assurer la transition entre la logique algorithmique et son implémentation concrète en Python.

1. Y. EL ALLIOUI – FPK – USMS – [email protected] 1 / 24

Module : Programmation orientée objets (Python)

Filière : Licence SIIA
Semestre : S6


Travaux Pratiques (TP)

Exercices (Énoncé)

Youssouf EL ALLIOUI
FPK - USMS

[email protected]




2025

2. Y. EL ALLIOUI – FPK – USMS – [email protected] 2 / 24
Série 1
LES STRUCTURES ALTERNATIVES
Exercice 1 : Vérifier l’appartenance à un intervalle
Écrire un programme Python qui demande à l’utilisateur de saisir deux nombres définissant les
bornes d’un intervalle (borne inférieure et borne supérieure) puis un nombre à tester. Le
programme affichera si le nombre appartient ou non à l’intervalle.
Exercice 2 : Vérifier la validité d’une date
Écrire un programme Python qui demande à l’utilisateur de saisir le jour, le mois (en numéro)
et l’année d’une date. On suppose que :
• L’année doit être entre 1900 et 2017,
• Le mois entre 1 et 12,
• Le jour entre 1 et 30.
Le programme doit vérifier la validité de la date et indiquer en cas d’erreur si c’est l’année, le
mois ou le jour qui est incorrect.
Exercice 3 : Produit sans multiplication
Écrire un programme Python qui demande à l’utilisateur de saisir deux nombres (non nuls) et
qui indique si leur produit serait négatif ou positif, sans calculer directement le produit.
Exercice 4 : Calcul des heures supplémentaires
Un employé est payé au tarif horaire de base. Pour les heures supplémentaires, le tarif est
majoré de la manière suivante :
• Les 39 premières heures sont payées au tarif normal,
• De la 40ème à la 44ème heure : majoration de 50% (bonus de 0,5× tarif),
• De la 45ème à la 49ème heure : majoration de 75% (bonus de 0,75× tarif),
• À partir de la 50ème heure : majoration de 100% (bonus de 1× tarif).
Écrire un programme Python qui demande à l’utilisateur le nombre d’heures travaillées et le
tarif horaire, puis qui calcule le montant total des heures supplémentaires (c’est-à-dire la
somme des bonus).
Exercice 5 : L’heure dans une minute
Écrire un programme Python qui demande à l’utilisateur de saisir l’heure et les minutes (en
respectant le format 24h), puis qui affiche l’heure qu’il sera une minute plus tard.
Exemple :
Si l’utilisateur saisit 21 pour l’heure et 32 pour les minutes, le programme affichera :
Dans une minute, il sera 21 heure(s) 33 .
Exercice 6 : Gestion des stocks
Une entreprise gère son stock. Pour honorer une commande, l’entreprise doit avoir la totalité
de la quantité demandée. Écrire un programme Python qui demande à l’utilisateur la quantité

3. Y. EL ALLIOUI – FPK – USMS – [email protected] 3 / 24
en stock et la quantité commandée, puis qui affiche la quantité qui pourra être livrée (si le stock
est inférieur à la commande, on ne peut livrer que ce que l’on a).
Exercice 7 : Produit en incluant le cas zéro
Écrire un programme Python qui demande à l’utilisateur de saisir deux nombres et qui indique
si leur produit serait négatif, positif ou nul, sans calculer directement le produit.
Exercice 8 : Catégorie d’un enfant
Écrire un programme Python qui demande l’âge d’un enfant et qui affiche sa catégorie selon
les critères suivants :
• 6 à 7 ans : « Poussin »
• 8 à 9 ans : « Pupille »
• 10 à 11 ans : « Minime »
• 12 ans et plus : « Cadet »
Exercice 9 : Afficher un jour de la semaine
Écrire un programme Python qui demande à l’utilisateur de saisir un nombre compris entre 1 et
7, puis qui affiche le jour de la semaine correspondant (par exemple, 1 pour Lundi, 2 pour
Mardi, etc.).
Exercice 10 : Mention selon la note
Écrire un programme Python qui demande à l’utilisateur de saisir une note (sur 20) et qui
affiche la mention correspondante selon l’échelle suivante (vous pouvez adapter l’échelle si
besoin) :
• Note inférieure à 10 : « Insuffisant »
• De 10 à 12 : « Passable »
• De 12 à 14 : « Assez bien »
• De 14 à 16 : « Bien »
• Supérieure ou égale à 16 : « Très bien »
Exercice 11 : Résolution d’une équation du second degré
Écrire un programme Python qui demande à l’utilisateur de saisir trois réels a, b et c et qui
résout l’équation :
!"
!
+$"+%=0
Les cas particuliers à traiter sont :
• Si a est nul, l’équation est du premier degré.
• Si le discriminant (Δ = b² – 4ac) est nul, il y a une solution double.
• Si Δ est positif, il y a deux solutions réelles.
• Si Δ est négatif, il n’y a pas de solution réelle.

4. Y. EL ALLIOUI – FPK – USMS – [email protected] 4 / 24
Série 2
LES STRUCTURES REPETITIVES
Exercice 1 : Saisie d’un nombre entre 1 et 3
Écrire un programme Python qui demande à l’utilisateur de saisir un nombre entre 1 et 3. La
demande se répète tant que la valeur saisie n’est pas comprise entre 1 et 3.
Exercice 2 : Saisie d’un nombre entre 10 et 20 avec indices
Écrire un programme Python qui demande à l’utilisateur de saisir un nombre entre 10 et 20.
• Si le nombre est supérieur à 20, afficher « Plus petit ! ».
• Si le nombre est inférieur à 10, afficher « Plus grand ! ».
La saisie se répète jusqu’à ce que la réponse convienne.
Exercice 3 : Afficher les dix nombres suivants
Écrire un programme Python qui demande à l’utilisateur de saisir un nombre de départ, puis
qui affiche les dix nombres suivants.
Exercice 4 : Table de multiplication
Écrire un programme Python qui demande à l’utilisateur de saisir un nombre, puis qui affiche
la table de multiplication de ce nombre de 1 à 10 sous la forme :
Table de 7 :
7 x 1 = 7
7 x 2 = 14
...
7 x 10 = 70
Exercice 5 : Somme des entiers jusqu’à N
Écrire un programme Python qui demande à l’utilisateur de saisir un nombre entier positif N et
qui calcule la somme des entiers de 1 à N. Seul le résultat final est affiché.
Exercice 6 : Calcul de la factorielle
Énoncé :
Écrire un programme Python qui demande à l’utilisateur de saisir un entier N et qui calcule la
factorielle de N (notée N!) :
(!=1×2×…×(
Par exemple, pour N = 8, 8! = 40320.
Exercice 7 : Trouver le plus grand de 20 nombres
Écrire un programme Python qui demande successivement 20 nombres à l’utilisateur, puis qui
affiche le plus grand nombre ainsi que sa position dans la séquence (la première position étant
1).
Exercice 8 : Trouver le maximum avec un nombre indéfini de saisies

5. Y. EL ALLIOUI – FPK – USMS – [email protected] 5 / 24
Réécrire l’exercice précédent en ne connaissant pas à l’avance le nombre de saisies. La saisie
s’arrête lorsque l’utilisateur entre zéro. Le programme affichera alors le plus grand nombre et
sa position dans la séquence.
Exercice 9 : Calcul de la monnaie à rendre
Un client a effectué plusieurs achats dont les prix (en euros entiers) sont saisis successivement
(la saisie se termine par 0).
1. Calculer le montant total dû.
2. Demander ensuite la somme payée par le client.
3. Calculer la monnaie à rendre et afficher, ligne par ligne, le nombre de billets/de
coupures à rendre en coupures de 10 €, 5 € et 1 € (en utilisant l’algorithme glouton).
Exercice 10 : Chances de gagner au Tiercé / Quarté / Quinté
Écrire un programme Python qui demande à l’utilisateur :
• Le nombre de chevaux partants n,
• Le nombre de chevaux joués p.
Le programme doit calculer deux valeurs :
• Dans l’ordre : .=
"!
("%&)!

• Dans le désordre : /=
"!
&!("%&)!

Ces formules correspondent respectivement aux chances de gagner si l’on doit trouver l’ordre
exact et si l’ordre n’a pas d’importance.
Affichez ensuite les messages :
Dans l'ordre : une chance sur X de gagner
Dans le désordre : une chance sur Y de gagner
Ensuite, proposez une version optimisée qui évite de calculer de très grands nombres en
calculant directement le produit itératif.
Exercice 11 : Suite récurrente u(n+1) = 3*u(n) + 4
Écrire un programme Python qui demande à l’utilisateur de saisir un entier N et qui calcule la
valeur de u(N) définie par :
• 0(0)=3
• 0(4+1)=3∗0(4)+4
Exercice 12 : Suite de Fibonacci modifiée
Écrire un programme Python qui demande à l’utilisateur de saisir un entier N et qui calcule la
valeur de u(N) définie par :
• 0(0)=1
• 0(1)=1
• 0(4+1)=0(4)+0(4−1) pour 4≥1
Exercice 13 : Calculatrice interactive sur un entier
Écrire un programme Python qui part d’un entier initialisé à 0 et qui permet à l’utilisateur
d’effectuer des opérations sur cet entier via un menu interactif. Le menu doit proposer :

6. Y. EL ALLIOUI – FPK – USMS – [email protected] 6 / 24
1. Ajouter
2. Multiplier par
3. Soustraire
4. Quitter
Après chaque opération (1 à 3), le programme affiche la nouvelle valeur de l’entier et réaffiche
le menu. Le programme se termine lorsque l’utilisateur choisit l’option 4.
Exercice 14 : Calcul de la moyenne de nombres positifs
Écrire un programme Python qui demande à l’utilisateur de saisir des entiers strictement
positifs pour calculer leur moyenne.
• Si l’utilisateur saisit un entier négatif, afficher « ERREUR » et redemander une valeur
positive.
• La saisie se termine lorsque l’utilisateur saisit 0.
• Si aucun entier positif n’a été saisi, n’afficher aucun résultat.

7. Y. EL ALLIOUI – FPK – USMS – [email protected] 7 / 24
Série 3
LES STRUCTURES DE DONNEES (LISTES ET MATRICES)
Exercice 1 – Compter les entiers supérieurs ou égaux à 10
Écrire un programme en Python qui demande à l’utilisateur de saisir 10 entiers (stockés dans
une liste) et qui affiche combien de ces entiers sont supérieurs ou égaux à 10.
Exercice 2 – Rechercher une valeur dans une liste
Écrire un programme en Python qui demande à l’utilisateur de saisir 10 entiers (dans une liste)
puis un entier V. Le programme doit vérifier si V se trouve dans la liste et afficher le message
correspondant.
Exercice 3 – Trouver l’indice du plus grand élément
Écrire un programme en Python qui demande à l’utilisateur de saisir 10 entiers dans une liste et
qui affiche l’indice du plus grand élément.
Exercice 4 – Suppression et décalage
Écrire un programme en Python qui demande à l’utilisateur de saisir 10 entiers dans une liste
ainsi qu’un entier V.
Si V se trouve dans la liste, supprimer sa première occurrence en décalant les éléments suivants
vers la gauche et ajouter un 0 à la fin pour maintenir une taille de 10.
Afficher la liste résultante.
Exercice 5 – Saisie d’une liste et calcul de somme
Écrire un programme en Python qui lit la dimension N d’une liste d’entiers, la remplit par des
valeurs saisies, affiche la liste et la somme de ses éléments.
Exercice 6 – Suppression des zéros et compactage
Écrire un programme en Python qui lit la dimension N d’une liste d’entiers, la remplit, affiche
la liste, puis supprime toutes les occurrences de la valeur 0 en tassant les éléments restants.
Afficher la liste obtenue.
Exercice 7 – Inversion en place
Écrire un programme en Python qui lit la dimension N d’une liste d’entiers, la remplit, affiche
la liste, puis inverse son ordre sans utiliser de liste auxiliaire. Afficher le résultat.
Exercice 8 – Séparation des valeurs positives et négatives
Écrire un programme en Python qui lit la dimension N d’une liste d’entiers, la remplit, affiche
la liste, puis copie dans deux listes distinctes les nombres strictement positifs (TPOS) et
strictement négatifs (TNEG). Afficher les deux listes.
Exercice 9 – Saisie d’une matrice et somme globale
Écrire un programme en Python qui lit les dimensions L (lignes) et C (colonnes) d’une matrice
d’entiers, la remplit par saisie clavier, affiche la matrice et calcule la somme de tous ses
éléments.
Exercice 10 – Sommes par lignes et colonnes

8. Y. EL ALLIOUI – FPK – USMS – [email protected] 8 / 24
Écrire un programme en Python qui lit les dimensions L et C d’une matrice d’entiers, la
remplit, affiche la matrice et calcule la somme de chaque ligne ainsi que de chaque colonne en
n’utilisant qu’une variable d’aide pour la somme.
Exercice 11 – Maximum et minimum avec indices
Écrire un programme en Python qui demande à l’utilisateur de saisir une liste d’entiers (par
exemple, en saisissant une série d’entiers séparés par des espaces).
Le programme doit déterminer la plus grande et la plus petite valeur ainsi que leurs indices
(première occurrence en cas de doublons).
Exercice 12 – Insertion dans une liste triée
Écrire un programme en Python qui part d’une liste d’entiers triée par ordre croissant (saisie
par l’utilisateur ou prédéfinie) et qui permet d’insérer une nouvelle valeur VAL de façon à ce
que la liste reste triée.
Afficher la liste résultante.
Exercice 13 – Recherche d’une valeur avec position
Écrire un programme en Python qui demande à l’utilisateur de saisir une liste d’entiers puis
une valeur VAL à rechercher.
Si VAL est trouvée, afficher son indice (première occurrence) ; sinon, afficher un message
indiquant son absence en utilisant une variable pos initialisée à -1.
Exercice 14 – Tri par sélection (ordre croissant)
Écrire un programme en Python qui demande à l’utilisateur de saisir 10 entiers dans une liste,
puis trie cette liste par ordre croissant en utilisant l’algorithme du tri par sélection (recherche
du plus petit élément et échange).
Exercice 15 – Fusion de deux listes triées
Écrire un programme en Python qui demande à l’utilisateur de saisir deux listes d’entiers triées
par ordre croissant (A et B) et qui fusionne ces deux listes dans une nouvelle liste FUS triée
par ordre croissant.
La fusion doit s’effectuer en parcourant les deux listes simultanément.
Exercice 16 – Tri par sélection (ordre décroissant)
Écrire un programme en Python qui demande à l’utilisateur de saisir une liste d’entiers et qui la
trie par ordre décroissant en utilisant une méthode similaire au tri par sélection (en cherchant le
maximum restant et en l’échangeant).
Exercice 17 – Triangle de Pascal
Écrire un programme en Python qui demande à l’utilisateur un entier N (limité à 13)
représentant le degré du triangle de Pascal.
Le programme doit construire le triangle de Pascal dans une matrice (liste de listes) de
dimension N+1 en utilisant la relation
9[;][=] = 9[;−1][=−1] + 9[;−1][=]
avec 9[;][0] et 9[;][;] égaux à 1.
Affichez le triangle jusqu’à la diagonale principale.

9. Y. EL ALLIOUI – FPK – USMS – [email protected] 9 / 24
Série 4
LES FONCTIONS
Exercice 1 – Fonction distance
Écrire une fonction distance(xa, ya, xb, yb) qui calcule et renvoie la distance entre deux
points A(xa, ya) et B(xb, yb).
Tester la fonction avec des saisies utilisateur.
Exercice 2 – Déterminer si un entier est premier
Écrire une fonction est_premier(n) qui prend un entier en paramètre et renvoie True si celui-
ci est premier, sinon False.
Tester la fonction.
Exercice 3 – Échanger deux valeurs (swap)
Écrire une fonction swap(a, b) qui échange les valeurs de a et b.
Tester la fonction.
Exercice 4 – Résolution d’une équation du second degré
Écrire une fonction resoudre_equation(a, b, c) qui calcule les solutions de l’équation :
!"² + $" + % = 0
La fonction doit gérer :
• le cas où a est nul (équation linéaire),
• le cas du discriminant nul (racine double),
• le cas du discriminant positif (deux solutions réelles),
• le cas du discriminant négatif (pas de solution réelle).
Tester la fonction.

10. Y. EL ALLIOUI – FPK – USMS – [email protected] 10 / 24
Série 5
MANIPULATION DES DONNEES ET ENTREES UTILISATEUR
Exercice 1
Partie 1 : Calcul de la vitesse
1. Objectif :
o Créez deux variables : temps et distance et affectez-leur les valeurs
respectives 6.892 et 19.7.
o Calculez la vitesse en divisant la distance par le temps.
o Affichez la vitesse en veillant à ce que le résultat affiche un chiffre après la
virgule.
Partie 2 : Saisie et transtypage
1. Objectif :
o Demandez à l'utilisateur d'entrer son nom et son âge en utilisant la fonction
input().
o Affichez ensuite le nom et l'âge saisis.
2. Note sur Python 3 :
o En Python 2, on utilisait raw_input() pour saisir une chaîne de caractères. En
Python 3, la fonction input() remplit ce rôle.
o Il est important de convertir (transtyper) la saisie en nombre quand cela est
nécessaire. Par exemple, si l'utilisateur saisit son âge, ce sera une chaîne de
caractères qu'il faudra convertir en entier.
Exercice 2
Consignes
1. Racine carrée d'un flottant
Demandez à l'utilisateur de saisir un nombre flottant.
o Si le nombre est positif ou nul : calculez et affichez sa racine carrée.
o Sinon : affichez un message d'erreur indiquant que la racine n'est pas définie.
2. Comparaison lexicographique de deux mots
o Saisissez deux mots (chaînes de caractères).
o Comparez-les selon l'ordre du dictionnaire pour déterminer lequel vient en
premier, et affichez-le.
o Refaites cette comparaison en utilisant l'instruction ternaire :
resultat = a if condition else b
3. Sécurisation d'une enceinte pressurisée
On fixe deux seuils :
o Pression seuil : pSeuil = 2.3

11. Y. EL ALLIOUI – FPK – USMS – [email protected] 11 / 24
o Volume seuil : vSeuil = 7.41
Demandez à l'utilisateur de saisir la pression et le volume actuels de l'enceinte.
Ensuite, selon les cas :
o Si la pression ET le volume sont supérieurs aux seuils : affichez « Arrêt
immédiat ! ».
o Si seule la pression dépasse son seuil : demandez d'augmenter le volume.
o Si seul le volume dépasse son seuil : demandez de diminuer le volume.
o Sinon : affichez « Tout va bien ».
4. Boucles et incrémentation/décrémentation
o Initialisez deux entiers : a = 0 et b = 10.
o Écrivez une boucle (par exemple, une boucle while) qui affiche et incrémente
la valeur de a tant qu'elle est inférieure à b.
o Ensuite, écrivez une autre boucle qui décrémente la valeur de b jusqu'à zéro et
affiche cette valeur uniquement si elle est impaire.
5. Saisie filtrée d'un entier
Demandez à l'utilisateur de saisir un entier compris entre 1 et 10 (bornes incluses).
La saisie doit être « filtrée » (vérifiez que l'entier est dans l'intervalle) et affichez
ensuite la valeur saisie.
6. Parcours d'une chaîne et d'une liste
o Affichez chaque caractère d'une chaîne (par exemple, "Bonjour") à l'aide d'une
boucle for.
o Affichez ensuite chaque élément d'une liste (par exemple, [10, 20, 30, 40,
50]) avec une boucle for.
7. Utilisation de range()
Affichez les entiers de 0 jusqu'à 14 (15 non compris) par pas de 3 en utilisant une
boucle for avec range().
8. Interruption de boucle avec break
Utilisez une boucle for pour afficher les entiers de 1 à 10 inclus, mais interrompez la
boucle dès que la variable vaut 5 (utilisez break).
9. Saut d'itération avec continue
Reprenez une boucle for pour afficher les entiers de 1 à 10, mais cette fois, sautez
l'affichage quand la variable vaut 5 (utilisez continue).
10. Gestion d'exception pour le calcul de sin(x)/x
Dans une boucle qui fait varier x de -3 à 3 (inclus), calculez la valeur de sin(x)/x.
Utilisez une exception pour gérer le cas où x vaut 0 (division par zéro).
11. Utilisation de la clause else avec les boucles et du module easygui
o Partie A :
§ Initialisez une liste contenant 5 entiers de votre choix.
§ Saisissez un entier à l'aide d'une integerbox (du module easygui).
§ Parcourez la liste avec une boucle for.

12. Y. EL ALLIOUI – FPK – USMS – [email protected] 12 / 24
§ Si l'entier saisi est trouvé dans la liste, enregistrez-le et
interrompez la boucle (utilisez break).
§ Si la boucle se termine sans trouver l'entier, utilisez la clause
else pour afficher un message indiquant qu'il n'a pas été trouvé
(affichez le résultat avec msgbox).
o Partie B :
§ Saisissez un autre entier positif (toujours avec integerbox).
§ Écrivez une boucle while pour déterminer si cet entier est premier.
§ S'il n'est pas premier, la boucle doit afficher (avec msgbox) le
premier diviseur trouvé et s'interrompre.
§ S'il est premier, utilisez la clause else de la boucle pour
l'annoncer.
Exercice 3
1. Procédure table
Écrire une procédure nommée table qui prend 4 paramètres :
o base : le nombre dont on veut afficher la table de multiplication
o debut : le début de l'intervalle
o fin : la fin de l'intervalle
o inc : l'incrément
La procédure doit afficher la table de multiplication de la base pour chaque entier
allant de debut à fin (inclus) en sautant de inc en inc.
Exemple : pour base=7, debut=1, fin=10 et inc=1, afficher :
python-repl
CopierModifier
7 x 1 = 7
7 x 2 = 14
...
7 x 10 = 70
Testez la procédure en l’appelant dans le programme principal.
2. Fonctions cube et volumeSphere
o Écrire une fonction cube qui retourne le cube de son argument.
o Écrire une fonction volumeSphere qui calcule le volume d’une sphère de rayon
r (volume = (4/3)·π·r³). Cette fonction doit utiliser la fonction cube.
Testez la fonction volumeSphere dans le programme principal.
3. Fonction maFonction et procédure tabuler
o Écrire une fonction maFonction qui calcule et retourne :
f(x)=2x3+x−5f(x)= 2x^3 + x - 5f(x)=2x3+x−5
o Écrire une procédure tabuler avec 4 paramètres :

13. Y. EL ALLIOUI – FPK – USMS – [email protected] 13 / 24
§ fonction : la fonction à évaluer
§ borneInf : la borne inférieure
§ borneSup : la borne supérieure
§ nbPas : le nombre de pas
La procédure doit afficher les valeurs de la fonction de borneInf à borneSup,
en réalisant nbPas intervalles. On demandera que borneInf < borneSup.
Testez cette procédure en la déclenchant dans le programme principal, après
avoir récupéré les bornes (avec une floatbox) et le nombre de pas (avec une
integerbox) via le module easygui.
4. Fonction volMasseEllipsoide
Écrire une fonction volMasseEllipsoide qui retourne à la fois le volume et la masse
d’un ellipsoïde sous forme de tuple.
o Le volume d’un ellipsoïde est : v=43πabcv = \frac{4}{3}\pi abcv=34πabc
o La masse est obtenue en multipliant le volume par la masse volumique.
Les 4 paramètres (les trois demi-axes a, b, c et la masse volumique) doivent avoir des
valeurs par défaut.
Testez cette fonction avec différents nombres d’arguments.
5. Fonctions de somme
o Écrire une fonction somme_tuple qui accepte un nombre variable d’arguments
(un tuple) et qui retourne la somme des nombres.
Testez-la avec différents tuples d’entiers ou de flottants.
o Écrire une autre fonction somme3 qui prend exactement 3 arguments et qui
renvoie leur somme.
Dans le programme principal, définissez un tuple de trois nombres, puis utilisez
la syntaxe de décomposition (*) pour appeler la fonction. Affichez le résultat.
6. Fonction unDictionnaire
Écrire une fonction unDictionnaire qui accepte un dictionnaire de longueur variable
(à l’aide de **kwargs) et qui affiche son contenu.
Dans le programme principal, définissez un dictionnaire, puis appelez la fonction en
décompressant le dictionnaire (avec **). Affichez le résultat.
Exercice 4
Consignes
1. Manipulations sur une liste
o Définissez la liste suivante :
liste = [17, 38, 10, 25, 72]
o Ensuite, effectuez les actions suivantes en affichant le résultat à chaque étape :
§ Trier la liste.
§ Ajouter l’élément 12 à la liste.
§ Renverser la liste.
§ Afficher l’indice de l’élément 17.

14. Y. EL ALLIOUI – FPK – USMS – [email protected] 14 / 24
§ Enlever l’élément 38 de la liste.
§ Afficher la sous-liste du 2ᵉ au 3ᵉ élément.
§ Afficher la sous-liste du début jusqu’au 2ᵉ élément.
§ Afficher la sous-liste à partir du 3ᵉ élément jusqu’à la fin.
§ Afficher la sous-liste complète.
§ Afficher le dernier élément en utilisant un indice négatif.
NB : Certaines méthodes (comme sort() ou reverse()) modifient la liste en
place et ne renvoient rien.
2. Manipulations avec range(), listes et compréhensions
o Initialisez :
§ truc comme une liste vide.
§ machin comme une liste contenant cinq flottants nuls.
o Affichez ces listes.
o Utilisez la fonction range() pour afficher :
§ Les entiers de 0 à 3.
§ Les entiers de 4 à 7.
§ Les entiers de 2 à 8 par pas de 2.
o Définissez chose comme la liste des entiers de 0 à 5 et testez l’appartenance des
éléments 3 et 6.
o Utilisez une liste en compréhension pour créer une liste contenant chacun des
entiers de 0 à 5 auquel on a ajouté 3.
3. Liste en compréhension avec condition
o Créez une liste en compréhension qui ajoute 3 à chaque entier de 0 à 5
seulement si cet entier est supérieur ou égal à 2.
NB : En Python, une liste de compréhension (list comprehension) est une manière
concise et élégante de créer une liste à partir d’une autre structure de données,
généralement avec une boucle et une condition optionnelle.
Syntaxe générale : [nouvelle_valeur for élément in iterable if condition] .
4. Combinaison de chaînes
o Utilisez une liste en compréhension avec deux boucles for imbriquées pour
obtenir la liste suivante à partir des chaînes "abc" et "de" :
['ad', 'ae', 'bd', 'be', 'cd', 'ce']
5. Somme d’une liste d’entiers
o Utilisez une liste en compréhension pour calculer la somme des entiers de 0 à 9.
6. Ensembles (sets)
o Définissez :
§ X = {'a', 'b', 'c', 'd'}

15. Y. EL ALLIOUI – FPK – USMS – [email protected] 15 / 24
§ Y = {'s', 'b', 'd'}
o Affichez :
§ Les ensembles initiaux.
§ Le test d’appartenance de 'c' dans X et de 'a' dans Y.
§ Les différences X - Y et Y - X.
§ L’union X ∪ Y et l’intersection X ∩ Y.
7. Fonction compterMots
o Écrivez une fonction compterMots(chaine) qui prend en argument une chaîne
de caractères et renvoie un dictionnaire indiquant la fréquence de chaque mot.
8. Dictionnaire structuré
o À partir du tableau suivant concernant des éléments simples, créez un
dictionnaire dico de manière à pouvoir accéder aux informations comme dans
l’exemple :
Pour l’or (Au) :
§ Températures d’ébullition et de fusion : 2970 et 1063
§ Numéro atomique et masse atomique : 79 et 196.967
Pour le gallium (Ga) :
§ Températures d’ébullition et de fusion : 2237 et 29.8
§ Numéro atomique et masse atomique : 31 et 69.72
Par exemple, l'instruction
print(dico["Au"]["Z/A"][0])
doit afficher 79.
9. Implémentation d'une pile LIFO)
o Écrivez trois fonctions :
§ pile(*elements) : qui retourne une pile (liste) initialisée avec un
nombre variable d’éléments.
§ empile(p, element) : qui ajoute (empile) un élément en « haut » de la
pile.
§ depile(p) : qui retire (dépile) et retourne l’élément situé en « haut » de
la pile.
10. Implémentation d'une queue (FIFO) avec menu
o En utilisant une variable globale (une liste), implémentez une queue FIFO en
définissant des procédures (sans argument) pour :
§ Afficher la queue.
§ Ajouter un élément à la queue.
§ Retirer un élément de la queue.
o Proposez ensuite un menu permettant de manipuler la queue.

16. Y. EL ALLIOUI – FPK – USMS – [email protected] 16 / 24

17. Y. EL ALLIOUI – FPK – USMS – [email protected] 17 / 24
Série 6
LES STRUCTURES DE DONNEES : LIST, TUPLE, DICT, SET
Exercice 1 : Analyse de données météorologiques
Objectif :
Manipuler différentes structures de données pour stocker et analyser des données
météorologiques.
Énoncé :
Vous êtes chargé de développer un système d'analyse de données météorologiques. Créez un
programme qui effectue les opérations suivantes :
1. Stockez les données météorologiques suivantes dans un dictionnaire :
o Températures quotidiennes (en °C) pour une semaine : [21, 24, 23, 19, 18, 22,
25]
o Précipitations (en mm) : [0, 0, 5.5, 10.2, 2.1, 0, 0]
o État du ciel : ["Ensoleillé", "Ensoleillé", "Nuageux", "Pluvieux", "Nuageux",
"Ensoleillé", "Ensoleillé"]
o Jours de la semaine : ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi",
"Samedi", "Dimanche"]
2. Créez une fonction calculer_statistiques qui :
o Calcule et retourne la température moyenne, minimale et maximale
o Calcule le total des précipitations
o Compte le nombre d'occurrences de chaque état du ciel (utilisez un dictionnaire)
3. Créez une fonction jours_selon_critere qui :
o Prend en paramètre un seuil de température et un état du ciel
o Retourne une liste des jours où la température dépassait le seuil ET où l'état du
ciel correspondait au paramètre
4. Créez une fonction meteo_demain qui :
o Utilise une structure conditionnelle et les données des jours précédents
o Retourne une prédiction pour demain sous forme de tuple (température prévue,
état du ciel)
o Basez la prédiction sur des règles simples comme la moyenne des 3 derniers
jours pour la température
Exercice 2 : Gestion d'un catalogue de films
Objectif :
Utiliser les structures de données pour créer un catalogue de films avec fonctionnalités de
recherche et filtrage.

18. Y. EL ALLIOUI – FPK – USMS – [email protected] 18 / 24
Énoncé :
Développez un système de gestion de catalogue de films avec les fonctionnalités suivantes :
1. Créez une liste de dictionnaires où chaque dictionnaire représente un film avec les
attributs :
o Titre (chaîne)
o Année (entier)
o Réalisateur (chaîne)
o Genres (liste)
o Note (float sur 10)
o Acteurs (liste)
2. Créez une fonction ajouter_film qui :
o Prend tous les attributs nécessaires en paramètres
o Crée un nouveau dictionnaire de film
o L'ajoute à la liste principale
o Vérifie qu'un film avec le même titre et la même année n'existe pas déjà (utiliser
les ensembles)
3. Créez une fonction recherche_films qui :
o Accepte des paramètres optionnels (titre, année, réalisateur, genre, note
minimale)
o Retourne une liste des films correspondant à TOUS les critères spécifiés
o Utilise des fonctions lambda pour certains filtres
4. Créez une fonction statistiques_catalogue qui retourne un dictionnaire contenant :
o Le nombre total de films
o La note moyenne de tous les films
o Le réalisateur le plus fréquent
o Une liste des 3 genres les plus populaires
o L'année avec le plus de films
5. Bonus : Créez une fonction récursive recommandation_films qui :
o Prend un titre de film en paramètre
o Retourne une liste de films recommandés (même genre ou même réalisateur)
o Limite la profondeur de récursion à 2 niveaux
Exercice 3 : Analyse de texte et traitement de données
Objectif :
Combiner plusieurs structures de données et fonctions pour analyser un texte.
Énoncé :
Développez un programme d'analyse de texte avec les fonctionnalités suivantes :

19. Y. EL ALLIOUI – FPK – USMS – [email protected] 19 / 24
1. Créez une fonction charger_texte qui :
o Prend un texte en paramètre (une longue chaîne)
o Nettoie le texte (supprime la ponctuation, convertit en minuscules)
o Retourne une liste de mots
2. Créez une fonction analyser_frequence qui :
o Prend la liste de mots
o Construit un dictionnaire avec la fréquence de chaque mot
o Retourne le dictionnaire trié par fréquence décroissante (utilisez une fonction
lambda)
3. Créez une fonction mots_exclusifs qui :
o Prend deux textes en paramètres
o Utilise des ensembles pour trouver les mots qui apparaissent dans le premier
texte mais pas dans le second
o Retourne ces mots triés par fréquence (dans le premier texte)
4. Créez une fonction vocabulaire_enrichi qui :
o Prend une liste de mots et un seuil de fréquence
o Retourne un tuple contenant deux ensembles :
§ L'ensemble des mots "courants" (fréquence > seuil)
§ L'ensemble des mots "rares" (fréquence <= seuil)
5. Créez une fonction analyser_phrases qui :
o Divise le texte original en phrases
o Pour chaque phrase, calcule :
§ Sa longueur en mots
§ Le pourcentage de mots rares qu'elle contient
§ Un "score de complexité" basé sur la longueur et le pourcentage de mots
rares
o Retourne les 3 phrases les plus "complexes"
6. Bonus : Implémentez une fonction generer_nuage qui :
o Simule la création d'un nuage de mots en attribuant une "taille" à chaque mot
basée sur sa fréquence
o Retourne une nouvelle structure combinant les mots et leurs tailles calculées

20. Y. EL ALLIOUI – FPK – USMS – [email protected] 20 / 24
Série 6
LA PROGRAMMATION ORIENTEE OBJET EN PYTHON
Exercice 1 : La classe Employé
Objectif :
Mettre en pratique la création d’une classe en Python, avec des attributs privés (ou protégés),
des accesseurs (getters/setters), des constructeurs, ainsi que des méthodes calculant l’âge,
l’ancienneté et une augmentation de salaire selon des règles prédéfinies.
Consignes :
1. Définition de la classe
Créez une classe Employe caractérisée par les attributs suivants :
o matricule
o nom
o prenom
o date_naissance (utilisez par exemple des objets datetime.date)
o date_embauche
o salaire
2. Constructeurs
o Un constructeur par défaut (qui initialise éventuellement à des valeurs par
défaut ou None).
o Un constructeur qui prend en paramètres les valeurs pour initialiser tous les
attributs.
3. Accesseurs et mutateurs
Définissez pour chaque attribut des méthodes d’accès (getter) et de modification (setter)
ou utilisez les propriétés Python pour un accès contrôlé.
4. Méthodes supplémentaires
o age() : retourne l’âge de l’employé (en années).
o anciennete() : calcule le nombre d’années d’ancienneté à partir de la date
d’embauche.
o augmentation_du_salaire() : augmente le salaire selon les règles suivantes :
§ Si ancienneté < 5 ans → +2%
§ Si ancienneté entre 5 et 10 ans → +5%
§ Sinon → +10%
o afficher_employe() : affiche les informations de l’employé avec le nom en
majuscules et le prénom avec la première lettre en majuscule (le reste en
minuscule).
5. Programme de test
Rédigez un script qui instancie plusieurs objets Employe et teste chacune des méthodes
implémentées.

21. Y. EL ALLIOUI – FPK – USMS – [email protected] 21 / 24
Exercice 2 : Représentation d’un point dans l’espace
Objectif :
Créer une classe Point qui représente un point dans l’espace 3D avec un nom et trois
coordonnées.
Consignes :
1. Constructeur
Le constructeur reçoit en arguments le nom et les coordonnées x, y, z.
2. Méthodes
o affiche() : affiche le nom et les coordonnées du point.
o translate(dx, dy, dz) : déplace le point en ajoutant les valeurs aux
coordonnées respectives.
o distance(autre_point) : calcule la distance euclidienne entre le point et un
autre point passé en paramètre.
3. Programme de test
Créez un point, affichez-le, déplacez-le et affichez-le à nouveau. Calculez la distance
entre ce point et un second point.
Exercice 3 : Implémentation d’une classe Livre
Objectif :
Développer une classe Livre avec divers attributs et méthodes de gestion.
Consignes :
1. Attributs
o ref (référence)
o titre
o liste_auteurs (liste de chaînes de caractères)
o annee
o maison_edition
2. Méthodes
o __str__() : retourne une chaîne de caractères contenant toutes les informations
du livre.
o Getters et setters pour chaque attribut (vous pouvez utiliser les propriétés).
o chercher_auteur(auteur) : retourne True si l’auteur se trouve dans la liste.
o chercher_theme(theme) : retourne True si le thème (recherché dans le titre)
correspond.
3. Programme de test
Instanciez un livre et testez les différentes méthodes.
Exercice 4 : Héritage – Bâtiment et Maison
Objectif :
Comprendre l’héritage en Python en créant une classe de base Batiment et une classe
dérivée Maison.

22. Y. EL ALLIOUI – FPK – USMS – [email protected] 22 / 24
Consignes :
1. Classe Batiment
o Attributs : nom et adresse
o Deux constructeurs : avec ou sans paramètres (en Python, on peut utiliser des
valeurs par défaut)
o Méthode __str__() pour donner une représentation textuelle du bâtiment
2. Classe Maison (héritée de Batiment)
o Attribut supplémentaire : nbre_pieces
o Constructeurs avec et sans paramètres (en utilisant éventuellement la
fonction super())
o Méthode __str__() propre à la classe Maison
3. Programme de test
Instanciez un objet Batiment et un objet Maison et affichez leurs représentations.
Exercice 5 : Attribut statique et héritage – Gestion de comptes
bancaires
Objectif :
Mettre en œuvre des attributs de classe (statiques) et illustrer le polymorphisme avec des
comptes bancaires de types différents.
Consignes :
1. Classe Compte
o Attributs : code (incrémenté automatiquement pour chaque nouveau
compte), solde
o Deux constructeurs : avec solde par défaut (zéro) et avec solde initial.
o Méthodes :
§ deposer(montant)
§ retirer(montant)
§ __str__() : afficher le code et le solde.
2. Classe CompteEpargne (héritée de Compte)
o Attribut de classe : TAUX_INTERET = 0.05
o Méthode calcul_interet() qui met à jour le solde en appliquant le taux
d’intérêt.
3. Classe ComptePayant (héritée de Compte)
o Pour chaque opération (dépôt ou retrait), appliquez une commission fixe (ex. 20
DH).
o Redéfinissez les méthodes deposer() et retirer() pour tenir compte de la
commission.
4. Programme de test
Créez une instance de chaque type de compte, effectuez des dépôts et retraits, appliquez
le calcul d’intérêt et affichez le solde final.

23. Y. EL ALLIOUI – FPK – USMS – [email protected] 23 / 24
Exercice 6 : Classes abstraites et polymorphisme
Objectif :
Utiliser les classes abstraites (via le module abc) pour définir une hiérarchie d’employés avec
une méthode abstraite get_salaire().
Consignes :
1. Classe abstraite EmployeAbstrait
o Attributs : matricule, nom, prenom, date_naissance
o Méthode __str__()
o Méthode abstraite get_salaire()
2. Classes dérivées : Ouvrier, Cadre, et Associe
o Ouvrier :
§ Attribut supplémentaire : date_entree
§ Salaire = SMIG + (ancienneté en années * 100), plafonné à 2 * SMIG,
où SMIG = 3000 DH.
o Cadre :
§ Attribut : indice (de 1 à 4)
§ Salaire fixé en fonction de l’indice (exemple : 1 → 12000 DH, 2 →
14000 DH, etc.)
o Associe :
§ Attributs : chiffre_affaires (commun à tous les
associés), benefice_net, et pourcentage
§ Salaire = BN * pourcentage.
3. Programme de test
Créez des instances de chaque type et affichez leurs informations et salaires.
Exercice 7 : Simulation d’une application de gestion de ventes avec
"interfaces"
Objectif :
Concevoir une application de gestion de ventes en simulant des interfaces grâce à l’héritage
multiple ou à la composition (puisque Python ne possède pas d’interfaces formelles).
Contexte :
Le magasin vend des articles divers (électroménagers et primeurs). Certains produits se
périment et certains peuvent être vendus en solde.
Consignes :
1. Interfaces simulées :
o ProduitPérissable
§ Méthode date_peremption() : retourne la date de fin de validité.
§ Méthode jours_restants() : retourne le nombre de jours avant
péremption.
o ProduitSolde
§ Méthode lancer_solde(pourcentage) : baisse le prix du produit.

24. Y. EL ALLIOUI – FPK – USMS – [email protected] 24 / 24
§ Méthode terminer_solde(pourcentage) : rétablit le prix initial ou
augmente le prix.
2. Classe de base Article :
o Attributs : prix_achat, prix_vente, nom, fournisseur
o Méthodes :
§ taux_rendement() : calcul du rendement (différence entre prix de vente
et prix d’achat).
§ afficher() : affiche les caractéristiques de l’article.
3. Classes dérivées :
o ArticleElectromenager
§ Attributs supplémentaires : voltage et marque
§ Implémentez les méthodes de l’interface ProduitSolde pour ajuster le
prix de vente.
o Primeur
§ Attribut supplémentaire : date_peremption
§ Implémentez les méthodes de l’interface ProduitPérissable.
Remarque : Les primeurs ne peuvent pas être soldées.
4. Classe Magasin :
o Gérer un stock (par exemple, un dictionnaire associant le nom de l’article à la
quantité en stock).
o Méthodes pour :
§ Vendre un article (mettre à jour le stock).
§ S’approvisionner.
§ Lister les articles en rupture de stock.
§ Lister les articles disponibles.
§ Afficher l’état général du magasin et le taux de rendement global.
5. Programme de test
Créez un magasin, ajoutez quelques articles électroménagers et primeurs, effectuez des
opérations de vente et de réapprovisionnement, et affichez l’état du magasin.