Maîtriser les boucles en Python

Les boucles en programmation permettent de réaliser des tâches répétitives. L’utilisation des boucles doit être bien maîtrisée si vous ne voulez que votre programme parte dans une boucle infinie par exemple. Mais pas de panique, ce n’est pas sorcier avec un peu de pratique. En Python, il y a deux instructions pour construire des boucles : « while » et « for ».

La boucle « while » en Python

La boucle « while », qui se traduit littéralement « tant que » en français porte bien son nom. C’est une boucle qui se répètera tant que la condition définie reste vraie. Voici le diagramme qui explique son fonctionnement :

Voici ensuite un exemple de boucle « while » écrite en Python :

# Tant que i est inférieur à 10 strictement, on incrémente i
i = 0
while i < 10:
  i += 1
  print(i)
print("Boucle terminée")
# Quand i = 10, le programme sort de la boucle et affiche "Boucle terminée".

La condition de votre boucle « while » est très importante. En effet, suivant la condition que vous définissez quand vous définissez une boucle while, le piège est d’entrer dans une boucle infinie. La forme la plus simple d’une boucle infinie est la suivante :

while True:
  print("Ce blog est super !")

Si vous vous retrouvez dans ce cas là, il faudra interrompre votre programme en appuyant sur le bouton d’interruption ou avec le raccourci CTRL+C. Ce raccourci provoquera dans Python une erreur de type « KeyboardInterrupt ».

L’instruction « continue »

L’instruction « continue » est un mot clé utilisé dans les boucles. Lorsque le programme rencontre ce mot clé, il revient automatiquement au départ et évalue à nouveau la condition. Cela permet d’éviter au programme de passer au travers de toute la boucle et de ne pas perdre du temps sur le reste du code à l’intérieur du bloc. Cependant, je pense (mais je peux me tromper) que ce mot clé peut être évité en réorganisant le code dans la plupart des cas. Néanmoins cet outil est disponible dans le langage donc pourquoi s’en passer ? Il faut, à mon avis, les utiliser uniquement quand on a pas le choix et dans les cas où cela améliore grandement la lecture du code. Une utilisation intensive de ce type de mot clé peut amener à ce qu’on appelle de la programmation spaghetti. Le programme part dans tous les sens 🙂

# Voici un programme qui affiche les nombres impaires uniquement
nb= 0
while nb < 10:
  nb += 1  # on incrémente de 1
  if nb % 2 == 0:  # Si le reste de la division euclidienne est nul => nombre pair.
    continue  # retour au début
  print(nb)

Quand on rentre dans la boucle, le nombre est incrémenté. Si le nombre est pair, on revient directement au début de la boucle et le nombre est alors incrémenté à nouveau. Si le nombre est impair, le programme suit son cours et affiche le nombre. Dans ce cas, nous aurions pu modifier le code pour éviter d’avoir à utiliser le mot clé « continue ».

# Voici un programme qui affiche les nombres impaires uniquement
nb= 0
while nb < 10:
  nb += 1  # on incrémente de 1
  if nb % 2 == 1:  # Si le reste de la division euclidienne est égal à 1 => nombre impair.
    print(nb)
  

Le résultat ici est strictement identique. Cela reste un exemple très simple. Je souhaitais juste attirer votre attention sur ce point. Il vaut mieux réfléchir deux minutes et se poser la question si ce mot clé est indispensable dans notre cas, auquel cas il faudra l’utiliser bien entendu.

L’instruction « break »

L’instruction « break » est quant à elle utilisée pour sortir d’une boucle. Si une condition est remplie et que le mot clé est rencontré par le programme, il sortira alors de la boucle et continuera son chemin. Tout comme le mot clé « continue », il faut réfléchir à deux fois avant d’utiliser ce mot clé. Cependant, il peut être utile de le mettre dans une boucle infinie sinon vous ne pourrez jamais en sortir. Voici un exemple :

while True:  # Boucle infinie.
  print("Quel est votre prénom ?")
  prenom = input()  # input() permet de récupérer ce que tape l'utilisateur dans la variable
  if prenom = "Benjamin":
    break
print("Bonne réponse !")

Dans cet exemple, tant que vous n’aurez pas donné le bon prénom, la boucle se répétera. Vous pouvez aussi faire un CTRL+C :).

La boucle « for » en Python

La boucle « while » vu précédemment se répète tant que sa condition est vraie. Elle se répétera donc un nombre de fois qui nous est inconnu. Si vous connaissez ce nombre, l’instruction « for … in … » est alors plus adaptée. Elle permet de boucler sur un nombre fini de répétitions et son écriture est plus concise.

L’instruction « for » en Python est très similaire à la même instruction dans les autres langages. La différence se trouve sur la façon d’itérer. Les langages « classiques » itèrent sur une suite arithmétique, une suite de nombre avec un début, une fin et un pas déterminé. En Python, l’instruction « for » itère sur un élément qui est dit « itérable ». Cet élément peut être une liste, une chaîne de caractère ou une suite arithmétique. Pour la suite arithmétique, nous verrons l’utilisation de la fonction « range() » dans la section suivante.

liste = ["voiture", "vélo", "à pied"]  # Création d'une liste avec les crochets
chaine = "bus"  # Création d'une chaîne de caractère entre guillemets
for mot in liste:
  print(mot, len(mot))
for character in chaine:
  print(character)

>>> voiture 7
>>> vélo 4
>>> à pied 6
>>> b
>>> u
>>> s

On peut utiliser les instructions break and continue dans les boucles for également. Dans l’exemple suivant, la boucle est définie pour i allant de 0 à 9 (10 exclu). On affiche la valeur de i uniquement si celle-ci est inférieure à 3 strictement. Ensuite, si la valeur de i est égale à 7, on sort de la boucle.

for i in range(10):
    if i == 7:
        break
    if i > 3:
        continue
    print(i)
print('i final :',i)

>>> 0
>>> 1
>>> 2
>>> 3
>>> i final : 7

Enfin, je terminerai cette section sur le fait qu’une boucle « for » peut aussi être écrite et réaliser la même chose avec une boucle « while ». Cependant, l’écriture de la boucle « for » est plus concise.

La fonction range en détails

Lorsque vous souhaitez boucler sur une suite de nombres, la fonction « range() » est faite pour cela. Elle génère des suites arithmétiques. Pour l’utiliser, vous devrez renseigner entre 1 et 3 arguments.

list(range(5))
>>> [0, 1, 2, 3, 4]

list(range(5,15))
>>> [5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

list(range(5,15,2))
>>> [5, 7, 9, 11, 13]

Lorsque vous renseignez un seul paramètre, celui-ci est considéré comme le nombre d’éléments de la suite arithmétique, qui commence par 0 et qui est incrémentée de 1 par défaut. L’argument qui est donné sera toujours considéré comme exclu. Cela rejoint le fonctionnement des indices avec les listes que je décris dans cet article.

Lorsque que vous renseignez deux paramètres, ils correspondent à la valeur de début et la valeur de fin exclue. L’incrément est par défaut de 1.

Enfin, lorsque vous renseignez 3 paramètres, ils correspondent au début, la fin et l’incrément. La valeur de l’incrément peut être négatif. Vous pouvez donc partir d’une valeur élevée et descendre à 0 ou une valeur définie dans le deuxième argument.

names = ['Bob','Ben','Irina','Igor','Lisa','Elise','Sasha','Max','Sam','Axel']
start = 0
end = len(names)
step = 2

# La fonction range dans sa forme la plus simple
for i range(end):
  print(names[i])

# La fonction range peut prendre 3 arguments pour contrôler la boucle
for i in range(start,end,step):
    print(names[i])

# Voici une façon plus pythonique de réaliser la même chose que précédemment
for name in names[::2]:
    print(name)

Bob
Ben
Irina
Igor
Lisa
Elise
Sasha
Max
Sam
Axel

Bob
Irina
Lisa
Sasha
Sam

Bob
Irina
Lisa
Sasha
Sam

Les boucles en Python, la base de votre programme

J’espère vous avoir aidé à mieux comprendre comment fonctionne le deux types de boucles en Python. L’utilisation de l’instruction « for » et « while » dépend de la condition sur laquelle vous allez contrôler la boucle. Les mots clés « continue » et « break » peuvent être très utiles mais leur utilisation doit être limitée à certains cas particuliers.

N’hésitez pas à me laisser un commentaire, j’y répondrai avec plaisir.
A bientôt,
Benjamin