Comment utiliser time.sleep() en Python

Il arrive qu’un programme doive faire une pause : attendre le chargement de données, laisser à l’utilisateur le temps de saisir une information ou réduire la charge du système. L’une des façons les plus simples d’y parvenir en Python consiste à utiliser la fonction time.sleep(), qui suspend l’exécution du programme pendant un intervalle donné.

Dans cet article, nous allons voir comment fonctionne time.sleep() en Python, ses particularités et ses alternatives, ainsi que les erreurs possibles.Nous expliquerons aussi quand l’utiliser dans les programmes multithread et asynchrones, et quand il vaut mieux préférer asyncio.sleep() ou d’autres mécanismes d’attente.

Qu’est-ce que la fonction sleep() en Python ?

La fonction sleep() a été ajoutée à la bibliothèque standard de Python afin de simplifier la création de pauses dans le code. Elle fait partie du module time et s’appelle via time.sleep(), ce qui permet d’interrompre temporairement l’exécution du programme pendant un certain nombre de secondes.

Dans la pratique, sleep() est utile pour insérer des pauses dans des environnements de test, entre des requêtes API ou entre l’envoi de messages. Cependant, elle ne doit pas être confondue avec les outils de synchronisation de threads ou les mécanismes de temporisation précise : pour cela, d’autres outils sont plus adaptés.

Comment fonctionne time.sleep()

La fonction time.sleep() met en pause le thread actuel pendant le nombre de secondes indiqué. Dans un programme multithread, les autres threads continuent de s’exécuter, tandis que celui où time.sleep() a été appelée reste « gelé » pendant cet intervalle.

Il est important de noter que time.sleep() bloque l’exécution du code à l’endroit où elle est appelée, retardant ainsi toutes les opérations suivantes. Une mauvaise utilisation peut donc entraîner une baisse de performance ou même figer l’interface utilisateur dans les applications de bureau.

Quand utiliser time.sleep()

La fonction time.sleep() est le plus souvent utilisée pour les tests ou le débogage, lorsqu’une courte pause est nécessaire — par exemple, pour vérifier la réponse d’une API ou attendre celle d’un serveur. Elle est également employée pour exécuter des scripts étape par étape, donnant à l’utilisateur le temps de lire ou de saisir des données.

Dans les démonstrations, tutoriels ou prototypes, time.sleep() sert à simuler des processus longs ; et dans les interactions avec des services externes, elle permet d’éviter des blocages dus à des requêtes trop fréquentes. Cependant, ce n’est pas le seul moyen de ralentir l’exécution du code — voyons maintenant quelques alternatives.

Utilisation de time.sleep() en Python

L’utilisation de time.sleep() en Python est simple, même pour les débutants. Néanmoins, certaines subtilités peuvent influencer les performances et la facilité de débogage.

Syntaxe de base

Pour utiliser time.sleep(), commencez par importer le module time :

import time
time.sleep(5)

Dans cet exemple, le programme « dort » pendant 5 secondes. Le paramètre transmis peut être un entier ou un nombre décimal, permettant ainsi des pauses de fractions de seconde.

Syntaxe :

time.sleep(seconds)

La fonction ne renvoie aucune valeur. Elle suspend simplement le thread actuel pendant la durée indiquée.

Exemple : retarder l’exécution du code

Voici un petit script qui affiche trois messages espacés de deux secondes :

import time
print("First message")
time.sleep(2)
print("Second message")
time.sleep(2)
print("Third message")

Lors de l’exécution, l’utilisateur verra une pause de 2 secondes entre chaque message. C’est ainsi que time.sleep(2) crée un délai en Python.

Paramètres de time.sleep()

La fonction accepte un seul paramètre, mais celui-ci peut être un entier ou un flottant. Cela offre une grande flexibilité pour définir des pauses.

Valeurs en secondes

La plupart du temps, on utilise un entier représentant le nombre de secondes :

time.sleep(10)

Le script s’interrompt ici pendant 10 secondes, idéal pour espacer les requêtes ou créer une longue pause.

Fractions de seconde (millisecondes)

Parfois, une pause plus courte suffit. Il est alors possible de passer un nombre à virgule:

time.sleep(0.5)

Cela crée une pause d’une demi-seconde. Cependant, à cause des limitations du système d’exploitation et de l’horloge interne de Python, la durée réelle peut légèrement dépasser la valeur indiquée. Dans les systèmes temps réel, il est préférable d’utiliser des outils de synchronisation plus précis.

Alternatives à time.sleep() en Python

Bien que time.sleep() soit le moyen le plus populaire et le plus simple pour insérer des pauses, d’autres méthodes sont parfois plus adaptées, notamment pour gérer des événements externes ou des exécutions concurrentes.

1. Utiliser input() pour marquer une pause

La manière la plus simple de suspendre un programme est d’utiliser input(). Cette fonction bloque l’exécution jusqu’à ce que l’utilisateur appuie sur Entrée ou saisisse une donnée.

print("Press Enter to continue...")
input()
print("Resuming program execution")

Ce n’est pas une pause chronométrée, mais une attente d’action utilisateur. Elle est utile pour le débogage ou dans des scripts interactifs, mais rarement dans des processus automatisés.

2. Utiliser threading.Event()

Dans un programme multithread, on peut utiliser des objets de synchronisation comme threading.Event(), qui bloquent un thread jusqu’à ce qu’un signal soit reçu.

import threading
event = threading.Event()

def worker():
    print("Starting work in thread")
    event.wait()
    print("Event received, resuming work")

thread = threading.Thread(target=worker)
thread.start()

import time
time.sleep(3)
event.set()

Ici, le thread reste bloqué jusqu’à l’appel de event.set(). Cette approche permet un contrôle plus souple : le thread peut être réveillé à tout moment, sans attendre la fin du délai.

3. Utiliser asyncio.sleep() dans un programme asynchrone

En programmation asynchrone (module asyncio), on utilise asyncio.sleep(). Contrairement à time.sleep(), cette fonction ne bloque pas tout le thread, mais uniquement la coroutine actuelle, permettant ainsi au boucle d’événements de continuer à exécuter d’autres tâches.

import asyncio

async def main():
    print("Start async work")
    await asyncio.sleep(2)
    print("2 seconds passed, resuming")

asyncio.run(main())

C’est particulièrement utile lorsque plusieurs fonctions asynchrones s’exécutent en parallèle. Si vous utilisiez time.sleep() dans ce contexte, cela bloquerait toute la boucle d’événements.

Problèmes courants avec time.sleep()

Même si time.sleep() est simple à utiliser, une mauvaise utilisation peut provoquer des blocages inattendus. Il est donc essentiel de comprendre comment elle affecte le déroulement du programme.

Blocage du thread principal

La fonction bloque le thread dans lequel elle est appelée. Dans une application à interface graphique (par exemple Tkinter ou PyQt), cela peut geler l’interface.

💡 Conseil :
N’utilisez time.sleep() que dans des threads secondaires ou remplacez-la par asyncio.sleep() pour éviter le blocage.
Dans les interfaces graphiques, préférez des minuteries comme QTimer ou la méthode after().

Utilisation dans du code multithread ou asynchrone

Dans un programme multithread, time.sleep() peut être appelée indépendamment dans chaque thread, mais elle ne libère pas automatiquement le Global Interpreter Lock (GIL). L’exécution d’autres threads dépend du planificateur du système d’exploitation.

Dans du code asynchrone, évitez d’utiliser time.sleep() dans une boucle d’événements (asyncio.run()), car elle la bloquerait entièrement.
Utilisez plutôt asyncio.sleep(), qui rend le contrôle au planificateur et laisse d’autres coroutines s’exécuter.

Exemple pratique : interroger une API périodiquement

Imaginons que vous écriviez un script pour interroger régulièrement une API, mais que ses règles imposent au moins 30 secondes entre chaque requête.

Solution avec time.sleep() :

import time
def poll_api():
    print("Making API request...")
def main():
    while True:
        poll_api()
        time.sleep(30)
if __name__ == "__main__":
    main()

Après chaque requête, le script se met en pause pendant 30 secondes, respectant ainsi les limites de fréquence.

Alternative asynchrone :

import asyncio
async def poll_api():
    print("Making API request...")
async def main():
    while True:
        await poll_api()
        await asyncio.sleep(30)
if __name__ == "__main__":
    asyncio.run(main())

Cette version ne bloque pas le programme : d’autres tâches peuvent s’exécuter en parallèle dans le même environnement asynchrone. C’est une approche plus flexible et évolutive.

Conclusion

Gérer les pauses et délais est un aspect important du développement Python.
time.sleep() est la méthode la plus simple et la plus directe, mais le choix entre time.sleep(), asyncio.sleep() et d’autres approches dépend de l’architecture du projet.

Recommandations clés :

• Utilisez time.sleep() pour des pauses courtes dans les tests, entre les requêtes ou dans des démonstrations.

• Ne bloquez pas le thread principal d’une application graphique.

• Dans le code asynchrone, remplacez time.sleep() par asyncio.sleep().

• Dans les programmes multithread, rappelez-vous que seul le thread courant est suspendu.

• Pour attendre un événement ou une action utilisateur, utilisez threading.Event() ou input().