Python time sleep() (time.sleep() Function)

In Python programming, there are times when you may need to introduce a delay in execution, such as waiting for a resource to become available, pacing the flow of a script, or simulating real-world timing scenarios. Python's time module offers a simple and effective way to pause your program with the Python sleep() function.

In this guide, we’ll dive into how the Python time sleep() function works, its usage, and practical examples to help you better understand its application.

Python time sleep (Python Sleep Command)

Python time sleep() function pauses the current thread's execution for a specified duration, measured in seconds. This function is commonly used to introduce delays in program execution. However, it's important to note that sleep() only halts the current thread, allowing other threads in the program to continue running.

Basic Syntax of Python time sleep function 

The Python time sleep() function is part of Python's time module. To use it, you first need to import the time module. 

Once imported, you can call the Python sleep function sleep() to pause the execution of your program. Here's how you can use it:

import time
time.sleep(seconds)

Here, time.sleep python method uses seconds, which is the duration the execution will be paused, specified as a floating-point or integer value.

Examples: Basic Usage of time.sleep Python Method

Example: Basic use of Python time sleep function

# Importing the time module
import time
print("Starting program...")
time.sleep(3) # Pauses execution for 3 seconds
print("Program resumed after 3 seconds.")

Output:

In the above code, the second print statement will appear after a 3-second delay. The sleep() function is helpful when you want to introduce a delay in your code.

Example: Add precise delays with the Python time sleep function

You can also pass floating-point values to the sleep() function for more precise delays.

import time
print("Starting delay for 150 milliseconds...")
time.sleep(0.150) # Delay of 150 milliseconds (0.15 seconds)
print("Delay over!")

Output:

The above example introduces a delay of 150 milliseconds before continuing execution.

Example: Calculate the Elapsed Time using the Python Sleep function

The sleep() function can be combined with time tracking to measure execution time.

import time
# Record the start time
start_time = time.time()
# Loop with a 2-second delay
for i in range(1, 4):
print(f"Step {i}")
time.sleep(2) # Delay for 2 seconds in each iteration
# Record the end time
end_time = time.time()
# Calculate the total elapsed time
elapsed_time = end_time - start_time
print(f"Total Elapsed Time: {elapsed_time:.2f} seconds")

Output:

The elapsed time is slightly more than 6 seconds due to additional time spent on program execution and thread scheduling.

Example: Use different delays using the Python time sleep function

Sometimes, you might need to introduce different delays between different actions with time.sleep Python. This can be achieved as shown below:

import time
delays = [0.2, 0.5, 1, 1.5] # List of delay times
for delay in delays:
print(f"Pausing for {delay} seconds...")
time.sleep(delay)

Output:

In this example, the program pauses for a different duration in each iteration based on the values in the delays list.

Example: Creating a Dramatic Text Effect Using Python Time Sleep

You can create suspenseful or dramatic effects by printing a message character by character with a delay.

import time
message = "Welcome to the world of Python!"

for char in message:

print(char, end='', flush=True) # Print each character without newline
time.sleep(0.2) # Delay between characters
print("\nMessage displayed dramatically!")

Output:

Each character appears with a delay, creating a suspenseful visual effect.

Example: Using Python time sleep in Multithreaded Programs

The Python sleep function is especially useful in multithreading to control the execution flow of individual threads without affecting others.

import time
from threading import Thread
class TaskOne(Thread):
    def run(self):
        for i in range(1, 4):
            print(f"TaskOne: Step {i}")
            time.sleep(2)  # Delay of 2 seconds between steps
class TaskTwo(Thread):
    def run(self):
        for i in range(10, 13):
            print(f"TaskTwo: Step {i}")
            time.sleep(1)  # Delay of 1 second between steps
print("Starting TaskOne thread")
task_one = TaskOne()
task_one.start()
print("Starting TaskTwo thread")
task_two = TaskTwo()
task_two.start()
print("Main thread continues...")

Output:



In this example, TaskOne and TaskTwo run concurrently, with different delays in their execution. The main thread continues execution independently, demonstrating how Python time.sleep() affects only the current thread.

Conclusion

That’s all about the Python time sleep function. The sleep() method is a versatile tool for introducing delays in your program, whether for pacing execution, creating effects, or managing multithreaded tasks.

Unlock lightning-fast speeds and limitless hosting with 10GBVPS! Enjoy global locations, no bandwidth limits, and unmatched website performance—get started today!