Les Boucles for et while en Python

Les Boucles for et while en Python

Ce document explique toutes les façons d’utiliser les boucles for et while en
Python, avec des exemples simples, puis des exemples plus complets (listes,
dictionnaires, fonctions), et enfin comment afficher, rechercher et récupérer un
élément situé à une position n donnée par l’utilisateur.

1. À quoi servent les boucles ?

Une boucle permet de répéter une action plusieurs fois sans réécrire le code à
chaque fois.

La boucle for est utilisée quand on connaît à l’avance la séquence à parcourir

(une liste, un texte, un intervalle de nombres…).
La boucle while est utilisée quand on répète une action tant qu’une condition
reste vraie, sans forcément connaître le nombre de répétitions à l’avance.

2. La boucle for : toutes les manières de l’utiliser

2.1. for avec range() — répéter un nombre de fois précis

for i in range(5):
print(i)
# Affiche : 0 1 2 3 4

Quand l’utiliser : quand on veut répéter une action un nombre exact de fois (ex:
afficher 10 lignes, calculer une somme de 1 à n).

2.2. for avec range(debut, fin)

for i in range(2, 6):

print(i)
# Affiche : 2 3 4 5

2.3. for avec range(debut, fin, pas) — y compris à l’envers

for i in range(10, 0, -2):

print(i)
# Affiche : 10 8 6 4 2

Quand l’utiliser : pour un décompte, ou pour parcourir un intervalle avec un écart

régulier (nombres pairs, multiples…).

2.4. for directement sur une liste

SOUMBOU IYO GILBERT JUDE GI1/B ECES

 fruits = ["pomme", "banane", "orange"]
for fruit in fruits:
print(fruit)
# Affiche chaque fruit, un par ligne

Quand l’utiliser : dès qu’on veut traiter chaque élément d’une liste, sans se soucier
de sa position.

2.5. for sur une chaîne de caractères

for lettre in "Python":

print(lettre)
# Affiche : P y t h o n (chaque lettre sur une ligne)

2.6. for sur un tuple

coordonnees = (10, 20, 30)

for valeur in coordonnees:
print(valeur)

2.7. for sur un ensemble (set)

nombres = {1, 2, 3}
for n in nombres:
print(n)
# L'ordre d'affichage n'est pas garanti (les ensembles ne sont pas ordonnés)

2.8. for avec enumerate() — obtenir la position ET la valeur

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

for position, fruit in enumerate(fruits):
print(position, "->", fruit)
# 0 -> pomme
# 1 -> banane
# 2 -> orange

Quand l’utiliser : dès qu’on a besoin de connaître à la fois la position et la valeur

(par exemple pour afficher un numéro devant chaque élément).

2.9. for sur un dictionnaire — trois façons

etudiant = {"nom": "Alice", "age": 22, "ville": "Paris"}

# a) parcourir uniquement les clés

for cle in etudiant:
print(cle)

# b) parcourir uniquement les valeurs

for valeur in [Link]():
print(valeur)

# c) parcourir les clés ET les valeurs en même temps (le plus utilisé)
for cle, valeur in [Link]():
print(cle, ":", valeur)

Quand l’utiliser : .items() est la méthode la plus courante car elle donne accès à la

SOUMBOU IYO GILBERT JUDE GI1/B ECES

clé et à la valeur en une seule boucle.

2.10. for avec zip() — parcourir deux listes en parallèle

noms = ["Alice", "Bob", "Charlie"]

notes = [17, 12, 9]
for nom, note in zip(noms, notes):
print(nom, "a eu", note)

Quand l’utiliser : quand on a deux listes liées entre elles (ex: noms et notes) et qu’on
veut les traiter ensemble.

2.11. Boucle for imbriquée (une boucle dans une autre)

matrice = [[1, 2, 3], [4, 5, 6]]

for ligne in matrice:
for element in ligne:
print(element, end=" ")
print()
# 1 2 3
# 4 5 6

Quand l’utiliser : pour parcourir des structures à deux dimensions (matrices, grilles,
tableau de tableaux).

2.12. for ... else

for i in range(5):
if i == 10:
break
else:
print("La boucle s'est terminée sans interruption")

Quand l’utiliser : rare, mais utile pour exécuter un bloc uniquement si la boucle est
allée jusqu’au bout (sans break).

2.13. for à l’intérieur d’une fonction

def afficher_liste(liste):
for element in liste:
print(element)

afficher_liste(["chat", "chien", "oiseau"])

Quand l’utiliser : dans presque toutes les fonctions qui doivent traiter une collection
(c’est le cas le plus fréquent en pratique).

3. La boucle while : toutes les manières de l’utiliser

3.1. while simple avec un compteur

i = 1
while i <= 5:
print(i)
i += 1

SOUMBOU IYO GILBERT JUDE GI1/B ECES

 # Affiche : 1 2 3 4 5

Quand l’utiliser : équivalent d’un for, mais utile quand la condition d’arrêt est plus
complexe qu’un simple compteur.

3.2. while avec une saisie utilisateur (boucle de validation)

mot_de_passe = ""
while mot_de_passe != "python123":
mot_de_passe = input("Entrez le mot de passe : ")
print("Accès autorisé !")

Quand l’utiliser : quand on ne sait pas combien de fois l’utilisateur devra ressaisir
une valeur avant qu’elle soit correcte.

3.3. while True + break (boucle “infinie” contrôlée)

while True:
reponse = input("Tapez 'stop' pour arrêter : ")
if reponse == "stop":
break
print("Vous avez tapé :", reponse)

Quand l’utiliser : pour un menu interactif ou un programme qui tourne jusqu’à ce

que l’utilisateur décide d’arrêter.

3.4. while avec else

i = 0
while i < 3:
print(i)
i += 1
else:
print("Boucle terminée normalement")

3.5. Boucle while imbriquée

i = 1
while i <= 3:
j = 1
while j <= 2:
print(f"i={i}, j={j}")
j += 1
i += 1

3.6. while pour parcourir une liste avec un index manuel

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

i = 0
while i < len(fruits):
print(fruits[i])
i += 1

Quand l’utiliser : quand on a besoin de contrôler précisément l’index (par exemple

pour l’augmenter de 2 en 2, ou revenir en arrière).

SOUMBOU IYO GILBERT JUDE GI1/B ECES

4. for ou while : lequel choisir ?

Boucle
Situation
recommandée
Parcourir tous les éléments d’une liste/dictionnaire for
Répéter une action un nombre de fois connu for avec range()
Répéter une action jusqu’à ce qu’une condition change (saisie
while
utilisateur, calcul itératif)
Boucle “infinie” contrôlée par un break (menu, jeu) while True
Besoin de connaître la position ET la valeur for avec enumerate()

5. Programme simple vs programme plus complexe

5.1. Exemple simple : afficher les nombres pairs de 1 à 10

for nombre in range(1, 11):

if nombre % 2 == 0:
print(nombre)

5.2. Exemple plus complexe : une fonction qui traite une liste de
dictionnaires

def afficher_moyennes(etudiants):
"""etudiants est une liste de dictionnaires : [{"nom":..., "notes":[...]},
...]"""
for etudiant in etudiants:
nom = etudiant["nom"]
notes = etudiant["notes"]
total = 0
for note in notes: # boucle imbriquée dans la fonction
total += note
moyenne = total / len(notes)
print(f"{nom} : moyenne = {moyenne:.2f}")

etudiants = [
{"nom": "Alice", "notes": [15, 18, 12]},
{"nom": "Bob", "notes": [10, 9, 14]},
]
afficher_moyennes(etudiants)
# Alice : moyenne = 15.00
# Bob : moyenne = 11.00

Ce que cet exemple montre : une fonction combine une boucle for externe (sur la
liste des étudiants) et une boucle for interne (sur les notes de chaque étudiant) —
c’est le principe des boucles imbriquées appliqué à un cas réel.

6. Afficher les éléments d’une liste grâce à une

boucle

6.1. Affichage simple (sans position)

SOUMBOU IYO GILBERT JUDE GI1/B ECES

 fruits = ["pomme", "banane", "orange"]
for fruit in fruits:
print(fruit)

6.2. Affichage avec la position (méthode 1 : range(len(...)))

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

for i in range(len(fruits)):
print(f"Position {i} : {fruits[i]}")

6.3. Affichage avec la position (méthode 2 : enumerate(),

recommandée)

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

for i, fruit in enumerate(fruits):
print(f"Position {i} : {fruit}")

6.4. Affichage avec une boucle while

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

i = 0
while i < len(fruits):
print(f"Position {i} : {fruits[i]}")
i += 1

7. Afficher les éléments d’un dictionnaire grâce à

une boucle

etudiant = {"nom": "Alice", "age": 22, "ville": "Paris"}

for cle, valeur in [Link]():

print(f"{cle} -> {valeur}")
# nom -> Alice
# age -> 22
# ville -> Paris

7.1. Avec numérotation (position de la paire clé/valeur)

for position, (cle, valeur) in enumerate([Link]()):

print(f"{position} : {cle} = {valeur}")
# 0 : nom = Alice
# 1 : age = 22
# 2 : ville = Paris

8. Rechercher et récupérer un élément à la position

n dans une liste

8.1. Méthode directe (la plus simple)

SOUMBOU IYO GILBERT JUDE GI1/B ECES

 def element_a_position(liste, n):
if 0 <= n < len(liste):
return liste[n]
else:
return None

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

n = int(input("Quelle position voulez-vous afficher ? "))
resultat = element_a_position(fruits, n)
if resultat is not None:
print(f"L'élément à la position {n} est : {resultat}")
else:
print("Position invalide.")

8.2. Méthode « pédagogique » avec une boucle for et un compteur

Cette méthode montre comment on retrouverait l’élément sans utiliser directement

liste[n], en comptant les positions une par une :

def element_a_position_avec_boucle(liste, n):

compteur = 0
for element in liste:
if compteur == n:
return element
compteur += 1
return None # n dépasse la taille de la liste

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

print(element_a_position_avec_boucle(fruits, 2)) # orange

8.3. Même principe avec une boucle while

def element_a_position_while(liste, n):

i = 0
while i < len(liste):
if i == n:
return liste[i]
i += 1
return None

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

print(element_a_position_while(fruits, 3)) # kiwi

8.4. Version complète avec gestion des erreurs

def rechercher_dans_liste(liste):
try:
n = int(input("Entrez la position recherchée : "))
if n < 0 or n >= len(liste):
raise IndexError("Position hors limites")
print(f"Élément trouvé à la position {n} : {liste[n]}")
except ValueError:
print("Erreur : veuillez entrer un nombre entier.")
except IndexError as e:
print("Erreur :", e)

rechercher_dans_liste(["pomme", "banane", "orange"])

SOUMBOU IYO GILBERT JUDE GI1/B ECES

9. Rechercher et récupérer la n-ième paire d’un
dictionnaire

Un dictionnaire n’a pas d’index comme une liste, mais depuis Python 3.7, il conserve
l’ordre d’insertion des éléments. On peut donc accéder à la n-ième paire clé/valeur
de deux façons :

9.1. Méthode rapide : convertir en liste de tuples

def n_ieme_entree(dictionnaire, n):

entrees = list([Link]())
if 0 <= n < len(entrees):
return entrees[n]
return None

etudiant = {"nom": "Alice", "age": 22, "ville": "Paris"}

print(n_ieme_entree(etudiant, 1)) # ('age', 22)

9.2. Méthode « pédagogique » avec une boucle for et un compteur

def n_ieme_entree_boucle(dictionnaire, n):

compteur = 0
for cle, valeur in [Link]():
if compteur == n:
return (cle, valeur)
compteur += 1
return None

etudiant = {"nom": "Alice", "age": 22, "ville": "Paris"}

print(n_ieme_entree_boucle(etudiant, 2)) # ('ville', 'Paris')

9.3. Même principe avec une boucle while

def n_ieme_entree_while(dictionnaire, n):

cles = list([Link]())
i = 0
while i < len(cles):
if i == n:
cle = cles[i]
return (cle, dictionnaire[cle])
i += 1
return None

9.4. Version complète interactive avec gestion des erreurs

def rechercher_dans_dictionnaire(dictionnaire):
try:
n = int(input("Entrez la position recherchée : "))
entrees = list([Link]())
if n < 0 or n >= len(entrees):
raise IndexError("Position hors limites")
cle, valeur = entrees[n]
print(f"À la position {n} : {cle} = {valeur}")
except ValueError:
print("Erreur : veuillez entrer un nombre entier.")
except IndexError as e:
print("Erreur :", e)

SOUMBOU IYO GILBERT JUDE GI1/B ECES

 etudiant = {"nom": "Alice", "age": 22, "ville": "Paris"}
rechercher_dans_dictionnaire(etudiant)

10. Programme complet (fil rouge) combinant tout

Ce programme illustre l’utilisation conjointe des boucles for/while, des fonctions,

d’une liste et d’un dictionnaire, avec recherche par position et gestion des erreurs.

def afficher_liste_numerotee(liste):
for i, element in enumerate(liste):
print(f" [{i}] {element}")

def afficher_dictionnaire_numerote(dictionnaire):
for i, (cle, valeur) in enumerate([Link]()):
print(f" [{i}] {cle} = {valeur}")

def rechercher_position(collection, n):

"""Fonctionne pour une liste OU un dictionnaire."""
if isinstance(collection, dict):
entrees = list([Link]())
if 0 <= n < len(entrees):
return entrees[n]
return None
else:
if 0 <= n < len(collection):
return collection[n]
return None

def menu():
fruits = ["pomme", "banane", "orange", "kiwi"]
etudiant = {"nom": "Alice", "age": 22, "ville": "Paris"}

while True:
print("\\n--- MENU ---")
print("1. Afficher la liste de fruits")
print("2. Afficher le dictionnaire étudiant")
print("3. Rechercher un élément par position")
print("4. Quitter")
choix = input("Votre choix : ")

if choix == "1":
afficher_liste_numerotee(fruits)
elif choix == "2":
afficher_dictionnaire_numerote(etudiant)
elif choix == "3":
cible = input("Chercher dans (fruits/etudiant) : ")
try:
n = int(input("Position recherchée : "))
collection = fruits if cible == "fruits" else etudiant
resultat = rechercher_position(collection, n)
if resultat is not None:
print("Résultat :", resultat)
else:
print("Position invalide.")
except ValueError:
print("Veuillez entrer un nombre entier.")
elif choix == "4":
print("Au revoir !")
break

SOUMBOU IYO GILBERT JUDE GI1/B ECES

 else:
print("Choix invalide, réessayez.")

menu()

Ce que ce programme illustre : - une boucle while True pour un menu qui tourne
jusqu’à ce que l’utilisateur choisisse “Quitter” (break) ; - des boucles for avec
enumerate() pour afficher une liste et un dictionnaire numérotés ; - une fonction
générique rechercher_position() qui fonctionne aussi bien sur une liste que sur un
dictionnaire ; - une gestion des erreurs avec try/except pour éviter que le programme
plante si l’utilisateur entre une valeur incorrecte.

11. Utiliser 1, 2, 3 ou 4 boucles dans un même

programme

On peut combiner plusieurs boucles de deux façons différentes :

Boucles successives : les boucles se suivent, l’une après l’autre, sans lien entre
elles.
Boucles imbriquées : une boucle est placée à l’intérieur d’une autre ; à
chaque tour de la boucle extérieure, la boucle intérieure recommence
entièrement.

⚠ Chaque niveau d’imbrication supplémentaire multiplie le nombre total de

répétitions (2 boucles de 10 imbriquées = 100 répétitions, 3 boucles de 10 = 1000
répétitions, etc.). Il faut donc les utiliser avec prudence.

11.1. Utiliser 1 seule boucle

# Une seule boucle for

for i in range(1, 6):
print(i)
# 1 2 3 4 5

# Une seule boucle while (équivalent)

i = 1
while i <= 5:
print(i)
i += 1

Quand l’utiliser : pour un traitement simple, sur une seule dimension (une liste, un
intervalle…).

11.2. Utiliser 2 boucles

a) Deux boucles successives (indépendantes)

for i in range(1, 4):

print("Premier passage :", i)

for j in range(1, 4):

print("Deuxième passage :", j)

Quand l’utiliser : quand on doit faire deux traitements différents, l’un après l’autre,
sans rapport entre eux (ex: afficher d’abord tous les fruits, puis tous les prix).

SOUMBOU IYO GILBERT JUDE GI1/B ECES

b) Deux boucles imbriquées (une dans l’autre)

# Table de multiplication de 1 à 3
for i in range(1, 4):
for j in range(1, 4):
print(f"{i} x {j} = {i*j}")

Quand l’utiliser : pour parcourir un tableau à deux dimensions (une grille, une
matrice, un damier — voir exercice 98).

11.3. Utiliser 3 boucles

a) Trois boucles successives

for i in range(2):
print("Étape 1 :", i)
for j in range(2):
print("Étape 2 :", j)
for k in range(2):
print("Étape 3 :", k)

b) Trois boucles imbriquées

# Toutes les combinaisons possibles de 3 chiffres entre 0 et 1

for i in range(2):
for j in range(2):
for k in range(2):
print(i, j, k)
# 0 0 0
# 0 0 1
# 0 1 0
# 0 1 1
# 1 0 0
# 1 0 1
# 1 1 0
# 1 1 1

Quand l’utiliser : pour parcourir une structure à trois dimensions, ou générer toutes
les combinaisons de 3 éléments (voir aussi l’exercice 140 trouver_triplets_somme).
c) Mélange : 2 boucles imbriquées + 1 boucle successive

# 2 boucles imbriquées pour une grille

for i in range(2):
for j in range(2):
print(f"case ({i},{j})")

# puis 1 boucle indépendante pour un résumé

for message in ["Fin de la grille", "Traitement terminé"]:
print(message)

11.4. Utiliser 4 boucles

a) Quatre boucles imbriquées (exemple : table de vérité à 4 variables)

for a in range(2):
for b in range(2):
for c in range(2):
for d in range(2):

SOUMBOU IYO GILBERT JUDE GI1/B ECES

 print(a, b, c, d)
# 16 lignes au total (2 x 2 x 2 x 2 = 16 combinaisons)

Quand l’utiliser : rarement en pratique (le nombre d’itérations augmente très vite),
mais utile pour des combinaisons complètes (table de vérité, mot de passe à 4 chiffres,
génération de toutes les combinaisons de 4 éléments).
b) Quatre boucles en deux paires imbriquées successives

# Première paire imbriquée : affichage d'une petite grille

for i in range(2):
for j in range(2):
print(f"Grille A ({i},{j})")

# Deuxième paire imbriquée : affichage d'une autre grille

for x in range(2):
for y in range(2):
print(f"Grille B ({x},{y})")

Quand l’utiliser : quand un programme doit traiter deux structures à deux

dimensions différentes, l’une après l’autre (ex: deux matrices distinctes).

11.5. Tableau récapitulatif

Nombre de
Organisation possible Exemple d’usage
boucles
1 boucle unique afficher une liste
table de multiplication
2 successives ou imbriquées
(imbriquées)
combinaisons de 3 éléments
3 successives, imbriquées, ou mélange
(imbriquées)
4 imbriquées, ou 2 paires imbriquées
4 table de vérité à 4 variables
successives

12. Le mot-clé break : toutes les manières de

l’utiliser et sa portée

12.1. break basique dans une boucle for

for i in range(10):
if i == 5:
break
print(i)
# Affiche : 0 1 2 3 4 (s'arrête avant d'afficher 5)

Quand l’utiliser : pour arrêter une boucle dès qu’une condition précise est atteinte.

12.2. break dans une boucle while True (menu interactif)

while True:
reponse = input("Tapez 'stop' pour arrêter : ")
if reponse == "stop":
break
print("Vous avez tapé :", reponse)

SOUMBOU IYO GILBERT JUDE GI1/B ECES

Quand l’utiliser : pour transformer une boucle sans fin en boucle contrôlée par
l’utilisateur.

12.3. La portée de break : il n’arrête que la boucle la plus proche

C’est l’erreur la plus fréquente chez les débutants : break n’arrête que la boucle
immédiatement englobante (la boucle intérieure), pas les boucles extérieures.

for i in range(3):
print("Tour extérieur :", i)
for j in range(3):
if j == 1:
break # arrête SEULEMENT la boucle "for j"
print(" Tour intérieur :", j)
# Tour extérieur : 0
# Tour intérieur : 0
# Tour extérieur : 1
# Tour intérieur : 0
# Tour extérieur : 2
# Tour intérieur : 0

À retenir : la boucle extérieure (for i) continue normalement malgré le break dans

la boucle intérieure (for j).

12.4. Sortir de plusieurs boucles imbriquées à la fois avec un

drapeau (flag)

Python ne permet pas de “casser” directement deux boucles à la fois. On utilise alors
une variable booléenne (un “drapeau”) :

trouve = False
for i in range(5):
for j in range(5):
if i * j == 6:
trouve = True
break # sort de la boucle "for j"
if trouve:
break # sort aussi de la boucle "for i"
print(f"Trouvé à i={i}, j={j}")

12.5. Sortir de plusieurs boucles avec return (méthode

recommandée)

Quand les boucles imbriquées sont placées dans une fonction, on peut utiliser return
pour sortir instantanément de toutes les boucles en une seule instruction — plus
propre que les drapeaux :

def trouver_produit(cible, limite):

for i in range(limite):
for j in range(limite):
if i * j == cible:
return (i, j) # sort de TOUTES les boucles d'un coup
return None

print(trouver_produit(6, 5)) # (1, 6) ou une autre paire valide

Quand l’utiliser : dès que des boucles imbriquées sont dans une fonction et qu’on
veut arrêter toute la recherche dès qu’un résultat est trouvé.

SOUMBOU IYO GILBERT JUDE GI1/B ECES

12.6. break pour une recherche (s’arrêter dès qu’un élément est
trouvé)

def rechercher_element(liste, element):

for i, valeur in enumerate(liste):
if valeur == element:
print(f"Élément trouvé à la position {i}")
break
else:
print("Élément non trouvé")

rechercher_element(["pomme", "banane", "orange"], "banane")

# Élément trouvé à la position 1

Quand l’utiliser : pour ne pas continuer à parcourir une liste inutilement une fois
l’élément trouvé (gain de performance).

12.7. break combiné avec for...else / while...else

Le bloc else d’une boucle ne s’exécute que si break n’a jamais été déclenché :

for i in range(10):
if i == 15: # condition jamais vraie ici
break
else:
print("Aucun break déclenché : la boucle est allée jusqu'au bout")
# Affiche bien le message, car le break n'a jamais eu lieu

Quand l’utiliser : pour savoir si une recherche a abouti (break déclenché) ou non (le
else s’exécute).

12.8. Récapitulatif sur break

Situation Effet de break

Une seule boucle arrête complètement la boucle
arrête uniquement la boucle la plus
Boucles imbriquées
intérieure
nécessite un drapeau, ou un return dans
Sortir de plusieurs boucles imbriquées
une fonction
le bloc else est ignoré si break a été
Utilisé avec for...else / while...else
exécuté

13. Résumé à retenir

for : idéal pour parcourir une collection connue (liste, dictionnaire, chaîne, tuple,
ensemble, range()).
while : idéal pour répéter tant qu’une condition est vraie (saisie utilisateur,
menu, calcul itératif).
enumerate() donne à la fois la position et la valeur dans une boucle for.
Pour une liste, l’accès à la position n se fait directement avec liste[n], ou via
une boucle avec un compteur si l’on veut comprendre le mécanisme.
Pour un dictionnaire, il n’y a pas d’index direct : on utilise
list([Link]())[n], ou une boucle avec compteur.
Toujours protéger l’accès à une position avec une vérification (if 0 <= n <

SOUMBOU IYO GILBERT JUDE GI1/B ECES

len(...)) ou un try/except pour éviter une erreur IndexError.

SOUMBOU IYO GILBERT JUDE GI1/B ECES