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.
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.
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.
Python propose deux types principaux de boucles :
Chaque type a ses cas d'utilisation spécifiques, et le choix dépend de la nature du problème à résoudre.
Les boucles sont particulièrement utiles dans les situations suivantes :
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.
La syntaxe de base d'une boucle for en Python est la suivante :
# 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.
La boucle for peut parcourir différents types de séquences :
# 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)
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 :
# 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
La fonction enumerate() est utile lorsque vous avez besoin à la fois de l'élément et de son index dans une séquence :
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}")
La fonction zip() permet de parcourir plusieurs séquences en parallèle :
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")
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.
La syntaxe de base d'une boucle while est la suivante :
# 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.
La condition d'une boucle while peut être n'importe quelle expression qui renvoie une valeur booléenne (True ou False) :
# 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)
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 :
# 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}")
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 :
# 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)}")
Python offre plusieurs instructions pour contrôler le déroulement des boucles, permettant de modifier leur comportement normal selon certaines conditions.
L'instruction break permet de sortir immédiatement d'une boucle, sans terminer les itérations restantes :
# 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}")
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 :
# 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}")
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 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")
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.
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 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
Les boucles imbriquées sont particulièrement utiles pour parcourir des matrices ou des tableaux bidimensionnels :
# 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
Les boucles imbriquées peuvent avoir un impact sur les performances et la lisibilité du code. Voici quelques conseils pour les utiliser efficacement :
# 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)
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.
La syntaxe de base d'une compréhension de liste est la suivante : [expression for élément in itérable]
# 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)]
On peut ajouter des conditions aux compréhensions de liste pour filtrer les éléments :
# 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']
Les compréhensions de liste offrent plusieurs avantages par rapport aux boucles traditionnelles, mais il est important de savoir quand les utiliser :
# 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}
Les boucles en Python peuvent être utilisées dans de nombreux contextes avancés. Explorons quelques-uns des cas d'usage les plus courants.
Les dictionnaires peuvent être parcourus de plusieurs manières selon qu'on a besoin des clés, des valeurs ou des deux :
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}")
Les boucles sont très utiles pour lire et traiter des fichiers ligne par ligne :
# 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")
Certains patterns reviennent fréquemment lorsqu'on travaille avec des boucles. En voici quelques-uns des plus utiles :
# 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")
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!