Structures itératives complètes : Pour…Faire

Plan de cours

Faire la même chose 100 fois — sans réécrire 100 lignes

La boucle est l'invention qui transforme un calcul long et répétitif en une instruction concise. Cette leçon vous donne le réflexe : dès que vous voyez "répéter pour chaque…", c'est une boucle Pour.

Concepts clés

1. Itération complète — le nombre de répétitions est connu à l'avance.
2. Compteur — variable qui prend successivement les valeurs de l'intervalle.
3. Accumulateur — variable qui stocke le résultat partiel à chaque tour.
4. Boucle imbriquée — une boucle à l'intérieur d'une autre, pour les structures 2D.

Avant de commencer — qu'est-ce que vous savez déjà ?

• Q1. Combien d'itérations effectue Pour i de 1 à 10 Faire ?
• Q2. Quelle est la valeur de S après S ← 0 puis S ← S + 1 répété 5 fois ?
• Q3. En Python, que produit range(1, 6) ?

Q3 est l'angle mort des élèves de 4ème : range(1, 6) donne [1, 2, 3, 4, 5] — la borne supérieure est exclue. Retenez-le maintenant, vous économiserez des heures de débogage.

1. Le contenu du cours

1.1 Analogie : la file de courriers

Imaginez un secrétaire qui doit tamponner 50 enveloppes. Au lieu d'écrire 50 instructions identiques, il automatise :

Pour chaque enveloppe de la pile, tamponner et passer à la suivante.

Une boucle Pour, c'est exactement ce mécanisme : un compteur (numéro de l'enveloppe) qui avance pas à pas, et un corps (l'action de tamponner) qui s'exécute à chaque pas.

1.2 La structure Pour…Faire

Forme algorithmique

Pour compteur de valeur_debut à valeur_fin [Pas n] Faire
    instructions
FinPour

• compteur : variable de type entier qui prend successivement chaque valeur.
• valeur_debut, valeur_fin : bornes incluses.
• Pas n (optionnel) : incrément. Par défaut, le pas est de 1.

Forme Python

for compteur in range(valeur_debut, valeur_fin + 1):
    instructions

1.3 Premier exemple — Afficher les 10 premiers entiers

Pour i de 1 à 10 Faire
    Écrire(i)
FinPour

Pour i de 1 à 10 Faire
    Écrire(i)
FinPour

for i in range(1, 11):
    print(i)

Trace mentale. i vaut 1, on affiche 1. i devient 2, on affiche 2. … i devient 10, on affiche 10. À 11, on sort.

1.4 Le motif « accumulateur »

L'usage le plus fréquent : calculer une somme, un produit, un compte, un maximum… en parcourant une plage.

Recette en 3 étapes :

1. Initialiser l'accumulateur avant la boucle.
2. Dans la boucle, mettre à jour l'accumulateur à partir du compteur.
3. Utiliser l'accumulateur après la boucle.

Exemple — Somme des 100 premiers entiers

0) Début somme_100
1) S ← 0                  { initialisation de l'accumulateur }
2) Pour i de 1 à 100 Faire
       S ← S + i           { mise à jour }
   FinPour
3) Écrire("Somme = ", S)   { utilisation après la boucle }
4) Fin somme_100

0) Début somme_100
1) S ← 0                  { initialisation de l'accumulateur }
2) Pour i de 1 à 100 Faire
       S ← S + i           { mise à jour }
   FinPour
3) Écrire("Somme = ", S)   { utilisation après la boucle }
4) Fin somme_100

S = 0
for i in range(1, 101):
    S = S + i
print("Somme =", S)
# Affiche : Somme = 5050

Valeurs initiales selon l'opération :

1.5 Boucle avec pas négatif

Pour parcourir de la fin vers le début :

Pour i de 10 à 1 Pas -1 Faire
    Écrire(i)
FinPour

Pour i de 10 à 1 Pas -1 Faire
    Écrire(i)
FinPour

for i in range(10, 0, -1):
    print(i)

1.6 Boucles imbriquées

Une boucle peut en contenir une autre. Le compteur extérieur change lentement, l'intérieur rapidement.

Exemple — Table de multiplication 5×5

for i in range(1, 6):
    for j in range(1, 6):
        print(i * j, end="\t")   # \t = tabulation
    print()                       # retour à la ligne en fin de ligne

Sortie :

1	2	3	4	5
2	4	6	8	10
3	6	9	12	15
4	8	12	16	20
5	10	15	20	25

Pour chaque valeur de i (extérieur), j parcourt entièrement [1..5] (intérieur). Total : 25 multiplications.

1.7 Trace d'exécution — Factorielle de 5

2. Exercices pratiques

Niveau Débutant — Type bac courant

S = 0
for i in range(1, 21):
    if i % 2 == 0:
        S = S + i
print("Somme des pairs =", S)

S = 0
for i in range(2, 21, 2):   # 2, 4, 6, ..., 20
    S = S + i
print("Somme des pairs =", S)

Niveau Intermédiaire — Type bac difficile

a = int(input("a = "))
b = int(input("b = "))

nb = 0      # compteur
somme = 0   # accumulateur

for i in range(a, b + 1):
    if i % 7 == 0:
        nb = nb + 1
        somme = somme + i

print("Nombre de multiples de 7 :", nb)
print("Somme :", somme)

Niveau Avancé — Hors bac (bonus)

   *
  ***
 *****
*******

n = int(input("n = "))

for k in range(1, n + 1):
    espaces = " " * (n - k)
    etoiles = "*" * (2 * k - 1)
    print(espaces + etoiles)

⚠️ Erreurs fréquentes au bac

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

• Erreur 1. range(1, N) au lieu de range(1, N+1) : on oublie le dernier élément. Python exclut la borne supérieure.
• Erreur 2. Oublier d'initialiser l'accumulateur avant la boucle (somme ← 0). Sans cette ligne, erreur à la première itération.
• Erreur 3. Modifier la variable de boucle dans le corps (Pour i ... i ← i + 5). Comportement imprévisible.
• Erreur 4. Confondre Pour i De 1 À N Faire (1 à N inclus) et for i in range(N) (0 à N-1).

3. Quiz de vérification

En résumé

Avant la leçon 1.4 (Fonctions prédéfinies), assurez-vous de pouvoir :

• ✅ Compter exactement le nombre d'itérations d'une boucle Pour,
• ✅ Choisir la bonne valeur initiale d'un accumulateur (0 pour somme, 1 pour produit, etc.),
• ✅ Traduire de l'algorithmique au Python sans oublier le +1 sur la borne supérieure,
• ✅ Lire une trace d'exécution sans erreur de pas.

Sinon, refaites l'exercice 2 avec différentes valeurs de a et b, et vérifiez à la main.