Qu'est-ce que l'itération ?

Un programme qui envoie un e-mail de rappel à 10 000 utilisateurs ne contient pas 10 000 copies du code d'envoi. Il contient ce code une seule fois, dans une boucle, et la boucle l'exécute une fois par utilisateur. Chaque exécution est une itération, et la boucle dans son ensemble est la façon dont le programme itère sur ses utilisateurs.

Comment fonctionne l'itération, étape par étape

Chaque boucle suit le même cycle :

1. Vérifier. Tester la condition de la boucle, qui est un booléen : reste-t-il un élément, ou le compteur est-il toujours sous la limite ?
2. Exécuter. Si la réponse est vraie, exécuter une fois le corps de la boucle.
3. Mettre à jour. Passer à l'élément suivant ou modifier le compteur.
4. Recommencer. Revenir à l'étape 1. Quand la vérification donne faux, le programme continue avec le code situé après la boucle.

Ici, le corps s'exécute cinq fois, et chaque itération ajoute le nombre suivant à un total cumulé :

total = 0

for n in range(1, 6):
    total = total + n
    print("iteration", n, "total is now", total)

print("Done:", total)

iteration 1 total is now 1
iteration 2 total is now 3
iteration 3 total is now 6
iteration 4 total is now 10
iteration 5 total is now 15
Done: 15

La variable total existe en dehors de la boucle, elle garde donc sa valeur d'une itération à l'autre. Ce schéma, une variable définie avant la boucle et mise à jour à l'intérieur, s'appelle un accumulateur, et on le retrouve dans presque toutes les boucles qui calculent quelque chose.

Boucles à compteur et boucles à condition

Il existe deux sortes d'itération. L'itération définie s'exécute un nombre de fois connu : une fois par élément d'une liste, ou une fois pour chaque nombre de 1 à 5. La boucle for de Python est faite pour cela, souvent avec range().

L'itération indéfinie se répète jusqu'à ce que quelque chose se produise, et le nombre de passages n'est pas connu à l'avance. Une boucle while convient à ce cas :

balance = 100
years = 0

while balance < 200:
    balance = balance * 1.10
    years = years + 1

print(years, "years, balance", round(balance, 2))

8 years, balance 214.36

Une somme qui augmente de 10 % par an met 8 ans à doubler. Le programme l'a découvert en itérant, pas en résolvant une équation. Les guides boucles for et boucles while couvrent les deux en Python.

Parcourir une collection

La plupart des boucles parcourent une collection : les éléments d'un tableau, les caractères d'une chaîne, les lignes d'un fichier. La boucle for de Python te donne directement chaque élément, et enumerate() y ajoute sa position :

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

En coulisses, for demande à la collection un itérateur avec iter(), puis appelle next() sur celui-ci une fois par itération. Tu peux faire les mêmes appels toi-même :

colors = ["red", "green", "blue"]

it = iter(colors)
print(next(it))
print(next(it))
print(next(it))
print(next(it, "no more items"))

red
green
blue
no more items

Sans la valeur par défaut, le quatrième next() lève StopIteration. Cette exception est le signal qu'utilise une boucle for pour savoir que la collection est terminée.

D'autres langages écrivent la même idée différemment. C compte avec un indice, tandis que Java et JavaScript ont aussi une boucle qui te donne chaque élément :

for (int i = 0; i < 3; i++) {
    printf("%s\n", colors[i]);
}

for (String color : colors) {
    System.out.println(color);
}

for (const color of colors) {
    console.log(color);
}

Itération et récursivité

La récursivité est l'autre façon de répéter un travail : une fonction s'appelle elle-même sur une version plus petite du problème jusqu'à atteindre un cas qu'elle sait résoudre directement. Tout ce qui s'écrit avec l'une peut s'écrire avec l'autre, mais elles se comportent différemment :

La ligne sur la mémoire compte en pratique. Python autorise environ 1000 appels imbriqués par défaut, donc une somme récursive de 5000 nombres échoue là où une boucle n'a aucun problème :

def sum_loop(n):
    total = 0
    for k in range(1, n + 1):
        total = total + k
    return total

def sum_recursive(n):
    if n == 0:
        return 0
    return n + sum_recursive(n - 1)

print(sum_loop(100), sum_recursive(100))
print(sum_loop(5000))

try:
    print(sum_recursive(5000))
except RecursionError:
    print("sum_recursive(5000) failed: RecursionError")

5050 5050
12502500
sum_recursive(5000) failed: RecursionError

La visualisation de la récursivité montre la pile d'appels qui grandit et rétrécit étape par étape.

Erreurs courantes

La boucle infinie. Une boucle while dont la condition ne devient jamais fausse tourne jusqu'à ce que tu arrêtes le programme. La cause habituelle est l'oubli de l'étape de mise à jour, par exemple l'absence de count = count - 1.

Le décalage d'une unité (off by one). range(1, 5) donne 1, 2, 3 et 4, pas 5, parce que la valeur de fin est exclue. Une boucle qui tourne une fois de trop ou de moins s'exécute quand même sans erreur et donne une mauvaise réponse, ce qui est une erreur de logique.

Modifier une liste pendant qu'on la parcourt. Supprimer des éléments de la liste sur laquelle tu itères fait sauter des éléments à la boucle :

numbers = [1, 2, 2, 3]

for n in numbers:
    if n == 2:
        numbers.remove(n)

print(numbers)

[1, 2, 3]

Un des 2 a survécu, parce que supprimer le premier 2 a décalé le second vers une position que la boucle avait déjà dépassée. Construis plutôt une nouvelle liste : numbers = [n for n in numbers if n != 2].

Pour aller plus loin

Les boucles parcourent des collections, donc ce qu'est un tableau est la page complémentaire naturelle, et ce qu'est un booléen explique les tests vrai ou faux qui décident quand une boucle s'arrête. Quand une boucle donne un mauvais résultat sans message d'erreur, lis ce qu'est une erreur de logique. Pour t'entraîner à écrire des boucles, commence le cours Python ou essaie les exemples ci-dessus dans le playground Python.