Boucles for et while

2. Parcourir par élément ou par indice

Quand on a une liste, il existe deux façons de la parcourir avec un for. Bien les distinguer évite de gros malentendus.

notes = [12, 8, 15]

# (A) parcours PAR ELEMENT : x prend directement les valeurs
for note in notes:
    print(note)            # 12, puis 8, puis 15

# (B) parcours PAR INDICE : i prend les positions 0, 1, 2
for i in range(len(notes)):
    print(i, notes[i])     # 0 12 / 1 8 / 2 15

3. La boucle while

while condition: répète le bloc tant que la condition est vraie. Trois ingrédients sont toujours présents : une initialisation avant la boucle, une condition d'arrêt testée à chaque tour, et une progression dans le corps qui rapproche la condition de « faux ». Oublie la progression et la boucle tourne à l'infini.

n = 1
while n < 100:
    n = n * 2
print(n)          # 128

valeurs = [4, 7, 2, -1, 9]
i = 0
somme = 0
while valeurs[i] != -1:      # -1 est la sentinelle : elle arrete le parcours
    somme = somme + valeurs[i]
    i = i + 1
print(somme)                 # 4 + 7 + 2 = 13

4. Le motif de l'accumulateur

Un accumulateur est une variable initialisée avant la boucle, puis mise à jour à chaque tour pour « accumuler » un résultat. Quatre usages reviennent sans arrêt : la somme, le comptage, le produit et le maximum. À chaque fois, la clé est de bien choisir la valeur de départ.

# SOMME : on part de 0 (element neutre de l'addition)
somme = 0
for i in range(1, 5):
    somme = somme + i
print(somme)      # 1 + 2 + 3 + 4 = 10

# PRODUIT (factorielle) : on part de 1 (element neutre du produit)
produit = 1
for i in range(1, 6):
    produit = produit * i
print(produit)    # 1 * 2 * 3 * 4 * 5 = 120

Deux variantes très courantes : compter les éléments qui vérifient une condition, et trouver le maximum.

notes = [12, 8, 15, 6, 11]

# COMPTAGE : combien de notes >= 10 ?
compteur = 0
for note in notes:
    if note >= 10:
        compteur = compteur + 1
print(compteur)   # 12, 15, 11 -> 3

# MAXIMUM : la meilleure note
maxi = notes[0]
for note in notes:
    if note > maxi:
        maxi = note
print(maxi)       # 15

5. Maîtriser le flux : break, continue et boucle infinie

Deux mots-clés permettent de piloter finement une boucle : break pour en sortir immédiatement, et continue pour passer directement au tour suivant. Bien utilisés, ils rendent le code plus clair ; mal maîtrisés, ils créent des boucles infinies.

# break : on sort de la boucle des que i vaut 3
for i in range(10):
    if i == 3:
        break
    print(i)          # 0, 1, 2  (puis on sort, on n'affiche PAS 3)

# continue : on saute l'affichage pour les nombres pairs
for i in range(6):
    if i % 2 == 0:
        continue
    print(i)          # 1, 3, 5

Un idiome très répandu combine while True (boucle « toujours vraie ») avec un break qui fournit la vraie condition d'arrêt à l'intérieur.

n = 1
while True:
    print(n)
    n = n + 1
    if n > 3:
        break         # LA condition de sortie est ici
print("fini")         # affiche 1, 2, 3 puis "fini"

6. Exercices d'application

À faire de tête (ou sur brouillon) avant d'ouvrir le corrigé.

n = 5
somme = 0
for i in range(1, n + 1):
    somme = somme + i
print(somme)

liste = [3, 7, 9, 4, 12, 5]
compteur = 0
for x in liste:
    if x % 3 == 0:
        compteur = compteur + 1
print(compteur)

n = 10
c = 0
while n > 1:
    n = n // 2
    c = c + 1
print(c)

7. Erreurs classiques (les pièges qui coûtent des points)

Ces quatre erreurs reviennent dans presque toutes les copies. Les connaître à l'avance, c'est déjà la moitié du travail.

8. Pour aller plus loin

Les boucles sont la brique de base : presque tout le reste de l'informatique de prépa les réinvestit. Voici trois chapitres où tu les retrouveras immédiatement.

• Fonctions — pour encapsuler une boucle réutilisable (une fonction somme(liste) ou maximum(liste)) et lui donner un nom.
• Listes et chaînes de caractères — le terrain de jeu naturel du parcours par élément et par indice, et de tous les motifs d'accumulateur.
• Recherche par dichotomie — un while qui divise l'intervalle par deux à chaque tour : l'exemple type d'une boucle dont on doit prouver qu'elle termine.