# Boucles > [!video] Vidéo explicative > <iframe width="560" height="315" src="https://www.youtube.com/embed/EKDiOhDaxzU?si=Krz3tyMbKOM0EHXm" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe> ## Introduction Les boucles sont des structures de contrôle fondamentales en algorithmique, permettant d'exécuter un bloc d'instructions de manière répétée. Elles sont essentielles pour automatiser des tâches, traiter des collections de données ou effectuer des calculs itératifs. L'utilisation appropriée des boucles est cruciale pour l'efficacité et la concision des algorithmes. > [!note] Lien avec les pré-requis > Les boucles correspondent à des structures de décision et de répétition dans les algorigrammes, où une condition est évaluée pour déterminer la poursuite ou l'arrêt de l'itération. ## 1. Boucle Tant Que La boucle "Tant Que" exécute un bloc d'instructions *tant qu'une condition donnée est vraie*. La condition est évaluée *avant* chaque exécution du bloc. Si la condition est fausse dès le départ, le bloc ne sera jamais exécuté. > [!definition] Définition > Une boucle `Tant Que` est une structure de contrôle itérative qui répète un ensemble d'instructions tant qu'une expression booléenne reste vraie. ### 1.1. Structure en pseudo-code ``` TANT QUE (condition) FAIRE { // Instructions à répéter instruction_1 instruction_2 ... } ``` > [!warning] Attention > Il est impératif que les instructions à l'intérieur de la boucle modifient des variables qui affectent la `condition`. Sans cela, la boucle pourrait ne jamais se terminer, conduisant à une boucle infinie. > [!example] Exemple > ``` > i <- 0 > TANT QUE (i < 5) FAIRE > { > AFFICHER "Itération numéro " + i > i <- i + 1 > } > ``` > Cet exemple affichera "Itération numéro X" pour X allant de 0 à 4. ## 2. Boucle Pour La boucle "Pour" est généralement utilisée lorsque le nombre d'itérations est connu à l'avance, ou lorsque l'on souhaite parcourir les éléments d'une collection. Elle est souvent basée sur un compteur qui est initialisé, testé et incrémenté (ou décrémenté) automatiquement. > [!definition] Définition > Une boucle `Pour` est une structure de contrôle itérative conçue pour exécuter un bloc d'instructions un nombre de fois prédéfini, souvent en utilisant un compteur ou en itérant sur une séquence. ### 2.1. Structure en pseudo-code ``` POUR compteur DE début À fin [PAS DE pas] FAIRE { // Instructions à répéter instruction_1 instruction_2 ... } ``` - `compteur`: Variable d'itération. - `début`: Valeur initiale du compteur. - `fin`: Valeur finale (inclusive ou exclusive selon les conventions). - `pas`: Valeur d'incrémentation/décrémentation (par défaut 1). > [!tip] Utilisation courante > Les boucles `Pour` sont idéales pour parcourir les éléments d'un tableau, d'une liste ou d'une chaîne de caractères, ou pour répéter une action un nombre fixe de fois. > [!example] Exemple > ``` > POUR i DE 1 À 3 FAIRE > { > AFFICHER "Compteur : " + i > } > ``` > Cet exemple affichera "Compteur : 1", "Compteur : 2", "Compteur : 3". ## 3. Boucle Répéter Jusqu'à La boucle "Répéter Jusqu'à" est similaire à la boucle "Tant Que", mais la condition est évaluée *après* l'exécution du bloc d'instructions. Cela garantit que le bloc est exécuté au moins une fois. La boucle se poursuit tant que la condition est fausse, et s'arrête lorsqu'elle devient vraie. (Attention, certains langages utilisent "Répéter Tant Que" où la condition est évaluée après et la boucle continue tant qu'elle est vraie, inverse de "Répéter Jusqu'à".) > [!definition] Définition > Une boucle `Répéter Jusqu'à` est une structure de contrôle itérative qui exécute un bloc d'instructions au moins une fois, puis répète ce bloc tant qu'une condition donnée est fausse (ou jusqu'à ce qu'elle devienne vraie, selon la sémantique du langage). ### 3.1. Structure en pseudo-code ``` RÉPÉTER { // Instructions à répéter instruction_1 instruction_2 ... } JUSQU'À (condition) ``` > [!note] Condition inversée > Dans la sémantique "JUSQU'À", la boucle continue tant que la condition est fausse et s'arrête quand elle devient vraie. C'est l'inverse de la boucle `TANT QUE`. > [!example] Exemple > ``` > choix <- "" > RÉPÉTER > { > AFFICHER "Voulez-vous continuer (oui/non) ?" > LIRE choix > } > JUSQU'À (choix = "oui" OU choix = "non") > ``` > Cet exemple demandera à l'utilisateur de saisir "oui" ou "non" et répétera la question tant que la saisie n'est ni l'un ni l'autre. ## 4. Contrôle des Boucles Il est parfois nécessaire de modifier le comportement normal d'une boucle. Des instructions spécifiques permettent d'interrompre une boucle ou de passer à l'itération suivante. ### 4.1. Instruction `CASSER` (break) > [!definition] CASSER (break) > L'instruction `CASSER` permet de terminer immédiatement la boucle la plus proche qui l'encapsule. L'exécution du programme reprendra à l'instruction qui suit la fin de la boucle. ### 4.2. Instruction `CONTINUER` (continue) > [!definition] CONTINUER (continue) > L'instruction `CONTINUER` permet de sauter le reste des instructions de l'itération courante et de passer directement à l'itération suivante de la boucle. La condition de la boucle est réévaluée. > [!example] Exemple avec `CASSER` et `CONTINUER` > ``` > POUR i DE 1 À 10 FAIRE > { > SI (i = 3) ALORS > { > CONTINUER // Passe à l'itération suivante (i=4) > } > SI (i = 7) ALORS > { > CASSER // Sort de la boucle > } > AFFICHER "Valeur de i : " + i > } > AFFICHER "Fin de la boucle." > ``` > Cet exemple affichera : > "Valeur de i : 1" > "Valeur de i : 2" > "Valeur de i : 4" > "Valeur de i : 5" > "Valeur de i : 6" > "Fin de la boucle." ## Résumé Les boucles sont des outils essentiels en algorithmique pour la répétition d'instructions. - La boucle **Tant Que** répète tant qu'une condition est vraie, la testant avant chaque exécution. - La boucle **Pour** est utilisée pour un nombre d'itérations connu ou pour parcourir des collections. - La boucle **Répéter Jusqu'à** garantit au moins une exécution, la condition étant testée après le bloc. - Les instructions `CASSER` et `CONTINUER` offrent un contrôle fin sur le déroulement des itérations. > [!note] Vers Python > Ces concepts fondamentaux de boucles se retrouvent dans la quasi-totalité des langages de programmation. En Python, par exemple, vous utiliserez `while` pour la boucle `Tant Que` et `for` pour la boucle `Pour` (souvent avec des itérateurs). La boucle `Répéter Jusqu'à` n'existe pas directement mais peut être simulée avec un `while True` et un `break`. ## 🗓️ Historique > **Dernière mise à jour :** `26 octobre 2025` > **Rédigé par :** [[Julien DUQUENNOY]]