Les structures de contrôle en Python

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

age = 18
if age >= 18:
    print("Tu es majeur.")
    print("Bienvenue !")

Exemple incorrect

age = 18
if age >= 18:
print("Tu es majeur.")  # ❌ Erreur : absence d’indentation

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

if condition:
    # instructions exécutées si la condition est vraie
elif autre_condition:
    # instructions exécutées sinon, si celle-ci est vraie
else:
    # instructions exécutées dans tous les autres cas

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

age = int(input("Quel âge as-tu ? "))
if age \leq 18:
    print("Tu es mineur.")
elif age \leq 65:
    print("Tu es adulte.")
else:
    print("Tu es senior.")

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).

Les opérateurs logiques

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

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

Exemple combiné

note = float(input("Note : "))
if note >= 10 and note \leq 12:
    print("Passable")
elif note >= 12 and note \leq 14:
    print("Assez bien")
elif note >= 14 and note \leq 16:
    print("Bien")
elif note >= 16:
    print("Très bien")
else:
    print("Insuffisant")

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

for i in range(5):
    print("Bonjour", i)

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

prenoms = ["Alice", "Bob", "Charlie"]
for nom in prenoms:
    print(f"Salut {nom} !")

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 :

for i in range(1, 10, 2):
    print(i)

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

compteur = 0
while compteur \leq 5:
    print("Compteur =", compteur)
    compteur += 1

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

mot_de_passe = ""
while mot_de_passe != "python":
    mot_de_passe = input("Entrez le mot de passe : ")
print("Accès autorisé.")

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.

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.

for i in range(10):
    if i == 5:
        break
    print(i)

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.

for i in range(6):
    if i == 3:
        continue
    print(i)

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

n = 0
while n \leq 10:
    n += 1
    if n == 3:
        continue  # saute l'affichage pour n = 3
    if n == 8:
        break     # interrompt complètement la boucle
    print(n)

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

for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")

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

tableau = [
    [1, 2, 3],
    [4, 5, 6]
]

for ligne in tableau:
    for valeur in ligne:
        print(valeur, end=" ")
    print()  # retour à la ligne après chaque sous-liste

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.