While True en Python, n'ayez plus peur des boucles infinies

Les boucles sont un concept fondamental en programmation. Elles consistent à répéter une action. Le langage Python dispose de deux structures: les boucles for et les boucles while. La première sert à parcourir des séquences et la seconde à répéter une action en fonction d’une condition. Et quand cette condition est toujours vraie, on appelle ça une boucle infinie.

On apprend souvent à se méfier des boucles infinies mais pourtant, c'est la base de beaucoup de programmes comme les tâches de fond (telles que les services Windows ou les daemons Linux) ou les jeux (une succession infinie de calculs d'images). C'est même le principe de fonctionnement des microcontrôleurs.

Avec ce tuto :

Vous devriez dédiaboliser la boucle infinie et l'appliquer dans des applications d'automatisation.

La boucle while : exécuter tant qu'une condition est vraie

Commençons par rappeler que la structure d’une boucle avec le mot-clef while :

while condition:
    action

La boucle utilisant le mot-clef while va répéter son action tant que la condition est vraie. Le nombre d’itérations n’est pas connu lors du démarrage de la boucle. La répétition de l'action se fera donc en fonction d’un état.

Cette boucle est souvent illustrée par la suite de Fibonacci pour laquelle nous souhaitons obtenir les valeurs de la suite jusqu’à une certaine limite. D’avance, nous ne connaissons pas le nombre d’itérations. Nous évaluons donc à chaque itération la valeur obtenue et si elle est inférieure à la limite, nous recommençons.

value = 1
previous = 0

while value < 30:
    print(value)
    value, previous = value + previous, value

Ceci est l'illustration classique où la condition est une expression qui retourne une valeur de type booléen, soit True ou False. Valeur que nous pourrions utiliser directement de la manière suivante :

value = 1
previous = 0
in_limit = True

while in_limit:
    print(value)
    value, previous = value + previous, value
    in_limit = value < 30

Que se passe-t-il si nous oublions la dernière ligne de cet extrait ? Et oui, in_limit reste à True ce qui entraine une boucle infinie. Dans ce cas, ce serait une erreur. Et si nous le faisons volontairement ?

Le while True : le cœur de l’automatisation

Un code qui fait souvent réagir avec la boucle while est le suivant :

while True:
    do_something()

Au lieu d’une condition ou d'une variable, nous avons une valeur True qui, cette fois-ci, ne peut jamais prendre une autre valeur. La boucle s’exécutera de manière infinie. À l’école, nous apprenons que c’est mal car, entre autres, le programme tourne alors sans fin.

Mais c’est justement le but !

L’objectif de la programmation est l’automatisation donc répéter des actions, pas juste de lancer des exécutions.

Souvent, cette automatisation consiste simplement à rester à l’écoute afin de réagir en fonction d’un état. Vous avez des dizaines d'exemples avec les Raspberry Pi et les GPIOs.

Si nous voulons faire quelque chose en fonction d'un capteur nous pouvons avoir un programme qui a cette structure (c’est du pseudocode) :

while True:
    if sensor.is_activated():
        do_something()
    time.sleep(1000)

Cette boucle fera quelque chose si le capteur est activé puis (dans tous les cas) attendra une seconde avant de réévaluer le capteur.

Une boucle infinie n'est pas obligée de consommer 100% du CPU de manière indéfinie. Dans l'exemple de code précédent, elle n'occupe pas le CPU pendant la seconde d'attente à chaque cycle (donc probablement la plupart du temps).

Et si on va plus loin, l'exemple précédent est une approche destinée aux débutants pour la rendre compréhensible. C'est du polling ou du busy-waiting. Les problèmes sont que vérifier l'état, ici du capteur, consomme de la ressource et il y a de la latence car si un changement survient, on ne le voit qu'au cycle suivant.

Il y a des moyens plus efficaces qu'un time.sleep() qui nécessitent un article dédié mais dans tous les cas, nous serons dans une boucle while.

Comment arrêter des boucles infinies ?

Certains programmes utiliseront des boucles infinies équivalentes à un while True mais auront tout de même une fin. C'est le cas par exemple pour les jeux vidéo qui calculent des images mais à un moment, le jeu s'arrête.

La manière la plus directe pour arrêter une boucle est d'utiliser l'instruction d'arrêt bien connue : break. Nous pourrions avoir le programme suivant :

while True:
    ...
    if condition:  # Par exemple, click sur exit
        break
    ...
print('All done')

Simple et efficace.

Mais dans cet exemple, nous gérons un état nous jouons encore que nous pouvons évaluer. Il est plus judicieux d'utiliser une variable qui va changer cet état.

running = True

while running:
    ...
    if condition:  # Par exemple, click sur exit
        running = False
    ...
print('All done')

Le bénéfice est que d'autres composants peuvent évaluer cet état et agir en fonction ou le modifier à nouveau.

Reste le cas où vous avez accidentellement basculé dans une boucle qui bloque votre programme. Rappelez-vous que la combinaison de touches Ctrl + c va interrompre votre programme et vous rendre la main. C'est ce que l'on appelle un KeyboardInterrupt.

Quand et comment utiliser une boucle infinie ?

La plupart du temps, vous n'écrirez pas de boucle infinie tout simplement parce que le traitement que vous voulez réaliser a une fin. La réflexion que vous allez avoir pour vos programmes aura donc un début et une fin. Jusqu'au jour où vous devrez répéter ces traitements. Alors ces traitements vont s'inscrire dans un programme de type service que vous lancerez et laisserez tourner jusqu'à l'extinction de la machine.

Notez que ces programmes, vous devrez les lancer en tâche de fond. Sous MacOS ou Linux, c'est le célèbre :

nohup python -m script > output.log 2>&1 &

Je ne suis pas assez expert pour Windows mais regardez l'usage de pythonw (qui fait partie de la distribution standard) ou Start-Process du PowerShell.

Notez qu'une fois que vous avez lancé votre service en tâche de fond, la seule manière de l'arrêter sera de tuer le processus (kill après avoir identifié le processus sous Linux/MacOS ou le gestionnaire de tâches).

En conclusion

Les boucles (pas forcément toujours) infinies sont la base de beaucoup de programmes comme les jeux vidéos, les interfaces graphiques mais aussi les services. Nous sommes en général habitués à écrire des programmes qui ont un début et une fin oubliant que cette action peut être répétée et pas uniquement par un lancement utilisateur.

Les boucles infinies ne sont pas diaboliques. C'est la base de l'automatisation.