12. Itération avec les boucles `for` et `range()`

Dans le chapitre 11, nous avons appris les boucles while, qui répètent des actions tant qu’une condition reste vraie. Même si les boucles while sont puissantes et flexibles, elles nous obligent à gérer manuellement les compteurs de boucle et à mettre à jour les conditions. Python fournit un autre type de boucle — la boucle for — qui excelle dans une tâche différente mais extrêmement courante : traiter chaque élément d’une collection de données, un par un.

La boucle for est l’une des fonctionnalités les plus utilisées de Python. Que vous traitiez des lignes dans un fichier, que vous calculiez des statistiques à partir d’une séquence de nombres, ou que vous vérifiiez chaque caractère d’une chaîne, la boucle for offre une façon claire et lisible de parcourir des séquences de données. Dans ce chapitre, nous allons explorer comment fonctionnent les boucles for, comment utiliser la fonction range() de Python pour les opérations de comptage, et comment contrôler l’exécution d’une boucle avec break, continue, et la clause else moins connue.

12.1) La boucle for et les concepts d’itération

12.1.1) Qu’est-ce qu’une boucle for ?

Une boucle for en Python répète un bloc de code une fois pour chaque élément d’une séquence. La séquence peut être une chaîne, une liste (que nous apprendrons en détail au chapitre 14), ou toute autre collection d’éléments. La différence clé avec une boucle while est qu’une boucle for gère automatiquement l’itération — vous n’avez pas besoin de mettre à jour manuellement un compteur ou de vérifier une condition.

Voici la structure de base d’une boucle for :

python

for variable in sequence:
    # Bloc de code à exécuter pour chaque élément
    # La variable contient l’élément courant

La boucle for fonctionne comme ceci :

Python prend le premier élément de la séquence et l’assigne à la variable
Le bloc de code (indenté sous l’instruction for) s’exécute
Python prend l’élément suivant, l’assigne à la variable, et exécute de nouveau le bloc
Cela continue jusqu’à ce que tous les éléments de la séquence aient été traités

Voyons un exemple simple avec une chaîne :

python

# Afficher chaque caractère dans un nom
name = "Alice"
for character in name:
    print(character)

Output:

A
l
i
c
e

Dans cet exemple, la chaîne "Alice" est la séquence. La boucle traite chaque caractère un à un. Lors de la première itération, character contient 'A', lors de la deuxième itération il contient 'l', et ainsi de suite. Le nom de variable character est notre choix — nous aurions pu l’appeler letter, char, ou même simplement c. Choisissez des noms qui rendent l’objectif de votre code clair.

Conventions de nommage des variables de boucle : Lorsque vous écrivez des boucles for, choisissez des noms de variables qui décrivent ce que représente chaque élément. Utilisez des noms descriptifs comme character, student, ou score lorsque la valeur compte pour comprendre votre code. Utilisez i pour des compteurs numériques simples lorsque vous ne faites que compter les itérations. Utilisez _ (underscore) lorsque vous n’avez pas besoin de la valeur — c’est une convention Python qui signifie « je m’en fiche de cette valeur ».

Voici un exemple pratique qui compte les voyelles dans un mot :

python

# Compter les voyelles dans un mot
word = "Python"
vowel_count = 0
 
for letter in word:
    if letter in "aeiouAEIOU":
        vowel_count += 1
        print(f"Found vowel: {letter}")
 
print(f"Total vowels: {vowel_count}")

Output:

Found vowel: o
Total vowels: 1

La boucle examine chaque lettre de "Python". Lorsqu’elle trouve une voyelle (en utilisant l’opérateur in que nous avons appris au chapitre 7), elle incrémente le compteur et affiche un message. Ce schéma — initialiser un compteur avant la boucle, puis le mettre à jour à l’intérieur — est extrêmement courant en programmation.

Voici un autre exemple qui démontre l’accumulation en construisant un résultat :

python

# Compter les lettres majuscules dans une chaîne
text = "Python Programming"
uppercase_count = 0
 
for char in text:
    if char.isupper():
        uppercase_count += 1
 
print(f"Found {uppercase_count} uppercase letters in '{text}'")

Output:

Found 2 uppercase letters in 'Python Programming'

Cet exemple montre le schéma d’accumulation : nous initialisons un compteur à zéro avant la boucle, puis examinons chaque caractère et incrémentons le compteur lorsque nous trouvons une lettre majuscule. Une fois la boucle terminée, nous utilisons le résultat accumulé. Ce schéma apparaît constamment en programmation — compter des éléments qui satisfont certains critères, sommer des valeurs, ou construire des résultats petit à petit.

12.1.2) Comprendre l’itération

L’itération(iteration) est le processus qui consiste à répéter une action pour chaque élément d’une collection. Quand nous disons qu’un objet est itérable(iterable), nous voulons dire que Python peut traiter ses éléments un par un dans une boucle for. Les chaînes sont itérables — nous pouvons parcourir leurs caractères. Comme nous le verrons bientôt, beaucoup d’autres types Python sont aussi itérables.

La variable dans une boucle for (comme character ou letter dans nos exemples) s’appelle la variable de boucle(loop variable). Cette variable est automatiquement créée par la boucle for et n’existe qu’à l’intérieur de la portée de la boucle. À chaque passage dans la boucle, Python assigne l’élément suivant de la séquence à cette variable.

Voici un exemple qui montre comment la variable de boucle change :

python

# Montrer comment la variable de boucle se met à jour
colors = "RGB"  # Rouge, Vert, Bleu
for color_code in colors:
    print(f"Processing color code: {color_code}")
    print(f"  This is iteration for '{color_code}'")

Output:

Processing color code: R
  This is iteration for 'R'
Processing color code: G
  This is iteration for 'G'
Processing color code: B
  This is iteration for 'B'

À chaque passage dans la boucle, color_code contient un caractère différent de la chaîne. La boucle passe automatiquement au caractère suivant — nous n’avons pas besoin d’écrire de code pour avancer dans la séquence.

12.1.3) La boucle for vs la boucle while pour l’itération

Nous pourrions accomplir le même traitement caractère par caractère avec une boucle while, mais cela demande plus de code et une gestion manuelle :

python

# Utiliser une boucle while pour itérer sur une chaîne (plus complexe)
name = "Alice"
index = 0
while index < len(name):
    character = name[index]
    print(character)
    index += 1  # Il faut mettre à jour l’index manuellement

Cela produit la même sortie que notre exemple de boucle for précédent, mais remarquez ce que nous avons dû faire :

Créer et initialiser une variable d’index
Vérifier la condition index < len(name) à chaque itération
Extraire manuellement le caractère avec name[index]
Penser à incrémenter l’index (oublier ceci crée une boucle infinie !)

La boucle for gère tout cela automatiquement :

python

# Utiliser une boucle for pour itérer sur une chaîne (plus simple)
name = "Alice"
for character in name:
    print(character)

C’est beaucoup plus propre et moins sujet aux erreurs. La boucle for est le choix naturel lorsque vous voulez traiter chaque élément d’une collection. Utilisez une boucle while lorsque vous avez besoin de plus de contrôle sur la logique d’itération ou lorsque vous ne savez pas à l’avance combien de fois répéter.

12.2) Utiliser range() pour les boucles de comptage

12.2.1) Présentation de la fonction range()

Alors que les boucles for excellent pour traiter des séquences existantes, nous avons souvent besoin de répéter une action un nombre précis de fois — comme afficher un message cinq fois ou calculer les dix premiers carrés parfaits. La fonction range() de Python génère une séquence de nombres que nous pouvons parcourir avec une boucle for.

La forme la plus simple de range() prend un argument — le nombre d’entiers à générer, en commençant à 0 :

python

# Afficher les nombres de 0 à 4
for number in range(5):
    print(number)

Output:

⚠️ Erreur courante : Les débutants s’attendent souvent à ce que range(5) produise 1, 2, 3, 4, 5, mais il produit en réalité 0, 1, 2, 3, 4. Rappelez-vous : range(n) commence à 0 et s’arrête avant n. Ce comportement « s’arrêter avant » est cohérent avec le slicing de Python, que nous avons appris au chapitre 5. La plage commence à 0 (par défaut) et va jusqu’à, mais sans inclure, la valeur d’arrêt.

Ce schéma est parfait pour répéter une action un nombre précis de fois :

python

# Afficher un message de bienvenue cinq fois
for i in range(5):
    print(f"Welcome! (iteration {i})")

Output:

Welcome! (iteration 0)
Welcome! (iteration 1)
Welcome! (iteration 2)
Welcome! (iteration 3)
Welcome! (iteration 4)

La variable i est un nom courant pour un compteur de boucle (abréviation de « index » ou « iteration »), même si vous pouvez utiliser n’importe quel nom de variable valide. Lorsque la valeur de la variable de boucle n’importe pas pour votre logique, i est un choix conventionnel.

12.2.2) Spécifier des valeurs de début et de fin

Vous pouvez fournir deux arguments à range() pour indiquer à la fois où commencer et où s’arrêter :

python

# Afficher les nombres de 1 à 5
for number in range(1, 6):
    print(number)

Output:

Ici, range(1, 6) commence à 1 et s’arrête avant 6, ce qui nous donne les nombres 1 à 5. C’est utile lorsque vous devez compter à partir d’une valeur autre que zéro.

Utilisons ceci pour calculer une table de multiplication simple :

python

# Afficher la table de 7 de 1 à 10
multiplier = 7
for number in range(1, 11):
    result = multiplier * number
    print(f"{multiplier} × {number} = {result}")

Output:

7 × 1 = 7
7 × 2 = 14
7 × 3 = 21
7 × 4 = 28
7 × 5 = 35
7 × 6 = 42
7 × 7 = 49
7 × 8 = 56
7 × 9 = 63
7 × 10 = 70

La boucle va de 1 à 10, en multipliant chaque nombre par 7. Cela montre comment range() facilite les calculs sur une séquence numérique précise.

12.2.3) Utiliser une valeur de pas

La fonction range() accepte un troisième argument optionnel : la valeur de pas(step), qui détermine de combien augmenter (ou diminuer) entre les nombres :

python

# Afficher les nombres pairs de 0 à 10
for number in range(0, 11, 2):
    print(number)

Output:

Avec range(0, 11, 2), on commence à 0, on s’arrête avant 11, et on augmente de 2 à chaque fois. Cela nous donne tous les nombres pairs de 0 à 10.

Vous pouvez aussi utiliser un pas négatif pour compter à rebours :

python

# Compte à rebours de 10 à 1
for number in range(10, 0, -1):
    print(number)
print("Liftoff!")

Output:

10
9
8
7
6
5
4
3
2
1
Liftoff!

Ici, range(10, 0, -1) commence à 10, s’arrête avant 0, et diminue de 1 à chaque fois. Le pas négatif fait compter la plage à l’envers.

Voyons un exemple pratique qui calcule la somme de tous les nombres impairs de 1 à 100 :

python

# Additionner tous les nombres impairs de 1 à 100
total = 0
for number in range(1, 101, 2):  # Commencer à 1, pas de 2
    total += number
 
print(f"Sum of odd numbers from 1 to 100: {total}")

Output:

Sum of odd numbers from 1 to 100: 2500

En utilisant range(1, 101, 2), nous générons uniquement les nombres impairs (1, 3, 5, ..., 99), ce qui évite d’avoir à vérifier la parité de chaque nombre à l’intérieur de la boucle. Cela rend le code plus efficace et l’intention plus claire.

12.2.4) Ce que range() renvoie réellement

La fonction range() ne crée pas une liste de nombres en mémoire — elle crée un objet range(range object) qui génère des nombres à la demande. C’est efficace en mémoire, surtout pour de grandes plages :

python

# range() renvoie un objet range, pas une liste
numbers = range(1000000)
print(type(numbers))  # Output: <class 'range'>
print(numbers)        # Output: range(0, 1000000)

Output:

<class 'range'>
range(0, 1000000)

Même si cette plage représente un million de nombres, elle utilise très peu de mémoire, car Python ne crée pas réellement les un million de nombres tant que vous n’itèrez pas dessus. Chaque nombre est généré uniquement lorsque la boucle en a besoin.

Si vous avez besoin d’une vraie liste de nombres, vous pouvez convertir la plage :

python

# Convertir un range en liste
small_numbers = list(range(5))
print(small_numbers)  # Output: [0, 1, 2, 3, 4]

Output:

[0, 1, 2, 3, 4]

Nous en apprendrons davantage sur les listes(lists) et la fonction list() au chapitre 14. Pour l’instant, retenez simplement que range() fonctionne parfaitement avec les boucles for sans aucune conversion.

12.3) Itérer sur des chaînes et d’autres séquences

12.3.1) Itérer sur des chaînes caractère par caractère

Nous avons déjà vu plusieurs exemples d’itération sur des chaînes. C’est l’un des usages les plus courants des boucles for parce que les chaînes sont des séquences de caractères, et que nous devons souvent examiner ou traiter chaque caractère individuellement.

Voici un exemple qui valide un mot de passe en vérifiant qu’il contient au moins un chiffre :

python

# Vérifier si un mot de passe contient au moins un chiffre
password = "secure123"
has_digit = False
 
for character in password:
    if character.isdigit():
        has_digit = True
        print(f"Found digit: {character}")
 
if has_digit:
    print("Password contains at least one digit ✓")
else:
    print("Password must contain at least one digit ✗")

Output:

Found digit: 1
Found digit: 2
Found digit: 3
Password contains at least one digit ✓

La boucle examine chaque caractère en utilisant la méthode de chaîne .isdigit() (que nous avons apprise au chapitre 5). Lorsqu’elle trouve un chiffre, elle met has_digit à True. Une fois la boucle terminée, nous vérifions ce drapeau pour déterminer si des chiffres ont été trouvés.

Voici un autre exemple pratique qui compte différents types de caractères :

python

# Analyser les types de caractères dans une chaîne
text = "Hello, World! 123"
letters = 0
digits = 0
spaces = 0
other = 0
 
for char in text:
    if char.isalpha():
        letters += 1
    elif char.isdigit():
        digits += 1
    elif char.isspace():
        spaces += 1
    else:
        other += 1
 
print(f"Letters: {letters}")
print(f"Digits: {digits}")
print(f"Spaces: {spaces}")
print(f"Other: {other}")

Output:

Letters: 10
Digits: 3
Spaces: 2
Other: 2

Cette boucle classe chaque caractère à l’aide de méthodes de chaîne que nous avons apprises au chapitre 5. La chaîne if-elif-else (du chapitre 8) garantit que chaque caractère est compté dans une seule catégorie.

12.3.2) Traiter des chaînes avec des indices

Parfois, vous avez besoin à la fois du caractère et de sa position dans la chaîne. Vous pouvez utiliser range(len(string)) pour itérer sur les indices :

python

# Trouver les positions d’un caractère spécifique
text = "Mississippi"
search_char = "s"
 
print(f"Looking for '{search_char}' in '{text}':")
for index in range(len(text)):
    if text[index] == search_char:
        print(f"  Found at index {index}")

Output:

Looking for 's' in 'Mississippi':
  Found at index 2
  Found at index 3
  Found at index 5
  Found at index 6

La boucle itère sur les indices de 0 à len(text) - 1. Pour chaque index, nous vérifions si le caractère à cette position correspond à notre caractère recherché. Cette approche est utile lorsque vous devez savoir où quelque chose apparaît, pas seulement si cela apparaît.

12.3.3) Itérer sur d’autres types de séquences

La boucle for fonctionne avec toute séquence itérable en Python. Même si nous nous sommes concentrés sur les chaînes dans ce chapitre, vous apprendrez d’autres types de séquences dans les chapitres suivants. Par exemple, le chapitre 14 vous apprendra les listes(lists), qui sont des collections ordonnées pouvant contenir plusieurs valeurs de n’importe quel type. La syntaxe des boucles for reste la même quel que soit le type de séquence sur lequel vous itérez — la boucle s’occupe automatiquement d’obtenir chaque élément depuis la séquence.

12.4) Utiliser break et continue dans les boucles for

12.4.1) L’instruction break dans les boucles for

Tout comme avec les boucles while (chapitre 11), l’instruction break sort immédiatement d’une boucle for, en sautant toutes les itérations restantes. C’est utile lorsque vous avez trouvé ce que vous cherchez et que vous n’avez pas besoin de continuer à chercher.

Voici un exemple qui recherche un caractère spécifique :

python

# Rechercher la première voyelle dans une chaîne
text = "Python"
found_vowel = False
 
for char in text:
    if char.lower() in "aeiou":
        print(f"First vowel found: {char}")
        found_vowel = True
        break  # Arrêter la recherche dès qu’on trouve la première voyelle
 
if not found_vowel:
    print("No vowels found")

Output:

First vowel found: o

Sans break, la boucle continuerait à examiner tous les caractères restants même après avoir trouvé la première voyelle. L’instruction break rend le code plus efficace en s’arrêtant dès que la tâche est terminée.

Voici un exemple pratique qui valide une entrée utilisateur en vérifiant les caractères invalides :

python

# Vérifier si un nom d’utilisateur ne contient que des caractères autorisés
username = "alice_123"
allowed = "abcdefghijklmnopqrstuvwxyz0123456789_"
is_valid = True
 
for char in username:
    if char.lower() not in allowed:
        print(f"Invalid character found: '{char}'")
        is_valid = False
        break  # Pas besoin de vérifier davantage
 
if is_valid:
    print(f"Username '{username}' is valid ✓")
else:
    print(f"Username '{username}' is invalid ✗")

Output:

Username 'alice_123' is valid ✓

La boucle vérifie chaque caractère par rapport à l’ensemble autorisé. Si elle trouve un caractère invalide, elle signale le problème et sort immédiatement de la boucle — cela ne sert à rien de vérifier le reste du nom d’utilisateur une fois qu’on sait qu’il est invalide.

12.4.2) L’instruction continue dans les boucles for

L’instruction continue saute le reste de l’itération en cours et passe à l’élément suivant de la séquence. C’est utile lorsque vous voulez ignorer certains éléments sans quitter entièrement la boucle.

Voici un exemple qui ne traite que certains caractères :

python

# Afficher uniquement les consonnes d’une chaîne
word = "Programming"
 
for letter in word:
    if letter.lower() in "aeiou":
        continue  # Ignorer les voyelles
    print(letter, end="")
print()  # Nouvelle ligne à la fin

Output:

Prgrmmng

Lorsque la boucle rencontre une voyelle, continue saute l’instruction print() et passe au caractère suivant. Seules les consonnes atteignent l’instruction d’affichage.

Voici un exemple plus pratique qui calcule des statistiques tout en ignorant des données invalides. Notez que la méthode .split() (du chapitre 6) renvoie une liste de chaînes, que nous apprendrons au chapitre 14. Pour l’instant, retenez simplement que les boucles for peuvent itérer sur le résultat :

python

# Calculer la moyenne de notes valides (0-100)
# La méthode .split() renvoie une liste de chaînes (chapitre 14)
scores_input = "85 92 -5 78 105 90 88"
valid_scores = 0
total = 0
 
for score_str in scores_input.split():
    score = int(score_str)
    
    if score < 0 or score > 100:
        print(f"Skipping invalid score: {score}")
        continue  # Ignorer cette note
    
    valid_scores += 1
    total += score
 
if valid_scores > 0:
    average = total / valid_scores
    print(f"Average of {valid_scores} valid scores: {average:.1f}")
else:
    print("No valid scores to average")

Output:

Skipping invalid score: -5
Skipping invalid score: 105
Average of 5 valid scores: 86.6

La boucle traite chaque chaîne de note. Lorsqu’elle rencontre une note invalide (négative ou supérieure à 100), elle affiche un avertissement et utilise continue pour ignorer l’ajout de cette note au total. Cela permet à la boucle de traiter toutes les notes valides tout en ignorant les notes invalides.

12.4.3) Quand utiliser break et continue

Utilisez break lorsque :

Vous cherchez quelque chose et voulez arrêter dès que vous le trouvez
Vous avez rencontré une condition d’erreur qui rend inutile la poursuite
Vous avez terminé votre tâche et n’avez pas besoin de traiter les éléments restants

Utilisez continue lorsque :

Vous voulez ignorer certains éléments selon une condition
Vous filtrez des données et voulez traiter uniquement les éléments qui satisfont des critères
Vous voulez éviter des instructions if trop imbriquées en gérant tôt les cas particuliers

break comme continue peuvent rendre votre code plus clair en montrant explicitement quand et pourquoi vous changez le flux normal de l’itération. Toutefois, en abuser peut rendre le code plus difficile à suivre — utilisez-les lorsqu’ils améliorent réellement la clarté.

12.5) Utiliser else avec les boucles for

12.5.1) Le motif for-else

Les boucles for de Python prennent en charge une clause else optionnelle qui s’exécute une fois la boucle terminée normalement — c’est-à-dire lorsque la boucle a fini d’itérer sur tous les éléments sans rencontrer d’instruction break. Cela peut sembler étrange au début (pourquoi « else » s’il n’y a pas de « if » ?), mais c’est utile pour distinguer « j’ai trouvé ce que je cherchais » de « j’ai tout cherché et je ne l’ai pas trouvé ».

Voici la structure de base :

python

for item in sequence:
    # Corps de la boucle
    if some_condition:
        break
else:
    # S’exécute uniquement si la boucle s’est terminée sans break
    print("Loop completed normally")

Le bloc else s’exécute si et seulement si la boucle se termine naturellement en épuisant la séquence. Si une instruction break quitte la boucle plus tôt, le bloc else est ignoré.

Voyons un exemple pratique qui recherche une valeur spécifique. La méthode .split() (du chapitre 6) renvoie une liste de chaînes, que nous apprendrons au chapitre 14 :

python

# Rechercher un nombre cible
numbers = "2 4 6 8 10"
target = 7
 
for num_str in numbers.split():
    num = int(num_str)
    if num == target:
        print(f"Found {target}!")
        break
else:
    print(f"{target} not found in the sequence")

Output:

7 not found in the sequence

La boucle parcourt tous les nombres. Comme elle ne trouve jamais 7, elle se termine normalement et le bloc else s’exécute. Cherchons maintenant un nombre qui existe :

python

# Rechercher un nombre cible qui existe
numbers = "2 4 6 8 10"
target = 6
 
for num_str in numbers.split():
    num = int(num_str)
    if num == target:
        print(f"Found {target}!")
        break
else:
    print(f"{target} not found in the sequence")

Output:

Found 6!

Cette fois, lorsque la boucle trouve 6, elle exécute break, ce qui saute entièrement le bloc else. Ce motif gère élégamment les cas « trouvé » et « non trouvé » sans avoir besoin d’une variable drapeau séparée.

12.5.2) Usages pratiques de for-else

Le motif for-else est particulièrement utile pour les opérations de recherche. Voici un exemple qui valide si une chaîne ne contient que des chiffres :

python

# Vérifier si une chaîne est un entier valide
user_input = "12345"
 
for char in user_input:
    if not char.isdigit():
        print(f"Invalid: '{char}' is not a digit")
        break
else:
    print(f"'{user_input}' is a valid integer")

Output:

'12345' is a valid integer

Si l’entrée contient un caractère non numérique, la boucle exécute break et le bloc else ne s’exécute pas. Si tous les caractères sont des chiffres, la boucle se termine normalement et le bloc else confirme la validité.

Testons avec une entrée invalide :

python

# Vérifier si une chaîne est un entier valide (cas invalide)
user_input = "123a5"
 
for char in user_input:
    if not char.isdigit():
        print(f"Invalid: '{char}' is not a digit")
        break
else:
    print(f"'{user_input}' is a valid integer")

Output:

Invalid: 'a' is not a digit

12.5.3) Comparer for-else avec des variables drapeau

Avant d’apprendre for-else, vous auriez pu utiliser une variable drapeau pour suivre si quelque chose a été trouvé :

python

# Utiliser une variable drapeau (approche traditionnelle)
text = "Python"
found_vowel = False
 
for char in text:
    if char.lower() in "aeiou":
        print(f"Found vowel: {char}")
        found_vowel = True
        break
 
if not found_vowel:
    print("No vowels found")

Output:

Found vowel: o

Le motif for-else élimine le besoin de variable drapeau :

python

# Utiliser for-else (plus Pythonic)
text = "Python"
 
for char in text:
    if char.lower() in "aeiou":
        print(f"Found vowel: {char}")
        break
else:
    print("No vowels found")

Output:

Found vowel: o

Les deux approches fonctionnent correctement, mais la version for-else est plus concise et exprime clairement l’intention : « chercher quelque chose, et si vous ne le trouvez pas, faire ceci ». La clause else représente directement le cas « non trouvé ».

12.6) Choisir entre les boucles for et while

12.6.1) Quand utiliser une boucle for

Utilisez une boucle for lorsque :

1. Vous traitez chaque élément d’une collection :

python

# Traiter chaque caractère d’une chaîne
message = "Hello"
for char in message:
    print(char.upper())

Output:

H
E
L
L
O

2. Vous devez répéter une action un nombre précis de fois :

python

# Afficher une ligne de bordure
for i in range(40):
    print("-", end="")
print()

Output:

----------------------------------------

3. Vous itérez sur une plage numérique :

python

# Calculer la factorielle de 5
factorial = 1
for n in range(1, 6):
    factorial *= n
print(f"5! = {factorial}")

Output:

5! = 120

4. Vous savez à l’avance sur quoi vous itérez :

python

# Traiter une séquence connue de valeurs
grades = "A B C D F"
for grade in grades.split():
    print(f"Grade: {grade}")

Output:

Grade: A
Grade: B
Grade: C
Grade: D
Grade: F

La caractéristique clé des boucles for est qu’elles fonctionnent avec une itération définie(definite iteration) — vous savez sur quelle séquence vous itérez, même si vous ne savez pas à l’avance combien d’éléments elle contient.

12.6.2) Quand utiliser une boucle while

Utilisez une boucle while lorsque :

1. Vous répétez jusqu’à ce qu’une condition change :

python

# Continuer à demander jusqu’à ce qu’une entrée valide soit reçue
while True:
    age_input = input("Enter your age: ")
    if age_input.isdigit():
        age = int(age_input)
        if age > 0:
            print(f"Age recorded: {age}")
            break
    print("Please enter a valid positive number")

2. Vous ne savez pas combien d’itérations vous devrez faire :

python

# Compter combien de fois vous pouvez doubler un nombre avant de dépasser 1000
number = 1
count = 0
while number <= 1000:
    number *= 2
    count += 1
print(f"Doubled {count} times to reach {number}")

Output:

Doubled 10 times to reach 1024

3. L’itération dépend de conditions complexes :

python

# Simuler un jeu simple où la santé du joueur diminue
health = 100
turn = 0
 
while health > 0 and turn < 10:
    damage = 15
    health -= damage
    turn += 1
    print(f"Turn {turn}: Health = {health}")
 
if health <= 0:
    print("Game over!")
else:
    print("Survived 10 turns!")

Output:

Turn 1: Health = 85
Turn 2: Health = 70
Turn 3: Health = 55
Turn 4: Health = 40
Turn 5: Health = 25
Turn 6: Health = 10
Turn 7: Health = -5
Game over!

4. Vous avez besoin de plus de contrôle sur la logique d’itération :

python

# Traiter une chaîne mais ignorer les doublons consécutifs
text = "bookkeeper"
index = 0
 
while index < len(text):
    char = text[index]
    print(char, end="")
    
    # Ignorer les caractères identiques consécutifs
    while index < len(text) and text[index] == char:
        index += 1
 
print()

Output:

bokeper

La caractéristique clé des boucles while est l’itération indéfinie(indefinite iteration) — vous continuez jusqu’à ce qu’une condition devienne fausse, mais vous ne savez peut-être pas à l’avance quand cela se produira.

12.6.3) Convertir entre for et while

De nombreux problèmes peuvent être résolus avec l’un ou l’autre type de boucle. Voici la même tâche implémentée des deux façons :

python

# Utiliser une boucle for : sommer les nombres de 1 à 10
total = 0
for number in range(1, 11):
    total += number
print(f"Sum (for loop): {total}")
 
# Utiliser une boucle while : sommer les nombres de 1 à 10
total = 0
number = 1
while number <= 10:
    total += number
    number += 1
print(f"Sum (while loop): {total}")

Output:

Sum (for loop): 55
Sum (while loop): 55

Les deux produisent le même résultat, mais la boucle for est plus concise et moins sujette aux erreurs — il n’y a aucun risque d’oublier d’incrémenter le compteur. Lorsque vous pouvez utiliser l’une ou l’autre, préférez la boucle for.

Cependant, certains problèmes s’expriment plus naturellement avec while :

python

# Trouver la première puissance de 2 supérieure à 1000
power = 1
exponent = 0
 
while power <= 1000:
    exponent += 1
    power = 2 ** exponent
 
print(f"2^{exponent} = {power} (first power of 2 > 1000)")

Output:

2^10 = 1024 (first power of 2 > 1000)

Ce problème ne s’intègre pas naturellement dans une boucle for parce que nous ne savons pas à l’avance combien d’itérations sont nécessaires — nous cherchons une valeur qui satisfait une condition.

Dans ce chapitre, nous avons exploré la boucle for de Python, qui offre une manière claire et puissante d’itérer sur des séquences. Nous avons appris comment range() génère des séquences numériques pour les opérations de comptage, comment contrôler le flux d’une boucle avec break et continue, et comment le motif for-else gère élégamment les opérations de recherche. Nous avons également examiné quand choisir les boucles for plutôt que les boucles while selon la nature de votre tâche d’itération.

La boucle for est l’une des fonctionnalités les plus utilisées de Python. À mesure que vous continuez à apprendre Python, vous utiliserez constamment des boucles for — pour traiter des données issues de fichiers, travailler avec des listes et des dictionnaires, et transformer des collections d’informations. Dans le prochain chapitre, nous explorerons l’instruction match de Python, qui offre une autre façon de prendre des décisions basées sur des valeurs, proposant une alternative plus structurée aux longues chaînes if-elif pour certains types de problèmes.

12. Itération avec les boucles for et range()

12.1) La boucle for et les concepts d’itération

12.1.1) Qu’est-ce qu’une boucle for ?

12.1.2) Comprendre l’itération

12.1.3) La boucle for vs la boucle while pour l’itération

12.2) Utiliser range() pour les boucles de comptage

12.2.1) Présentation de la fonction range()

12.2.2) Spécifier des valeurs de début et de fin

12.2.3) Utiliser une valeur de pas

12.2.4) Ce que range() renvoie réellement

12.3) Itérer sur des chaînes et d’autres séquences

12.3.1) Itérer sur des chaînes caractère par caractère

12.3.2) Traiter des chaînes avec des indices

12.3.3) Itérer sur d’autres types de séquences

12.4) Utiliser break et continue dans les boucles for

12.4.1) L’instruction break dans les boucles for

12.4.2) L’instruction continue dans les boucles for

12.4.3) Quand utiliser break et continue

12.5) Utiliser else avec les boucles for

12.5.1) Le motif for-else

12.5.2) Usages pratiques de for-else

12.5.3) Comparer for-else avec des variables drapeau

12.6) Choisir entre les boucles for et while

12.6.1) Quand utiliser une boucle for

12.6.2) Quand utiliser une boucle while

12.6.3) Convertir entre for et while

12. Itération avec les boucles `for` et `range()`