Instructions conditionnelles et boucles : cours de 1re technologique

Jusqu'ici, tes programmes s'exécutaient ligne après ligne, de haut en bas, sans jamais sauter ni revenir en arrière. Or, pour résoudre de vrais problèmes, il faut pouvoir choisir (si le client a moins de 12 ans, le tarif change) et répéter (calculer la somme de tous les entiers de 1 à 100 sans écrire cent additions).

Ces deux besoins correspondent à deux familles d'outils que tu retrouves dans tous les langages de programmation : les instructions conditionnelles et les boucles. Les documents officiels de mathématiques les placent ensemble dans le chapitre d'algorithmique, avec les variables ¹. Tu as déjà manipulé les variables et les affectations ; ce cours s'appuie dessus.

Dans ce cours, nous verrons dans l'ordre :

• les conditions et les booléens, c'est-à-dire ce qui peut être vrai ou faux ;
• l'instruction if avec ses variantes else et elif ;
• la boucle for, quand on sait combien de fois répéter ;
• la boucle while, quand on répète tant qu'une condition est vraie ;
• les deux mots continue et else associés aux boucles ;
• une méthode pour suivre un programme à la main et éviter les erreurs classiques.

On fabrique le plus souvent une condition avec un opérateur de comparaison :

Si x vaut 7, alors x > 5 donne True, x == 8 donne False et x != 8 donne True.

On peut combiner plusieurs conditions avec les mots and, or et not :

• a and b est vrai seulement si les deux conditions sont vraies ;
• a or b est vrai dès qu'au moins une des deux est vraie ;
• not a est vrai quand a est fausse.

Par exemple, x >= 10 and x < 20 est vrai pour x = 15, mais faux pour x = 20, car la deuxième condition échoue.

La forme la plus simple s'écrit ainsi :

note = 14
if note >= 10:
    print("Admis")

La ligne if se termine par deux-points. Les lignes qui dépendent de la condition sont décalées vers la droite : on dit qu'elles sont indentées. Les blocs de code, qu'ils soient conditionnels ou répétés, reposent sur cette indentation de chaque instruction ². Si la condition est fausse, Python saute tout le bloc et passe à la suite.

Pour prévoir aussi ce qui se passe quand la condition est fausse, on ajoute else :

note = 8
if note >= 10:
    print("Admis")
else:
    print("Refusé")

Ici, un seul des deux blocs s'exécute, jamais les deux. Avec note = 8, le programme affiche Refusé.

Quand il y a plus de deux cas, on enchaîne des tests avec elif (contraction de « else if », « sinon si ») :

age = 15
if age < 12:
    tarif = 5
elif age < 18:
    tarif = 8
else:
    tarif = 12
print(tarif)

Python teste les conditions dans l'ordre, s'arrête à la première qui est vraie et ignore les autres. Avec age = 15, la première condition est fausse, la deuxième est vraie : tarif vaut 8.

La fonction range fabrique la suite des entiers que la variable de boucle va parcourir :

• range(5) donne 0, 1, 2, 3, 4 (cinq valeurs, on commence à 0 et on s'arrête avant 5) ;
• range(1, 6) donne 1, 2, 3, 4, 5 ;
• range(0, 10, 2) donne 0, 2, 4, 6, 8 (le troisième nombre est le pas).

for i in range(1, 4):
    print("tour numéro", i)

Ce programme affiche trois lignes, pour i valant 1, puis 2, puis 3. À chaque tour, la variable i reçoit automatiquement la valeur suivante.

Pour sortir de la boucle for, il n'existe pas d'instruction à écrire : il suffit de revenir à la marge, c'est-à-dire à un niveau d'indentation moins profond ². Tout ce qui est décalé fait partie de la boucle ; la première ligne non décalée s'exécute après la fin des répétitions.

Le principe : avant chaque tour, Python évalue la condition. Si elle est vraie, il exécute le bloc puis recommence. Si elle est fausse, il sort de la boucle et poursuit après.

n = 1
tours = 0
while n < 100:
    n = n * 2
    tours = tours + 1
print(n, tours)

Le tableau de suivi montre comment la boucle s'arrête :

Le programme affiche 128 7 : on a doublé sept fois pour dépasser 100.

Une règle pratique : si tu peux répondre à la question « combien de fois ? » avant de lancer la boucle, utilise for. Si la réponse dépend du déroulement du calcul (« jusqu'à ce que le seuil soit dépassé »), utilise while.

Tout programme écrit avec un for peut s'écrire avec un while, mais le for est plus court et évite d'oublier de faire avancer le compteur. C'est donc le choix à privilégier dès que le nombre de tours est connu.

La vraie puissance apparaît quand on place une instruction conditionnelle à l'intérieur d'une boucle. Chaque niveau est alors indenté un cran plus loin. Les boucles et les conditions sont des blocs de code où chaque instruction est décalée ², et on peut les imbriquer.

compteur = 0
for n in range(1, 21):
    if n % 3 == 0:
        compteur = compteur + 1
print(compteur)

Ce programme compte les multiples de 3 entre 1 et 20 : ce sont 3, 6, 9, 12, 15 et 18, donc il affiche 6. Le if est testé à chaque tour du for, mais l'addition n'a lieu que lorsque la condition est vraie.

Python offre deux mots supplémentaires pour affiner le comportement d'une boucle :

• continue passe directement à l'itération suivante, sans exécuter la fin du bloc ² ;
• else, placé après une boucle, exécute un bloc à la sortie normale de la boucle (notion facultative, hors attendus du programme) ².

for n in range(1, 8):
    if n % 2 == 0:
        continue
    print(n)

Pour chaque nombre pair, continue saute le print. Le programme affiche donc 1, 3, 5, 7.