Python

Python Time.sleep Milliseconds

The sleep() method in Python takes time to delay the execution of the program in the form of seconds. However, it can easily be made to work with milliseconds. To stop the execution of the program for some specific milli-seconds, then the user can pass the time in the sleep() function after dividing it by 1000 or multiplying it by 0.001.

This post will cover the methods to alter the program default execution flow and delay it by a set time in milliseconds.

Method 1: Time Sleep in Milliseconds

The “time” library provides a function “sleep()” that takes the delay interval in seconds, and the best part about this function is that it can take float values. This simply means that it allows the users to pass the time in milliseconds as well. But rather than calculating the value in floating point digits, it is much more convenient to simply take time as milliseconds and then either divide it by 1000 or multiply it by 0.001.

Syntax of sleep() Function With Milliseconds:

time.sleep( MS / 1000)

Let’s take an example to showcase this method. For this, start by importing the “time” library in your program using the following line:

import time

After that, set the time interval in milliseconds:

sleepIntervalMS = 1500

print("The Program is reaching the sleep")

Pass this time interval in the sleep() method using the following line:

time.sleep(sleepIntervalMS/1000)

In the end, after the sleep, prompt the user by printing the following:

print("This is the output after sleep")

The complete code snippet for this example is as follows:

import time

sleepIntervalMS = 1500

print("The Program is reaching the sleep")

time.sleep(sleepIntervalMS/1000)

print("This is the output after sleep")

When this code is executed, it produces the following output on the terminal:

As you can notice in the GIF above, there is a slight delay of about 1.5 seconds or 1500 milliseconds in the execution of the program.

Method 2: Using Timer() From Threading Package

This is an alternate solution to the sleep() method of the time package. This timer() is used to execute a function after a set amount of time (usually in seconds) has elapsed. Look at the syntax of the Timer() method given below.

Syntax of Timer() Method

timerVar = Timer(timeInterval, functionToCall)

In this syntax:

  • timerVar is the variable that will be used to start the timer using the start() method.
  • timeInterval will define the amount of time to be delayed before calling the function inside the second argument.
  • functionToCall is the function that will be called after the delay.

Note: Since this post is concerned with sleeping the program for some specific milliseconds, the user can pass the time to Timer() method after dividing the time by 1000.

To demonstrate an example of working of this function, start by importing the Timer package from the threading library:

from threading import Timer

Once that is done, define the interval duration of the sleep in a variable:

delayMS = 2500

Define a function that will be called using the Timer() method:

def basicPrompt():

print("This function was executed after a delay")

Call the Timer() method to set a timer on the function created above using the delay mentioned above as well:

timeVar = Timer(delayMS/1000, basicPrompt)

Prompt the user that the program is about to go into sleep and call the start() method of the Timer variable:

print("The program is reaching the sleep")

timeVar.start()

The complete code snippet for this example is given below:

from threading import Timer
delayMS = 2500
def basicPrompt():
  print("This function was executed after a delay")
timeVar = Timer(delayMS/1000, basicPrompt)
print("The program is reaching the sleep")
timeVar.start()

When this program is executed, it produces the following results:

It can be seen in the output above that the function was executed after two and a half seconds or after 2500 milliseconds. That also concludes this post for sleep() in milliseconds.

Conclusion

The Python’s sleep() method from the time package can easily be made to delay the execution of the program for a set amount of time which is passed in the form of milliseconds. To do this, the user has to either multiply the milliseconds by “.001” or divide it by a thousand while passing it in the argument of the sleep method. Alternatively, the user can also use the Timer() method, which has also been demonstrated in this article.

About the author

Admin

A passionate Linux user for personal and professional reasons, always exploring what is new in the world of Linux and sharing with my readers.