Les boucles en Python

Une boucle répète un bloc de code. Chaque passage dans le bloc est une itération. Une boucle while vérifie une condition avant chaque passage et exécute son corps tant que cette condition est vraie. Cela convient à une tâche comme « continuer à additionner jusqu’à ce que le total atteigne 100 ».

Initialiser, tester et mettre à jour

Une boucle de comptage comporte une valeur initiale, une condition et une mise à jour. L’en-tête se termine par deux-points. Indente le corps de quatre espaces :

n = 3
while n > 0:
    print(n)
    n = n - 1
print("Liftoff!")

La sortie est :

3
2
1
Liftoff!

Lors de la première vérification, n > 0 est vrai car n vaut 3. Python affiche 3, soustrait 1 et revient à l’en-tête. Il recommence avec 2, puis 1. La mise à jour donne à n la valeur 0, donc la vérification suivante est fausse. Python saute le corps et exécute le dernier print.

L’indentation détermine ce qui se répète. Les deux lignes indentées appartiennent au corps. La dernière ligne est alignée sur while, donc elle s’exécute une fois après la boucle. Un if vérifie sa condition une fois ; while revient la vérifier après chaque exécution complète du corps.

La vérification a lieu au début

Modifier une variable n’interrompt pas le reste du corps en cours :

n = 1
while n > 0:
    n -= 1
    print("Still in this pass")
print(n)

Ce code affiche Still in this pass, puis 0, sur des lignes séparées. La mise à jour rend la condition fausse, mais Python ne la vérifie qu’à son retour à l’en-tête. En partant de n = 0, il sauterait tout le corps : une boucle while peut ne s’exécuter aucune fois.

Mises à jour courtes et changements de valeurs

n -= 1 signifie n = n - 1. De même, count += 1 ajoute 1, balance *= 1.07 multiplie par 1,07 et n //= 10 remplace n par son quotient entier par 10. Python n’a pas d’opérateur d’incrémentation : count++ est une erreur de syntaxe. Écrire ++count applique deux fois le plus unaire et laisse l’entier inchangé.

Ici, une boucle retire un chiffre à chaque passage :

n = 472
total = 0
while n > 0:
    total += n % 10
    n //= 10
print(total)

Le reste n % 10 est le dernier chiffre. D’abord, 2 est ajouté et n devient 47. Ensuite, 7 est ajouté et n devient 4. Enfin, 4 est ajouté et n devient 0. La sortie est 13. La mise à jour prépare le passage suivant tout en rapprochant la boucle de sa sortie.

Une boucle qui vise un objectif n’a pas nécessairement un nombre d’itérations connu à l’avance. En partant d’un solde de 1 000, le multiplier par 1,07 et augmenter un compteur d’années jusqu’à ce que le solde atteigne 2 000 prend 11 passages. Après 10 passages, le solde est d’environ 1 967,15 ; après 11, il est d’environ 2 104,85.

Les conditions peuvent combiner des comparaisons avec and, or et not. La valeur de vérité fonctionne aussi : pour un entier, while n: répète la boucle tant que n est non nul. Utilise une condition dont le sens est facile à suivre. Indente de manière cohérente avec des espaces ; des niveaux mal alignés peuvent lever IndentationError, et un mélange de tabulations et d’espaces peut lever TabError.

Une boucle infinie continue de se répéter sans atteindre de sortie. Tu peux voir la même sortie défiler ou un programme sembler ne rien faire. Pour trouver la cause, suis les valeurs utilisées dans la condition et cherche une sortie qui peut être atteinte.

Trouver la mise à jour

Cette boucle continue d’afficher 3 :

n = 3
while n > 0:
    print(n)

Le test reste vrai car rien ne modifie n. Ajoute n -= 1 dans le corps pour que les valeurs 3, 2 et 1 s’affichent avant l’arrêt de la boucle. Placer cette mise à jour après la boucle ne sert à rien : le programme ne peut pas l’atteindre tant que la boucle s’exécute.

Le sens compte aussi. Avec while n > 0:, une mise à jour n += 1 fait augmenter une valeur positive. Les entiers Python ne rebasculent pas à une valeur négative à partir d’un maximum fixe qui permettrait une sortie accidentelle. Nomme le changement attendu, par exemple « une tentative de moins restante », et vérifie que le code effectue ce changement sur chaque chemin dans le corps.

Une cible peut être manquée

Une mise à jour peut modifier la valeur à chaque passage sans jamais atteindre une valeur cible :

n = 1
while n != 10:
    print(n)
    n += 2

Les valeurs sont 1, 3, 5, 7, 9, 11, et ainsi de suite. Elles sont toujours impaires, donc aucune n’est égale à 10. Pour la tâche « afficher les valeurs impaires inférieures à 10 », utilise while n < 10:. Dès que n vaut 11, cette condition est fausse. Le choix de la comparaison doit correspondre à la tâche : se termine-t-elle à une valeur donnée ou lorsqu’une borne est franchie ?

Pas décimaux et égalité exacte

De nombreuses fractions décimales sont stockées approximativement sous forme de flottants. Ajouter 0.1 à 0.0 dix fois de suite donne 0.9999999999999999. Une boucle qui attend une égalité exacte avec 1.0 manque donc l’arrêt prévu.

Lorsque la tâche consiste à parcourir un ensemble fixé de dixièmes, compte avec des entiers et calcule chaque nombre décimal :

for i in range(11):
    x = i / 10
    print(x)

Ce code parcourt 11 valeurs de 0.0 à 1.0. Le comptage entier contrôle les répétitions ; ce n’est pas le nombre décimal stocké qui décide si la boucle doit s’arrêter.

Vérifier chaque chemin dans le corps

Avant d’exécuter une boucle while, repère ses valeurs initiales, sa condition et chaque instruction qui modifie ces valeurs. Vérifie que le changement peut rendre la condition fausse. Si un if saute une mise à jour, suis aussi ce chemin. Une ligne temporaire comme print("n =", n) dans le corps peut montrer une valeur qui reste bloquée ou qui s’éloigne de la borne.

Pour interrompre un programme en cours d’exécution, appuie sur Ctrl+C dans un terminal ou utilise le bouton d’arrêt ou d’interruption de l’éditeur. Dans un terminal, Python affiche normalement KeyboardInterrupt avec une trace d’appels.

Répétition intentionnelle

while True: maintient volontairement la condition de son en-tête vraie. Son corps utilise break pour quitter la boucle lorsqu’un événement se produit, par exemple lorsque l’utilisateur saisit « quit ». La sortie doit pouvoir être atteinte. Une boucle de saisie peut continuer à attendre parce que l’utilisateur n’a pas demandé à sortir ; il y a un bug lorsque la logique de la boucle rend la sortie prévue impossible.

Une boucle de saisie peut recueillir une quantité inconnue de données ou continuer à poser une question jusqu’à obtenir une réponse acceptable. Dans les deux cas, la nouvelle saisie doit influer sur la décision de répéter.

S’arrêter à une sentinelle

Une sentinelle est une saisie particulière qui signifie « plus de données ». Choisis une valeur qui ne peut pas être une véritable donnée. Pour des nombres strictement positifs, 0 peut convenir ; si 0 est une mesure valide, choisis un autre signal d’arrêt.

La lecture initiale obtient la première valeur avant que la condition soit vérifiée :

total = 0
number = int(input("Number (0 to stop): "))
while number != 0:
    total += number
    number = int(input("Number (0 to stop): "))
print("Total:", total)

Pour les saisies 4, 7 et 0, le corps ajoute d’abord 4, puis 7. La lecture de 0 rend la condition suivante fausse. Le programme affiche Total: 11 ; il ne traite jamais la sentinelle. Si la première saisie est 0, le corps ne s’exécute aucune fois et le total reste égal à 0.

La dernière lecture dans le corps est essentielle. Sans elle, la même première valeur est traitée indéfiniment. Le test doit aussi avoir lieu avant le traitement d’une valeur nouvellement lue : sinon, une sentinelle peut être comptée comme une donnée.

Garder des types cohérents

input() renvoie du texte. La chaîne "0" n’est pas égale à l’entier 0. Convertis une saisie numérique avec int() avant de la comparer à une sentinelle numérique, ou garde la saisie sous forme de texte et compare-la à une chaîne comme "done". Une conversion numérique attend une chaîne numérique valide ; une vérification d’intervalle teste le nombre obtenu.

Pour calculer une moyenne, garde un compteur à côté du total. Avec la sentinelle -1 et les saisies 8, 6, 10 et -1, le total est 24 et le nombre de valeurs est 3. Divise après la boucle pour obtenir 8.0. Si la première saisie est -1, le nombre de valeurs reste égal à 0 : utilise donc if count > 0: avant la division. Cela permet de traiter un ensemble de données vide sans ZeroDivisionError.

Reposer la question tant qu’une réponse est invalide

Une boucle de validation décrit les réponses inacceptables dans sa condition :

age = int(input("Age (0-120): "))
while age < 0 or age > 120:
    print("Please enter an age from 0 to 120.")
    age = int(input("Age (0-120): "))
print("Thank you.")

Avec 150, -2 et 34, l’avertissement apparaît deux fois. La valeur 34 rend les deux comparaisons fausses, donc la boucle se termine. Les bornes 0 et 120 sont aussi acceptées.

Le mot or compte : un âge est invalide s’il est inférieur au minimum ou supérieur au maximum. Écrire age < 0 and age > 120 ne rejetterait rien, car un nombre ne peut pas être les deux à la fois.

Pour une réponse oui ou non, le test d’invalidité est answer != "y" and answer != "n". Une réponse doit différer des deux chaînes acceptées pour être rejetée. Avec or, même "y" provoquerait une répétition car cette réponse diffère de "n". Suis une réponse acceptable et une réponse inacceptable pour vérifier une telle condition.

Les mêmes tâches peuvent utiliser while True avec une seule lecture dans le corps, suivie d’un test de sortie et de break. La décision est ainsi placée immédiatement après la saisie et la lecture n’a pas besoin d’être écrite deux fois.

Une boucle for parcourt les éléments d’une séquence dans l’ordre. À chaque passage, Python affecte l’élément suivant à la variable de boucle et exécute le corps indenté. Une boucle sur une séquence est souvent appelée boucle bornée car les éléments définissent le travail à accomplir.

Un élément à la fois

Une chaîne est une séquence de caractères :

for ch in "cat":
    print(ch)

Ce code affiche c, a et t sur des lignes séparées. Les espaces et les signes de ponctuation comptent aussi comme caractères. La chaîne "hi there" comporte huit caractères, dont son espace ; parcourir chaque caractère prend donc huit passages.

Une liste contient une séquence de valeurs. Sa forme littérale utilise des crochets et des virgules :

scores = [3, 41, 12]
for score in scores:
    print(score * 2)

La sortie est 6, 82 et 24, chaque valeur sur sa propre ligne. score contient un nombre à la fois, pas toute la liste ni sa position. Aucune mise à jour manuelle d’un compteur n’est nécessaire pour passer de 3 à 41 puis à 12.

Utilise un nom qui décrit un élément : name dans names, ou score dans scores. Si le corps n’a jamais besoin de la valeur actuelle, _ est un nom courant pour cette variable de boucle inutilisée.

Une affectation ne remplace pas un élément

La variable de boucle est une variable ordinaire. Lui affecter un autre nombre ne remplace pas le nombre dans la liste :

numbers = [1, 2, 3]
for n in numbers:
    n = n * 10
    print(n)
print(numbers)

Le corps affiche 10, 20 et 30. À chaque nouvelle itération, l’élément suivant de la liste d’origine est affecté à n. La dernière ligne de sortie est [1, 2, 3] : la liste elle-même n’a pas changé. Après la boucle, n garde 30, la dernière valeur qui lui a été affectée dans le corps.

Une séquence vide ne donne aucun travail au corps. Avec for ch in "":, il n’y a aucun passage et la boucle n’affecte aucune valeur à ch. Ne compte pas sur la boucle pour créer sa variable lorsqu’il peut n’y avoir aucun élément.

Appartenance dans une boucle

Dans un en-tête for, in introduit la séquence à parcourir. Dans une condition, il teste l’appartenance et produit True ou False. Ces utilisations peuvent fonctionner ensemble :

vowels = 0
for ch in "education":
    if ch in "aeiou":
        vowels += 1
print(vowels)

Chaque caractère est parcouru, mais le compteur ne change que pour e, u, a, i et o. La sortie est 5. Le if est indenté dans la boucle, et la mise à jour du compteur est indentée dans le if.

Cette boucle montre aussi pourquoi une variable de boucle et un compteur ont des rôles différents. ch contient le caractère actuel ; vowels indique combien de caractères ont vérifié la condition jusqu’ici. Le compteur est initialisé avant la boucle afin de conserver son résultat entre les passages.

Un entier seul ne peut pas fournir d’éléments : for i in 5: lève TypeError. Pour répéter une action cinq fois, écris for _ in range(5):. Le range fournit les étapes, même lorsque le corps n’utilise pas leurs valeurs.

Un range décrit des entiers régulièrement espacés. Il sert à répéter une action un nombre fixé de fois, à compter en montant ou en descendant et à sélectionner des pas réguliers. Sa valeur de fin est toujours exclue.

Trois formes

Avec un argument, celui-ci est la fin. Avec deux arguments, ce sont le début et la fin. Avec trois, le dernier argument est le pas ajouté après chaque valeur. range(0, 10, 3) parcourt 0, 3, 6 et 9 ; le pas suivant atteindrait 12, qui n’est donc pas fourni.

La fin reste exclue même lorsqu’un pas pourrait tomber exactement dessus. range(0, 10, 5) ne fournit que 0 et 5. Avec le pas positif par défaut de 1 et une fin supérieure au début, le nombre de valeurs fournies est la fin moins le début.

Compter à rebours avec un pas négatif

range(5, 0, -1) fournit 5, 4, 3, 2 et 1. Pour inclure 0, place la fin en dessous : range(5, -1, -1) fournit six valeurs, qui se terminent à 0.

Le sens doit correspondre aux bornes. range(5, 0) est vide car son pas par défaut est positif. range(1, 5, -1) est aussi vide car il commence sous la fin mais descend. Les ranges vides sont valides et entraînent zéro itération ; un pas nul, en revanche, lève ValueError.

Placer la dernière valeur nécessaire à l’intérieur de la borne

Pour additionner les entiers pairs de 2 à 20 inclus :

total = 0
for n in range(2, 21, 2):
    total += n
print(total)

La fin fixée à 21 permet de parcourir 20. Les dix valeurs totalisent 110, donc le programme affiche 110. Utiliser 20 comme fin exclurait 20 et donnerait 90.

Pour une table de multiplication, laisse le range fournir les facteurs :

for i in range(1, 11):
    print(7, "x", i, "=", 7 * i)

La première ligne de sortie est 7 x 1 = 7, et la dixième est 7 x 10 = 70. Si le nombre lui-même n’est pas utilisé, for _ in range(3): peut répéter un message trois fois.

Examiner un range et vérifier ses arguments

list(range(2, 6)) produit [2, 3, 4, 5], ce qui est utile pour vérifier les bornes. len(range(0, 10, 3)) vaut 4. Un range stocke les bornes et le pas qui le définissent au lieu de construire une liste contenant chaque entier.

Les arguments sont des entiers, y compris zéro et les entiers négatifs : range(-3, 3) parcourt les nombres de -3 à 2. Un flottant comme 3.0 est rejeté avec TypeError, même s’il n’a pas de partie fractionnaire. Un nombre de répétitions saisi sous forme de texte peut d’abord être converti avec n = int(input("How many? ")), puis utilisé dans range(n).

Choisis une boucle en te demandant ce qui contrôle la répétition. S’il y a une séquence d’éléments à parcourir ou un nombre de répétitions, for exprime généralement le travail directement. Si la répétition suivante dépend d’une condition qui change ou d’une saisie future, while place cette décision dans son en-tête.

Éléments définis ou condition changeante

Un nombre de répétitions n’a pas besoin d’être écrit sous forme de littéral dans le programme. Après la saisie de n, range(n) donne tout de même un ensemble défini d’étapes. Une boucle non bornée dépend d’une condition dont le point d’arrêt n’est pas précisé sous forme d’un nombre de répétitions.

Deviner un grand nombre de répétitions convient mal à une tâche à poursuivre « jusqu’à ce qu’elle soit terminée ». Une boucle sur range(1000) peut épuiser ses tentatives avant que l’utilisateur ait terminé, et une version sans test de sortie continuera après la fin du travail.

Réécrire une boucle de comptage

Ces deux boucles affichent les nombres de 1 à 5, chacun sur sa propre ligne :

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

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

Dans la version while, le début du range devient l’initialisation, la fin exclue devient la comparaison < et le pas devient la mise à jour. Le corps utilise i avant cette mise à jour. Déplacer la mise à jour avant print(i) décalerait les valeurs affichées.

Un compte à rebours modifie à la fois la comparaison et la mise à jour :

i = 10
while i > 0:
    print(i)
    i -= 2

Ce code affiche 10, 8, 6, 4 et 2, comme le ferait for i in range(10, 0, -2):. Le range décroissant exclut sa fin, donc la condition while correspondante est i > 0.

Les deux formes conviennent à la tâche qui consiste à afficher ces nombres, mais les valeurs finales de leur variable de boucle diffèrent. La version while effectue sa dernière mise à jour jusqu’à 0 avant de s’arrêter. La version for se termine après avoir affecté sa dernière valeur fournie, 2.

Un range garde les bornes qui lui ont été données

n = 3
for i in range(n):
    n = 10
    print(i)

Ce code affiche toujours 0, 1 et 2. Le range a été créé avec 3 ; affecter 10 à n ne le reconstruit pas. Un break peut terminer la boucle plus tôt, mais modifier cette variable distincte ne change pas les nombres fournis par le range.

Un en-tête while, en revanche, évalue à nouveau son expression à chaque retour. Si cette expression utilise n, modifier n dans le corps peut changer le moment où la boucle se termine. Lorsque les deux formes expriment clairement une tâche de comptage, la version for gère le passage d’une valeur à la suivante sans mise à jour manuelle que l’on pourrait oublier.

break termine immédiatement la boucle la plus interne qui le contient. Python saute le reste de ce corps et toutes les itérations restantes, puis continue après la boucle. Une condition dans le corps détermine quand cette sortie anticipée doit avoir lieu.

S’arrêter dès que le premier résultat est trouvé

Recherche le premier multiple de 7 supérieur à 50 :

for n in range(51, 100):
    if n % 7 == 0:
        print(n)
        break

La boucle vérifie 51, 52, 53, 54, 55 et 56. Le reste est nul à 56, donc Python affiche 56 et quitte la boucle. Cela prend six itérations, même si le range peut fournir 49 nombres. Sans break, la boucle afficherait aussi les multiples de 7 suivants.

break est indenté dans le if, donc il ne s’exécute que pour une correspondance. S’il était aligné sur if, il s’exécuterait dès la toute première itération, quel que soit le test. Un break dans un if termine la boucle qui contient ce if ; il ne termine pas seulement le bloc conditionnel.

Lire une fois, puis décider s’il faut traiter

Une boucle while True place la décision de sortie après la lecture d’une saisie :

while True:
    line = input("> ")
    if line == "done":
        break
    print(line)
print("Done!")

Pour les saisies « hello », « there » et « done », les lignes de réponse sont :

hello
there
Done!

La sentinelle est testée avant la ligne de traitement. Lorsqu’elle apparaît, break saute print(line). Le dernier print, sans indentation, s’exécute quand même après la boucle. Il n’y a qu’une seule instruction de saisie, car chaque passage commence par la lecture d’une nouvelle ligne.

Un total numérique suit le même ordre : initialise total = 0 avant la boucle ; lis et convertis un nombre ; quitte la boucle s’il vaut 0 ; sinon, ajoute-le. Pour 4, 7 et 0, le total est 11. Traiter la valeur avant le test de sortie laisserait la sentinelle atteindre le calcul, ce qui compte lorsque la valeur d’arrêt pourrait modifier un comptage, un produit ou une moyenne.

Valider au moment de la saisie

while True:
    age = int(input("Age: "))
    if 0 <= age <= 120:
        break
    print("Please enter an age from 0 to 120.")
print("Accepted:", age)

La comparaison chaînée accepte un âge de 0 à 120 inclus. Elle signifie 0 <= age and age <= 120. Un nombre accepté entraîne la sortie avant l’avertissement ; un nombre hors de cet intervalle atteint l’avertissement, puis une nouvelle saisie. Sous cette forme, le if décrit une réponse valide, tandis qu’une boucle de validation contrôlée par son en-tête décrit une réponse invalide.

Suivre le saut à la lettre

Une instruction après break dans le même bloc ne peut pas s’exécuter. Place un message ou un résultat mémorisé avant le break lorsqu’il appartient au cas de réussite. Place le code après la boucle lorsqu’il doit s’exécuter aussi bien après une sortie anticipée qu’après une fin normale.

break doit se trouver dans une boucle ; sinon, Python lève SyntaxError. Plusieurs points de sortie distincts peuvent rendre une boucle plus difficile à suivre. Lorsqu’une seule condition décrit naturellement la règle d’arrêt de la tâche, la garder dans l’en-tête peut rendre le chemin plus facile à suivre.

continue saute le reste de l’itération en cours. La boucle reste active : une boucle for prend son élément suivant et une boucle while revient à sa condition. Cette instruction est utile lorsqu’un élément ne doit recevoir aucun des traitements qui suivent une vérification.

Sauter certaines valeurs

total = 0
for n in range(1, 11):
    if n % 3 == 0:
        continue
    total += n
print(total)

Le range fournit les dix entiers de 1 à 10 inclus. Pour 3, 6 et 9, continue saute l’addition. La somme des dix nombres est 55 ; retirer ces trois valeurs enlève 18, donc le programme affiche 37.

Continue ne retire pas une itération du range. Le corps commence quand même avec chaque valeur, y compris celles qui sont sautées. L’instruction change les lignes suivantes qui s’exécutent pendant ce passage.

Un filtre positif peut exprimer le même travail. Dans une boucle sur [5, -2, 8, -7, 3], if n < 0: continue suivi de print(n) affiche 5, 8 et 3. Placer le print dans if n >= 0: donne la même sortie. Continue est souvent utile lorsque plusieurs lignes de traitement suivent, car les éléments rejetés peuvent immédiatement quitter cette partie du corps.

Ne pas sauter une mise à jour de while

i = 0
while i < 5:
    if i == 2:
        continue
    print(i)
    i += 1

Ce code affiche 0 et 1, puis reste bloqué à 2. À 2, continue revient à la condition sans atteindre la mise à jour. La condition reste vraie et la même branche est empruntée à nouveau.

Pour ne pas afficher 2 tout en continuant à avancer, effectue aussi la mise à jour dans cette branche :

i = 0
while i < 5:
    if i == 2:
        i += 1
        continue
    print(i)
    i += 1

La sortie est maintenant 0, 1, 3 et 4 sur des lignes séparées. Le chemin qui saute l’affichage avance de 2 à 3. Chaque chemin dans ce corps effectue exactement une mise à jour.

Break, continue et pass

Pour une boucle sur [1, 2, 3, 4], supposons qu’un if n == 2: contienne l’une de ces instructions et que print(n) suive le if. Break affiche seulement 1. Continue affiche 1, 3 et 4. Pass affiche les quatre valeurs car il ne saute pas le print.

pass peut remplir un corps où Python exige une instruction pendant le développement du code. Il ne fournit ni mise à jour ni sortie : while True: pass continue de s’exécuter. Break et continue doivent se trouver dans une boucle et n’agissent que sur la boucle la plus interne qui les contient.

Un bloc else peut appartenir à une boucle for ou while. Il s’exécute une fois lorsque la boucle se termine normalement : une boucle for épuise ses éléments ou une condition while devient fausse. Il est sauté lorsque cette boucle se termine par break. Lis-le comme le cas sans break.

Signaler une recherche sans correspondance

for n in [4, 9, 15, 22]:
    if n % 5 == 0:
        print("First multiple of 5:", n)
        break
else:
    print("No multiple of 5")

La boucle atteint 15, affiche First multiple of 5: 15 et s’interrompt. Le else est sauté. Avec [4, 9, 22], la boucle utilise tous les éléments sans interruption et affiche No multiple of 5 une fois.

L’alignement est décisif. Le else est aligné sur for, donc il appartient à la boucle. Un else aligné sur le if interne s’exécuterait pour chaque élément sans correspondance, annonçant un échec avant la fin de la recherche.

Une liste vide atteint aussi le else de la boucle. Il n’y a aucun élément, donc le corps ne s’exécute aucune fois et aucun break ne se produit. De même, une boucle while dont la condition est fausse dès la première vérification exécute immédiatement son else.

Chercher un diviseur

Un nombre premier est un entier supérieur ou égal à 2 dont les seuls diviseurs positifs sont 1 et lui-même. Cherche un diviseur entre ces deux bornes :

n = 29
if n < 2:
    print("Not prime")
else:
    for d in range(2, n):
        if n % d == 0:
            print(n, "is divisible by", d)
            break
    else:
        print(n, "is prime")

Pour 29, tous les restes sont non nuls et le else de la boucle affiche 29 is prime. Pour 21, le premier diviseur est 3 et le break saute le else de la boucle. La vérification externe traite les nombres inférieurs à 2. Sans elle, le range vide pour 1 atteindrait le else et qualifierait à tort 1 de nombre premier. Pour 2, le range est aussi vide, mais la conclusion « premier » est correcte.

Limiter les tentatives avec while et else

attempts = 0
while attempts < 3:
    guess = input("Password: ")
    if guess == "open sesame":
        print("Welcome!")
        break
    attempts += 1
else:
    print("Too many attempts.")

Une réponse correcte déclenche le break, même à la troisième tentative. Trois réponses incorrectes portent le compteur à 3 ; la condition devient fausse et le else affiche le message d’échec. Une instruction ordinaire après la boucle s’exécuterait dans les deux cas et ne les distinguerait donc pas.

Enregistrer le résultat avec un drapeau

Un drapeau est une variable booléenne qui indique si quelque chose s’est produit. Commence avec found = False, passe à True lorsqu’une correspondance apparaît, puis quitte la boucle avec break. Après la boucle, if not found: traite l’échec. Cela donne le même résultat de recherche que le else de la boucle, en conservant explicitement la trace de l’événement. Choisis une forme dont tu peux expliquer clairement l’indentation et le chemin de sortie.

Un accumulateur conserve un résultat entre les itérations. Un compteur est un accumulateur particulier qui augmente de 1 chaque fois qu’un événement se produit. Fixe la valeur initiale avant la boucle, mets-la à jour dans celle-ci et utilise ensuite le résultat final.

Compter des événements ou additionner des valeurs

count = 0
for n in [4, 15, 22, 8, 11]:
    if n > 10:
        count += 1
print(count)

Le test réussit pour 15, 22 et 11, donc la sortie est 3. La mise à jour ajoute 1 pour un élément qui vérifie la condition ; ajouter n ferait plutôt la somme des valeurs correspondantes.

Pour additionner tous les éléments, initialise total = 0, retire le test if, ajoute total += n directement dans le corps et affiche ensuite total. Les cinq valeurs totalisent 60. Leur moyenne est 60 / 5, ce qui donne 12.0 ; la division avec / renvoie un flottant pour ces opérandes entiers.

Pour une moyenne filtrée, mets à jour le total et le compteur sous la même condition :

total = 0
count = 0
for n in [4, 15, 22, 8, 11]:
    if n > 10:
        total += n
        count += 1
if count > 0:
    print(total / count)
else:
    print("No matching values")

Ici, le total des valeurs sélectionnées est 48 et leur nombre est 3, donc la sortie est 16.0. Diviser par la longueur de toute la liste utiliserait le mauvais groupe. La vérification du compteur traite aussi le cas d’une liste vide ou sans correspondance.

Choisir une valeur initiale adaptée à l’opération

Un produit des entiers de 1 à 5 commence à 1 et se termine à 120. En partant de 0, tous les produits resteraient égaux à 0.

L’accumulation de texte dépend aussi de l’ordre :

rev = ""
for ch in "stressed":
    rev = ch + rev
print(rev)

Chaque nouveau caractère est placé devant le texte mémorisé, ce qui produit desserts. Remplacer la mise à jour par rev = rev + ch ajoute les caractères à la fin et reconstruit stressed.

Conserver le résultat entre les itérations

Déplacer total = 0 dans une boucle de somme efface le travail précédent à chaque passage. Avec [4, 15, 22, 8, 11], réinitialiser avant chaque addition ne laisse que 11 à la fin. Initialise hors de la boucle pour que l’addition suivante utilise le sous-total précédent.

Un print dans le corps affiche le total cumulé après chaque mise à jour : 4, 19, 41, 49 et 60 dans cet exemple. Un print après la boucle n’affiche que 60. Choisis son emplacement en fonction de la sortie demandée.

Pour une simple liste stockée, sum(values) donne son total et len(values) donne son nombre d’éléments. Une boucle explicite permet de filtrer les valeurs, de suivre plusieurs résultats ensemble ou de traiter les valeurs au fur et à mesure de leur saisie.

Pour trouver un maximum, conserve la plus grande valeur rencontrée jusqu’ici. Compare chaque nouvel élément à cette valeur mémorisée et ne la remplace que si le nouvel élément est plus grand. Le schéma du minimum fonctionne de la même façon avec la comparaison inversée.

Commencer sans inventer de valeur de donnée

None est la valeur Python qui signifie « rien pour le moment ». Elle donne au premier élément un moyen clair de devenir la meilleure valeur actuelle :

largest = None
for n in [12, -3, 25, 7]:
    if largest is None or n > largest:
        largest = n
print(largest)

Les valeurs mémorisées après chaque élément sont 12, 12, 25 et 25. Le programme affiche 25. Pour le premier élément, largest is None est vrai. Le or de Python s’arrête là, donc il ne tente pas la comparaison invalide d’un nombre avec None. Aux passages suivants, la valeur mémorisée est un nombre et la deuxième comparaison est utilisée.

Pour un minimum, commence avec smallest = None et utilise smallest is None or n < smallest. La même liste produit -3.

Commencer la recherche d’un maximum à 0 peut conduire à indiquer une valeur qui n’est jamais apparue. Pour -5, -2 et -9, aucune valeur ne dépasse 0, donc cette version garderait 0 à tort. Le maximum est -2. Commencer la recherche d’un minimum à 0 pose le problème correspondant lorsque tous les éléments sont positifs.

Si l’on sait que les données contiennent un élément, utiliser cette première valeur comme meilleure valeur initiale fonctionne aussi. Les fonctions natives traitent les listes stockées simples : max([12, -3, 25, 7]) donne 25 et min([12, -3, 25, 7]) donne -3. Une boucle personnalisée peut conserver des informations associées, comme l’endroit où la valeur est apparue.

Mémoriser la position lorsque la meilleure valeur change

largest = None
best_day = None
day = 0
for temperature in [18, 23, 21, 26, 24]:
    day += 1
    if largest is None or temperature > largest:
        largest = temperature
        best_day = day
print(largest, best_day)

Le compteur de jours avance pour chaque élément. Le meilleur jour ne change que lorsqu’un nouveau maximum apparaît. La sortie finale est 26 4, ce qui signifie une température de 26 au jour 4. Mémoriser le jour après la boucle ne ferait que conserver le dernier jour examiné.

Décider quoi faire en cas d’ex aequo

Pour [5, 8, 8, 3], le test n > largest conserve le premier 8 et sa position, 2 en comptant à partir de 1. Remplacer > par >= effectue aussi une mise à jour en cas d’égalité et conserve le dernier 8 à la position 3. Le plus grand nombre reste inchangé ; la position mémorisée diffère.

Une liste vide laisse inchangée la meilleure valeur initialisée à None. Vérifie cet état avant d’annoncer un nombre ou de l’utiliser dans un calcul. Il signifie qu’aucun élément n’a fourni de meilleure valeur.

La comparaison peut utiliser une propriété d’un élément. Pour conserver le mot le plus long parmi « poire », « banane » et « figue », compare len(word) à la longueur du mot mémorisé. « Banane » a six caractères, donc il l’emporte. Mémorise le mot lui-même lorsqu’il devient le meilleur pour que le résultat désigne l’élément, et pas seulement sa longueur.

Une recherche séquentielle vérifie les éléments dans l’ordre jusqu’à trouver une correspondance ou à épuiser les éléments. Une correspondance peut être une valeur exacte, le premier élément qui vérifie une condition ou un élément de réponse à une question d’existence ou universelle.

Mémoriser une réussite

names = ["Ana", "Ben", "Chen"]
found = False
for name in names:
    if name == "Ben":
        found = True
        break
if found:
    print("Ben is on the list")
else:
    print("Ben is not on the list")

Le drapeau commence à faux car rien n’a encore été trouvé. La première vérification, Ana, le laisse inchangé. La deuxième trouve Ben, met le drapeau à vrai et quitte la boucle. La sortie est Ben is on the list.

Le drapeau enregistre un événement sur toute la durée de la recherche. Ne le réinitialise pas à chaque élément sans correspondance. Si une boucle continue après avoir trouvé Ben et affecte found = False lorsqu’elle atteint Chen, le résultat positif est perdu. De même, « non trouvé » doit apparaître après l’échec de toutes les vérifications, pas dans un else propre à chaque élément qui annoncerait un échec pour Ana avant l’examen de Ben.

Première ou dernière correspondance

Pour [7, 4, 9, 10], le premier nombre pair est 4 et le dernier est 10. Cette boucle mémorise le premier :

match = None
for n in [7, 4, 9, 10]:
    if n % 2 == 0:
        match = n
        break
print(match)

La sortie est 4. Retire le break et chaque nouvelle correspondance écrase la précédente, laissant 10. Si rien ne correspond, la valeur mémorisée reste None. Détermine si la tâche demande l’existence, le premier élément, le dernier élément ou une position avant de décider quoi stocker.

Pour indiquer une position, maintiens un compteur qui avance pour chaque élément examiné et mémorise-le lors d’une correspondance. Précise comment les positions sont numérotées : en comptant à partir de 1, Chen est en position 3 dans la liste des noms ; la numérotation habituelle des positions en Python commence à 0.

Une réussite suffit pour l’existence ; un échec suffit pour le test universel

Une recherche d’existence commence à faux et devient vraie au premier élément qui vérifie la condition. Elle peut s’arrêter là car une réussite répond à la question.

Une recherche universelle commence à vrai et devient fausse au premier échec :

all_positive = True
for n in [3, 8, -1, 5]:
    if n <= 0:
        all_positive = False
        break
print(all_positive)

La troisième valeur, -1, réfute « toutes les valeurs sont positives », donc la sortie est False. Il n’est pas nécessaire d’examiner 5. Zéro échouerait aussi car positif signifie supérieur à zéro. S’il n’y a aucun élément, le drapeau reste vrai : aucun contre-exemple n’est apparu.

Appartenance exacte et conditions personnalisées

Pour une simple égalité, "Ben" in names donne directement True ou False. Une boucle rend visible l’évolution de l’état de la recherche et permet au test d’exprimer une condition personnalisée, comme « le premier mot de plus de cinq caractères ».

Les comparaisons de chaînes sont exactes. "ben" diffère de "Ben", et "Ben " comprend un espace final. Une recherche portant sur l’une de ces chaînes ne doit pas considérer les autres comme égales.

Une boucle imbriquée est une boucle placée dans le corps d’une autre boucle. À chaque itération externe, la boucle interne démarre et effectue son travail. La variable externe reste fixe pendant que la variable interne change.

Construire une ligne à la fois

for row in range(1, 4):
    for col in range(1, 5):
        print(row * col, end=" ")
    print()

La sortie comporte ces trois lignes, chacune avec un espace après son dernier nombre :

1 2 3 4 
2 4 6 8 
3 6 9 12 

D’abord, row vaut 1 tandis que col prend les valeurs de 1 à 4. Puis row devient 2 et la boucle interne recommence à la colonne 1. Enfin, la ligne 3 obtient les mêmes quatre colonnes. Le corps interne s’exécute douze fois.

end=" " remplace le saut de ligne habituel de print par un espace. Le print() vide termine la ligne. Il se trouve dans le corps externe mais hors du corps interne, donc il s’exécute trois fois. L’indenter d’un niveau supplémentaire placerait chaque nombre sur sa propre ligne. Supprimer son indentation ne terminerait une ligne qu’une fois, après les deux boucles.

Donne des noms distincts aux variables de boucle, comme row et col. Réutiliser le nom externe dans la boucle interne écrase la valeur nécessaire pour identifier la ligne actuelle.

Compter le travail

Lorsque chaque passage externe comporte le même nombre de passages internes, multiplie ces nombres. Trois lignes et quatre colonnes donnent douze exécutions internes. Deux boucles de 100 passages chacune donnent 10 000 exécutions internes ; trois niveaux en donnent 1 000 000. Une petite augmentation de chaque borne peut donc créer beaucoup plus de travail répété.

Si la borne interne change avec la variable externe, additionne les nombres obtenus séparément :

for row in range(1, 5):
    for _ in range(row):
        print("*", end="")
    print()

Ce code affiche :

*
**
***
****

Les longueurs des lignes sont 1, 2, 3 et 4, soit dix étoiles au total. Pour un motif de n lignes de ce type, le total est $n(n+1)\mathrm{/}2$. Multiplier quatre par quatre supposerait à tort que chaque ligne comporte quatre étoiles.

Réinitialiser un résultat pour chaque groupe

Pour totaliser chaque ligne de la grille de multiplication, fixe row_total = 0 dans la boucle externe, juste avant la boucle interne. Ajoute row * col dans le corps interne et affiche row_total après la boucle interne. Les sorties sont 10, 20 et 30.

Initialiser une seule fois, avant les deux boucles, conserve aussi les totaux des lignes précédentes. Afficher après chaque ligne donne alors 10, 30 et 60. Les deux placements conservent un résultat, mais l’un conserve un résultat par ligne et l’autre un total cumulé pour toute la grille.

Parcourir des combinaisons

Deux boucles sur range(1, 7) parcourent les 36 résultats ordonnés possibles pour deux dés. La première boucle fournit le premier dé et la seconde fournit le second. Une condition dans le corps interne peut compter les couples dont la somme est 7. Six vérifient la condition : (1 ; 6), (2 ; 5), (3 ; 4), (4 ; 3), (5 ; 2) et (6 ; 1). Inverser un couple décrit un résultat ordonné différent.

Break et continue agissent sur la boucle la plus interne qui les contient. Dans du code imbriqué, repère cette boucle avant de prévoir la suite. Un break dans le corps interne n’arrête pas à lui seul la boucle externe.

Suivre un break interne

for a in range(1, 4):
    for b in range(1, 4):
        if b > a:
            break
        print(a, b)

Pour a = 1, le couple 1 1 s’affiche. Lorsque b devient égal à 2, le break termine cette boucle interne. La boucle externe passe à a = 2 et démarre une nouvelle boucle interne avec b égal à 1. Elle affiche 2 1 et 2 2, puis s’interrompt lorsque b vaut 3. Pour a égal à 3, toutes les valeurs de b passent. Les six lignes de sortie sont :

1 1
2 1
2 2
3 1
3 2
3 3

Arrêter les deux boucles avec un résultat enregistré

Une recherche de combinaison peut utiliser un drapeau et un break à chaque niveau :

found = False
for a in range(1, 6):
    for b in range(1, 6):
        if a * b == 12:
            found = True
            break
    if found:
        break
if found:
    print(a, b)
else:
    print("No matching pair")

Les lignes où a vaut 1 et 2 ne contiennent aucune correspondance. À la ligne 3, b atteint 4 et le produit est 12. Le break interne termine la boucle sur b ; le drapeau déclenche ensuite le break externe. La sortie finale est 3 4.

Le drapeau est initialisé avant les deux boucles, car il enregistre un résultat pour toute la recherche. Le if found: externe se place après la boucle interne mais dans le corps externe. Son indentation entraîne une vérification par ligne terminée ou interrompue.

Conserver les valeurs lorsque la recherche continue

Retirer uniquement le break externe fait continuer la recherche sur les lignes suivantes. Dans cet exemple, une correspondance ultérieure est 4 3, mais la boucle finit par examiner la ligne 5 et se termine avec a = 5 et b = 5. Afficher alors les variables de boucle donne 5 5, et non une correspondance mémorisée.

Si la tâche demande le dernier couple correspondant, mémorise best_a = a et best_b = b chaque fois qu’une correspondance apparaît. Ces variables distinctes conservent une correspondance pendant que les variables de boucle continuent de changer. Vérifie le drapeau avant de les afficher lorsqu’il est possible qu’aucune correspondance n’existe.

Sauter un couple, puis poursuivre la ligne

Un continue dans la boucle interne passe à sa valeur interne suivante. Pour deux boucles parcourant les nombres de 1 à 4, if a == b: continue avant le traitement saute quatre couples de valeurs égales. Douze couples ordonnés restent sur les seize de départ.

Un if peut aussi sélectionner des couples sans saut. Deux dés ont trois couples ordonnés dont la somme est 10 : (4 ; 6), (5 ; 5) et (6 ; 4). Une condition dans le corps interne les repère.

Le traçage consiste à exécuter un programme à la main, une instruction à la fois, en notant ses valeurs et sa sortie. Un tableau de suivi donne une colonne à chaque variable pertinente. Indique si une valeur est notée avant ou après une mise à jour pour que les lignes aient un sens clair.

Suivre une boucle while

total = 0
i = 1
while i <= 4:
    total = total + i
    i = i + 1
print(total)

Commence avec total = 0 et i = 1. Vérifie la condition avant d’entrer dans le corps. À chaque vérification vraie, effectue l’addition avant l’incrémentation :

La vérification suivante est 5 <= 4, qui est fausse. Il n’y a pas de cinquième ligne pour le corps. Le corps s’exécute quatre fois, la condition est vérifiée cinq fois et le print après la boucle affiche 10 une fois. Les valeurs finales sont i = 5 et total = 10.

Distingue la vérification qui échoue d’une itération : elle termine la boucle sans exécuter son corps. Si la condition initiale est déjà fausse, il n’y a aucune ligne pour le corps et les variables gardent leurs valeurs initiales.

L’ordre des instructions change le résultat

Si l’incrémentation est déplacée avant l’addition, chaque passage utilise la nouvelle valeur de i. Les quatre additions deviennent 2, 3, 4 et 5, ce qui donne 14. La condition teste toujours i au début, avant cette incrémentation. Suivre seulement les valeurs à l’en-tête ne montrerait pas quelle valeur l’addition utilise réellement.

Lorsque le corps contient un break ou un continue, arrête de suivre ses lignes restantes dès que le saut se produit. Avec continue, reviens à l’en-tête ou à l’élément suivant ; avec break, poursuis après la boucle. Un suivi doit emprunter ces chemins et ne pas simplement copier toutes les instructions du corps dans chaque ligne.

Suivre les caractères et les boucles imbriquées

Une boucle for affecte l’élément suivant au début de son passage :

rev = ""
for ch in "abc":
    rev = ch + rev
print(rev)

Le texte mémorisé devient "a", puis "ba", puis "cba". La sortie est cba. Note le texte réel, y compris son ordre, au lieu d’écrire seulement qu’« un caractère a été ajouté ».

Pour des boucles imbriquées, utilise une ligne pour chaque itération interne. Note les deux variables de boucle pour que la valeur externe se répète sur les lignes qui lui correspondent. Dans une boucle à deux lignes et trois colonnes, les valeurs de ligne sont 1, 1, 1, 2, 2, 2 tandis que les valeurs de colonne sont 1, 2, 3, 1, 2, 3.

Produire un suivi avec print

Un print("i =", i, "total =", total) temporaire après les deux mises à jour dans la boucle de somme affiche i et total à la fin de chaque passage. Le placer avant les mises à jour montre un moment différent. Compare l’emplacement du print aux intitulés de colonnes de ton tableau. Supprime les affichages de diagnostic après avoir corrigé le code afin qu’ils ne deviennent pas une sortie supplémentaire du programme.

Pour une question « qu’est-ce qui s’affiche ? », ne note que les instructions qui affichent réellement quelque chose. Le changement d’une variable n’est pas en lui-même une sortie ; plusieurs mises à jour peuvent avoir lieu avant un seul affichage final.

Une erreur de décalage d’une unité parcourt une valeur de trop ou pas assez, ou décale les valeurs parcourues d’une unité. Elle provient souvent de la fin exclue d’un range, d’un choix entre < et <=, ou de la valeur initiale d’un compteur.

Indiquer les bornes souhaitées

Pour additionner les nombres de 1 à 10 inclus, range(1, 10) est trop court. Il ne fournit que les nombres de 1 à 9, ce qui donne un total de 45. range(1, 11) inclut 10 et donne 55. Pour un range croissant d’entiers avec un pas de 1, utilise la fin n + 1 pour inclure la valeur finale n.

Avec un pas par défaut de 1, range(a, b) fournit b - a valeurs lorsque b est supérieur à a. Un break peut tout de même terminer la boucle avant qu’elles soient toutes utilisées. Avec d’autres tailles de pas, énumère les valeurs d’un petit cas ou utilise len(range(...)) pour vérifier leur nombre.

Le nombre d’itérations d’une boucle while dépend à la fois de son début, de sa comparaison et de sa mise à jour. Pour un entier positif ou nul n, avec i += 1 à la fin de chaque passage et sans sortie anticipée :

Pour n égal à 0, les deux premières sautent le corps. La troisième s’exécute une fois avec i égal à 0. Ce tout petit cas révèle le passage supplémentaire sans suivre une longue boucle.

Bornes d’un compte à rebours

En partant de 5 et en affichant avant n -= 1, while n > 0: affiche cinq valeurs, en terminant à 1. Utiliser n >= 0 en affiche six, en terminant à 0. Les ranges décroissants correspondants sont range(5, 0, -1) et range(5, -1, -1).

Vérifie aussi l’ordre. Mettre à jour un compteur avant de l’utiliser peut décaler chaque valeur même lorsque la boucle effectue le nombre de passages attendu. Un suivi doit noter les première et dernière valeurs réellement utilisées par le calcul.

Les éléments et les espaces qui les séparent

Une erreur de l’intervalle confond le nombre d’éléments et le nombre d’espaces entre eux. Cinq sections de clôture nécessitent six poteaux. Cinq nombres affichés ne nécessitent que quatre séparateurs entre eux.

for i in range(1, 6):
    print(i, end="-")

Ce code affiche 1-2-3-4-5-, avec un tiret final non souhaité. Chaque print ajoute un tiret après un élément, même le dernier.

Une correction consiste à afficher le premier élément séparément, puis à afficher un séparateur avant chaque élément suivant :

print(1, end="")
for i in range(2, 6):
    print("-" + str(i), end="")
print()

La sortie est 1-2-3-4-5. La boucle affiche quatre morceaux composés d’un tiret et d’un nombre, et le print vide final termine la ligne. Cette version a un premier élément connu ; dans le cas général de données vides, il faut aussi sauter l’affichage de ce premier élément.

Vérifier la correction avec de petits cas

Note la première valeur, la dernière valeur et le nombre de passages attendus avant de modifier le code. Choisis les bornes et la comparaison en conséquence, puis suis une courte exécution. Vérifie aussi les cas de zéro et d’un élément ainsi qu’un cas ordinaire. Zéro révèle un travail qui devrait être sauté ; un révèle un séparateur inutile ou une mise à jour supplémentaire. Modifie la borne qui provoque l’erreur pour que les répétitions du code correspondent à la tâche.