Les boucles en Python

Boucles — for et while

En Python, les instructions s'exécutent séquentiellement : le programme commence par la première ligne, puis passe à la suivante, et ainsi de suite. Cependant, il est souvent utile de répéter un bloc de code plusieurs fois, par exemple jusqu'à ce qu'une condition soit satisfaite. C'est là que les boucles entrent en jeu.

Fonction range()

La fonction intégrée range() génère une séquence de nombres entre une valeur de départ et une valeur d'arrivée. Elle est particulièrement utile pour contrôler le nombre de répétitions dans une boucle for.

range(fin)                  # de 0 à fin-1
range(début, fin)           # de début à fin-1
range(début, fin, pas)      # de début à fin-1 par pas

Exemple

list(range(5))        # [0, 1, 2, 3, 4]
list(range(2, 5))     # [2, 3, 4]
list(range(0, 10, 2)) # [0, 2, 4, 6, 8]
list(range(5, 0, -1)) # [5, 4, 3, 2, 1]  — décompte

Boucle for

La boucle for permet d'itérer sur une collection d'éléments, tels que les générateurs (range()), les séquences (listes, tuples, chaînes), ou les structures de données (dictionnaires, ensembles). Elle exécute automatiquement un bloc de code pour chaque élément de la collection.

for variable in séquence:
    # bloc d'instructions

Exemple — Calcul de la factorielle

La factorielle d'un entier naturel n (notée n!) est le produit de tous les entiers positifs inférieurs ou égaux à n :

n = 5
fact = 1
for i in range(1, n + 1):   # De 1 à n inclus
    fact *= i

print(f"{n}! = {fact}")

5! = 120

Exemple — Somme des éléments d'une liste

somme = 0
liste = [1, 2, 6, 8, 9, 10]
for elem in liste:
    somme += elem

print(f"La somme des éléments = {somme}")

La somme des éléments = 36

Exemple — Parcours d'une chaîne

mot = "Python"
for lettre in mot:
    print(lettre, end="-")
# Sortie : P-y-t-h-o-n-

Exemple — Parcours d'un dictionnaire

etudiant = {"nom": "Ismail", "note": 17, "ville": "Meknès"}

for cle, valeur in etudiant.items():
    print(f"{cle} : {valeur}")

nom : Ismail
note : 17
ville : Meknès

Boucle while

La boucle while répète un bloc de code tant qu'une condition reste vraie. Dès que la condition devient False, la boucle s'arrête. Elle est utilisée lorsque le nombre d'itérations n'est pas connu à l'avance.

while condition:
    # bloc d'instructions
    # (penser à modifier la condition pour éviter une boucle infinie)

Exemple — Compteur simple

compteur = 0
while compteur < 3:
    print(f"Compteur = {compteur}")
    compteur += 1   # indispensable pour éviter la boucle infinie

Compteur = 0
Compteur = 1
Compteur = 2

Éviter la boucle infinie

Trois stratégies pour éviter les boucles infinies :

1. Modifier une variable de contrôle

actif = True
while actif:
    reponse = input("Quitter ? (o/n) ")
    if reponse == "o":
        actif = False   # Met fin à la boucle

Quitter ? (o/n) n
Quitter ? (o/n) n
Quitter ? (o/n) o

2. Utiliser break pour sortir

while True:
    nombre = int(input("Entrez un nombre positif pour s'arrêter : "))
    if nombre > 0:
        break   # Sort immédiatement de la boucle

Entrez un nombre positif pour s'arrêter : -2
Entrez un nombre positif pour s'arrêter : -1
Entrez un nombre positif pour s'arrêter : 1

3. Utiliser un compteur de garde

tentatives = 0
MAX = 5
while tentatives < MAX:
    mdp = input("Mot de passe : ")
    if mdp == "secret":
        print("Accès accordé")
        break
    tentatives += 1
    print(f"Échec ({tentatives}/{MAX})")
else:
    print("Compte bloqué après 5 tentatives.")

Exemple — Saisie de notes jusqu'à une valeur négative

Demander à un enseignant de saisir des notes d'étudiants jusqu'à ce qu'une valeur négative soit entrée, puis calculer la somme et la moyenne des notes valides.

print("Saisie des notes (valeur négative pour terminer)")

somme_notes = 0.0
nb_notes    = 0
note        = 0.0

while note >= 0:
    note = float(input("Entrez une note : "))
    if note >= 0:
        somme_notes += note
        nb_notes    += 1

if nb_notes > 0:
    print(f"Nombre de notes  : {nb_notes}")
    print(f"Somme des notes  : {somme_notes}")
    print(f"Moyenne          : {somme_notes / nb_notes:.2f}")
else:
    print("Aucune note saisie.")

Saisie des notes (valeur négative pour terminer)
Entrez une note : 12
Entrez une note : 13
Entrez une note : 16
Entrez une note : -1
Nombre de notes  : 3
Somme des notes  : 41.0
Moyenne          : 13.67

Boucles imbriquées

Les boucles imbriquées consistent à placer une boucle à l'intérieur d'une autre. Elles permettent de traiter des structures complexes nécessitant des répétitions multi-niveaux :

• Parcourir des tableaux multidimensionnels (matrices).
• Générer des motifs ou des pyramides.
• Produire des combinaisons ou des tables (multiplication, etc.).

Exemple — Générer un motif triangle

Générer le motif :

*
**
***
****
*****
******

for i in range(1, 7):           # Lignes : 1 à 6
    for j in range(i):          # Colonnes : 0 à i-1
        print("*", end="")
    print()                     # Retour à la ligne

*
**
***
****
*****
******

Exemple — Tables de multiplication (1 à 10)

for table in range(1, 11):
    print(f"\n─── Table de {table} ───")
    for multi in range(1, 11):
        print(f"  {table} × {multi:2} = {table * multi:3}")

─── Table de 1 ───
  1 ×  1 =   1
  1 ×  2 =   2
  ...
─── Table de 10 ───
  10 ×  1 =  10
  10 × 10 = 100

Exemple — Matrice identité 4×4

n = 4
for i in range(n):
    for j in range(n):
        print(1 if i == j else 0, end="  ")
    print()

1  0  0  0
0  1  0  0
0  0  1  0
0  0  0  1

Instructions de contrôle de boucle

Python propose trois instructions spéciales pour modifier le déroulement d'une boucle : break, continue et pass.

Instruction break

L'instruction break interrompt immédiatement l'exécution d'une boucle (for ou while), même si la condition de répétition est encore vraie.

Début boucle
  ├─ condition vraie ?
  │     ├─ OUI → exécuter bloc
  │     │        ├─ break rencontré ? → Sortie immédiate ──►
  │     │        └─ non              → retour au début
  │     └─ NON → fin normale ──►

Exemple — Sortie anticipée

for i in range(5):
    if i == 2:
        break       # Sort dès que i vaut 2
    print(i)

0
1

Exemple — Recherche dans une liste

notes = [12, 8, 17, 5, 19, 14]
cible = 17

for i, note in enumerate(notes):
    if note == cible:
        print(f"Note {cible} trouvée à l'indice {i}")
        break
else:
    print(f"Note {cible} introuvable.")

Note 17 trouvée à l'indice 2

Instruction continue

L'instruction continue saute le reste du code de l'itération courante et passe immédiatement à l'itération suivante, sans quitter la boucle.

Exemple — Ignorer une valeur

for i in range(5):
    if i == 2:
        print("On saute 2 !")
        continue        # Retourne au début de la boucle
    print(i)

0
1
On saute 2 !
3
4

Exemple — Filtrer les notes invalides

notes = [12, -1, 15, 200, 8, 17, -5, 10]

print("Notes valides :")
for note in notes:
    if note < 0 or note > 20:
        print(f"  ✗ {note} ignorée (hors [0, 20])")
        continue
    print(f"  ✓ {note}")

Notes valides :
  ✓ 12
  ✗ -1 ignorée (hors [0, 20])
  ✓ 15
  ✗ 200 ignorée (hors [0, 20])
  ✓ 8
  ✓ 17
  ✗ -5 ignorée (hors [0, 20])
  ✓ 10

Instruction pass

L'instruction pass est une instruction vide : elle ne fait rien. Elle sert de corps provisoire pour une boucle ou une fonction non encore implémentée, afin que Python ne lève pas d'erreur de syntaxe.

for i in range(5):
    pass   # À implémenter plus tard

# Utile aussi pour ignorer explicitement certaines valeurs
for note in notes:
    if note < 0:
        pass    # On ne traite pas les notes négatives pour l'instant
    else:
        print(note)

Récapitulatif des instructions de contrôle