How to Make a Time Delay in Python Using the sleep() Function

As a full-stack developer, you‘ll often find yourself needing to add delays to your Python programs. Whether it‘s waiting for an external service to respond, checking for a condition to be met, or simply pausing for dramatic effect, being able to make your code sleep for a bit can be very handy. Luckily, Python provides a simple way to do this using the built-in time module and its sleep() function.

The time.sleep() Function

The sleep() function suspends execution of the current thread for a given number of seconds. The argument may be a floating point number to indicate a more precise sleep time. The actual suspension time may be less than that requested because any caught signal will terminate the sleep() following execution of that signal‘s catching routine.

Here‘s the basic syntax:

import time

time.sleep(secs)

Where secs is the number of seconds you want the program to pause for. This can be an integer or a float. For example, to pause your program for 5 seconds, you would do:

import time

print("Starting")
time.sleep(5)
print("Finished")

This will output:

Starting
# 5 second delay
Finished

Fractional Sleep Times

Since sleep() accepts floats, you can pass in fractional seconds for more precise delays. For example, to sleep for half a second:

import time

print("Starting")
time.sleep(0.5)
print("Finished")

This will pause the program for 500 milliseconds before continuing.

You can get even more granular if needed. To sleep for 10 milliseconds:

import time 

print("Starting")
time.sleep(0.01) 
print("Finished")

However, keep in mind that very small sleep durations may not be entirely accurate, as there is some overhead to making the system call to actually suspend the process. Sleeping for extremely short durations on the order of a few milliseconds may end up being closer to 10-20ms in practice.

Calculating Sleep Durations

Instead of always passing a fixed number of seconds to sleep(), you can calculate a duration based on some dynamic condition. A common example is sleeping until a specific time in the future.

To do this, you can use the datetime module to get the current time, then add a timedelta representing the amount of time you want to wait. Subtracting the current time from the target time will give you the number of seconds to sleep.

Here‘s an example that waits until the next 10-minute mark before continuing:

import datetime
import time

now = datetime.datetime.now()
nextTenMinutes = now + datetime.timedelta(minutes=10)
nextTenMinutes = nextTenMinutes.replace(second=0, microsecond=0)

sleepDuration = (nextTenMinutes - now).total_seconds()

print(f"It is now {now}")  
print(f"Sleeping until {nextTenMinutes}")
time.sleep(sleepDuration)
print("Finished sleeping")

This will output something like:

It is now 2022-03-10 09:41:39.662661
Sleeping until 2022-03-10 09:50:00
# sleep until 09:50
Finished sleeping

The key steps are:

1. Get the current time with datetime.now()
2. Calculate the target time by adding a timedelta
3. Zero-out the seconds and microseconds of the target time for an even 10 minute boundary
4. Calculate the sleep duration by subtracting the current time from the target time
5. Pass the sleep duration in seconds to time.sleep()

This technique generalizes to any time-based delay you need. Just change the timedelta and truncation as needed for other intervals like waiting an hour, a day, etc.

Sleeping in Loops

Sleep is often used in loops to add a delay between each iteration. This is useful for things like polling for a condition, backing off retries, or simply spacing out print statements.

Here‘s an example that prints each character in "Hello World" with a 100ms delay between them:

import time

msg = "Hello World"

for char in msg:
    print(char)
    time.sleep(0.1)

This will output:

H
# 100ms delay
e
# 100ms delay
l
# 100ms delay
l
# 100ms delay
o
# 100ms delay
# etc... 

You can also use sleep() with a while loop to continually run some code on a fixed time interval. For example, to print a message every 5 seconds:

import time

while True:
    print("Polling for condition...")
    time.sleep(5)

This will output:

Polling for condition...
# 5 second delay
Polling for condition...
# 5 second delay 
Polling for condition...
# 5 second delay
# etc...

The loop will continue running forever, sleeping for 5 seconds between each print statement. To exit the loop, you can either set a flag variable that gets checked each iteration, or use a break statement.

Handling Interrupts

One thing to keep in mind is that sleep() can be interrupted by signals before the full sleep duration has elapsed. This may happen if the program receives a SIGINT from a Ctrl-C keystroke, or some other signal.

If a signal is received during a sleep, an InterruptedError will be raised. You can handle this by wrapping sleeps in a try/except block:

import time

try:
    print("Sleeping...")
    time.sleep(5)
except InterruptedError:
    print("Sleep interrupted")
else:
    print("Finished sleeping")

If the sleep completes without interruption, the else block will run, otherwise the except block will run to handle the interruption.

Alternatives to sleep()

While sleep() is simple and easy to use, it has some limitations. Since it blocks the executing thread, long sleeps can make your program unresponsive unless called on a background thread.

For more advanced use cases, Python provides some other options in the threading and asyncio modules.

The threading.Timer class allows you to schedule a function to be called after a certain time interval. The key difference from sleep() is that the timer runs on a separate thread, so your main program can continue doing other work while the timer is running.

Here‘s an example:

from threading import Timer

def hello():
    print("Hello from the future!")

t = Timer(5.0, hello)
t.start()

print("Waiting for timer...")
t.join()

This will output:

Waiting for timer...
# 5 second delay
Hello from the future!

The timer is started with t.start() and the main thread continues running, printing "Waiting for timer…". After 5 seconds, the hello function is called on the timer thread, printing "Hello from the future!". Meanwhile, the main thread blocks on t.join() until the timer finishes.

For a more modern, asynchronous approach, you can use the asyncio.sleep() function along with the asyncio event loop. This allows you to sleep without blocking the main thread, and is well-suited for applications with lots of concurrent I/O like web servers.

Here‘s an example:

import asyncio

async def hello():
    await asyncio.sleep(5)
    print("Hello from the future!")

async def main():
    print("Waiting for hello...")
    await hello()
    print("Finished waiting")

asyncio.run(main())

This will output:

Waiting for hello...
# 5 second delay
Hello from the future!
Finished waiting

The asyncio.sleep() function is called inside an async function, which gets scheduled to run on the event loop. Other coroutines can run concurrently on the same thread while hello() is sleeping.

Conclusion

In this guide, we‘ve covered how to use the time.sleep() function to add delays to your Python programs. We‘ve seen how to sleep for a fixed duration, calculate dynamic durations, handle interruptions, and some alternative approaches using timers and async/await.

Whether you need to add dramatic pauses, poll for conditions, or simply wait for something to happen, the sleep() function is a handy tool to have in your Python toolbelt. Just remember to use it judiciously, as blocking sleeps can make your program unresponsive if used inappropriately.

As with any powerful tool, the key is to experiment and find what works best for your particular use case. Don‘t be afraid to mix and match approaches, and always keep performance and user experience in mind. With a little practice, you‘ll be sleeping like a pro in no time!