7. Les boucles for

08/24/2025 - By 

Retourner à : Python pour débutants

0

Dans ce nouveau chapitre, on va s’attaquer aux boucles for en python. On verra :

  • ce qu’est une boucle for et comment itérer à travers des listes,
  • comment utiliser les fonctions range() et enumerate(),
  • on verra les instructions continue et break
  • et pour finir on verra comment utiliser l’instruction else avec une boucle for.

L’instruction for

Une boucle for, qu’est-ce que c’est ? Et bien une boucle for permet de répéter un bloc de code plusieurs fois, mais contrairement aux boucles while, une boucle for s’execute un nombre de fois déterminé à l’avance.

On va, par exemple, pouvoir utiliser une boucle for pour itérer à travers tous les éléments d’une liste ou d’un dictionnaire, ou encore afin d’executer une instruction un nombre précis de fois. Le plus simple pour mieux comprendre comment une boucle for marche est de s’attaquer à un exemple.

Une boucle for a la structure suivante :

Python
for <item> in <collection>:
   <code_block>

Ici <item>, est la variable qui va contenir l’objet de l’iteration en cours, <collection> est la collection à travers laquelle on veut itérer. Et comme d’habitude, <code_block> est le bloque de code qui sera executé à chaque itération de notre boucle.

Maintenant, mettons tout ça en pratique. Pour cela créons une liste d’ingrédients et utilisons une boucle for pour imprimer chaque ingrédient de la liste :

main.py
ingredients = ["Eggs", "butter", "chocolate"]

print("You need: ")
for ingredient in ingredients:
    print(f"{ingredient}")

Quand python atteint cette instruction for, il va prendre chaque élément de la liste ingredients un à un, stocker l’ingredient de l’itération en cours dans la variable locale ingredient et puis executer le block de code du for, donc ici le print de l’ingrédient.

Si on execute le code on voit bien que chaque ingrédient est affiché à l’écran :

l’instruction range()

Il y a des situations où on veut pouvoir exécuter du code un nombre spécifique de fois. Pour cela, on peut utiliser la fonction range(), qui génère une suite de nombres sur laquelle la boucle for va itérer.

Si on veut créer un boucle qui va itérer à travers les chiffres de 0 à 9, on peut utiliser range en lui passant le nombre 10 en paramètre :

main.py
for i in range(10):
    print(i)

Si on relance le code, on peut voir qu’on a bien les chiffre de 0 à 9 qui sont affichés, étant donné que range exclue la limite supérieur qu’on lui passe en paramètre.

On peut aller plus loin avec range en lui passant quelques paramètre en plus. On peut par exemple lui passer deux paramètre, et dans ce cas, le premier indiquera le nombre de départ et le deuxième la limite exclue jusqu’à laquelle le nombres seront générés. Si on veut générer les nombre de 1 à 10, on peut donc faire :

main.py
for i in range(1, 11):
    print(i)

Ce qui nous donne :

On peut encore passer un paramètre suplémentaire à range(), qui va indiquer de combien on va incrémenter nos valeurs à chaque itération. Si on fait un range(1, 11, 3) on devrait donc obtenir les nombres 1, 4, 7, 10, le prochain nombre serait le nombre 13 qui est plus grand ou égale à 11 et ne sera donc pas renvoyé :

main.py
for i in range(1, 11, 3):
    print(i)

Et si on lance se programme, on obtient bien le résultat attendu :

On a vu comment utilisé range pour des nombres croissants, mais bien entendu avec ces trois paramètre on pourrait aussi générés de suites de nombres décroissants. Par exemple:

main.py
for i in range(20, 5, -5):
    print(i)

Ce qui nous renvoie donc le nombre 20, 15, 10 et puis 5 n’est pas imprimé car c’est notre limite inférieur qui est donc exclue.

l’instruction enumerate()

Il arrive qu’on ait besoin de savoir à quelle position on se trouve dans la boucle, lorsqu’on itère à travers une liste. Pour cela, on peut utiliser la fonction enumerate() à laquelle on va passer notre liste en paramètre, et qui permet d’obtenir à la fois l’index et la valeur de chaque élément de la liste.

Dans un for, ça nous donne la code suivant:

main.py
for index, ingredient in enumerate(ingredients):
     print(f"{index}. {ingredient}")

Et la si on execute notre code on voit bien l’index de chaque ingrédient, suivi de l’ingrédient qui se situe à cet index dans notre liste.

Une petite astuce : si jamais vous souhaitez que l’index commence à une autre position, que 0, vous pouvez passer l’indexe de départ en paramètre en indiquant start= suivi de la position à laquelle votre index doit commencer:

main.py
for index, ingredient in enumerate(ingredients, start=1):
     print(f"{index}. {ingredient}")

Dans cet exemple, on voit que notre index commence bien à 1 et va jusqu’à 3.

continue et break

Lors de notre introduction aux boucles while, on a vue les instruction continue et break. continue, permet de lancer immédiatement la prochaine itération de la boucle sans executer le reste du block de code de celle-ci, et break permet de quitter l’exécution d’une boucle à tout moment.

Ces deux mots-clés peuvent aussi être utilisés dans des boucles for. Par exemple si on souhaite imprimer tous les nombres divisible par trois dans un for qui va de 0 à 20, on peut faire la chose suivante:

main.py
for number in range(0, 20):
    if number % 3 != 0:
        continue
    print(number)

L’execution de ce code nous donne :

Prennons un deuxième exemple, ou on va reprendre notre liste d’ingrédients et on va définir une deuxième liste avec des ingrédients qui ne sont pas disponibles. Si l’un des ingrédients de notre liste est indisponible, on imprime un message à l’écran :

main.py
ingredients = ["eggs", "butter", "chocolate"]
out_of_stock = ["eggs"]
for ingredient in ingredients:
    if ingredient in out_of_stock:
        print(f"{ingredient} is out of stock.")
        break

Si on execute le code, et qu’un de nos ingrédients est indisponible, on a bien le message qui s’affiche :

L’instruction else

Allons un peu plus loin et modifions cette exemple afin qu’on affiche un message indiquant que tous les ingrédients sont disponibles, si aucun des ingrédients n’est trouvé dans la liste d’ingrédients indisponibles.

Ici on pourrait définir une variable qu’on mettrait à True, si jamais on trouve un ingrédient indisponible, et puis, si cette variable est à False quand on quitte la boucle, on peut afficher le message indiquant que tous les ingrédients sont disponibles :

main.py
ingredients = ["eggs", "butter", "chocolate"]
out_of_stock = ["watter"]
found_out_of_stock = False
for ingredient in ingredients:
    if ingredient in out_of_stock:
        found_out_of_stock = True
        print(f"{ingredient} is out of stock.")
        break

if not found_out_of_stock:
    print("All ingredients are in stock.")

Et ce code donne bien le résultat attendu :

Ce code fonctionne, mais en python on à une autre manière d’aboutir au même résultat : on peut utiliser un else ! Et oui, en python on peut utiliser le mot clé else à la fin d’une boucle afin de détecter si la boucle s’est terminé normalement, donc sans être intérrompu par un break.

Ici c’est exactement ce que nous voulons faire, si on trouve un élément qui n’est pas disponible on quitte la boucle avec un break, et si on n’a jamais quitté la boucle avec un break, ça veut dire que tous les ingrédients étaient bien tous disponibles :

main.py
ingredients = ["eggs", "butter", "chocolate"]
out_of_stock = ["watter"]
for ingredient in ingredients:
     if ingredient in out_of_stock:
         print(f"{ingredient} is out of stock.")
         break
else:
     print("All ingredients are in stock.")

Et si on relance le programme on a bien le même résultat :

Et voilà, on a fait le tour des boucles for. Le prochain chapitre sera un projet à faire par vous même, donc n’hésitez pas à revoir les différents concepts vus jusqu’ici avant de passer à la suite.

Ressources

Vous retrouvez ci-dessous un lien vers le code source utilisé dans ce chapitre. Ce lien est uniquement disponible pour les abonnés Standard et Premium.

Laisser un commentaire