Skip to content

Python Delay: Effortlessly Adding Delays in Your Code


Python Delay: How to Add Time Delays to Your Code

by [Your Name]

Have you ever needed to make your Python program wait for something? Most of the time, you’d want your code to execute as quickly as possible. But there are times when letting your code sleep for a while is actually in your best interest.

For example, you might use a Python sleep() call to simulate a delay in your program. Perhaps you need to wait for a file to upload or download, or for a graphic to load or be drawn to the screen. You might even need to pause between calls to a web API, or between queries to a database. Adding Python sleep() calls to your program can help in each of these cases, and many more!

In this tutorial, you’ll learn how to add Python sleep() calls using different techniques. We’ll cover the following topics:

  • Adding a Python sleep() Call with time.sleep()
  • Adding a Python sleep() Call with Decorators
  • Adding a Python sleep() Call with Threads
  • Adding a Python sleep() Call with Async IO
  • Adding a Python sleep() Call with GUIs

This article is intended for intermediate developers who are looking to grow their knowledge of Python. If that sounds like you, then let’s get started!

Adding a Python sleep() Call with time.sleep()

Python has built-in support for putting your program to sleep. The time module has a function sleep() that you can use to suspend execution of the calling thread for a specified number of seconds.

Here’s an example of how to use time.sleep():

import time
time.sleep(3) # Sleep for 3 seconds

If you run this code, you will experience a 3-second delay before you can enter a new statement in the REPL.

Note: In Python 3.5 and above, the time.sleep() function behavior slightly changed. The sleep will last at least the number of seconds specified, even if it is interrupted by a signal. However, if the signal itself raises an exception, this behavior does not apply.

You can test the duration of the sleep using Python’s timeit module:

Terminal window
$ python3 -m timeit -n 3 "import time; time.sleep(3)"

In this example, the timeit module runs the import time; time.sleep(3) statement 3 times and reports the best run time, which should be around 3 seconds.

Let’s create a more practical example. Imagine you are a system administrator and you need to check the status code of a website regularly. You want to be able to sleep between checks to avoid overwhelming the server. Here’s how you can achieve this with time.sleep():

  1. Import the necessary libraries:
import requests
import time
  1. Create a function to check the website status code:
def check_website_status(url):
response = requests.get(url)
return response.status_code
  1. Implement the main program:
if __name__ == "__main__":
website_url = ""
delay_seconds = 5
while True:
status_code = check_website_status(website_url)
print(f"Website Status Code: {status_code}")

In this example, the program continuously checks the status code of a website every 5 seconds using the check_website_status() function. The time.sleep() function ensures there is a delay between each check.

Feel free to adjust the website URL and delay seconds according to your needs.

That’s it! You have successfully added a time delay to your Python code using time.sleep().

Adding a Python sleep() Call with Decorators, Threads, Async IO, and GUIs

In addition to time.sleep(), Python provides other methods to add delays to your code in specific contexts. These methods include using decorators, threads, async IO, and GUI libraries like Tkinter or wxPython.


Adding time delays to your Python code can be beneficial in various scenarios, such as simulating file uploads, controlling web API requests, or managing GUI interactions. In this tutorial, you have learned how to add time delays to your code using time.sleep() and explored other techniques like decorators, threads, async IO, and GUI libraries.

Remember to use delays wisely and consider the impact on overall program performance. With the knowledge and examples provided, you can confidently incorporate time delays into your Python programs when necessary.

Write Your Name is a technical writer and Python enthusiast.