Ceci est une ancienne révision du document !
Table des matières
Structures répétitives
Principes
Les structures répétitives, également appelées boucles, permettent de répéter automatiquement un bloc d'instructions tant qu'une condition est vraie. Elles sont essentielles en programmation pour automatiser les tâches répétitives et rendre le code plus concis et efficace.
Pourquoi utiliser les structures répétitives ? - Éviter les redondances dans le code. - Automatiser les calculs ou actions répétitives. - Faciliter la gestion de grandes quantités de données.
Les boucles se basent sur une condition logique (exemple : `x < 10`) qui est évaluée à chaque itération : - Si la condition est vraie, le bloc d'instructions est exécuté. - Si elle est fausse, la boucle s'arrête.
Voici un schéma simplifié illustrant le fonctionnement d'une boucle :
Exemple pratique : Un programme qui affiche les nombres de 1 à 5 :
En Python : ```python i = 1 while i ⇐ 5:
print(i)
i += 1
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
Condition
Les structures répétitives reposent sur une condition logique qui détermine si la boucle doit continuer ou s’arrêter. Cette condition est évaluée à chaque itération.
Principe : - Si la condition est vraie, le bloc d'instructions s'exécute. - Si elle est fausse, la boucle s'arrête.
Exemple en Python (affiche les nombres inférieurs à 5) : ```python x = 0 while x < 5:
print(x) x += 1 int x = 0;
while (x < 5) {
System.out.println(x); x++;
Voir aussi Structures conditionnelles
Forme Pour
La boucle Pour (ou `for`) est utilisée lorsque le nombre d’itérations est connu à l’avance. Elle suit généralement ce schéma :
1. Initialisation : Définir une variable de contrôle (ex. : `i = 0`). 2. Condition : Vérifier si la boucle doit continuer (ex. : `i < 10`). 3. Incrémentation/Décrémentation : Modifier la variable à chaque itération (ex. : `i++`).
Syntaxe générale : ```plaintext Pour (initialisation; condition; incrémentation) {
instructions;
}
for i in range(5):
print(i)
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
Forme TantQue
La boucle TantQue (ou `while`) est utilisée lorsque le nombre d'itérations n'est pas connu à l'avance. Elle répète un bloc d'instructions tant qu'une condition logique est vraie.
Syntaxe générale : ```plaintext TantQue (condition) {
instructions;
}
x = 0 while x < 5:
print(x) x += 1 int x = 0;
while (x < 5) {
System.out.println(x); x++;
}
Forme Répéter-Jqa
La boucle Répéter-Jusqu'à (ou `do-while` dans certains langages) exécute un bloc d'instructions au moins une fois, puis vérifie une condition pour décider si elle doit continuer.
Syntaxe générale : ```plaintext Répéter {
instructions;
} Jusqu'à (condition);
x = 0 while True:
print(x)
x += 1
if x >= 5:
break
int x = 0;
do {
System.out.println(x); x++;
} while (x < 5);
Forme généralisée
Les boucles peuvent être combinées et imbriquées pour résoudre des problèmes plus complexes. Cela permet de parcourir plusieurs dimensions de données ou d'exécuter des tâches répétitives liées.
Principe : Une boucle généralisée peut être représentée par : - Une boucle simple : effectue une seule tâche répétitive. - Des boucles imbriquées : une boucle à l’intérieur d’une autre.
Exemple : Boucle imbriquée pour une table de multiplication (en Python) : ```python for i in range(1, 6):
for j in range(1, 6):
print(f"{i} x {j} = {i * j}")
print("---")
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++) {
System.out.println(i + " x " + j + " = " + (i * j));
}
System.out.println("---");
}