Comment faire une boucle sur Python ?

Comment fonctionnent les boucles en Python ? Est-ce que c’est mieux d’utiliser for ou while ? Découvrez comment utiliser les boucles en Python et bien plus en lisant cet article.

Une boucle est une structure de contrôle qui permet de répéter un bloc de code jusqu’à ce qu’une condition soit remplie. Les deux types de boucles qu’on utilise le plus en Python sont la boucle for et la boucle while.

Quels sont les deux boucles de Python ?

Les deux types de boucles en Python sont les boucles while (tant qu’une condition est vraie) et les boucles for (pour un élément dans un itérable).

La boucle while exécute un bloc de code tant qu’une condition est vraie alors que la boucle for itère sur un objet et répète un bloc de code pour chaque élément de l’objet.

On peut donc se dire qu’on utilise la boucle while quand on veut itérer sur un entier (while i < n) car ça ne semble par possible avec une boucle for comme un entier n’est pas itérable 🤷‍♂️.

C’est là que la fonction native range est utile.

range permet de générer un itérable (un objet de type range) sur le quel on peut boucler.

Ainsi, for i in range(n) revient à avoir un while while i < n et ça vient avec plusieurs avantages :

• on pas craindre les boucles infinies si on oublie d’incrémenter i
• le code sera plus court (et lisible) avec un for et range qu’avec un while

Les développeurs Python utilisent donc beaucoup plus souvent les boucles for que les boucles while. Les cas d’utilisations justifiant d’utiliser while plutôt que for sont assez rares.

🧠 TL;DR utilisez les boucles for (avec la fonction range si besoin) plutôt que les boucles while quand vous le pouvez.

La boucle while Python

La boucle while permet de répéter une portion de code tant qu’une condition n’est pas remplie.

Voici un exemple d’une boucle while en Python :

i = 0

while i < 42:
  print(i)
  i += 1

💡 Je vous recommande la lecture de mon article sur les boucles while en Python si vous souhaitez en apprendre plus sur la boucle while !

La boucle for Python

La boucle for permet de boucler sur des itérables comme des listes, des dictionnaires, des tuples et d’autres types d’objets.

Voici un exemple d’une boucle for en Python :

nombres = [1, 2, 3, 4, 5]

for nombre in nombres:
  print(nombre)

💡 Je vous recommande la lecture de mon article sur les boucles for en Python si vous souhaitez en apprendre plus sur la boucle for !

Comment imbriquer des boucles en Python ?

Une boucle imbriquée est une boucle dans une boucle. Les types de boucles peuvent être différents, on peut avoir une boucle while dans une boucle for ou l’inverse. Le nombre d’imbrication est infini mais chaque imbrication augmente la complexité algorithmique de manière exponentielle.

Comment faire une boucle for imbriquée ?

Pour faire une boucle for imbriquée en Python, on met une boucle for dans une autre boucle for. Il faut utiliser 2 noms de variables différents pour chaque boucle for afin d’éviter des résultats inattendus.

for i in range(10):
  for j in range(5):
    print(i, j)

Comment faire une boucle while imbriquée ?

Pour faire une boucle while imbriquée en Python, on met une boucle while dans un autre while. Il faut, par exemple, faire attention de bien utiliser deux indices différents et de remettre l’indice de la boucle interne à 0 à chaque itération de la boucle externe et incrémenter les 2 adéquatement.

Exemple de code avec deux boucles whiles imbriquée

i = 0

# Boucle externe avec la variable i comme indice
while i < 10:
  # On remet bien j à 0 sinon il sera supérieur ou égale à 5 quand i > 0
  j = 0

  # Boucle while interne avec variable j comme indice
  while j < 5:
    print(i, j)
    # On n'oublie pas d'incrémenter j
    j += 1

  # On n'oublie pas d'incrémenter i
  i + = 1

Comment boucler en une seule ligne en Python ?

Les listes en compréhension permettent de coder des boucles en une seule ligne. Par exemple, la boucle [i for i in range(5)] crée une liste python [0, 1, 2, 3, 4].

En d’autres termes, la compréhension de liste :

ma_liste = [i for i in range(5)]

Revient à écrire :

ma_liste = []

for i in range(5):
  ma_liste.append(i)

Dans les deux cas, la variable ma_liste sera égale à [0, 1, 2, 3, 4]

💡 Vous voulez en apprendre plus sur cette syntaxe pour construire des listes en Python ? Alors mon article Comment utiliser les listes en compréhension ? vous intéressera sûrement !

Comment contrôler une boucle Python ?

• break : l’instruction python break permet de sortir de la boucle et de poursuivre l’exécution du script
• continue : l’instruction python continue ignore le reste du contenu de la boucle et passe à l’itération suivante
• pass : l’instruction python pass permet d’avoir une boucle vide en remplaçant son contenu par pass

Comment boucler avec map en Python ?

Une autre manière de boucler sur un objet en Python est d’utiliser la la fonction native map. La fonction map applique une fonction sur chaque élément d’un itérable. Elle prend le plus souvent 2 paramètres :

• une fonction que map applique sur chaque élément de l’objet, souvent une fonction lambda
• un objet itérable sur lequel la fonction sera appliquée sur chaque élément qui le compose

💡 Vous souhaitez en apprendre plus sur lambda ? Alors mon article sur les fonctions anonymes avec lambda vous intéressera sûrement !

Voici un exemple de la fonction map pour boucler en Python :

nombres = [1, 4, 9, 16, 25, 36]

racines = map(math.sqrt, nombres)

print(list(racines))  # [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]

⚠️ on utilise list(racines) car la fonction map renvoie un objet de type map object par défaut sur Python 3, on doit donc “caster” le résultat en liste (par exemple) pour afficher un résultat lisible par l’humain

Comment boucler avec filter en Python ?

La fonction native filter permet de filter des éléments d’un itérable en fonction d’une condition donnée. L’itérable reste inchangé et la fonction filter renvoie un nouvel itérable de type filter sur lequel on a appliqué la fonction de condition de script.

On devra transformer l’objet filter en liste pour pouvoir le lire à l’oeil nu.

filter prend donc 2 paramètres :

• une fonction qui renvoie True ou False. Si elle revoie True, on garde l’élément, sinon on le filtre
• un itérable sur lequel on applique la fonction de filtre

Concrètement, ça donne :

ma_liste = [1, 2, 3, 4, 5]

# fonction qui renvoie True si le nombre donné en argument  est pair
def is_even(n):
  return n % 2 == 0

ma_nouvelle_liste = filter(is_even, ma_liste)

print(list(ma_nouvelle_liste))  # ne contient que les nombres pairs [2, 4]

print(ma_liste)  # toujours [1, 2, 3, 4, 5]

💡 Vous voulez en apprendre plus sur le filtrage en Python ? Je vous recommande la lecture de mon article sur la fonction filter.

Comment boucler avec itertools en Python ?

Itertools est un package en Python qui donne accès à des fonctions permettant d’effectuer des tâches sur des itérables. Le module python donne donc accès à des itérateurs comme accumulate pour faire la somme des éléments d’une liste par exemple.

Prenons l’exemple de chain du module itertools. chain permet de créer un itérateur qui renvoie les éléments du premier itérable, puis passe à l’itérable suivant.

import itertools

ma_chaine = itertools.chain('abc', 'def')

print(ma_chaine)  # <itertools.chain object at 0x103220eb0>

print(list(ma_chaine))  # ['a', 'b', 'c', 'd', 'e', 'f']

Qu’est-ce qu’un itérable en Python ?

Un itérable est un objet Python pour lequel on on peut parcourir chaque élément qui le compose en bouclant dessus. Les types d’itérables les plus connus sont les listes, dictionnaires, tuples, mais aussi les objets de type iterable, filter, map et bien d’autres.

Qu’est-ce qu’un itérateur en Python ?

Un itérateur qui est un objet utilisé pour itérer sur un itérable. L’itérateur connait le nombre d’éléments que l’itérable contient. Il permet de boucler sur un itérable en prenant l’élément actuel (n) de l’itérable et en ayant accès accès à son élément suivant (n + 1) s’il existe.

Comment arrêter une boucle en Python ?

Pour arrêter une boucle en Python quand une certaine condition est remplie, on peut utiliser le mot clé break.

Comment arrêter une boucle infinie ?

Pour arrêter une boucle infinie causé par une mauvaise implémentation de code avec une boucle while, on peut envoyer un signal d’interruption avec Python avec le raccourci clavier CTRL + c par exemple.