How do I add a delay in Pygame?

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[]:

If you run this code in your console, then you should experience a delay before you can enter a new statement in the REPL.

You can test how long the sleep lasts by using Pythons timeit module:

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:

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:

Go ahead and update the code to use a known good URL, like //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.

Adding a Python sleep[] Call With Decorators

There 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:

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.

Adding a Python sleep[] Call With GUIs

Command-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.

Conclusion

With 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:

• time.sleep[]
• Decorators
• Threads
• asyncio
• Tkinter
• wxPython

Now you can take what youve learned and start putting your code to sleep!