La structure Tant que…Faire

Plan de cours

Tester d'abord, agir ensuite : le contrat strict

Deuxième structure itérative à condition d'arrêt, Tant que est sans doute la plus polyvalente. À la différence de Répéter, elle peut ne pas exécuter le corps du tout.

Concepts clés

1. Test avant action : la condition est évaluée au début.
2. Condition de continuation (vrai = on continue, faux = on sort).
3. Traduction directe : Tant que ↔ while (Python).
4. Boucle infinie : risque majeur si la condition ne change jamais.

Avant de commencer

• Q1. Si la condition d'un Tant que est fausse au premier test, combien de fois le corps s'exécute-t-il ?
• Q2. Quelle est la différence entre une condition d'arrêt et une condition de continuation ?
• Q3. Qu'est-ce qu'une « boucle infinie » ?

1. Le contenu du cours

1.1 Analogie : la file d'attente

Vous arrivez à un guichet :

Tant qu'il reste des personnes devant vous, attendre.

Si vous arrivez et qu'il n'y a personne devant vous, vous n'attendez pas du tout. C'est exactement le contrat de Tant que…Faire : la condition est testée avant d'entrer dans la boucle.

1.2 La structure Tant que

Forme algorithmique

Tant que condition_de_continuation Faire
    instructions
FinTantQue

Sémantique :

1. Évaluer condition_de_continuation.
2. Si faux → sortir sans exécuter le corps.
3. Si vrai → exécuter instructions puis retourner en 1.

1.3 Traduction Python directe

Python a un while natif équivalent terme à terme :

i ← 1
Tant que i <= 5 Faire
    Écrire(i)
    i ← i + 1
FinTantQue

i ← 1
Tant que i <= 5 Faire
    Écrire(i)
    i ← i + 1
FinTantQue

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

Sortie : 1 2 3 4 5. Quand i devient 6, la condition i <= 5 devient fausse → sortie.

1.4 Le piège classique : la boucle infinie

Une boucle infinie se produit quand la condition de continuation ne devient jamais fausse. Ces deux exemples bouclent à l'infini :

# Cas 1 : on oublie de mettre à jour la variable de la condition
i = 1
while i <= 5:
    print(i)
    # i = i + 1  ← OUBLIÉ !

# Cas 2 : on modifie dans le mauvais sens
i = 1
while i <= 5:
    print(i)
    i = i - 1   # devrait être i + 1

1.5 Cas canonique : itération sur une condition complexe

Exemple — Compter les chiffres d'un entier positif

n = int(input("Entier > 0 : "))
nb_chiffres = 0

while n > 0:
    n = n // 10        # division entière par 10
    nb_chiffres = nb_chiffres + 1

print("Nombre de chiffres :", nb_chiffres)

Trace avec n = 4789 :

4789 contient 4 chiffres ✓

1.6 Trace d'exécution interactive

1.7 Tant que vs Répéter — comparaison serrée

2. Exercices pratiques

Niveau Débutant — Type bac courant

S = 0
n = int(input("Entier (0 pour finir) : "))

while n != 0:
    S = S + n
    n = int(input("Entier (0 pour finir) : "))

print("Somme =", S)

Niveau Intermédiaire — Type bac difficile

n = int(input("Entier > 0 : "))
inverse = 0

while n > 0:
    chiffre = n % 10
    inverse = inverse * 10 + chiffre
    n = n // 10

print("Inverse :", inverse)

Niveau Avancé — Hors bac (bonus)

n = int(input("n > 0 : "))
etapes = 0
maximum = n

print(n, end=" ")

while n != 1:
    if n % 2 == 0:
        n = n // 2
    else:
        n = 3 * n + 1
    
    etapes = etapes + 1
    if n > maximum:
        maximum = n
    
    print(n, end=" ")

print()  # retour à la ligne final
print(f"{etapes} étapes, maximum atteint : {maximum}")

6 3 10 5 16 8 4 2 1
8 étapes, maximum atteint : 16

27 82 41 124 62 31 ... 1
111 étapes, maximum atteint : 9232

⚠️ Erreurs fréquentes au bac

Avant le quiz, mémorisez ces pièges classiques qui font perdre des points :

• Erreur 1. Oublier d'initialiser la variable testée AVANT le Tant que. Sinon NameError au premier test.
• Erreur 2. Mise à jour de la variable manquante dans le corps → boucle infinie classique.
• Erreur 3. Confondre Tant que x ≠ 0 (continue tant que x non-nul) et Tant que x = 0 (continue tant que x nul). Sens opposés.
• Erreur 4. Penser que le corps s'exécute au moins une fois. FAUX : si la condition est fausse au départ, 0 exécution.

3. Quiz de vérification

En résumé

Avant la leçon 2.3 (Comment choisir entre Pour, Tant que et Répéter), assurez-vous de :

• ✅ Reconnaître qu'une boucle Tant que peut ne jamais s'exécuter,
• ✅ Détecter une potentielle boucle infinie en relisant un code,
• ✅ Traduire fluidement entre Tant que algorithmique et while Python,
• ✅ Savoir utiliser une valeur sentinelle pour signaler la fin de saisie.

La prochaine leçon vous donnera un arbre de décision clair pour choisir la bonne structure de boucle face à un énoncé.