How to Use Python time.sleep()

Technical writer

Python

19.09.2025

Reading time: 8 min

Sometimes, while running a program, it’s necessary to pause: wait for data to load, give the user time to enter input, or reduce the load on the system. One of the simplest ways to achieve this in Python is with the time.sleep() function, which suspends program execution for a given interval.

In this article, we’ll examine how time.sleep() works in Python, its features and alternatives, as well as possible errors. We’ll discuss when it’s appropriate to use it in multithreaded and asynchronous programs, and when it’s better to choose asyncio.sleep() or other waiting mechanisms.

What is the sleep() Function in Python?

The sleep() function in Python was added to the standard library to simplify creating pauses in code. It is located in the time module and is called time.sleep, allowing you to pause program execution for a specified number of seconds.

In practice, sleep() is useful for pauses in test environments, delays between API requests, or intervals between sending messages. However, you should not confuse its use for system-level tasks, such as thread synchronization, with simply slowing down a script. If precise timing coordination or asynchronous I/O is needed, other tools are more suitable.

How time.sleep() Works

The time.sleep() function in Python pauses the current thread for the specified number of seconds. In a multithreaded scenario, other threads continue running, but the one where time.sleep() was called remains "frozen" for that interval.

It’s important to note that time.sleep() blocks code execution at that point, delaying all subsequent operations. Ignoring this rule can lead to reduced performance or even a frozen user interface in desktop applications.

When time.sleep() is Used

Most often, time.sleep() is used in testing and debugging, when a short delay is needed—for example, to verify the correctness of an API response or wait for a server reply. It’s also used for step-by-step script execution, giving the user time to view information or enter data.

In demonstrations, tutorials, and prototyping, time.sleep() helps simulate long-running processes, and when working with external services, it helps avoid penalties or blocks from too frequent requests.

However, sleep() is not the only way to slow down code execution. Further in the article, we’ll review some alternatives.

How to Use time.sleep() in Python

Using time.sleep() in Python is straightforward, and even beginners quickly master this tool. Still, it’s important to know its nuances, as they can affect performance and debugging convenience.

Basic Syntax of time.sleep()

To call the time.sleep() function, first import the time module:

import time
time.sleep(5)

In this example, the program will "sleep" for 5 seconds. The number passed to the function can be either an integer or a float, which allows sleeping for fractions of a second.

Syntax:

time.sleep(seconds)

The time.sleep() function does not return any value. That means you cannot precisely determine how accurate the pause was—it simply suspends the current thread for the specified duration.

Example: Delaying Code Execution

Suppose you have a small script that prints messages with a 2-second interval. To add a delay in Python, just insert time.sleep(2):

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

When running this script, the user will see a 2-second pause between each message. That’s exactly how a delay in Python works using time.sleep(2).

Parameters of time.sleep()

The time.sleep() function accepts only one parameter, but it can be either an integer or a float. This adds flexibility when implementing delays in Python.

Passing Values in Seconds

Most examples of time.sleep() usage pass an integer representing seconds. For example:

time.sleep(10)

Here, the script pauses for 10 seconds. This is convenient when you need a long pause or want to limit request frequency.

Using Fractions of a Second (Milliseconds)

Sometimes you need to pause for a few milliseconds or fractions of a second. To do this, you can pass a floating-point number:

time.sleep(0.5)

This creates a half-second pause. However, because of OS and Python timer limitations, the delay may slightly exceed 500 milliseconds. For most tasks, this isn’t critical, but in high-precision real-time systems, specialized tools should be used instead.

Alternative Ways to Pause in Python

Although time.sleep() is the most popular and simplest way to create pauses, there are other methods that may be more suitable when waiting for external events or handling multiple threads. Let’s look at the most common alternatives.

Using input() for Waiting

The simplest way to pause in Python is by calling input(). It suspends execution until the user presses Enter or enters data.

Example:

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

While this feels like a pause, technically it’s not a timed delay. The program waits for user action, not a fixed interval. This method is rarely useful in automated scripts but can be handy in debugging or console utilities where a "pause on demand" is needed.

Waiting with threading.Event()

If you’re writing a multithreaded program, it can be more useful to use synchronization objects like threading.Event(). You can configure it to block a thread until a signal is received.

Example:

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()

In this case, the thread is blocked until event.set() is called. You can still use time.sleep() to set a maximum pause, but unlike plain sleep(), this approach allows more flexible control. The thread can be "woken up" immediately without waiting for the full interval.

asyncio.sleep() for Asynchronous Programs

In asynchronous Python programming (asyncio module), asyncio.sleep() is used. Unlike time.sleep(), it doesn’t block the entire thread but only suspends the current coroutine, allowing the event loop to continue running other tasks.

Example:

import asyncio

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

asyncio.run(main())

This is especially useful when you have multiple asynchronous functions that should run in parallel without interfering with each other. If you use regular time.sleep() in async code, it will block the entire event loop, causing other coroutines to wait too.

Common Issues When Using time.sleep()

The time.sleep() function is simple, but misusing it can cause unexpected problems. It’s important to understand how it affects program execution so you don’t block important processes.

Blocking the Main Thread

The main feature of time.sleep() is that it blocks the thread where it was called. If you use it in the main thread of a GUI application (for example, Tkinter or PyQt), the interface will stop responding, creating a "frozen" effect.

To avoid this, use time.sleep() only in separate threads or switch to asynchronous approaches like asyncio.sleep() for non-blocking delays. In GUI applications, it’s better to use timers (QTimer, after, etc.), which call functions at intervals without blocking the interface.

Use in Multithreaded and Asynchronous Code

In multithreaded code, time.sleep() can be called independently in each thread, but note that it doesn’t automatically release the Global Interpreter Lock (GIL). While other threads can still run during one thread’s sleep, in Python this depends on OS-level thread scheduling.

In asynchronous code, time.sleep() should be used cautiously. If called inside an event loop (like with asyncio.run()), it blocks the entire loop, defeating the benefits of async programming. Instead, use asyncio.sleep(), which hands control back to the scheduler, letting other coroutines run in the background.

Real-World Example of Using time.sleep()

Imagine you’re writing a script to periodically poll an external API, which, according to its rules, must not be called more than once every 30 seconds. If requests are too frequent, the server may return errors or block your IP.

Solution using time.sleep():

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

Here, after each request, we pause for 30 seconds with time.sleep(). This ensures no more than two requests per minute, respecting the limits.

Async alternative:

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())

This version doesn’t block the entire program, allowing other requests or tasks to run in the same async environment. It’s more flexible and scalable.

Conclusion

Organizing pauses and delays is an important aspect of Python development. time.sleep() is the first and most obvious tool for this, but choosing between time.sleep(), asyncio.sleep(), and other methods should depend on your project’s architecture.

In single-threaded scripts and console utilities, time.sleep() is perfectly fine, but for multithreaded and asynchronous applications, other mechanisms are better.

Key recommendations:

Use time.sleep() for short delays in tests, pauses between requests, or interface demonstrations.
Don’t block the main thread of GUI applications to avoid a "frozen" interface.
In async code, replace time.sleep() with asyncio.sleep() to keep the event loop efficient.
In multithreaded programs, remember only the current thread pauses, but GIL affects scheduling.
In special cases, use threading.Event() or input() to wait for events or user actions.

Python

19.09.2025

Reading time: 8 min

Similar

Python

How to Use Python time.sleep()

What is the sleep() Function in Python?

How time.sleep() Works

When time.sleep() is Used

How to Use time.sleep() in Python

Basic Syntax of time.sleep()

Example: Delaying Code Execution

Parameters of time.sleep()

Passing Values in Seconds

Using Fractions of a Second (Milliseconds)

Alternative Ways to Pause in Python

Using input() for Waiting

Waiting with threading.Event()

asyncio.sleep() for Asynchronous Programs

Common Issues When Using time.sleep()

Blocking the Main Thread

Use in Multithreaded and Asynchronous Code

Real-World Example of Using time.sleep()

Conclusion

Similar

How to Delete Characters from a String in Python

Command-Line Option and Argument Parsing using argparse in Python

How to Get the Length of a List in Python

Do you have questions, comments, or concerns?

Do you have questions,
comments, or concerns?