How do I add a delay in Pygame?
Python sleep(): How to Add Time Delays to Your Codeby Mike Driscoll intermediate python Mark as Completed Tweet Share Email Table of Contents Show
Remove ads Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Using sleep() to Code a Python Uptime Bot Have you ever needed to make your Python program wait for something? Most of the time, youd 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, youll learn how to add Python sleep() calls with:
This article is intended for intermediate developers who are looking to grow their knowledge of Python. If that sounds like you, then lets get started! Free Bonus: Get our free "The Power of Python Decorators" guide that shows you 3 advanced decorator patterns and techniques you can use to write to cleaner and more Pythonic programs. 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 however many seconds you specify. Heres an example of how to use time.sleep(): >>>>>> import time
>>> time.sleep(3) # Sleep for 3 seconds
If you run this code in your console, then you should experience a delay before you can enter a new statement in the REPL. Note: In Python 3.5, the core developers changed the behavior of time.sleep() slightly. The new Python sleep() system call will last at least the number of seconds youve specified, even if the sleep is interrupted by a signal. This does not apply if the signal itself raises an exception, however. You can test how long the sleep lasts by using Pythons timeit module: $ python3 -m timeit -n 3 "import time; time.sleep(3)"
3 loops, best of 5: 3 sec per loop
Here, you run the timeit module with the -n parameter, which tells timeit how many times to run the statement that follows. You can see that timeit ran the statement 3 times and that the best run time was 3 seconds, which is what was expected. The default number of times that timeit will run your code is one million. If you were to run the above code with the default -n, then at 3 seconds per iteration, your terminal would hang for approximately 34 days! The timeit module has several other command line options that you can check out in its documentation. Lets create something a bit more realistic. A system administrator needs to know when one of their websites goes down. You want to be able to check the websites status code regularly, but you cant query the web server constantly or it will affect performance. One way to do this check is to use a Python sleep() system call: import time
import urllib.request
import urllib.error
def uptime_bot(url):
while True:
try:
conn = urllib.request.urlopen(url)
except urllib.error.HTTPError as e:
# Email admin / log
print(f'HTTPError: {e.code} for {url}')
except urllib.error.URLError as e:
# Email admin / log
print(f'URLError: {e.code} for {url}')
else:
# Website is up
print(f'{url} is up')
time.sleep(60)
if __name__ == '__main__':
url = 'http://www.google.com/py'
uptime_bot(url)
Here you create uptime_bot(), which takes a URL as its argument. The function then attempts to open that URL with urllib. If theres an HTTPError or URLError, then the program catches it and prints out the error. (In a live environment, you would log the error and probably send out an email to the webmaster or system administrator.) If no errors occur, then your code prints out that all is well. Regardless of what happens, your program will sleep for 60 seconds. This means that you only access the website once every minute. The URL used in this example is bad, so it will output the following to your console once every minute: HTTPError: 404 for http://www.google.com/py
Go ahead and update the code to use a known good URL, like http://www.google.com. Then you can re-run it to see it work successfully. You can also try to update the code to send an email or log the errors. For more information on how to do this, check out Sending Emails With Python and Logging in Python. Remove ads Adding a Python sleep() Call With DecoratorsThere are times when you need to retry a function that has failed. One popular use case for this is when you need to retry a file download because the server was busy. You usually wont want to make a request to the server too often, so adding a Python sleep() call between each request is desirable. Another use case that Ive personally experienced is where I need to check the state of a user interface during an automated test. The user interface might load faster or slower than usual, depending on the computer Im running the test on. This can change whats on the screen at the moment my program is verifying something. In this case, I can tell the program to sleep for a moment and then recheck things a second or two later. This can mean the difference between a passing and failing test. You can use a decorator to add a Python sleep() system call in either of these cases. If youre not familiar with decorators, or if youd like to brush up on them, then check out Primer on Python Decorators. Lets look at an example: import time
import urllib.request
import urllib.error
def sleep(timeout, retry=3):
def the_real_decorator(function):
def wrapper(*args, **kwargs):
retries = 0
while retries < retry:
try:
value = function(*args, **kwargs)
if value is None:
return
except:
print(f'Sleeping for {timeout} seconds')
time.sleep(timeout)
retries += 1
return wrapper
return the_real_decorator
sleep() is your decorator. It accepts a timeout value and the number of times it should retry, which defaults to 3. Inside sleep() is another function, the_real_decorator(), which accepts the decorated function. Finally, the innermost function wrapper() accepts the arguments and keyword arguments that you pass to the decorated function. This is where the magic happens! You use a while loop to retry calling the function. If theres an exception, then you call time.sleep(), increment the retries counter, and try running the function again. Now rewrite uptime_bot() to use your new decorator: @sleep(3)
def uptime_bot(url):
try:
conn = urllib.request.urlopen(url)
except urllib.error.HTTPError as e:
# Email admin / log
print(f'HTTPError: {e.code} for {url}')
# Re-raise the exception for the decorator
raise urllib.error.HTTPError
except urllib.error.URLError as e:
# Email admin / log
print(f'URLError: {e.code} for {url}')
# Re-raise the exception for the decorator
raise urllib.error.URLError
else:
# Website is up
print(f'{url} is up')
if __name__ == '__main__':
url = 'http://www.google.com/py'
uptime_bot(url)
Here, you decorate uptime_bot() with a sleep() of 3 seconds. Youve also removed the original while loop, as well as the old call to sleep(60). The decorator now takes care of this. One other change youve made is to add a raise inside of the exception handling blocks. This is so that the decorator will work properly. You could write the decorator to handle these errors, but since these exceptions only apply to urllib, you might be better off keeping the decorator the way it is. That way, it will work with a wider variety of functions. Note: If youd like to brush up on exception handling in Python, then check out Python Exceptions: An Introduction. There are a few improvements that you could make to your decorator. If it runs out of retries and still fails, then you could have it re-raise the last error. The decorator will also wait 3 seconds after the last failure, which might be something you dont want to happen. Feel free to try these out as an exercise! Adding a Python sleep() Call With ThreadsThere are also times when you might want to add a Python sleep() call to a thread. Perhaps youre running a migration script against a database with millions of records in production. You dont want to cause any downtime, but you also dont want to wait longer than necessary to finish the migration, so you decide to use threads. Note: Threads are a method of doing concurrency in Python. You can run multiple threads at once to increase your applications throughput. If youre not familiar with threads in Python, then check out An Intro to Threading in Python. To prevent customers from noticing any kind of slowdown, each thread needs to run for a short period and then sleep. There are two ways to do this:
Lets start by looking at time.sleep(). Remove ads Using time.sleep()The Python Logging Cookbook shows a nice example that uses time.sleep(). Pythons logging module is thread-safe, so its a bit more useful than print() statements for this exercise. The following code is based on this example: import logging
import threading
import time
def worker(arg):
while not arg["stop"]:
logging.debug("worker thread checking in")
time.sleep(1)
def main():
logging.basicConfig(
level=logging.DEBUG,
format="%(relativeCreated)6d %(threadName)s %(message)s"
)
info = {"stop": False}
thread = threading.Thread(target=worker, args=(info,))
thread_two = threading.Thread(target=worker, args=(info,))
thread.start()
thread_two.start()
while True:
try:
logging.debug("Checking in from main thread")
time.sleep(0.75)
except KeyboardInterrupt:
info["stop"] = True
logging.debug('Stopping')
break
thread.join()
thread_two.join()
if __name__ == "__main__":
main()
Here, you use Pythons threading module to create two threads. You also create a logging object that will log the threadName to stdout. Next, you start both threads and initiate a loop to log from the main thread every so often. You use KeyboardInterrupt to catch the user pressing Ctrl+C. Try running the code above in your terminal. You should see output similar to the following: 0 Thread-1 worker thread checking in
1 Thread-2 worker thread checking in
1 MainThread Checking in from main thread
752 MainThread Checking in from main thread
1001 Thread-1 worker thread checking in
1001 Thread-2 worker thread checking in
1502 MainThread Checking in from main thread
2003 Thread-1 worker thread checking in
2003 Thread-2 worker thread checking in
2253 MainThread Checking in from main thread
3005 Thread-1 worker thread checking in
3005 MainThread Checking in from main thread
3005 Thread-2 worker thread checking in
As each thread runs and then sleeps, the logging output is printed to the console. Now that youve tried an example, youll be able to use these concepts in your own code. Using Event.wait()The threading module provides an Event() that you can use like time.sleep(). However, Event() has the added benefit of being more responsive. The reason for this is that when the event is set, the program will break out of the loop immediately. With time.sleep(), your code will need to wait for the Python sleep() call to finish before the thread can exit. The reason youd want to use wait() here is because wait() is non-blocking, whereas time.sleep() is blocking. What this means is that when you use time.sleep(), youll block the main thread from continuing to run while it waits for the sleep() call to end. wait() solves this problem. You can read more about how all this works in Pythons threading documentation. Heres how you add a Python sleep() call with Event.wait(): import logging
import threading
def worker(event):
while not event.isSet():
logging.debug("worker thread checking in")
event.wait(1)
def main():
logging.basicConfig(
level=logging.DEBUG,
format="%(relativeCreated)6d %(threadName)s %(message)s"
)
event = threading.Event()
thread = threading.Thread(target=worker, args=(event,))
thread_two = threading.Thread(target=worker, args=(event,))
thread.start()
thread_two.start()
while not event.isSet():
try:
logging.debug("Checking in from main thread")
event.wait(0.75)
except KeyboardInterrupt:
event.set()
break
if __name__ == "__main__":
main()
In this example, you create threading.Event() and pass it to worker(). (Recall that in the previous example, you instead passed a dictionary.) Next, you set up your loops to check whether or not event is set. If its not, then your code prints a message and waits a bit before checking again. To set the event, you can press Ctrl+C. Once the event is set, worker() will return and the loop will break, ending the program. Note: If youd like to learn more about dictionaries, then check out Dictionaries in Python. Take a closer look at the code block above. How would you pass in a different sleep time to each worker thread? Can you figure it out? Feel free to tackle this exercise on your own! Adding a Python sleep() Call With Async IOAsynchronous capabilities were added to Python in the 3.4 release, and this feature set has been aggressively expanding ever since. Asynchronous programming is a type of parallel programming that allows you to run multiple tasks at once. When a task finishes, it will notify the main thread. asyncio is a module that lets you add a Python sleep() call asynchronously. If youre unfamiliar with Pythons implementation of asynchronous programming, then check out Async IO in Python: A Complete Walkthrough and Python Concurrency & Parallel Programming. Heres an example from Pythons own documentation: import asyncio
async def main():
print('Hello ...')
await asyncio.sleep(1)
print('... World!')
# Python 3.7+
asyncio.run(main())
In this example, you run main() and have it sleep for one second between two print() calls. Heres a more compelling example from the Coroutines and Tasks portion of the asyncio documentation: import asyncio
import time
async def output(sleep, text):
await asyncio.sleep(sleep)
print(text)
async def main():
print(f"Started: {time.strftime('%X')}")
await output(1, 'First')
await output(2, 'Second')
await output(3, 'Third')
print(f"Ended: {time.strftime('%X')}")
# Python 3.7+
asyncio.run(main())
In this code, you create a worker called output() that takes in the number of seconds to sleep and the text to print out. Then, you use Pythons await keyword to wait for the output() code to run. await is required here because output() has been marked as an async function, so you cant call it like you would a normal function. When you run this code, your program will execute await 3 times. The code will wait for 1, 2, and 3 seconds, for a total wait time of 6 seconds. You can also rewrite the code so that the tasks run in parallel: import asyncio
import time
async def output(text, sleep):
while sleep > 0:
await asyncio.sleep(1)
print(f'{text} counter: {sleep} seconds')
sleep -= 1
async def main():
task_1 = asyncio.create_task(output('First', 1))
task_2 = asyncio.create_task(output('Second', 2))
task_3 = asyncio.create_task(output('Third', 3))
print(f"Started: {time.strftime('%X')}")
await task_1
await task_2
await task_3
print(f"Ended: {time.strftime('%X')}")
if __name__ == '__main__':
asyncio.run(main())
Now youre using the concept of tasks, which you can make with create_task(). When you use tasks in asyncio, Python will run the tasks asynchronously. So, when you run the code above, it should finish in 3 seconds total instead of 6. Remove ads Adding a Python sleep() Call With GUIsCommand-line applications arent the only place where you might need to add Python sleep() calls. When you create a Graphical User Interface (GUI), youll occasionally need to add delays. For example, you might create an FTP application to download millions of files, but you need to add a sleep() call between batches so you dont bog down the server. GUI code will run all its processing and drawing in a main thread called the event loop. If you use time.sleep() inside of GUI code, then youll block its event loop. From the users perspective, the application could appear to freeze. The user wont be able to interact with your application while its sleeping with this method. (On Windows, you might even get an alert about how your application is now unresponsive.) Fortunately, there are other methods you can use besides time.sleep(). In the next few sections, youll learn how to add Python sleep() calls in both Tkinter and wxPython. Sleeping in Tkintertkinter is a part of the Python standard library. It may not be available to you if youre using a pre-installed version of Python on Linux or Mac. If you get an ImportError, then youll need to look into how to add it to your system. But if you install Python yourself, then tkinter should already be available. Youll start by looking at an example that uses time.sleep(). Run this code to see what happens when you add a Python sleep() call the wrong way: import tkinter
import time
class MyApp:
def __init__(self, parent):
self.root = parent
self.root.geometry("400x400")
self.frame = tkinter.Frame(parent)
self.frame.pack()
b = tkinter.Button(text="click me", command=self.delayed)
b.pack()
def delayed(self):
time.sleep(3)
if __name__ == "__main__":
root = tkinter.Tk()
app = MyApp(root)
root.mainloop()
Once youve run the code, press the button in your GUI. The button will stick down for three seconds as it waits for sleep() to finish. If the application had other buttons, then you wouldnt be able to click them. You cant close the application while its sleeping, either, since it cant respond to the close event. To get tkinter to sleep properly, youll need to use after(): import tkinter
class MyApp:
def __init__(self, parent):
self.root = parent
self.root.geometry("400x400")
self.frame = tkinter.Frame(parent)
self.frame.pack()
self.root.after(3000, self.delayed)
def delayed(self):
print('I was delayed')
if __name__ == "__main__":
root = tkinter.Tk()
app = MyApp(root)
root.mainloop()
Here you create an application that is 400 pixels wide by 400 pixels tall. It has no widgets on it. All it will do is show a frame. Then, you call self.root.after() where self.root is a reference to the Tk() object. after() takes two arguments:
In this case, your application will print a string to stdout after 3 seconds. You can think of after() as the tkinter version of time.sleep(), but it also adds the ability to call a function after the sleep has finished. You could use this functionality to improve user experience. By adding a Python sleep() call, you can make the application appear to load faster and then start some longer-running process after its up. That way, the user wont have to wait for the application to open. Sleeping in wxPythonThere are two major differences between wxPython and Tkinter:
The wxPython framework is not included with Python, so youll need to install it yourself. If youre not familiar with wxPython, then check out How to Build a Python GUI Application With wxPython. In wxPython, you can use wx.CallLater() to add a Python sleep() call: import wx
class MyFrame(wx.Frame):
def __init__(self):
super().__init__(parent=None, title='Hello World')
wx.CallLater(4000, self.delayed)
self.Show()
def delayed(self):
print('I was delayed')
if __name__ == '__main__':
app = wx.App()
frame = MyFrame()
app.MainLoop()
Here, you subclass wx.Frame directly and then call wx.CallLater(). This function takes the same parameters as Tkinters after():
When you run this code, you should see a small blank window appear without any widgets. After 4 seconds, youll see the string 'I was delayed' printed to stdout. One of the benefits of using wx.CallLater() is that its thread-safe. You can use this method from within a thread to call a function thats in the main wxPython application. Remove ads ConclusionWith this tutorial, youve gained a valuable new technique to add to your Python toolbox! You know how to add delays to pace your applications and prevent them from using up system resources. You can even use Python sleep() calls to help your GUI code redraw more effectively. This will make the user experience much better for your customers! To recap, youve learned how to add Python sleep() calls with the following tools:
Now you can take what youve learned and start putting your code to sleep! Mark as Completed Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Using sleep() to Code a Python Uptime Bot Python Tricks Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team. Send Me Python Tricks » About Mike Driscoll Mike has been programming in Python for over a decade and loves writing about Python! » More about MikeEach tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are: Aldren Geir Arne Jaya Jon Joanna Master Real-World Python Skills With Unlimited Access to RealPython Join us and get access to hundreds of tutorials, hands-on video courses, and a community of expertPythonistas: Level Up Your Python Skills » Master Real-World Python Skills Join us and get access to hundreds of tutorials, hands-on video courses, and a community of expert Pythonistas: Level Up Your Python Skills » What Do You Think? Tweet Share Email Real Python Comment Policy: The most useful comments are those written with the goal of learning from or helping out other readersafter reading the whole article and all the earlier comments. Complaints and insults generally wont make the cut here. Whats your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know. Keep Learning Related Tutorial Categories: intermediate python Recommended Video Course: Using sleep() to Code a Python Uptime Bot Keep reading RealPython by creating a free account or signingin:Continue » Already have an account? Sign-In |
