Boucles pour, tant que et répéter

Une boucle répète un bloc d'instructions : un nombre de fois connu à l'avance avec la boucle Pour, ou tant qu'une condition reste vraie avec la boucle TantQue et sa variante Répéter … Jusqu'à. Ce chapitre montre comment choisir la bonne boucle, comment la construire (initialisation, mise à jour, résultat final) et comment éviter la boucle infinie et l'erreur d'un tour en trop.

Pourquoi des boucles ?

Afficher les nombres de 1 à 5, tu peux l'écrire en cinq lignes. De 1 à 1 000, non. Et compter les tickets d'un fichier dont tu ne connais pas la taille, c'est impossible sans boucle. Une boucle décrit une fois un traitement qui s'exécutera autant de fois que nécessaire.

Chaque passage dans le corps de la boucle s'appelle une itération (ou un tour). Le programme du BTS insiste : les structures de contrôle sont le cœur de l'algorithmique, et les évaluations sont centrées sur elles. Ce chapitre est le plus important du cours.

La boucle Pour

La boucle Pour répète un bloc pour chaque valeur d'un compteur, d'une valeur de départ à une valeur d'arrivée. On l'utilise quand le nombre de tours est connu avant d'entrer dans la boucle.

Pour i de 1 à 5 Faire
    Afficher(i, " × 7 = ", i × 7)
FinPour

for i in range(1, 6):
    print(i, "× 7 =", i * 7)

1 × 7 = 7
2 × 7 = 14
3 × 7 = 21
4 × 7 = 28
5 × 7 = 35

À chaque tour, le compteur prend la valeur suivante, automatiquement. Tu n'écris jamais i ← i + 1 dans une boucle Pour.

En pseudo-code, les deux bornes sont incluses : Pour i de 1 à 5 fait 5 tours. En Python, range(début, fin) s'arrête avant fin : pour aller de 1 à 5, on écrit range(1, 6). C'est la source n° 1 des erreurs de traduction.

Python sait aussi parcourir directement les éléments d'une liste ou les caractères d'une chaîne, sans compteur :

for serveur in ["web01", "web02", "bdd01"]:
    print("Sauvegarde de", serveur)
for lettre in "SIO":
    print(lettre)

C'est la forme à privilégier quand tu n'as pas besoin de la position. Les deux formes de parcours d'un tableau sont comparées au chapitre 7.

La boucle TantQue

La boucle TantQue répète un bloc tant qu'une condition est vraie. La condition est testée avant chaque tour : si elle est fausse dès le départ, le bloc n'est jamais exécuté. On l'utilise quand on ne sait pas à l'avance combien de tours il faudra.

Un capital de 1 000 € est placé à 3 % par an. Au bout de combien d'années aura-t-il doublé ?

Algorithme Doublement
Variables
    capital : réel
    annees : entier
Début
    capital ← 1000
    annees ← 0
    TantQue capital < 2000 Faire
        capital ← capital × 1,03
        annees ← annees + 1
    FinTantQue
    Afficher(annees, " ans, capital : ", capital)
Fin

capital = 1000.0
annees = 0
while capital < 2000:
    capital = capital * 1.03
    annees = annees + 1
print(annees, "ans, capital :", round(capital, 2))

24 ans, capital : 2032.79

Impossible d'écrire une boucle Pour ici : le nombre d'années est justement ce qu'on cherche.

Trois éléments doivent être présents dans toute boucle TantQue :

1. L'initialisation des variables de la condition, avant la boucle (capital ← 1000).
2. La condition, testée à chaque tour (capital < 2000).
3. La mise à jour, dans le corps, d'au moins une variable de la condition, pour que celle-ci finisse par devenir fausse (capital ← capital × 1,03).

La boucle Répéter … Jusqu'à

La boucle Répéter exécute le bloc puis teste la condition. Le bloc est donc exécuté au moins une fois. Attention au sens : on répète jusqu'à ce que la condition soit vraie ; c'est une condition d'arrêt, l'inverse de celle du TantQue.

L'usage typique est la saisie contrôlée : on demande une valeur, et on redemande tant qu'elle est invalide.

Répéter
    Afficher("Note entre 0 et 20 ?")
    Saisir(note)
Jusqu'à note ≥ 0 ET note ≤ 20

Python n'a pas de boucle Répéter. On l'écrit avec une boucle while True (infinie en apparence) dont on sort par break quand la condition d'arrêt est vraie :

while True:
    note = float(input("Note entre 0 et 20 ? "))
    if 0 <= note <= 20:
        break
print("Note enregistrée :", note)

On peut aussi écrire un TantQue avec une première saisie avant la boucle. C'est un peu plus long, mais sans break :

note = float(input("Note entre 0 et 20 ? "))
while note < 0 or note > 20:
    print("Valeur incorrecte.")
    note = float(input("Note entre 0 et 20 ? "))
print("Note enregistrée :", note)

Remarque comment la condition s'inverse en passant d'une version à l'autre : on répète jusqu'à 0 ≤ note ≤ 20, c'est-à-dire tant que note < 0 OU note > 20 (loi de De Morgan, chapitre 2).

TantQue ou Répéter : le test avant ou après

Choisir la bonne boucle

Toute boucle Pour peut s'écrire avec un TantQue (on gère le compteur à la main), mais pas l'inverse. Utilise quand même le Pour dès que c'est possible : il est plus court et il ne peut pas boucler à l'infini.

# La même boucle, deux écritures
for i in range(1, 6):
    print(i)

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

Construire une itération

Le programme décrit la construction d'une boucle en trois temps : la préparation (initialiser les variables), l'itération elle-même (la mise à jour à chaque tour) et la mise en forme finale (ce qu'on fait du résultat après la boucle). Applique-les dans cet ordre et la plupart des boucles s'écrivent seules.

Exemple : la moyenne de n notes saisies.

// Préparation
somme ← 0
// Itération
Pour i de 1 à n Faire
    Saisir(note)
    somme ← somme + note
FinPour
// Mise en forme finale
moyenne ← somme / n
Afficher(moyenne)

Une aide pour vérifier une boucle : formuler ce qui est vrai à la fin de chaque tour. Ici : « après le tour i, somme contient la somme des i premières notes ». Si c'est vrai au premier tour, et que chaque tour le conserve, c'est vrai au dernier : somme contient la somme des n notes. Cette phrase s'appelle un invariant de boucle. On ne te demandera pas de démonstration, mais la formuler dans ta tête te dit tout de suite si l'initialisation est la bonne.

Accumulateurs : somme, produit, compteur

Trois motifs reviennent dans presque tous les exercices. Ils s'appuient tous sur une affectation récursive : la variable est mise à jour à partir de sa propre valeur.

Les symboles Σ (somme) et Π (produit) des maths se traduisent directement par ces motifs. La somme des entiers de 1 à n, Σ i, et la factorielle n! = Π i = 1 × 2 × … × n :

n = 100
somme = 0
for i in range(1, n + 1):
    somme = somme + i
print("Somme de 1 à", n, ":", somme)

n = 5
produit = 1
for i in range(1, n + 1):
    produit = produit * i
print(n, "! =", produit)

Somme de 1 à 100 : 5050
5 ! = 120

Python a des raccourcis : somme += i équivaut à somme = somme + i (de même -=, *=, //=). Ils sont courants en Python, en C# et en JavaScript ; en pseudo-code, écris l'affectation complète.

Les boucles imbriquées

Une boucle peut en contenir une autre. Pour chaque tour de la boucle externe, la boucle interne fait tous ses tours. Si l'externe fait n tours et l'interne m, le corps interne s'exécute n × m fois.

for i in range(1, 4):
    ligne = ""
    for j in range(1, 6):
        ligne = ligne + str(i * j) + "\t"
    print(ligne)

1	2	3	4	5
2	4	6	8	10
3	6	9	12	15

"\t" est une tabulation, qui aligne les colonnes. La variable ligne est réinitialisée à chaque tour de la boucle externe : chaque ligne repart de zéro.

Les bornes de la boucle interne peuvent dépendre du compteur externe. Le programme cite explicitement ce cas (« itérations en dépendance »), en le limitant à deux niveaux :

n = 4
for i in range(1, n + 1):
    print("*" * i)

*
**
***
****

Ici la boucle interne est cachée dans "*" * i (répéter i fois). Écrite explicitement, elle fait i tours au tour i : 1 + 2 + 3 + 4 = 10 étoiles en tout.

Sortir d'une boucle : break et continue

Python propose deux instructions pour modifier le déroulement d'une boucle :

• break sort immédiatement de la boucle ;
• continue passe directement au tour suivant.

tickets = [12, 0, 7, -1, 3]
for t in tickets:
    if t < 0:
        print("Valeur sentinelle : arrêt")
        break
    if t == 0:
        continue
    print("Ticket", t)

Ticket 12
Ticket 7
Valeur sentinelle : arrêt

Elles sont pratiques, mais elles cachent la condition de sortie au milieu du corps. En pseudo-code d'examen, préfère une condition de boucle explicite (un TantQue avec un booléen trouve, par exemple) ; garde break pour la boucle Répéter traduite en Python.

Les erreurs classiques

Le dernier piège des réels mérite un exemple : en ajoutant 0,1 dix fois à 0, on n'obtient pas exactement 1.

x = 0.0
for i in range(10):
    x = x + 0.1
print(x, x == 1.0)

0.9999999999999999 False

Une boucle while x != 1.0: x = x + 0.1 ne s'arrêterait donc jamais. Utilise un compteur entier (for i in range(10)) ou une comparaison while x < 1.0.

Exercices

# A
k = 0
for i in range(3, 9):
    k = k + 1

# B
k = 1
while k < 100:
    k = k * 3

# C
k = 10
while k > 10:
    k = k - 1

nb = 0
total = 0.0
montant = float(input("Montant (0 pour finir) ? "))
while montant != 0:
    nb = nb + 1
    total = total + montant
    montant = float(input("Montant (0 pour finir) ? "))
if nb > 0:
    print(nb, "frais, total", total, "- moyenne", round(total / nb, 2))
else:
    print("Aucun frais saisi")

nb ← 0
TantQue n > 0 Faire
    n ← n DIV 10
    nb ← nb + 1
FinTantQue
Afficher(nb)

n = 0
nb = 0
while True:
    n = n // 10
    nb = nb + 1
    if n == 0:
        break
print(nb)

import random

secret = random.randint(1, 100)
essais = 0
while True:
    proposition = int(input("Ton nombre ? "))
    essais = essais + 1
    if proposition < secret:
        print("plus grand")
    elif proposition > secret:
        print("plus petit")
    else:
        break
print("Trouvé en", essais, "essais")

a = 0
b = 1
for i in range(10):
    print(a, end=" ")
    suivant = a + b
    a = b
    b = suivant
print()

0 1 1 2 3 5 8 13 21 34

1
1 2
1 2 3
1 2 3 4

n = 4
for i in range(1, n + 1):
    for j in range(1, i + 1):
        print(j, end=" ")
    print()

n = int(input("n ? "))
etapes = 0
while n != 1:
    if n % 2 == 0:
        n = n // 2
    else:
        n = 3 * n + 1
    etapes = etapes + 1
print(etapes, "étapes")