Les 3 points clés à retenir :

• La boucle for permet d’itérer sur une séquence d’éléments (liste, tuple, chaîne, etc.) en exécutant un bloc de code pour chaque élément. Sa syntaxe concise et ses nombreux cas d’utilisation en font un outil incontournable.

• La boucle while exécute un bloc d’instructions tant qu’une condition donnée est vraie. Elle convient lorsque le nombre d’itérations dépend d’un critère variable ou d’une entrée utilisateur.

• Les instructions break, continue et else permettent de contrôler le flux d’exécution des boucles. Les compréhensions de listes offrent une alternative concise aux boucles for dans certains cas.

Présentation des boucles en Python

Les boucles représentent un concept fondamental en programmation. Elles permettent d’exécuter un même bloc d’instructions de manière répétée, jusqu’à ce qu’une condition particulière soit remplie. Python propose deux types principaux de boucles : la boucle for et la boucle while.

Qu’est-ce qu’une boucle sur Python ?

Une boucle désigne une structure de contrôle qui permet d’itérer, c’est-à-dire de répéter une suite d’instructions, un certain nombre de fois.

En Python, les boucles constituent un outil indispensable pour automatiser des tâches répétitives, parcourir des listes, traiter des données de manière itérative, etc.

La logique d’une boucle for

La boucle for itère sur une séquence d’éléments (liste, tuple, chaîne de caractères, etc.). À chaque itération, la variable de boucle prend la valeur de l’élément courant de la séquence. La boucle s’exécute jusqu’à ce que tous les éléments aient été traités. C’est un moyen puissant d’appliquer une opération sur chaque élément d’un ensemble de données.

La syntaxe d’une boucle for en Python

La syntaxe de base d’une boucle for en Python s’écrit comme suit :

for élément in itérable:
    # Instructions à exécuter

Où :
– élément représente la variable qui prendra successivement les valeurs de l’itérable à chaque tour de boucle.
– itérable est un objet sur lequel on peut itérer, comme une liste, un tuple, un ensemble, un dictionnaire ou même une chaîne de caractères.

Utilisation de la boucle for en Python

La boucle for permet d’itérer sur une séquence d’éléments, en exécutant un bloc de code pour chacun d’entre eux. Elle convient parfaitement lorsqu’on connaît à l’avance le nombre d’itérations à effectuer.

Par exemple, pour afficher chaque élément d’une liste :

fruits = ["pomme", "banane", "orange"]
for fruit in fruits:
    print(fruit)

Affichera :

pomme
banane
orange

Effectuer une boucle for sur une chaîne de caractères, une liste ou un dictionnaire

La boucle for peut parcourir différents types d’itérables en Python :

– Chaîne de caractères :

for lettre in "Python":
    print(lettre)

– Liste :

nombres = [1, 2, 3, 4, 5]
for nombre in nombres:
    print(nombre)

– Dictionnaire (parcourt les clés) :

personne = {"nom": "Dupont", "age": 32}
for cle in personne:
    print(cle, personne[cle])

Les étapes clés pour effectuer une boucle for sont :

1. Initialisation de la boucle avec l’itérable
2. Vérification s’il reste des éléments dans l’itérable
3. Exécution du bloc d’instructions avec l’élément courant
4. Passage à l’élément suivant de l’itérable
5. Fin de la boucle si plus d’éléments

En résumé, la boucle for est un outil puissant en Python pour parcourir des séquences d’éléments de manière simple et lisible. Sa syntaxe concise et ses nombreux cas d’utilisation en font un incontournable de la programmation.

Bouclez selon une condition avec la boucle while

Contrairement à la boucle for qui itère sur une séquence, la boucle while exécute un bloc de code tant qu’une condition donnée est vraie. Elle constitue une structure de contrôle fondamentale en programmation, permettant de répéter des instructions jusqu’à ce qu’un critère soit rempli. Son fonctionnement repose sur l’évaluation d’une expression booléenne (vraie ou fausse) à chaque itération.

Comment écrire et utiliser la condition « while »

La syntaxe de la boucle while s’articule autour de trois éléments clés :

• Le mot-clé while suivi d’une condition booléenne
• Un bloc d’instructions indenté, exécuté tant que la condition est vraie
• Une instruction permettant de modifier la condition pour éviter une boucle infinie

Voici un exemple simple d’utilisation :

compteur = 0
while compteur < 5:
    print(compteur)
    compteur += 1 # Incrémentation du compteur

Dans cet exemple, la boucle s’exécute tant que compteur est inférieur à 5. À chaque itération, la valeur de compteur est affichée, puis incrémentée de 1. Une fois compteur égal à 5, la condition devient fausse et la boucle se termine.

Comment choisir entre boucle for et boucle while

Le choix entre boucle for et boucle while dépend principalement de la nature des données à traiter :

• Utilisez une boucle for lorsque vous savez d’avance le nombre d’itérations à effectuer, ou que vous voulez itérer sur une séquence (liste, chaîne, etc.)
• Préférez une boucle while lorsque le nombre d’itérations dépend d’une condition, souvent liée à des données en entrée ou à un événement externe

Cependant, dans de nombreux cas, les deux boucles sont interchangeables. Le choix relève alors de préférences personnelles ou de considérations de lisibilité du code. En règle générale, on privilégie la boucle for lorsque c’est possible, car elle est plus concise et explicite.

Voici un tableau récapitulatif des principales différences :

	Boucle for	Boucle while
Cas d’utilisation	Itérer sur une séquence connue	Exécuter un bloc tant qu’une condition est vraie
Condition d’arrêt	Fin de la séquence	Condition booléenne devenue fausse
Risque de boucle infinie	Non	Oui, si la condition n’est jamais fausse

Ainsi, les boucles for et while sont des outils complémentaires pour contrôler le flux d’exécution en Python. Leur maîtrise est essentielle pour écrire des programmes robustes et efficaces.

Sortir d’une boucle avec l’instruction break

L’instruction break permet de sortir prématurément d’une boucle, c’est-à-dire d’interrompre son exécution avant la fin prévue. Dès que Python rencontre un break, il quitte immédiatement la boucle en cours sans exécuter le reste des instructions. Pour illustrer, voici un exemple où on souhaite afficher les nombres de 1 à 10, sauf le 5 :

for i in range(1, 11):
    if i == 5:
        break
    print(i)

La sortie sera :

1
2 
3
4

Lorsque i vaut 5, l’instruction break est exécutée, ce qui fait sortir de la boucle for. Ainsi, les nombres 6 à 10 ne sont pas affichés.

Les instructions break et continue

Outre break pour sortir d’une boucle, Python dispose d’une autre instruction : continue. Celle-ci ne met pas fin à la boucle mais passe directement à l’itération suivante en ignorant le reste des instructions pour l’itération en cours. Voici un exemple où on affiche les nombres pairs de 1 à 10 :

for i in range(1, 11):
    if i % 2 != 0:
        continue
    print(i)

La sortie :

2
4
6 
8
10

Quand i est impair, continue est exécuté, ce qui fait passer à l’itération suivante sans afficher i.

Utiliser else dans une boucle for

En Python, il est possible d’associer un bloc else à une boucle for ou while. Ce bloc sera exécuté une fois que la boucle sera terminée, sauf si elle a été interrompue par un break. Cela permet par exemple d’exécuter du code après la boucle si celle-ci s’est déroulée normalement.

for i in range(3):
    print(i)
else:
    print("Boucle terminée")

Affichera :

0
1
2
Boucle terminée

En revanche, si on ajoute un break dans la boucle :

for i in range(3):
    if i == 2:
        break
    print(i)
else:
    print("Boucle terminée") 

La sortie sera :

0 
1

Le bloc else n’est pas exécuté car la boucle a été interrompue par break avant sa fin normale.

En résumé, voici un tableau récapitulatif des instructions pour contrôler les boucles en Python :

Instruction	Rôle
break	Sortir immédiatement de la boucle en cours
continue	Passer à l’itération suivante sans exécuter le reste des instructions
else	Exécuter un bloc de code après la fin normale de la boucle (sauf si break a été utilisé)

Techniques avancées avec les boucles

Faire une boucle dans une boucle : les boucles imbriquées

Les boucles imbriquées, ou boucles nichées, permettent d’itérer sur plusieurs séquences à la fois. Elles consistent à placer une boucle à l’intérieur d’une autre. La boucle externe effectue une itération pour chaque élément de la séquence principale, tandis que la boucle interne s’exécute pour chaque itération de la boucle externe.

Par exemple, pour parcourir les éléments d’une matrice 2D, on utilise deux boucles imbriquées : la boucle externe itère sur les lignes, et la boucle interne sur les colonnes. À chaque itération de la boucle externe, la boucle interne s’exécute entièrement.

matrix = [[1, 2, 3], 
          [4, 5, 6],
          [7, 8, 9]]

for row in matrix:
    for element in row:
        print(element)

Cet exemple affichera chaque élément de la matrice, ligne par ligne. On peut imbriquer autant de boucles que nécessaire, mais au-delà de 3 niveaux, le code devient vite illisible.

Boucler comme un pro avec les « compréhensions de liste » en Python

Les compréhensions de liste sont une syntaxe concise permettant de créer une nouvelle liste en itérant sur une séquence existante. Elles combinent les boucles for et les expressions conditionnelles en une seule ligne de code élégante.

Leur structure générale est :

[expression for item in sequence if condition]

Où :
– expression définit la transformation à appliquer à chaque élément
– item est la variable d’itération
– sequence est la séquence à parcourir (liste, tuple, chaîne…)
– if condition (optionnel) filtre les éléments selon une condition

Exemple classique : créer une liste des carrés des nombres pairs jusqu’à 10 :

squares = [x**2 for x in range(11) if x % 2 == 0]
# Output: [0, 4, 16, 36, 64, 100]

On peut également imbriquer des compréhensions pour créer des listes de listes, de dictionnaires, etc. Bien que concises, elles restent lisibles lorsqu’utilisées à bon escient.

Remplacer les loops for par des compréhensions

Dans de nombreux cas, on peut remplacer une boucle for classique par une compréhension de liste, plus compacte. Cela améliore la lisibilité du code et évite les effets de bord.

Par exemple, au lieu de :

result = []
for x in range(11):
    if x % 2 == 0:
        result.append(x**2)

On peut écrire simplement :

result = [x**2 for x in range(11) if x % 2 == 0]

Cependant, les compréhensions ne conviennent pas à toutes les situations, notamment lorsque :

– Le code dans la boucle est complexe (plusieurs instructions)
– On a besoin d’interrompre la boucle avec break ou continue
– On souhaite modifier la séquence d’origine

Dans ces cas, mieux vaut utiliser une boucle for classique pour plus de clarté. Les compréhensions restent un outil puissant mais à utiliser avec discernement.