Structures Itératives en Python: Les boucles while et for, la fonction range(), les instructions break et continue.

10 min readFeb 14, 2024

Dans notre quotidien, tout comme en programmation nous sommes souvent confrontés à des tâches répétitives et fastidieuses. Imaginons que sur votre répertoire de contacts, vous ayez une liste de dix (10) amis à qui vous voulez envoyer un message pour leur souhaiter une “bonne année 2024”. Une solution plutot simple qu’une personne lambda peut adopter est de faire des “copier-coller” du même message à chaque ami, ce qui prendrait beaucoup de temps et d’efforts.

Contenu de l’article:
· 1. Définition d’une boucle
· 2. La boucle while
· 3. La boucle for
· 4. Utilisation de la fonction range()
· 5. Instructions de contrôle : break et continue
· 6. Quelques exemples pratiques
· 7. Défi à relever: Utilisation de boucles imbriquées.

Un petit défi avant de commencer?

Avant de commencer et pour simplifier le problème, voici comment cela pourrait ressembler en Python :

ami1 = "Roland"
ami2 = "Bob"
ami3 = "Marcus"
ami4 = "David"
ami5 = "Ange"
ami6 = "Frank"
ami7 = "Grace"
ami8 = "Hannah"
ami9 = "Isaac"
ami10 = "Julia"

message = "Bonne et Heureuse année 2024 à toi!"

print("Envoyer un message à", ami1, ": ", message)
print("Envoyer un message à", ami2, ": ", message)
print("Envoyer un message à", ami3, ": ", message)
print("Envoyer un message à", ami4, ": ", message)
print("Envoyer un message à", ami5, ": ", message)
print("Envoyer un message à", ami6, ": ", message)
print("Envoyer un message à", ami7, ": ", message)
print("Envoyer un message à", ami8, ": ", message)
print("Envoyer un message à", ami9, ": ", message)
print("Envoyer un message à", ami10, ": ", message)

Cela fonctionne, mais cela semble assez fastidieux, n’est-ce pas? Eh bien imaginons maintenant qu’au lieu de 10 contacts, vous en ayez en réalité des centaines ou meme des milliers à qui envoyer le message! Qu’allez-vous faire?

La solution? Utiliser une boucle.

Heureusement, avec Python et ses structures itératives, nous pouvons automatiser cette tâche répétitive de manière simple et efficace et of course gagner un temps précieux. Regardons comment nous pourrions accomplir la même tâche en utilisant une boucle for:

amis = ["Roland", "Bob", "Marcus", "David", "Ange", "Frank", "Grace", "Hannah", "Isaac", "Julia"]
message = "Bonne et Heureuse année 2024 à toi!"

for ami in amis:
    print("Envoyer un message à", ami, ": ", message)

Cette approche nous permet de parcourir la liste de nos amis et envoyer le même message à chacun d’eux. C’est beaucoup plus efficace et plus rapide que d’écrire chaque ligne d’envoi du message individuellement.

NB: Le but ici ce n’est pas de comprendre la syntaxe d’une boucle mais juste d’avoir une idée de la puissance de ces structures itératives dans notre la vie réelle.

Dans ce article nous allons donc étudier plus en détails cette notion de boucle en complément de ce qu’on a vu précemment et aussi nous introduirons deux instructions capitales que sont les intructions break et continue.

1. Définition d’une boucle

En programmation, une structure itérative encore appelée boucle est un moyen de répéter l’exécution d’un ensemble d’instructions soit:

un certain nombre de fois ( 5 fois, 20 fois ou 10.000 fois)
oubien jusqu’à ce qu’une condition spécifique soit satisfaite (tant qu’elle soit vraie)

Cela permet d’automatiser des tâches répétitives et de traiter des ensembles de données de manière efficace comme vous l’avez constaté plus haut.

Plus précisément en Python, les structures itératives comprennent principalement deux types de boucles : la boucle while et la boucle for.

2. La boucle while

Définition et Utilité: La boucle while permet de répéter un bloc d’instructions tant qu’une certaine condition spécifiée reste vraie (True). Elle est utile lorsque le nombre d’itérations n’est pas connu à l’avance ou lorsque la répétition doit se poursuivre jusqu’à ce qu’une condition soit remplie.

Par exemple, vous pourriez utiliser une boucle while pour lire les données d'un fichier jusqu'à ce que vous atteigniez la fin du fichier, ou pour demander à l'utilisateur de saisir des informations jusqu'à ce qu'il entre une valeur spécifique.

Syntaxe de base:

while condition:
    # bloc de code à exécuter tant que la condition est vraie

Dans cette structure, condition est une expression booléenne. Tant que cette condition est vraie, le bloc de code à l'intérieur de la boucle while est exécuté de manière répétée. Lorsque la condition devient fausse, l'exécution de la boucle s'arrête et le programme passe à l'instruction suivante après la boucle.

Exemples :

# Exemple 1 : Afficher les nombres de 1 à 5
nombre = 1
while nombre <= 5:
    print(nombre)
    nombre += 1

------------------------ Output --------------------------
1
2
3
4
5

Dans cet exemple, la boucle while affiche les nombres de 1 à 5 en augmentant la valeur de nombre à chaque itération.

# Exemple 2 : Demander à l'utilisateur un nombre positif
nombre = int(input("Entrez un nombre positif : "))
while nombre <= 0:
    print("Le nombre doit être positif!")
    nombre = int(input("Entrez un nombre positif : "))
print("Vous avez entré le nombre", nombre)

Dans cet exemple, la boucle while demande à l'utilisateur de saisir un nombre positif. Tant que l'utilisateur entre un nombre négatif ou zéro, la boucle continue de demander à l'utilisateur de saisir un nombre positif.

Attention aux boucles infinies: Lorsque vous utilisez une boucle while, assurez-vous toujours que la condition finira par devenir fausse à un moment donné. Sinon, vous risquez de créer une boucle infinie, ce qui entraînera le blocage de votre programme.

Par exemple, si vous oubliez d’incrémenter une variable dans une boucle while, la condition restera vraie indéfiniment et votre programme continuera à s'exécuter sans fin.

3. La boucle for

Définition: Elle permet de parcourir une séquence (comme une liste, une chaîne de caractères ou un objet itérable) et exécute un bloc d’instructions pour chaque élément de la séquence. Cela facilite le traitement d’ensembles de données structurés et la réalisation d’opérations répétitives sur chaque élément de la séquence.
Syntaxe de base:

for element in sequence:
    # bloc de code à exécuter pour chaque élément de la séquence

Dans cette structure, element est une variable qui prend successivement la valeur de chaque élément de la sequence. Le bloc de code à l'intérieur de la boucle for est exécuté pour chaque élément de la séquence.

Comparaison avec la boucle while: Contrairement à la boucle while, où vous spécifiez une condition à vérifier, la boucle for est utilisée lorsque vous devez itérer sur une séquence d'éléments connue à l'avance. La boucle for est souvent utilisée lorsque vous avez besoin de parcourir chaque élément d'une séquence de manière séquentielle, sans avoir besoin de gérer manuellement un compteur d'itération.

Par exemple, la boucle for est idéale pour parcourir les éléments d'une liste ou les caractères d'une chaîne de caractères, tandis que la boucle while est plus adaptée lorsque vous devez répéter une séquence d'instructions tant qu'une condition donnée reste vraie.

Exemple:

# Exemple 1 : Afficher les éléments d'une liste
fruits = ["pomme", "banane", "orange"]
for fruit in fruits:
    print(fruit)

-------------------------- Output ---------------------------
pomme
banane
orange

Dans cet exemple, la boucle for parcourt chaque élément de la liste fruits et affiche le fruit correspondant.

4. Utilisation de la fonction range()

La fonction range() est une fonction intégrée en Python qui génère une séquence de nombres selon les paramètres spécifiés. Elle est souvent utilisée en conjonction avec la boucle for pour spécifier une plage d’itération. Cette fonction est extrêmement utile lorsque vous devez itérer sur une séquence de nombres de manière séquentielle.

Exemples: Différentes façons d’utiliser range()

Voici quelques exemples illustrant différentes façons d’utiliser la fonction range() avec les boucles en Python :

Utilisation de range() pour générer une séquence de nombres:

for i in range(5):
  print(i)

------------------------- Output --------------------------
0
1
2
3
4

Dans cet exemple, range(5) génère une séquence de nombres de 0 à 4 (exclusivement), et la boucle for itère sur chaque nombre de cette séquence et l’affiche.

- Utilisation de range() avec un point de départ et une fin:

for i in range(2, 6):
  print(i)

------------------------ Output --------------------------
2
3
4
5

Ici, range(2, 6) génère une séquence de nombres de 2 à 6 (exclusivement), et la boucle for itère sur chaque nombre de cette séquence et l’affiche.

Utilisation de range() avec un pas spécifié:

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

------------------------ Output --------------------------
1
3
5
7
9

Dans cet exemple, range(1, 10, 2) génère une séquence de nombres de 1 à 9 (exclusivement), en sautant de 2 en 2, et la boucle for itère sur chaque nombre de cette séquence et l’affiche.

Utilisation de range() en arrière:

for i in range(4, 0, -1):
  print(i)

------------------------ Output --------------------------
4
3
2
1

Ici, range(4, 0, -1) génère une séquence de nombres de 4 à 1 (exclusivement), en décroissant de 1 à chaque itération, et la boucle for itère sur chaque nombre de cette séquence et l’affiche.

Tous ces exemples illustrent différentes façons d’utiliser la fonction range() avec les boucles en Python, vous permettant ainsi de spécifier facilement des plages d’itération pour vos boucles.

5. Instructions de contrôle : break et continue

L’instruction “break”:

L’instruction break est utilisée pour sortir prématurément d’une boucle lorsqu’une condition spécifique est remplie. Elle permet d’arrêter l’exécution de la boucle immédiatement, même si la condition de fin de boucle n’est pas encore atteinte.

Exemple : utilisation de break pour sortir d’une boucle lorsque la valeur 5 est atteinte.

for i in range(1, 11):
  print(i)
  if i == 5:
    print("Sortie de la boucle")
    break

-------------------------- Output --------------------------
1
2
3
4
5
Sortie de la boucle

Dans cet exemple, la boucle for itère de 1 à 10. Lorsque la valeur de i atteint 5, l’instruction break est exécutée, ce qui sort prématurément de la boucle.

L’instruction “continue”:

L’instruction continue est utilisée pour passer à l’itération suivante de la boucle sans exécuter le reste du code à l’intérieur de la boucle pour cette itération spécifique. Cela permet d’ignorer certaines itérations de la boucle en fonction d’une condition donnée.

Exemple : utilisation de continue pour ignorer les nombres pairs

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

------------------------ Output --------------------------
1
3
5
7
9

Dans cet exemple, la boucle for itère de 1 à 10. Lorsque i est pair, l’instruction continue est exécutée, ce qui passe à l’itération suivante de la boucle sans exécuter le reste du code pour cette itération. Ainsi, seuls les nombres impairs sont affichés.

Ces exemples démontrent comment utiliser efficacement les instructions break et continue pour contrôler le flux d’exécution des boucles en Python. Que ce soit pour sortir prématurément d’une boucle ou ignorer certaines itérations, ces instructions sont des outils puissants pour manipuler le comportement des boucles selon vos besoins.

6. Quelques exemples pratiques

Exemple 1 : Calculer la moyenne des notes d’un étudiant.

Supposons que vous ayez une liste de notes d’un étudiant et que vous vouliez calculer sa moyenne. Voici comment vous pourriez le faire avec une boucle for :

notes = [15, 18, 14, 16, 19]
somme = 0
for note in notes:
  somme += note

moyenne = somme / len(notes)
print("La moyenne des notes est :", moyenne)

------------------------- Output ---------------------------
La moyenne des notes est : 16.4

Exemple 2: Recherche d’un élément dans une séquence prédéfinie (un peu avancé)

Imaginons que vous ayez une liste de nombres et que vous vouliez vérifier si un nombre donné est présent dans la liste. Voici un exemple utilisant une boucle while:

elements = [-85, 45, 17, 3, 6, 9, 12, 15, 2025, 96, 145]
element_recherche = 12
trouve = False
indice = 0

while indice < len(elements):
    if elements[indice] == element_recherche:
        trouve = True
        break
    indice += 1

if trouve == True:
    print("Elément trouvé dans la séquence.")
else:
    print("Elément non trouvé dans la séquence.")


--------------------------- Output -----------------------------
Elément trouvé dans la séquence.

Dans cet exemple, nous utilisons une boucle for pour itérer sur une séquence prédéfinie et comparer chaque élément avec l'élément recherché. Si l'élément est trouvé, nous définissons la variable trouve sur True et sortons de la boucle à l'aide de l'instruction break.

7. Défi à relever: Utilisation de boucles imbriquées.

Une boucle imbriquée est tout simplement une structure de contrôle dans la programmation où une boucle est placée à l’intérieur d’une autre boucle.

Les boucles imbriquées sont couramment utilisées pour traiter des structures de données multidimensionnelles, générer des motifs complexes, effectuer des calculs matriciels, ou pour toute autre tâche nécessitant des itérations multiples dans un contexte de programmation.

Exemple : Affichage d’un motif de carré à l’aide d’étoiles

n = 6
for i in range(n):
    for j in range(n):
        print("*", end=" ")
    print()

------------------------- Output ---------------------------
* * * * * * 
* * * * * * 
* * * * * * 
* * * * * * 
* * * * * * 
* * * * * *

Maintenat je vous défi de tracer ce motif de triangle en utilisant des boucles for imbriquées :)

# Ecrivez votre solution ici


------------------------- Output ---------------------------
* 
* * 
* * * 
* * * * 
* * * * *

En résumé, les structures itératives en Python permettent de répéter des blocs de code de manière contrôlée, ce qui les rend essentielles pour résoudre une grande variété de problèmes de programmation.