Avez-vous déjà songé à ralentir votre code Python pour en optimiser les performances ou simuler des délais ? Bien que l'objectif principal soit souvent d'accélérer l'exécution, certaines situations nécessitent une pause stratégique. Que ce soit pour attendre le téléchargement d'un fichier, synchroniser des appels API, ou gérer des interfaces graphiques, le recours à la fonction sleep() de Python peut s'avérer crucial. Dans cet article, nous explorerons divers moyens d'intégrer des pauses dans votre code, en utilisant time.sleep(), les décorateurs, les threads, Async IO, et des interfaces graphiques comme Tkinter et wxPython. Plongeons ensemble dans cet univers fascinant !
Avez-vous déjà eu besoin de faire attendre votre programme Python pour quelque chose ? La plupart du temps, vous souhaitez que votre code s'exécute aussi rapidement que possible. Mais il y a des moments où laisser votre code dormir pendant un certain temps est en fait dans votre meilleur intérêt.
Dans ce tutoriel, vous apprendrez à ajouter des appels Python
time.sleep()- Des décorateurs
- Des threads
- Async IO
- Des interfaces graphiques
Cet article est destiné aux développeurs intermédiaires qui cherchent à approfondir leurs connaissances en Python. Si cela vous ressemble, alors commençons !
Ajouter un appel Python sleep() avec time.sleep()
Python offre un support intégré pour mettre votre programme en pause. Le module time a une fonction sleep() que vous pouvez utiliser pour suspendre l'exécution du thread appelant pour le nombre de secondes que vous spécifiez.
Voici un exemple d'utilisation de time.sleep() :
Si vous exécutez ce code dans votre console, vous devriez constater un délai avant de pouvoir entrer une nouvelle instruction dans le REPL.
Vous pouvez tester la durée de la pause en utilisant le module timeit de Python :
Ici, vous exécutez le module timeit avec le paramètre -n, qui indique à timeit combien de fois exécuter l'instruction qui suit. Vous pouvez voir que timeit a exécuté l'instruction 3 fois et que le meilleur temps d'exécution était de 3 secondes, ce qui est ce à quoi on s'attendait.
Le nombre par défaut de fois que timeit exécutera votre code est d'un million. Si vous deviez exécuter le code ci-dessus avec le -n par défaut, alors à 3 secondes par itération, votre terminal se bloquerait pendant environ 34 jours ! Le module timeit a plusieurs autres options en ligne de commande que vous pouvez consulter dans sa documentation.
Créons quelque chose d'un peu plus réaliste. Un administrateur système doit savoir quand l'un de ses sites web tombe en panne. Vous voulez pouvoir vérifier régulièrement le code d'état du site web, mais vous ne pouvez pas interroger le serveur web constamment, sinon cela affectera la performance. Une façon de faire cette vérification est d'utiliser un appel système Python sleep() :
Ici, vous créez uptime_bot(), qui prend une URL comme argument. La fonction tente ensuite d'ouvrir cette URL avec urllib. S'il y a une erreur HTTPError ou URLError, alors le programme la capture et l'imprime. (Dans un environnement réel, vous enregistreriez l'erreur et probablement enverriez un email au webmaster ou à l'administrateur système.)
Si aucune erreur ne se produit, alors votre code imprime que tout va bien. Quoi qu'il arrive, votre programme dormira pendant 60 secondes. Cela signifie que vous accédez au site web seulement une fois par minute. L'URL utilisée dans cet exemple est mauvaise, donc elle affichera ce qui suit dans votre console une fois par minute.
Allez-y et mettez à jour le code pour utiliser une URL valide, comme
http://www.google.com. Ensuite, vous pouvez le réexécuter pour le voir fonctionner avec succès. Vous pouvez également essayer de mettre à jour le code pour envoyer un email ou enregistrer les erreurs. Pour plus d'informations sur la façon de faire cela, consultez l'envoi d'emails avec Python et la journalisation en Python.
Ajouter un appel Python sleep() avec des décorateurs
Il y a des moments où vous devez réessayer une fonction qui a échoué. Un cas d'utilisation populaire pour cela est quand vous devez réessayer de télécharger un fichier parce que le serveur était occupé. Vous ne voudrez généralement pas faire une demande au serveur trop souvent, donc ajouter un appel Python sleep() entre chaque demande est souhaitable.
Un autre cas d'utilisation que j'ai personnellement expérimenté est lorsque je dois vérifier l'état d'une interface utilisateur pendant un test automatisé. L'interface utilisateur peut se charger plus rapidement ou plus lentement que d'habitude, selon l'ordinateur sur lequel je fais le test. Cela peut changer ce qui est affiché à l'écran au moment où mon programme vérifie quelque chose.
Dans ce cas, je peux dire au programme de dormir un moment puis de revérifier les choses une ou deux secondes plus tard. Cela peut faire la différence entre un test réussi et un test échoué.
Vous pouvez utiliser un décorateur pour ajouter un appel système Python sleep() dans l'un de ces cas. Si vous n'êtes pas familier avec les décorateurs, ou si vous souhaitez vous rafraîchir la mémoire à leur sujet, consultez l'introduction aux décorateurs Python. Voyons un exemple :
sleep() est votre décorateur. Il accepte une valeur timeout et le nombre de fois qu'il doit retry, qui par défaut est 3. À l'intérieur de sleep() se trouve une autre fonction, therealdecorator(), qui accepte la fonction décorée.
Enfin, la fonction la plus interne,
wrapper(), accepte les arguments et les mots-clés que vous passez à la fonction décorée. C'est ici que la magie opère ! Vous utilisez une boucle
while pour réessayer d'appeler la fonction. S'il y a une exception, alors vous appelez
time.sleep(), incrémentez le compteur
retries, et essayez de relancer la fonction.
Maintenant, réécrivez uptime_bot() pour utiliser votre nouveau décorateur :
Ici, vous décorez
uptime_bot() avec un
sleep() de 3 secondes. Vous avez également supprimé la boucle
while originale, ainsi que l'ancien appel à
sleep(60). Le décorateur s'en charge maintenant.
Un autre changement que vous avez fait est d'ajouter un
raise à l'intérieur des blocs de gestion des exceptions. C'est pour que le décorateur fonctionne correctement. Vous pourriez écrire le décorateur pour gérer ces erreurs, mais comme ces exceptions ne s'appliquent qu'à
urllib, il pourrait être préférable de garder le décorateur tel quel. De cette façon, il fonctionnera avec une plus grande variété de fonctions.
Il y a quelques améliorations que vous pourriez apporter à votre décorateur. S'il manque de tentatives et échoue toujours, alors vous pourriez le faire relancer la dernière erreur. Le décorateur attendra également 3 secondes après le dernier échec, ce qui pourrait être quelque chose que vous ne voulez pas qu'il se produise. N'hésitez pas à essayer cela comme exercice !
Ajouter un appel Python sleep() avec des threads
Il y a aussi des moments où vous pourriez vouloir ajouter un appel Python sleep() à un thread. Peut-être exécutez-vous un script de migration contre une base de données avec des millions d'enregistrements en production. Vous ne voulez pas causer de temps d'arrêt, mais vous ne voulez pas non plus attendre plus longtemps que nécessaire pour terminer la migration, alors vous décidez d'utiliser des threads.
Pour empêcher les clients de remarquer un quelconque ralentissement, chaque thread doit s'exécuter pendant une courte période, puis dormir. Il y a deux façons de faire cela :
- Utiliser
time.sleep() comme précédemment. - Utiliser
Event.wait() du module threading.
Commençons par examiner time.sleep().
Utiliser time.sleep()
Le
cookbook de log de Python montre un exemple intéressant qui utilise
time.sleep(). Le module
logging de Python est thread-safe, donc il est un peu plus utile que les instructions pour cet exercice. Le code suivant est basé sur cet exemple :
Ici, vous utilisez le module threading de Python pour créer deux threads. Vous créez également un objet de journalisation qui enregistrera le threadName dans stdout. Ensuite, vous démarrez les deux threads et initiez une boucle pour enregistrer depuis le thread principal de temps en temps. Vous utilisez KeyboardInterrupt pour capturer l'utilisateur appuyant sur Ctrl+C.
Essayez d'exécuter le code ci-dessus dans votre terminal. Vous devriez voir une sortie similaire à la suivante :
À mesure que chaque thread s'exécute puis dort, la sortie de journalisation est imprimée dans la console. Maintenant que vous avez essayé un exemple, vous pourrez utiliser ces concepts dans votre propre code.
Utiliser Event.wait()
Le module threading fournit un Event() que vous pouvez utiliser comme time.sleep(). Cependant, Event() a l'avantage supplémentaire d'être plus réactif. La raison en est que lorsque l'événement est défini, le programme sortira immédiatement de la boucle. Avec time.sleep(), votre code devra attendre que l'appel Python sleep() se termine avant que le thread puisse sortir.
La raison pour laquelle vous voudriez utiliser
wait() ici est que
wait() est
non-bloquant, tandis que
time.sleep() est
bloquant. Cela signifie que lorsque vous utilisez
time.sleep(), vous bloquerez le thread principal de continuer à s'exécuter pendant qu'il attend que l'appel
sleep() se termine.
wait() résout ce problème. Vous pouvez en savoir plus sur le fonctionnement de tout cela dans la
documentation du threading de Python.
Voici comment vous ajoutez un appel Python sleep() avec Event.wait() :
Dans cet exemple, vous créez threading.Event() et le passez à worker(). (Rappelez-vous que dans l'exemple précédent, vous avez plutôt passé un dictionnaire.) Ensuite, vous configurez vos boucles pour vérifier si l'événement est défini ou non. Si ce n'est pas le cas, alors votre code imprime un message et attend un peu avant de vérifier à nouveau. Pour définir l'événement, vous pouvez appuyer sur Ctrl+C. Une fois que l'événement est défini, worker() retournera et la boucle se brisera, mettant fin au programme.
Regardez de plus près le bloc de code ci-dessus. Comment passeriez-vous un temps de sommeil différent à chaque thread de travail ? Pouvez-vous le comprendre ? N'hésitez pas à aborder cet exercice par vous-même !
Ajouter un appel Python sleep() avec Async IO
Les capacités asynchrones ont été ajoutées à Python dans la version 3.4, et cet ensemble de fonctionnalités s'est développé de manière agressive depuis lors. La programmation asynchrone est un type de programmation parallèle qui vous permet d'exécuter plusieurs tâches à la fois. Lorsqu'une tâche se termine, elle notifiera le thread principal.
asyncio est un module qui vous permet d'ajouter un appel Python sleep() de manière asynchrone. Si vous n'êtes pas familier avec l'implémentation de la programmation asynchrone en Python, consultez Async IO en Python : Un guide complet et Concurrence et programmation parallèle en Python.
Dans cet exemple, vous exécutez main() et le faites dormir pendant une seconde entre deux appels print().
Voici un exemple plus convaincant tiré de la section
Coroutines et tâches de la documentation
asyncio :
Dans ce code, vous créez un travailleur appelé output() qui prend le nombre de secondes pour sleep et le text à imprimer. Ensuite, vous utilisez le mot-clé await de Python pour attendre que le code output() s'exécute. await est requis ici car output() a été marqué comme une fonction async, donc vous ne pouvez pas l'appeler comme vous le feriez pour une fonction normale.
Lorsque vous exécutez ce code, votre programme exécutera await 3 fois. Le code attendra 1, 2 et 3 secondes, pour un temps d'attente total de 6 secondes. Vous pouvez également réécrire le code pour que les tâches s'exécutent en parallèle :
Maintenant, vous utilisez le concept de tâches, que vous pouvez créer avec create_task(). Lorsque vous utilisez des tâches dans asyncio, Python exécutera les tâches de manière asynchrone. Donc, lorsque vous exécutez le code ci-dessus, il devrait se terminer en 3 secondes au total au lieu de 6.
Conclusion
Avec ce tutoriel, vous avez acquis une nouvelle technique précieuse à ajouter à votre boîte à outils Python ! Vous savez comment ajouter des délais pour rythmer vos applications et les empêcher d'utiliser trop de ressources système. Vous pouvez même utiliser les appels Python sleep() pour aider votre code GUI à se redessiner plus efficacement. Cela améliorera l'expérience utilisateur pour vos clients !
Pour récapituler, vous avez appris à ajouter des appels Python sleep() avec les outils suivants :
time.sleep()- Les décorateurs
- Les threads
asyncio
Maintenant, vous pouvez prendre ce que vous avez appris et commencer à faire dormir votre code !
