Répéter des actions un nombre défini de fois : la boucle `for` avec `range()`

Le concept de boucle `for` et son utilité

En programmation, il est extrêmement courant d'avoir besoin de répéter un ensemble d'instructions plusieurs fois. Que ce soit pour traiter chaque élément d'une collection, effectuer un calcul un nombre précis de fois, ou générer une série de valeurs, les boucles sont l'outil fondamental pour l'automatisation de tâches répétitives. La boucle `for` en Python est une structure de contrôle puissante et flexible conçue pour l'itération.

Contrairement à certains autres langages où la boucle `for` est principalement un compteur, la boucle `for` de Python est plus générale : elle itère sur les éléments de n'importe quelle séquence (comme une liste, une chaîne de caractères, un tuple) ou d'autres objets itérables, dans l'ordre où ils apparaissent dans la séquence. Pour l'instant, nous allons nous concentrer sur un cas d'usage très fréquent : répéter un bloc de code un nombre déterminé de fois.

Pour accomplir cela, la boucle `for` est souvent utilisée en conjonction avec la fonction intégrée `range()`, qui génère une séquence de nombres. C'est cette combinaison qui nous permet de dire "fais ceci N fois".

La fonction `range()` : générer des séquences de nombres

Avant de plonger dans la syntaxe de la boucle `for` elle-même, il est essentiel de comprendre la fonction `range()`. Cette fonction génère une séquence immuable de nombres et est couramment utilisée pour boucler un nombre spécifique de fois dans les boucles `for`. Elle peut être appelée de plusieurs manières :

• `range(stop)` : Génère une séquence de nombres commençant par 0 (inclus) et allant jusqu'à `stop` (exclus). Par exemple, `range(5)` génère les nombres 0, 1, 2, 3, 4.
• `range(start, stop)` : Génère une séquence de nombres commençant par `start` (inclus) et allant jusqu'à `stop` (exclus). Par exemple, `range(2, 6)` génère les nombres 2, 3, 4, 5.
• `range(start, stop, step)` : Génère une séquence de nombres commençant par `start` (inclus), allant jusqu'à `stop` (exclus), avec un incrément (ou décrément si négatif) de `step`. Par exemple, `range(1, 10, 2)` génère 1, 3, 5, 7, 9. Et `range(5, 0, -1)` génère 5, 4, 3, 2, 1.

Il est important de noter que `range()` ne crée pas réellement la liste complète des nombres en mémoire, mais plutôt un objet `range` qui génère les nombres à la demande. C'est très efficace en termes de mémoire, surtout pour de grandes séquences.

# Exemples d'utilisation de range()
print(list(range(5)))       # Affiche [0, 1, 2, 3, 4]
print(list(range(3, 8)))    # Affiche [3, 4, 5, 6, 7]
print(list(range(0, 11, 2)))# Affiche [0, 2, 4, 6, 8, 10]
print(list(range(3, 0, -1)))# Affiche [3, 2, 1]

Syntaxe de la boucle `for` avec `range()`

Maintenant que nous comprenons `range()`, voyons comment l'utiliser avec une boucle `for`. La syntaxe générale est :

for variable_iteration in range(...):
    # Bloc de code à répéter
    # Ce bloc est indenté
    # La variable_iteration prendra successivement chaque valeur de la séquence range()

Voici quelques exemples concrets :

# Exemple 1: Répéter une action 5 fois
print("Début de l'exemple 1")
for i in range(5):  # i prendra les valeurs 0, 1, 2, 3, 4
    print(f"Itération numéro {i}")
print("Fin de l'exemple 1\n")

# Exemple 2: Afficher les nombres de 1 à 3
print("Début de l'exemple 2")
for compteur in range(1, 4): # compteur prendra les valeurs 1, 2, 3
    print(compteur)
print("Fin de l'exemple 2\n")

# Exemple 3: Compte à rebours de 3 à 1
print("Début de l'exemple 3")
for decompte in range(3, 0, -1): # decompte prendra les valeurs 3, 2, 1
    print(f"{decompte}...")
print("Partez !")
print("Fin de l'exemple 3")

Dans chaque itération de la boucle, la `variable_iteration` (souvent nommée `i`, `j`, `k` pour des compteurs simples, ou un nom plus descriptif comme `compteur` ou `decompte`) prend la valeur suivante de la séquence générée par `range()`. Le bloc de code indenté sous la ligne `for` est alors exécuté avec cette valeur actuelle de la variable d'itération. Une fois que toutes les valeurs de la séquence `range()` ont été parcourues, la boucle se termine et le programme continue avec les instructions suivant le bloc de la boucle.

Cas d'utilisation et bonnes pratiques

La boucle `for` avec `range()` est incroyablement utile pour :

• Exécuter une tâche un nombre fixe de fois (par exemple, simuler 10 lancers de dés).
• Générer des données séquentielles (par exemple, les N premiers termes d'une suite).
• Accéder à des éléments par index dans des séquences (bien qu'il existe souvent des manières plus pythoniques de le faire directement sur la séquence).

Quelques bonnes pratiques :

• Choisissez des noms de variables d'itération significatifs si le simple `i` n'est pas assez clair, surtout si la variable est utilisée de manière complexe dans la boucle.
• Si vous n'avez pas besoin de la valeur de la variable d'itération elle-même dans le corps de la boucle (vous voulez juste répéter N fois), il est courant d'utiliser un tiret du bas (`_`) comme nom de variable pour indiquer que sa valeur est ignorée : `for _ in range(10): print("Action répétée")`.
• Assurez-vous que les paramètres de `range()` (start, stop, step) sont corrects pour obtenir le nombre exact d'itérations et la séquence de valeurs souhaitées. Une erreur d'un cran (off-by-one error) est fréquente si l'on oublie que `stop` est exclusif.

La maîtrise de la boucle `for` avec `range()` est une étape cruciale pour écrire des programmes plus dynamiques et capables de gérer des tâches répétitives efficacement. Elle est souvent la première structure de boucle que les développeurs Python apprennent et utilisent abondamment.