Solving problem is about exposing yourself to as many situations as possible like How can I make a time delay in Python? [duplicate] and practice these strategies over and over. With time, it becomes second nature and a natural way you approach any problems in general. Big or small, always start with a plan, use other strategies mentioned here till you are confident and ready to code the solution.
In this post, my aim is to share an overview the topic about How can I make a time delay in Python? [duplicate], which can be followed any time. Take easy to follow this discuss.
I would like to know how to put a time delay in a Python script.
import time time.sleep(5) # Delays for 5 seconds. You can also use a float value.
Here is another example where something is run approximately once a minute:
import time while True: print("This prints once a minute.") time.sleep(60) # Delay for 1 minute (60 seconds).
You can use the
sleep() function in the
time module. It can take a float argument for sub-second resolution.
from time import sleep sleep(0.1) # Time in seconds
How can I make a time delay in Python?
In a single thread I suggest the sleep function:
from time import sleep sleep(4)
This function actually suspends the processing of the thread in which it is called by the operating system, allowing other threads and processes to execute while it sleeps.
Use it for that purpose, or simply to delay a function from executing. For example:
def party_time(): print('hooray!') ... sleep(3); party_time() hooray!
“hooray!” is printed 3 seconds after I hit Enter.
sleep with multiple threads and processes
sleep suspends your thread – it uses next to zero processing power.
To demonstrate, create a script like this (I first attempted this in an interactive Python 3.5 shell, but sub-processes can’t find the
party_later function for some reason):
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed from time import sleep, time def party_later(kind='', n=''): sleep(3) return kind + n + ' party time!: ' + __name__ def main(): with ProcessPoolExecutor() as proc_executor: with ThreadPoolExecutor() as thread_executor: start_time = time() proc_future1 = proc_executor.submit(party_later, kind='proc', n='1') proc_future2 = proc_executor.submit(party_later, kind='proc', n='2') thread_future1 = thread_executor.submit(party_later, kind='thread', n='1') thread_future2 = thread_executor.submit(party_later, kind='thread', n='2') for f in as_completed([ proc_future1, proc_future2, thread_future1, thread_future2,]): print(f.result()) end_time = time() print('total time to execute four 3-sec functions:', end_time - start_time) if __name__ == '__main__': main()
Example output from this script:
thread1 party time!: __main__ thread2 party time!: __main__ proc1 party time!: __mp_main__ proc2 party time!: __mp_main__ total time to execute four 3-sec functions: 3.4519670009613037
You can trigger a function to be called at a later time in a separate thread with the
Timer threading object:
from threading import Timer t = Timer(3, party_time, args=None, kwargs=None) t.start() >>> hooray! >>>
The blank line illustrates that the function printed to my standard output, and I had to hit Enter to ensure I was on a prompt.
The upside of this method is that while the
Timer thread was waiting, I was able to do other things, in this case, hitting Enter one time – before the function executed (see the first empty prompt).
There isn’t a respective object in the multiprocessing library. You can create one, but it probably doesn’t exist for a reason. A sub-thread makes a lot more sense for a simple timer than a whole new subprocess.
Delays can be also implemented by using the following methods.
The first method:
import time time.sleep(5) # Delay for 5 seconds.
The second method to delay would be using the implicit wait method:
The third method is more useful when you have to wait until a particular action is completed or until an element is found:
A bit of fun with a sleepy generator.
The question is about time delay. It can be fixed time, but in some cases we might need a delay measured since last time. Here is one possible solution:
Delay measured since last time (waking up regularly)
The situation can be, we want to do something as regularly as possible and we do not want to bother with all the
next_time stuff all around our code.
The following code (sleepy.py) defines a
import time from itertools import count def buzzergen(period): nexttime = time.time() + period for i in count(): now = time.time() tosleep = nexttime - now if tosleep > 0: time.sleep(tosleep) nexttime += period else: nexttime = now + period yield i, nexttime
Invoking regular buzzergen
from sleepy import buzzergen import time buzzer = buzzergen(3) # Planning to wake up each 3 seconds print time.time() buzzer.next() print time.time() time.sleep(2) buzzer.next() print time.time() time.sleep(5) # Sleeping a bit longer than usually buzzer.next() print time.time() buzzer.next() print time.time()
And running it we see:
1400102636.46 1400102639.46 1400102642.46 1400102647.47 1400102650.47
We can also use it directly in a loop:
import random for ring in buzzergen(3): print "now", time.time() print "ring", ring time.sleep(random.choice([0, 2, 4, 6]))
And running it we might see:
now 1400102751.46 ring (0, 1400102754.461676) now 1400102754.46 ring (1, 1400102757.461676) now 1400102757.46 ring (2, 1400102760.461676) now 1400102760.46 ring (3, 1400102763.461676) now 1400102766.47 ring (4, 1400102769.47115) now 1400102769.47 ring (5, 1400102772.47115) now 1400102772.47 ring (6, 1400102775.47115) now 1400102775.47 ring (7, 1400102778.47115)
As we see, this buzzer is not too rigid and allow us to catch up with regular sleepy intervals even if we oversleep and get out of regular schedule.
There are five methods which I know:
time.sleep() example (do not use if using tkinter):
import time print('Hello') time.sleep(5) # Number of seconds print('Bye')
pygame.time.wait() example (not recommended if you are not using the pygame window, but you could exit the window instantly):
import pygame # If you are going to use the time module # don't do "from pygame import *" pygame.init() print('Hello') pygame.time.wait(5000) # Milliseconds print('Bye')
pyplot.pause() example (not recommended if you are not using the graph, but you could exit the graph instantly):
import matplotlib print('Hello') matplotlib.pyplot.pause(5) # Seconds print('Bye')
.after() method (best with Tkinter):
import tkinter as tk # Tkinter for Python 2 root = tk.Tk() print('Hello') def ohhi(): print('Oh, hi!') root.after(5000, ohhi) # Milliseconds and then a function print('Bye')
import asyncio asyncio.sleep(5)
The Tkinter library in the Python standard library is an interactive tool which you can import. Basically, you can create buttons and boxes and popups and stuff that appear as windows which you manipulate with code.
If you use Tkinter, do not use
time.sleep(), because it will muck up your program. This happened to me. Instead, use
root.after() and replace the values for however many seconds, with a milliseconds. For example,
time.sleep(1) is equivalent to
root.after(1000) in Tkinter.
time.sleep(), which many answers have pointed out, which is the way to go.
To just make it wait for a second:
from time import sleep sleep(1)
This works because by doing:
from time import sleep
Rather than having to type out
Which is awkwardly long to type.
With this method, you wouldn’t get access to the other features of the time library and you can’t have a variable called
sleep. But you could create a variable called
from [library] import [function] (, [function2]) is great if you just want certain parts of a module.
You could equally do it as:
import time time.sleep(1)
and you would have access to the other features of the time library like
time.clock() as long as you type
time.[function](), but you couldn’t create the variable time because it would overwrite the import. A solution to this to do
import time as t
which would allow you to reference the time library as
t, allowing you to do:
This works on any library.