INGENIEUR Agro-Industrie, GÉOLOGIE &

Environnement (IAGE)

Chapitre 5 : Instructions itératives

Prérequis :
 Interpréteur Python Installé et fonctionnel ;
 Connaissance sur la notion de variable ;
 Utilisation des fonctions en Python ;
 Connaissance des types de bases Built-in ;
 Connaissance du type List ;
 Manipulation du type List ;

Objectifs : A la fin de cette leçon chaque étudiant en classe de 1 ère Année Agro doit
être capable de :

 Utilisation de la boucle for avec une performance de 100% ;

 Utilisation de la boucle while avec une performance de 100% ;
 Résolution des problèmes algorithmiques nécessitant l’utilisation de la répétition
avec une performance de 100% ;
 Faire la différence entre for et while avec une performance de 100% ;
 Parcourir un objet de type List via une boucle for avec une performance de 100% ;
 Parcourir un objet de type List via une boucle while avec une performance de
100% ;
 Afficher les éléments d’un objet de type List via une boucle while avec une
performance de 100% ;
 Afficher les éléments d’un objet de type List via une boucle for avec une
performance de 100% ;
 Afficher les éléments d’une chaine de caractère via une boucle for avec une
performance de 100% ;
 Afficher les éléments d’une chaine de caractère via une boucle while avec une
performance de 100% ;
 Utilisation de la fonction zip avec une performance de 100% ;
 Utilisation de la fonction enumerate avec une performance de 100% ;
 Donner la différence entre la fonction zip et enumerate avec une performance de
100% ;
 Donner la différence entre break et continue avec une performance de 100% ;
 Utiliser l’instruction continue dans une boucle avec une performance de 100% ;
 Utiliser l’instruction break dans une boucle avec une performance de 100% ;
 Utilisation de la fonction filter avec une performance de 100% ;
 Utilisation de la fonction map avec une performance de 100% ;

Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 1/14

 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

Introduction
Dans les chapitres précédents, nous avons vu comment écrire des programmes Python
en utilisant des choix (if), et les fonctions. Dans ce nouveau chapitre, nous allons
présenter comment effectuer les répétitions en Python. Les répétitions, sont une notion
omniprésente dans les activités quotidiennes de l’homme (marcher, courir, manger,
mâcher, etc.). C’est donc une notion nécessaire de maîtriser afin d’être capable d’écrire
des programmes capables de répéter une ou plusieurs instructions.

I. Rappels algorithmiques
En algorithmique, pour réaliser des répétions ou boucles, on utilise principalement
trois structures de répétition :

 La structure Pour…finpour ;
 La structure Tantque … Fintantque ;
 La structure Répéter … Finrépéter.

1. La structure Pour
La structure algorithmique Pour est utilisée pour répéter une ou plusieurs instructions.
Sa syntaxe est la suivante :
Pour iter allant de valeur_min à valeur_max [pas de valeur_pas] Faire
Instruction i
…
Instruction i+k
Finpour

Dans cette écriture, les mots clés sont soulignés et les valeurs ou variables sont en
gras. L’expression iter représente une variable entière déclarée au préalable dans
l’entête de l’algorithme, de la fonction ou de la procédure. Elle est utilisée pour
déterminer l’itération en cours. L’expression valeur_min représente la valeur entière
de début de la variable iter, pour la première itération. L’expression valeur_max
représente la valeur maximale que prendra la variable iter pendant la répétition.
L’expression valeur_pas représente la valeur du pas (différence entre les valeurs de la
variable iter entre deux itérations). Lorsque la valeur du pas vaut 1 (valeur par défaut
du pas), le pas peut être omis. Voyons un peu comment utiliser cette structure au
travers des deux exemples suivants :

Exemple 1 :
Pour i allant de 1 à 10 Faire
Ecrire (‘Bonjour le monde’) ;
Finpour

Dans cet exemple, l’expression « Bonjour le monde », sera affichée 10 fois. La

variable i prend 1 comme première valeur. A chaque fois que l’instruction
Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 2/14
 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

(respectivement les instructions lorsqu’il y’en plusieurs) contenue dans la boucle est
exécutée, la variable i est incrémentée automatiquement de 1 (c’est-à-dire augmenté de
1), puisque le pas vaut 1 (valeur par défaut du pas lorsqu’elle est omise). La boucle
s’arrête lorsque la valeur de la variable i a dépassé la valeur maximale (10).

Exemple 2 :
Pour i  0 à 20 Pas de 2 Faire
Ecrire (i, ‘est paire’) ;
Finpour

Cet exemple permet d’afficher les nombres pairs compris entre 0 et 20 (0 et 20 inclus).
Les valeurs de la variable i varient de 0 à 20. A chaque fois que l’instruction
(respectivement les instructions lorsqu’il y’en plusieurs) contenue dans la boucle est
exécutée, la variable i est incrémenté automatiquement de 2 (c’est-à-dire augmenté de
2), puisque le pas vaut 2 (définition explicite au sein de la boucle). La boucle s’arrête
lorsque la valeur de la variable i a dépassé la valeur maximale (20).

Remarque : La structure de répétition Pour est utilisée, lorsque le nombre d’itération

maximale est connu d’avance.

2. La structure Tantque
Comme la structure Pour, la structure algorithmique Tantque est utilisée pour répéter
une ou plusieurs instructions. A la différence de la structure Pour où le nombre de
répétition est connu à l’avance, la structure Tantque s’exécute tant qu’une (ou un
ensemble de) condition(s) reste vérifiée. Sa syntaxe est la suivante :
Tantque (condition) Faire
Instruction i
…
Instruction i + k
Fintantque

Dans cette écriture, les mots clés de la structure sont soulignés. L’instruction Tantque
dépends de la condition d’arrêt ou de contrôle (condition). La condition d’arrêt ou de
contrôle (condition) s’applique sur une ou plusieurs variables, elle permet de contrôler
l’évolution des répétitions. Ces variables doivent dont être initialisées avant le début
de la structure par la ou les valeurs par défaut. A la différence de la boucle Pour où
l’incrémentation de la variable permettant de compter les itérations est effectuée
automatiquement de façon implicite, au niveau de la boucle Tantque, l’incrémentation
de ladite (desdites) variable(s) est explicite. La structure Tantque est propice pour la
répétition d’un ensemble d’instructions lorsque le nombre maximal de répétition n’est
pas connu à l’avance. Du fait que le test de la condition d’arrêt est réalisé au début de
Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 3/14
 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

la structure, celle-ci peut ne pas s’exécuter. Voyons un peu tout cela au travers de
quelques exemples :
Exemple 1
i  1 ;
Tantque (i <10) Faire
Ecrire (‘Bonjour le monde’) ;
i  i + 1 ;
Fintantque

Cet exemple, permet d’afficher 10 fois l’expression « Bonjour le monde ». La variable

i est utilisée pour compter le nombre d’itération, elle est donc initialisée avant la
structure Tantque avec la valeur 1 (cette valeur représente la valeur initiale ou
minimale comme c’était le cas avec la structure Pour). La condition de contrôle
(i<10) permet de déterminer quand la boucle doit s’arrêter. L’instruction i  i + 1
permet de faire avancer la structure itérative 1, en faisant évoluer la structure à
l’itération suivante.
Exemple 2
i  0 ;
Tantque (i <= 20) Faire
Ecrire (i, ‘est paire’) ;
i  i +2 ;
Fintantque

Cet exemple permet d’afficher les nombres pairs compris entre 0 et 20 (0 et 20 inclus),
en utilisant la structure Tantque. La variable i est utilisée pour compter le nombre
d’itération, elle est donc initialisée avant la structure Tantque avec la valeur 0. La
condition de contrôle (i<= 20) permet de déterminer quand la boucle doit s’arrêter.
L’instruction i  i + 2 permet de faire avancer la structure itérative, en faisant
évoluer la structure à l’itération suivante.

3. La structure Répéter
La structure algorithmique Répéter est utiliser pour répéter une ou plusieurs
instructions tant qu’une condition reste vérifiée. Son fonctionnement est presque
similaire à celui de la boucle Tantque. Sa syntaxe générale est la suivante :
Répéter
Instruction i
…
Instruction i + k
Jusqu’à (condition)

1
Généralement, cette instruction est la dernière des instructions du bloc Tantque.
Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 4/14
 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

Avec la condition d’arrêt (condition) testée à la fin de l’exécution du bloc d’instruction

de la structure Répéter, celle-ci s’exécute toujours au moins une fois.

II. La répétition en Python

Python offre principalement, deux instructions pour effectuer des répétitions :

 For (équivalent de la structure Pour utilisée en algorithmique)

 While (équivalent de la structure Tantque utilisé en algorithmique)
1. For
En Python, l’instruction For permettant de faire une répétition d’un bloc d’instruction
en parcourant une séquence. Dans ce chapitre nous nous limiterons à une seule
séquence : la liste, les autres types de séquence seront présentés au chapitre suivant.
Pour parcourir une liste en utilisant la boucle for, on peut soit utiliser une liste déjà
existante, soit en créer une au travers de la fonction range.

a. For utilisant une liste existante

En Python, la syntaxe pour parcourir les éléments d’une liste en utilisant le for est la
suivante :
for var in liste :
Instruction i
…
Instruction i + k
Dans cette écriture var est une variable, et liste une liste d’éléments quelconques.
Voyons un peu comment l’utiliser au travers de quelques exemples.

Exemple : On souhaite afficher les éléments de la liste suivante [10, 30, 50, [10], 45],
en utilisant la boucle for. Le code suivant présente une solution possible :
>>>for var in [10, 30, 50, [10], 45]:
print(var)
On obtient le résultat suivant à l’exécution
10
30
50
[10]
45
Que s’est-il passé ? La variable var a pris tour à tour les valeurs de la séquence (notre
liste en occurrence) de façon séquentielle, à chaque itération. Pour chaque valeur de la
liste prise par la variable var, les instructions du bloc for sont exécutées avec cette
valeur. A la fin de l’exécution de ces instructions, la variable var prend la valeur de
l’élément suivant de la liste si ce n’est pas le dernier, sinon la boucle s’arrête. Comme

Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 5/14

 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

vous avez pu le constater, les éléments de la liste ne sont pas obligés d’être homogènes
pour être parcourus par la boucle for.

Exemple 2 : Affichons au travers de la boucle for le carré des nombres compris entre 1
et 10. Le code suivant présente une solution possible :
>>> for nb in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
print(f"{nb*nb}")
1
4
9
16
25
36
49
64
81
100
Cet exemple affiche le carré des nombres compris entre 1 et 10.

b. For utilisant la fonction range

Dans le deuxième exemple de la partie précédente (a), nous avons écrit un programme
Python qui affiche les carrés des nombres compris entre 1 et 10 en utilisant la boucle
for et la liste [1, 2, 3, 4,5, 6, 7, 8, 9, 10]. Cette méthode, devient très limitée lorsqu’on
souhaite opérer la répétition dans un exemple plus grand. Imaginons par exemple
qu’on souhaite afficher la liste des carrés des nombres compris entre 1 et 100. Créer
une liste contenant les nombres compris entre 1 et 100 comme nous l’avons fait avec
les nombres compris entre 1 et 10 se révèlera très fastidieux. Pour faciliter la création
de ce type de liste, Python offre la fonction range donc la syntaxe est la suivante
range(valeur_min, valeur_max+1, pas)

Cette fonction permet de créer une séquence de nombre entier consécutif, donc le
premier élément est valeur_min et le dernier valeur_max, la différence entre deux
éléments consécutifs de cette liste est pas.

Remarque : La fonction range possède plusieurs contrainte :

 Tous ses paramètres doivent être des nombres entiers (positif et/ou négatif) ;
 Si la fonction est utilisée avec un seul paramètre, alors, ce paramètre est
considéré comme la valeur valeur_max+1. La fonction range crée alors une
séquence d’objets entier de 0 à valeur_max. Par exemple, range(5) est
équivalent à range(0, 5), c’est-à-dire une liste de nombres entiers de 0 à 4.

Voyons un peu cela au travers de quelques exemples concrets :

Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 6/14
 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

>>>range(11)

Une séquence contenant les nombres compris entre 0 et 10. Pour afficher le contenu de
la dite séquence, parcourons là avec une instruction for.
>>>for i in range(11):
print(i, end=’, ’)
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

>>>range(3, 40, 3) 

Une séquence contenant les multiples de 3 compris entre 3 et 39. On peut afficher le
contenu dudit range via le code suivant :
>>>for i in range(3, 40, 3):
print(i)

Exemple : On souhaite créer une liste des nombres pairs compris entre 1 et 50. Le
programme Python suivant est une solution possible.
>>> liste = []
>>> for nb in range(0, 51, 2):
liste.append(nb)
>>> liste
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36,
38, 40, 42, 44, 46, 48, 50]

Comme on peut le voir la fonction range crée un objet (range) constitué d’une
séquence d’objet entier, donc le premier élément est 0 et le dernier, 50, les éléments de
la liste sont séparés d’un pas de 2.

Outre la possibilité d’utilisation de range, Python offre la possibilité de créer une liste
en utilisant l’écriture en compréhension de liste via l’utilisation du for.

c. La compréhension de liste
La compréhension de liste permet de créer des listes qui respectant certaines
contraintes. La syntaxe générale de l’écriture d’une liste en compréhension est la
suivante :

[apply_fonction(elt) for elt in start_liste if condition(elt)]

Que fait cette écriture contrairement ? elle permet de créer une liste donc les éléments
(elt) proviennent de la liste start_liste et sur chaque élément de cette liste (start_liste),

Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 7/14

 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

on applique la fonction apply_fonction, pour les éléments respectant la condition

condition(elt). Voyons un peu de quoi il s’agit de façon contrait via quelques
exemples.

Exemple : Soit la liste suivante [1, 4, 2, 7, 9, 0, 3, 4, 6, 6, 6, 8, 3], on souhaite à travers

cette liste créer une liste contenant les nombres supérieure à 4 en utilisant la
compréhension de liste. Le code suivant est un exemple possible.
>>> liste = [1, 4, 2, 7, 9, 0, 3, 4, 6, 6, 6, 8, 3]
>>> [elt for elt in liste if elt > 5]
[7, 9, 6, 6, 6, 8]
Dans cet exemple, comme on souhaite uniquement filtrer le contenu de la liste [1, 4, 2,
7, 9, 0, 3, 4, 6, 6, 6, 8, 3], il n’y a aucune fonction à appliquer aux éléments de liste
[1, 4, 2, 7, 9, 0, 3, 4, 6, 6, 6, 8, 3] respectant la contrainte (elt > 5).

Exemple : Supposons que nous voulons créer et afficher la liste des carrés des nombres
pairs compris entre 1 et 20 (20 exclus). Le code suivant présente une solution possible.
>>> def carre(nb):
return nb**2
>>> liste = [carre(nb) for nb in range(1,20) if nb%2 == 0]
>>> for nb in liste :
print(f"{nb}", end=", ")

4, 16, 36, 64, 100, 144, 196, 256, 324,

Dans cette exemple pour respecter la syntaxe générale de l’écriture en compréhension
d’une liste, nous avons d’abord créé une fonction carre qui détermine le carré d’un
nombre (nb) passé comme paramètre. Ensuite grâce à l’écriture en compréhension,
nous pouvons alors créer une liste constituée des nombres pairs compris entre 1 et 20
(20 exclus). Ensuite nous pouvons parcourir cette liste pour l’afficher avec un for.

d. Fonction zip
Dans les parties précédentes, nous présenté uniquement comment parcourir une liste
avec la boucle for. Supposons que nous souhaitons parcourir et afficher plusieurs listes
dans une même boucle, que faire. Python offre pour cela la fonction zip, elle permet de
combiner plusieurs listes en une seule, de manière à rendre les itérations efficaces. La
syntaxe générale de la fonction zip est la suivante.

zip(liste1, liste2 [, liste3, …, listen]

Pour parcourir une séquence créer avec la fonction zip la syntaxe générale est la
suivante :

for elt1, elt2, …, eltn in zip(liste1, liste2, [, liste3, …, listen] :

Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 8/14

 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

Dans cette écriture, elt1, elt2, …, eltn proviennent respectivement des listes liste1,
liste2, …, listen.

Voyons comment utiliser cette fonction via les exemples suivants.

Exemple : Supposons que nous ayons les 2 listes de noms suivants [‘Azetsa’,
‘Fomena’, ‘Alone’] et [‘Nziim’, ‘Eyoum’, ‘Mouafo’]. Supposons que nous voulons
afficher des messages du genre « x est l’amie de y » avec x et y appartenant
respectivement à la première et la seconde liste. Le code suivant montre une solution
possible.
>>> liste1 = ['Azetsa', 'Fomena', 'Alone']
>>> liste2 = ['Nziim', 'Eyoum', 'Mouafo']
>>> for name1, name1 in zip(liste1, liste2):
print(f"{name1} est l'amie de {name2}")
Azetsa est l'amie de Nziim
Fomena est l'amie de Eyoum
Alone est l'amie de Mouafo
Comme nous pouvons le voir, la fonction zip à créer une liste unique donc chaque
élément appartient à chacune des listes passées comme argument.

Exemple 2 : Soient les trois listes suivantes : [‘Mani’, ‘Kengne’, ‘Messi’, ‘Yoga’,
‘Mokam’], [‘Danse’, ‘Hand-ball’, ‘Football’, ‘Nage’, ‘Taekwondo’], [‘visionner’,
‘manger’, ‘se balader’, ‘Lire’], représentant respectivement les noms des étudiants de
la filière Agro1, leurs sports préférés et leurs hobbies. On souhaite écrire un code
Python qui affiche la phrase « le sport favori de x est y, et son hobby est z » avec x, y
et z appartenant à la première, seconde et troisième liste. Le code suivant présente un
résultat possible.
>>> noms = ["Mani", "Kengne", "Messi", "Yoga", "Mokam"]
>>> sports = ["Danse", "Hand-ball", "Football", "Nage", "Taekwondo"]
>>> hobbies = ["visionner", "manger", "se balader", "Lire"]
>>> for nom, sport, hobby in zip(noms, sports, hobbies):
print(f"Le sport préféré de {nom.upper()} est {sport}, et son hobby
{hobby}")
Le sport préféré de MANI est Danse, et son hobby visionner
Le sport préféré de KENGNE est Hand-ball, et son hobby manger
Le sport préféré de MESSI est Football, et son hobby se balader
Le sport préféré de YOGA est Nage, et son hobby Lire
Comme nous pouvons le voir dans l’exemple ci-dessus, la fonction zip travaille avec
les listes de même taille. Si les listes n’ont pas la même taille, elle ignore les éléments
de la (des) liste(s) qui dépasse(nt) la taille de la plus petite liste.

Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 9/14

 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

e. Fonction enumerate
La fonction zip n’est pas la seule fonction permettant de combiner une liste avec une
autre. La fonction enumerate, permet d’effectuer la même tâche. Cependant, la
fonction enumerate, combine une liste avec une énumération. Sa syntaxe est la
suivante :

enumerate(sequence, start=0)

Séquence est un objet itérable (objet qu’on peut parcourir avec une itération), start
représente le premier élément de l’énumération, si ce paramètre est omis la valeur 0 est
considéré comme valeur de début de l’énumération (comme nous l’avons vu dans le
chapitre sur les fonctions, 0 est la valeur par défaut du paramètre start). Toutefois, il
faut signaler que le résultat de la fonction enumerate peut être également obtenu avec
la fonction zip.

zip(sequence, range(len(sequence)))

Dans cette écriture sequence, représente un itérable, len(sequence) permet d’obtenir la

taille de la liste sequence.

Voyons un peu comment utiliser la fonction enumerate dans un exemple.

Exemple. Soit la liste ['Ongono', 'Kofane', 'Kofana', 'Kono']. On souhaite à partir de

cette liste afficher un message de la forme « le numéro x de la classe est y », où x est
un élément de la liste et y le rang de x dans la liste. On supposera que les rangs
commencent à 1. Le code suivant est un résultat possible.
>>> for i, nom in enumerate(noms, 1):

print(f"Le numéro {i} de la classe est {nom.upper()}")

Le numéro 1 de la classe est ONGONO

Le numéro 2 de la classe est KOFANE

Le numéro 3 de la classe est KOFANA

Le numéro 4 de la classe est KONO

On peut obtenir le même résultat avec la fonction zip, de la manière suivante :

>>> for nom, i in zip(noms, range(1, len(noms)+1)):
print(f"Le numéro {i} de la classe est {nom.upper()}")

Le numéro 1 de la classe est ONGONO

Le numéro 2 de la classe est KOFANE
Le numéro 3 de la classe est KOFANA

Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 10/14

 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

Le numéro 4 de la classe est KONO

2. While
Comme nous l’avons vu au début de cette partie, for n’est pas la seule structure en
Python permettant de parcourir une séquence (un objet itérable). On peut également
utiliser la structure while. Comme nous l’avons vu, while est l’équivalent de la
structure Tantque en algorithmique. La syntaxe du while en Python est la suivante :
while(condition(var)) :
Instruction i
…
Instruction i+k
Dans cette écriture condition (var) est une condition sur une ou plusieurs variables.
Comme en algorithmique, la (les) variable(s) doit (doivent) être initialisée(s) avant
d’être utilisée(s) comme test de contrôle de la boucle. Voyons un peu cela au travers
de quelques exemples.

Exemple 1 : Soit la liste suivante [10, 11, 10.5, 20, 12, 15, 17, 19, 13, 11.5, 15.5]
représentant un sous ensemble des notes d’informatique. Affichons les éléments de
cette liste en utilisant la structure while. Le code suivant, est une solution possible :
>>> notes = [10, 11, 10.5, 20, 12, 15, 17, 19, 13, 11.5, 15.5]
>>> i = 0
>>> while( i < len(notes)):
print(notes[i], end=", ")
i = i + 1
10, 11, 10.5, 20, 12, 15, 17, 19, 13, 11.5, 15.5,

Comme vous pouvez le voir via l’exemple ci-dessus, pour parcourir notre liste, nous
avons utilisé la fonction len( ) que nous avons vu au chapitre précédent, cette fonction
permet d’obtenir la taille d’une liste. Pour parcourir une liste avec la boucle while (de
façon générale), la condition de contrôle de la boucle est dépendante de la taille de
liste. En effet, comme nous l’avons vu, les index des éléments d’une liste vont de 0 à
taille -1 de la liste, d’où la condition (i < len(notes)). Comme nous l’avons vu dans la
première partie, l’incrémentation du compteur (i) n’est pas automatique avec la boucle
while, cette incrémentation est obligatoire si on ne souhaite pas obtenir une boucle
infinie (c’est-à-dire une boucle qui ne finit jamais).

Exemple : Soit la liste suivante [10, 11, 10.5, 20, 12, 15, 17, 19, 13, 11.5, 15.5]
représentant un sous ensemble des notes d’informatique. On souhaite parcourir cette
liste avec la boucle while et afficher une appréciation pour chaque note. Le tableau
suivant présente les appréciations attendues.

Notes Appréciations
Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 11/14
 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

10-11.99 Passable
12-13.99 Assez Bien
14-15.99 Bien
16-17.99 Très bien
18-19.99 Excellent
20 Parfait
Le code suivant est une solution possible.
>>> notes = [10, 11, 10.5, 20, 12, 15, 17, 19, 13, 11.5, 15.5]
>>> i = 0
>>> while( i < len(notes)):
if(notes[i] >= 10) and (notes[i] <12):
print(f"{notes[i]} : Passable")
elif(notes[i] >= 12) and (notes[i] < 14):
print(f"{notes[i]} : Assez bien")
elif(notes[i] >= 14) and (notes[i] < 16):
print(f"{notes[i]} : Bien")
elif(notes[i] >= 16) and (notes[i] < 18):
print(f"{notes[i]} : Très Bien")
elif(notes[i] >= 18) and (notes[i] < 20):
print(f"{notes[i]} : Excellent")
else:
print(f"{notes[i]} : Parfait")
i = i + 1

10 : Passable
11 : Passable
10.5 : Passable
20 : Parfait
12 : Assez bien
15 : Bien
17 : Très Bien
19 : Excellent
13 : Assez bien
11.5 : Passable
15.5 : Bien

Si la structure for est utilisé en général pour parcourir une liste, la structure while
permet de résoudre des problèmes sans utiliser une séquence (ou un objet itérable).

Exemple. On souhaite écrire un script Python qui affiche la liste des 25 nombres
premiers Le code suivant est une solution possible.
>>> # Nous créons d'abord une fonction permettant de vérifier si un nombre
est premier

Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 12/14

 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

>>> def prime(nb: int = 0) -> bool:

if (nb <= 1 ):
return False
else:
diviseur = 0
for i in range(1, nb+1):
if(nb%i == 0):
diviseur = diviseur + 1
if diviseur == 2 :
return True
else:
return False
>>> nb = 1 #initialisation du compteur à 1
>>> compt = 0# initialisation du compteur de nombre premier
>>> while (nb <= 100) and compt <= 25:
if prime(nb):
print(nb, end=", ")
compt = compt + 1
nb = nb +1
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
71, 73, 79, 83, 89, 97,

III. Les instructions break et continue

On peut souhaiter arrêter prématurément une boucle ou passer à l’itération suivante
dans certaines conditions. Python offre pour cela les instructions break et continue :

 Break permet d’arrêter (casser) l’exécution d’une boucle (for ou while). Elle
permet donc de sortir de la boucle et de continuer à l’instruction suivante (après
la structure itérative).
 Continue permet de passer prématurément au tour de boucle suivant. Elle fait
continuer l’exécution de la boucle à la prochaine itération de celle-ci.

Voyons un peu leur fonctionnement, via les exemples suivants :

Exemple : On souhaite afficher les nombres pairs compris entre 0 et 20 inférieur à 15.
Le code suivant présente une solution possible :
>>> for nb in range(21):
if nb >= 15:
break
if nb%2 == 0 :
print(nb, end= " ")
0 2 4 6 8 10 12 14

Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 13/14

 INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)

Comme nous pouvons le voir à travers le résultat de l’exécution, les nombres pairs
après 14 supérieurs à 15, compris entre 0 et 20 ne sont pas afficher, car l’instruction
nous cassons la boucle avec l’instruction break dès que le nb est supérieur ou égale à
15.

Exemple : Soit les listes suivantes [‘Janvier’, ‘Février’, ‘Mars’, ‘Avril’, ‘Mai’, ‘Juin’,
‘Juillet’, ‘Mai’, ‘Août’, ‘Septembre’, ‘Octobre’, ‘Novembre’, ‘Décembre’], [31, 28,
31, 30, 31, 30, 31, 31, 30, 31, 30, 31] représentant les mois de l’année et le nombre de
jours de chaque mois. Ecrivons un script python permettant d’afficher uniquement les
mois donc le nombre de jour est égal à 31. Le script est une solution possible.
>>> jours = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
>>> mois = ["Janvier", "Février", "Mars", "Avril", "Mai", "Juin",
"Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre"]
>>> for month, day in zip(mois, jours):
if day == 28 or day == 30:
continue
print(f"Le mois {month} a {day} jours")

Le mois Janvier a 31 jours

Le mois Mars a 31 jours
Le mois Mai a 31 jours
Le mois Juillet a 31 jours
Le mois Août a 31 jours
Le mois Octobre a 31 jours
Le mois Décembre a 31 jours
Comme on peut le voir, si le nombre de jours est 28 ou 30, la boucle passe à
l’itération suivante et le message n’est affiché.

Par Donald A. VOUNDI | Chapitre 5 : Instructions itératives 14/14