img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Python les Bases
Chapitre 6 : Les boucles

Ce chapitre a pour but de vous faire découvrir les boucles, des structures fondamentales qui permettent d'automatiser la répétition de tâches. Vous apprendrez à utiliser la boucle for pour parcourir des éléments et la boucle while pour répéter des actions tant qu'une condition est vraie. Enfin, vous maîtriserez les mots-clés break et continue pour contrôler finement leur comportement et écrire des programmes plus efficaces.

6.1 Introduction aux Boucles

Les boucles sont des structures fondamentales en programmation qui permettent de répéter une série d'instructions plusieurs fois. Elles sont essentielles pour automatiser des tâches répétitives et traiter des collections de données.

6.1.1 Qu'est-ce qu'une boucle ?

Une boucle est une structure de contrôle qui exécute un bloc de code de manière répétée tant qu'une condition spécifiée est vraie. Elle permet d'éviter la répétition manuelle de code et rend les programmes plus efficaces et concis.

Imaginez que vous deviez afficher les nombres de 1 à 100. Sans boucle, vous devriez écrire 100 lignes de code avec des instructions print(). Avec une boucle, vous pouvez accomplir la même tâche avec seulement quelques lignes.

6.1.2 Types de boucles en Python

Python propose deux types principaux de boucles :

  • Boucle for : Utilisée pour itérer sur les éléments d'une séquence (liste, tuple, chaîne de caractères, etc.) ou sur une plage de valeurs définie.
  • Boucle while : Exécute un bloc de code tant qu'une condition spécifiée reste vraie.

Chaque type a ses cas d'utilisation spécifiques, et le choix dépend de la nature du problème à résoudre.

6.1.3 Quand utiliser les boucles ?

Les boucles sont particulièrement utiles dans les situations suivantes :

  • Traitement de collections : Parcourir les éléments d'une liste, d'un dictionnaire ou d'une autre structure de données.
  • Automatisation de tâches répétitives : Exécuter une opération un nombre spécifique de fois.
  • Calculs itératifs : Réaliser des calculs qui nécessitent plusieurs itérations pour converger vers une solution.
  • Validation d'entrée : Redemander une entrée à l'utilisateur jusqu'à ce qu'elle soit valide.

6.2 La Boucle for

La boucle for est l'une des structures de contrôle les plus utilisées en Python. Elle permet d'itérer sur les éléments d'une séquence ou sur tout objet itérable.

6.2.1 Syntaxe de base de for

La syntaxe de base d'une boucle for en Python est la suivante :

syntaxe_for.py
# Syntaxe de base
for élément in séquence:
    # Bloc de code à exécuter
    # pour chaque élément

Le mot-clé for est suivi d'un nom de variable qui représentera chaque élément de la séquence, du mot-clé in, et de la séquence à parcourir. Le bloc de code indenté sous la boucle sera exécuté pour chaque élément.

6.2.2 Parcourir des séquences (listes, chaînes)

La boucle for peut parcourir différents types de séquences :

parcourir_sequences.py
# Parcourir une liste
fruits = ["pomme", "banane", "orange"]
for fruit in fruits:
    print(fruit)

# Parcourir une chaîne de caractères
mot = "Python"
for lettre in mot:
    print(lettre)

# Parcourir un tuple
coordonnées = (10, 20, 30)
for coord in coordonnées:
    print(coord)

6.2.3 La fonction range()

La fonction range() est souvent utilisée avec les boucles for pour générer une séquence de nombres. Elle peut prendre un, deux ou trois arguments :

fonction_range.py
# range(stop) : génère de 0 à stop-1
for i in range(5):
    print(i)  # Affiche 0, 1, 2, 3, 4

# range(start, stop) : génère de start à stop-1
for i in range(2, 6):
    print(i)  # Affiche 2, 3, 4, 5

# range(start, stop, step) : génère de start à stop-1 avec un pas
for i in range(0, 10, 2):
    print(i)  # Affiche 0, 2, 4, 6, 8

6.2.4 Boucle for avec enumerate()

La fonction enumerate() est utile lorsque vous avez besoin à la fois de l'élément et de son index dans une séquence :

enumerate_example.py
fruits = ["pomme", "banane", "orange"]

# Sans enumerate()
for i in range(len(fruits)):
    print(i, fruits[i])

# Avec enumerate() - plus pythonique
for i, fruit in enumerate(fruits):
    print(i, fruit)

# On peut aussi spécifier le début de l'index
for i, fruit in enumerate(fruits, start=1):
    print(f"Fruit n°{i}: {fruit}")

6.2.5 Boucle for avec zip()

La fonction zip() permet de parcourir plusieurs séquences en parallèle :

zip_example.py
noms = ["Alice", "Bob", "Charlie"]
âges = [25, 30, 35]
villes = ["Paris", "Lyon", "Marseille"]

# Parcourir plusieurs listes en parallèle
for nom, âge, ville in zip(noms, âges, villes):
    print(f"{nom} a {âge} ans et habite à {ville}")

# zip() s'arrête à la fin de la séquence la plus courte
noms_courts = ["Alice", "Bob"]
for nom, âge in zip(noms_courts, âges):
    print(f"{nom} a {âge} ans")

6.3 La Boucle while

La boucle while exécute un bloc de code tant qu'une condition spécifiée reste vraie. Contrairement à la boucle for qui itère sur une séquence, la boucle while continue jusqu'à ce que sa condition devienne fausse.

6.3.1 Syntaxe de base de while

La syntaxe de base d'une boucle while est la suivante :

syntaxe_while.py
# Syntaxe de base
while condition:
    # Bloc de code à exécuter
    # tant que la condition est vraie

La condition est évaluée avant chaque itération. Si elle est vraie, le bloc de code est exécuté. Ce processus se répète jusqu'à ce que la condition devienne fausse.

6.3.2 Condition de continuation

La condition d'une boucle while peut être n'importe quelle expression qui renvoie une valeur booléenne (True ou False) :

condition_while.py
# Condition avec comparaison
compteur = 0
while compteur < 5:
    print(compteur)
    compteur += 1

# Condition avec variable booléenne
exécuter = True
while exécuter:
    réponse = input("Continuer? (o/n) ")
    if réponse == 'n':
        exécuter = False

# Condition avec valeur de vérité
liste = [1, 2, 3]
while liste:  # Tant que la liste n'est pas vide
    élément = liste.pop()
    print(élément)

6.3.3 Éviter les boucles infinies

Une boucle infinie se produit lorsque la condition de la boucle while reste toujours vraie. Cela peut causer le blocage du programme. Voici comment les éviter :

boucle_infinie.py
# EXEMPLE DE BOUCLE INFINIE (à éviter)
# compteur = 0
# while compteur < 5:
#     print(compteur)
#     # Oubli d'incrémenter le compteur → boucle infinie

# COMMENT ÉVITER LES BOUCLES INFINIES

# 1. S'assurer que la condition deviendra fausse à un moment
compteur = 0
while compteur < 5:
    print(compteur)
    compteur += 1  # Modification de la variable de condition

# 2. Utiliser un mécanisme de sortie avec break
while True:
    réponse = input("Tapez 'quit' pour quitter: ")
    if réponse == 'quit':
        break  # Sort de la boucle
    print(f"Vous avez tapé: {réponse}")

6.3.4 Compteurs et accumulateurs

Les boucles while sont souvent utilisées avec des compteurs et des accumulateurs pour suivre l'évolution d'une valeur au fil des itérations :

compteurs_accumulateurs.py
# Compteur simple
compteur = 0
while compteur < 10:
    print(f"Itération n°{compteur + 1}")
    compteur += 1

# Accumulateur de valeurs
total = 0
nombre = int(input("Entrez un nombre (0 pour terminer): "))
while nombre != 0:
    total += nombre
    nombre = int(input("Entrez un nombre (0 pour terminar): "))

print(f"La somme des nombres est: {total}")

# Compteur avec condition complexe
nombres = []
entrée = ""
while entrée != "stop":
    entrée = input("Entrez un nombre ou 'stop' pour terminer: ")
    if entrée != "stop":
        nombres.append(int(entrée))

print(f"Vous avez entré {len(nombres)} nombres")
print(f"La moyenne est {sum(nombres) / len(nombres)}")

6.4 Contrôle de Flux dans les Boucles

Python offre plusieurs instructions pour contrôler le déroulement des boucles, permettant de modifier leur comportement normal selon certaines conditions.

6.4.1 L'instruction break

L'instruction break permet de sortir immédiatement d'une boucle, sans terminer les itérations restantes :

instruction_break.py
# Sortir d'une boucle quand une condition est remplie
nombres = [1, 3, 5, 7, 9, 2, 4, 6, 8]

for nombre in nombres:
    if nombre % 2 == 0:  # Si le nombre est pair
        print(f"Premier nombre pair trouvé: {nombre}")
        break  # Sort de la boucle
    print(f"{nombre} est impair")

# Dans une boucle while
while True:
    réponse = input("Entrez 'quit' pour quitter: ")
    if réponse == 'quit':
        break
    print(f"Vous avez dit: {réponse}")

6.4.2 L'instruction continue

L'instruction continue permet de passer à l'itération suivante de la boucle, sans exécuter le reste du code de l'itération courante :

instruction_continue.py
# Sauter certaines itérations
for i in range(10):
    if i % 2 == 0:  # Si i est pair
        continue  # Passe à l'itération suivante
    print(i)  # N'affiche que les nombres impairs

# Traiter uniquement les éléments valides
nombres = [1, 2, 0, 4, 5, 0, 7]

for num in nombres:
    if num == 0:
        print("Division par zéro ignorée")
        continue
    résultat = 10 / num
    print(f"10 / {num} = {résultat}")

6.4.3 La clause else dans les boucles

Une particularité de Python est la clause else qui peut être utilisée avec les boucles. Elle s'exécute seulement si la boucle se termine normalement (sans instruction break) :

else_boucles.py
# else avec une boucle for
nombres = [1, 3, 5, 7, 9]

for num in nombres:
    if num % 2 == 0:
        print(f"Nombre pair trouvé: {num}")
        break
else:
    print("Aucun nombre pair trouvé")

# else avec une boucle while
compteur = 0
while compteur < 5:
    print(compteur)
    compteur += 1
else:
    print("Boucle terminée normalement")

# La clause else ne s'exécute pas si on utilise break
compteur = 0
while compteur < 5:
    if compteur == 3:
        break
    print(compteur)
    compteur += 1
else:
    print("Ce message ne s'affichera pas")

6.5 Boucles Imbriquées

Les boucles imbriquées sont des boucles placées à l'intérieur d'autres boucles. Elles sont utiles pour traiter des structures de données multidimensionnelles ou pour générer des combinaisons.

6.5.1 Principe des boucles imbriquées

Une boucle imbriquée consiste en une boucle interne à l'intérieur d'une boucle externe. Pour chaque itération de la boucle externe, la boucle interne s'exécute complètement :

boucles_imbriquees.py
# Boucles for imbriquées
for i in range(3):  # Boucle externe
    print(f"Boucle externe, itération {i}")
    for j in range(2):  # Boucle interne
        print(f"  Boucle interne, itération {j}")

# Table de multiplication avec boucles imbriquées
for i in range(1, 4):
    for j in range(1, 4):
        produit = i * j
        print(f"{i} x {j} = {produit}")
    print("---")  # Séparateur entre les tables

6.5.2 Parcours de structures bidimensionnelles

Les boucles imbriquées sont particulièrement utiles pour parcourir des matrices ou des tableaux bidimensionnels :

parcours_matrices.py
# Parcours d'une matrice (liste de listes)
matrice = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Parcours par lignes et colonnes
print("Parcours par lignes:")
for ligne in matrice:
    for élément in ligne:
        print(élément, end=" ")
    print()  # Nouvelle ligne après chaque ligne

# Parcours avec indices
print("\nParcours avec indices:")
for i in range(len(matrice)):
    for j in range(len(matrice[i])):
        print(f"matrice[{i}][{j}] = {matrice[i][j]}")

# Recherche dans une matrice
recherché = 5
trouvé = False
for i in range(len(matrice)):
    for j in range(len(matrice[i])):
        if matrice[i][j] == recherché:
            print(f"Trouvé à la position ({i}, {j})")
            trouvé = True
            break  # Sort de la boucle interne
    if trouvé:
        break  # Sort de la boucle externe

6.5.3 Optimisation et lisibilité

Les boucles imbriquées peuvent avoir un impact sur les performances et la lisibilité du code. Voici quelques conseils pour les utiliser efficacement :

optimisation_boucles.py
# 1. Éviter les boucles trop profondes
# Mauvaise pratique (3 niveaux de boucles)
# for i in range(10):
#     for j in range(10):
#         for k in range(10):
#             # Code complexe

# 2. Précalculer les valeurs si possible
# Au lieu de recalculer à chaque itération
n = 1000
for i in range(n):
    for j in range(n):  # n est fixe, pas besoin de recalculer
        # Traitement
        pass

# 3. Utiliser des fonctions pour améliorer la lisibilité
def traiter_ligne(ligne, index_ligne):
    # Traitement de la ligne
    for j, élément in enumerate(ligne):
        print(f"Element [{index_ligne}][{j}]: {élément}")

matrice = [[1, 2], [3, 4], [5, 6]]
for i, ligne in enumerate(matrice):
    traiter_ligne(ligne, i)

# 4. Utiliser des compréhensions de liste quand c'est approprié
# Au lieu de boucles imbriquées pour créer une liste
matrice = [[i * j for j in range(3)] for i in range(3)]
print(matrice)

6.6 Compréhensions de Liste

Les compréhensions de liste (list comprehensions) sont une fonctionnalité puissante de Python qui permet de créer des listes de manière concise et élégante, souvent en remplacement des boucles traditionnelles.

6.6.1 Syntaxe des list comprehensions

La syntaxe de base d'une compréhension de liste est la suivante : [expression for élément in itérable]

syntaxe_comprehensions.py
# Créer une liste avec une boucle for traditionnelle
carrés = []
for x in range(10):
    carrés.append(x**2)

print(carrés)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Même résultat avec une compréhension de liste
carrés = [x**2 for x in range(10)]
print(carrés)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Autres exemples de compréhensions de liste
# Liste des longueurs des mots
mots = ["python", "est", "génial"]
longueurs = [len(mot) for mot in mots]
print(longueurs)  # [6, 3, 7]

# Conversion en majuscules
majuscules = [mot.upper() for mot in mots]
print(majuscules)  # ['PYTHON', 'EST', 'GÉNIAL']

# Création de paires (nombre, carré)
paires = [(x, x**2) for x in range(5)]
print(paires)  # [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16)]

6.6.2 Conditions dans les compréhensions

On peut ajouter des conditions aux compréhensions de liste pour filtrer les éléments :

conditions_comprehensions.py
# Filtrer les nombres pairs
nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pairs = [x for x in nombres if x % 2 == 0]
print(pairs)  # [2, 4, 6, 8, 10]

# Nombres impairs au carré
impairs_carrés = [x**2 for x in nombres if x % 2 != 0]
print(impairs_carrés)  # [1, 9, 25, 49, 81]

# Mots de plus de 3 caractères
mots = ["python", "est", "un", "langage", "de", "programmation"]
longs_mots = [mot for mot in mots if len(mot) > 3]
print(longs_mots)  # ['python', 'langage', 'programmation']

# Condition if-else dans une compréhension
nombres = [1, 2, 3, 4, 5]
resultats = ["pair" if x % 2 == 0 else "impair" for x in nombres]
print(resultats)  # ['impair', 'pair', 'impair', 'pair', 'impair']

6.6.3 Compréhensions vs boucles traditionnelles

Les compréhensions de liste offrent plusieurs avantages par rapport aux boucles traditionnelles, mais il est important de savoir quand les utiliser :

comparaison_comprehensions.py
# AVANTAGES des compréhensions de liste

# 1. Plus concises et lisibles
# Boucle traditionnelle
carrés = []
for i in range(10):
    carrés.append(i**2)

# Compréhension de liste (plus concise)
carrés = [i**2 for i in range(10)]

# 2. Meilleures performances dans certains cas
# Les compréhensions sont généralement plus rapides
# que les boucles for équivalentes

# LIMITATIONS des compréhensions de liste

# 1. Moins adaptées aux opérations complexes
# Si vous avez besoin de plusieurs lignes de code
# ou de structures de contrôle complexes,
# une boucle for traditionnelle est préférable

# 2. Peuvent devenir illisibles si trop complexes
# Compréhension complexe (difficile à lire)
resultat = [x**2 if x % 2 == 0 else x**3 for x in range(10) if x > 3]

# Même logique avec une boucle for (plus lisible)
resultat = []
for x in range(10):
    if x > 3:
        if x % 2 == 0:
            resultat.append(x**2)
        else:
            resultat.append(x**3)

# AUTRES types de compréhensions

# Compréhension de dictionnaire
carrés_dict = {x: x**2 for x in range(5)}
print(carrés_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Compréhension d'ensemble (set)
carrés_set = {x**2 for x in range(5)}
print(carrés_set)  # {0, 1, 4, 9, 16}

6.7 Cas d'Usage Avancés

Les boucles en Python peuvent être utilisées dans de nombreux contextes avancés. Explorons quelques-uns des cas d'usage les plus courants.

6.7.1 Parcours de dictionnaires

Les dictionnaires peuvent être parcourus de plusieurs manières selon qu'on a besoin des clés, des valeurs ou des deux :

parcours_dictionnaires.py
personne = {
    "nom": "Dupont",
    "prénom": "Jean",
    "âge": 30,
    "ville": "Paris"
}

# Parcourir les clés (méthode par défaut)
print("Clés:")
for clé in personne:
    print(clé)

# Parcourir les clés explicitement
for clé in personne.keys():
    print(clé)

# Parcourir les valeurs
print("\nValeurs:")
for valeur in personne.values():
    print(valeur)

# Parcourir les clés et valeurs simultanément
print("\nClés et valeurs:")
for clé, valeur in personne.items():
    print(f"{clé}: {valeur}")

# Parcourir un dictionnaire avec enumerate
print("\nAvec index:")
for i, (clé, valeur) in enumerate(personne.items()):
    print(f"{i}. {clé} = {valeur}")

6.7.2 Boucles avec des fichiers

Les boucles sont très utiles pour lire et traiter des fichiers ligne par ligne :

boucles_fichiers.py
# Lire un fichier ligne par ligne
with open("fichier.txt", "r") as fichier:
    for ligne in fichier:
        print(ligne.strip())  # strip() enlève les sauts de ligne

# Compter les lignes d'un fichier
compteur = 0
with open("fichier.txt", "r") as fichier:
    for ligne in fichier:
        compteur += 1

print(f"Le fichier contient {compteur} lignes")

# Traiter un fichier CSV simple
with open("donnees.csv", "r") as fichier:
    for ligne in fichier:
        données = ligne.strip().split(",")
        # Traiter chaque ligne comme une liste de valeurs
        print(données)

# Écrire dans un fichier avec une boucle
noms = ["Alice", "Bob", "Charlie"]
with open("noms.txt", "w") as fichier:
    for nom in noms:
        fichier.write(nom + "\n")

6.7.3 Patterns courants avec les boucles

Certains patterns reviennent fréquemment lorsqu'on travaille avec des boucles. En voici quelques-uns des plus utiles :

patterns_boucles.py
# 1. Accumulation de valeurs
nombres = [1, 2, 3, 4, 5]
somme = 0
for num in nombres:
    somme += num
print(f"Somme: {somme}")

# 2. Recherche d'éléments
nombres = [10, 20, 30, 40, 50]
recherché = 30
trouvé = False
for num in nombres:
    if num == recherché:
        trouvé = True
        break
print(f"Élément trouvé: {trouvé}")

# 3. Filtrage d'éléments
nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pairs = []
for num in nombres:
    if num % 2 == 0:
        pairs.append(num)
print(f"Nombres pairs: {pairs}")

# 4. Transformation d'éléments
nombres = [1, 2, 3, 4, 5]
carrés = []
for num in nombres:
    carrés.append(num ** 2)
print(f"Carrés: {carrés}")

# 5. Parcours avec index et élément
fruits = ["pomme", "banane", "orange"]
for i, fruit in enumerate(fruits):
    print(f"Index {i}: {fruit}")

# 6. Parcours de plusieurs séquences
noms = ["Alice", "Bob", "Charlie"]
âges = [25, 30, 35]
for nom, âge in zip(noms, âges):
    print(f"{nom} a {âge} ans")
Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!

Revenir aux chapitres : Python les Bases | Allez au cours gratuits