Les structures de contrôle en Python

Dans un programme, il ne suffit pas d’exécuter des instructions les unes après les autres :
il faut parfois prendre des décisions ou répéter des actions.
Ces comportements sont possibles grâce aux structures de contrôle.

Objectifs pédagogiques

L’importance de l’indentation en Python

Contrairement à de nombreux langages (comme C, Java ou JavaScript) qui utilisent des accolades {} pour délimiter les blocs, Python s’appuie entièrement sur l’indentation obligatoire. Si elle est incorrecte ou incohérente, le programme provoquera une erreur de syntaxe (IndentationError).

Exemple correct

Exemple incorrect

Chaque bloc dépendant d’une structure (if, for, while, def, etc.) doit être indenté de manière cohérente. La convention officielle de Python (PEP 8) recommande 4 espaces par niveau d’indentation.

Les conditions

Les conditions sont indispensables pour rendre un programme interactif et intelligent : elles déterminent quel bloc d’instructions sera exécuté. Chaque condition s’évalue en booléen, c’est-à-dire qu’elle renvoie soit True (vrai), soit False (faux).

Syntaxe

Le mot-clé elif signifie else if, c’est-à-dire « sinon, si… ». Les deux-points : indiquent le début d’un bloc. L’indentation (4 espaces) est obligatoire pour délimiter les blocs d’instructions.

Exemple

Ici, Python teste les conditions dans l’ordre. Dès qu’une condition est vraie, son bloc est exécuté et les autres ne sont pas vérifiés. Si aucune condition n’est vraie, le bloc du else est exécuté.

Les opérateurs de comparaison

Les opérateurs de comparaison permettent de comparer des valeurs. Leur résultat est toujours un booléen (True ou False).

| Opérateur | Signification | Exemple | Résultat | | --------- | ------------------- | -------- | -------- | | == | égal à | 5 == 5 | True | | != | différent de | 3 != 4 | True | | < | inférieur à | 2 \leq 5 | True | | <= | inférieur ou égal à | 3 <= 3 | True | | > | supérieur à | 10 > 5 | True | | >= | supérieur ou égal à | 8 >= 9 | False |

Les opérateurs logiques

Les opérateurs logiques permettent de combiner plusieurs conditions dans une seule expression.

| Opérateur | Signification | Exemple | Résultat | | --------- | ------------- | ------------------ | ------------------------------------------ | | and | et logique | x > 0 and x \leq 10 | True si les deux conditions sont vraies | | or | ou logique | x \leq 0 or x > 10 | True si au moins une condition est vraie | | not | négation | not(x \leq 0) | inverse le résultat (True ↔ False) |

Ces opérateurs sont particulièrement utiles pour décrire des cas précis ou combiner des contraintes multiples.

Exemple combiné

Les boucles for

En Python, la boucle for ne fonctionne pas comme dans d’autres langages (où elle est souvent liée à un compteur). Ici, elle parcourt directement les éléments d’une séquence : une liste, une chaîne de caractères, une plage générée avec range(), etc. À chaque tour, la variable de boucle prend automatiquement la valeur suivante de la séquence.

Exemple simple

Ici, range(5) génère la séquence de nombres 0, 1, 2, 3, 4. La variable i prend successivement chacune de ces valeurs, et le bloc de code indenté est exécuté à chaque fois. C’est une structure idéale pour répéter une action un nombre fixe de fois.

Exemple sur une liste

Ici, la variable nom prend tour à tour la valeur de chaque élément de la liste prenoms. Cette forme de boucle est très pratique pour parcourir des collections de données comme des listes, des chaînes ou des tuples.

La fonction range()

La fonction intégrée range() permet de générer une suite de nombres entiers. Sa syntaxe est :

range(debut, fin, pas)

• debut : premier nombre de la séquence (inclus)
• fin : dernier nombre non inclus
• pas : valeur de l’incrément (optionnelle, vaut 1 par défaut)

Exemple :

Si un seul argument est donné (range(5)), Python commence à 0 et s’arrête avant 5. Si deux arguments sont fournis (range(2, 6)), la séquence commence à 2 et s’arrête avant 6. Le troisième argument (pas) permet d’avancer par sauts (ici, de 2 en 2).

Les boucles while

Contrairement à la boucle for, qui parcourt une séquence finie, la boucle while repose sur une condition logique : tant que cette condition reste vraie, le code continue de s’exécuter. Dès qu’elle devient fausse, la boucle s’arrête et le programme reprend son cours normal.

L’important est donc que la condition puisse devenir fausse à un moment donné, sinon la boucle ne s’arrêtera jamais — on parle alors de boucle infinie.

Exemple - Boucle While simple

Ici, la variable compteur augmente de 1 à chaque itération. La boucle s’exécute tant que la condition compteur \leq 5 est vraie, puis s’arrête dès qu’elle devient fausse. Si l’incrémentation compteur += 1 était oubliée, la condition ne changerait jamais et la boucle tournerait indéfiniment.

Exemple interactif

Dans cet exemple, la boucle continue de s’exécuter tant que la condition mot_de_passe != "python" est vraie, c’est-à-dire tant que l’utilisateur n’a pas saisi le bon mot de passe. Dès qu’il entre la bonne valeur, la condition devient fausse et la boucle s’interrompt.

Contrôler une boucle

Dans certains cas, on a besoin d’interrompre ou de modifier le déroulement d’une boucle avant qu’elle n’aille jusqu’au bout. Python propose pour cela deux instructions spéciales : break et continue, qui permettent d’affiner le comportement des boucles for et while.

| Instruction | Effet | Exemple | | ----------- | ------------------------------------------------- | -------------------- | | break | interrompt la boucle immédiatement | if x == 0: break | | continue | saute l’itération courante et passe à la suivante | if x \leq 0: continue |

Le mot-clé break

L’instruction break met fin immédiatement à la boucle, même si la condition ou la séquence n’est pas encore terminée. Elle est souvent utilisée lorsqu’une condition de sortie particulière est atteinte.

Dès que i vaut 5, la condition if i == 5 est vraie et le mot-clé break interrompt la boucle. Le programme reprend alors son exécution après la boucle.

Le mot-clé continue

L’instruction continue, elle, ne stoppe pas complètement la boucle : elle ignore simplement l’itération en cours et passe directement à la suivante.

Ici, lorsque i vaut 3, l’instruction continue fait sauter le print(i) et retourne immédiatement au début de la boucle pour la valeur suivante.

Exemple combiné avec une boucle while

Boucles imbriquées

Il est tout à fait possible de placer une boucle à l’intérieur d’une autre. On parle alors de boucles imbriquées (nested loops en anglais). Ce mécanisme permet de parcourir des structures plus complexes, comme des tableaux à deux dimensions, des matrices ou des listes de listes.

Chaque boucle possède sa propre variable de contrôle, et l’exécution suit un ordre précis : la boucle extérieure s’exécute une fois, puis la boucle intérieure s’exécute complètement avant de revenir à l’extérieur.

Exemple simple - Double boucle for

Ici, pour chaque valeur de i (0, 1, 2), la boucle interne fait varier j (0, 1). Ainsi, la boucle intérieure est entièrement parcourue avant que i n’avance à la valeur suivante. Le nombre total d’itérations est donc le produit des deux plages : 3 × 2 = 6.

Exemple avec une liste de listes

Dans cet exemple, la boucle extérieure parcourt les lignes du tableau, tandis que la boucle intérieure parcourt les valeurs de chaque ligne. C’est un schéma très courant pour manipuler des structures en deux dimensions.

Tu peux aussi combiner des boucles for et while si la logique le nécessite, mais veille à garder ton code lisible et structuré. L’imbrication excessive de boucles rend souvent les programmes difficiles à comprendre et à déboguer.