{"id":3842,"date":"2023-08-25T23:26:33","date_gmt":"2023-08-26T06:26:33","guid":{"rendered":"https:\/\/ioflood.com\/blog\/?p=3842"},"modified":"2024-02-07T13:50:42","modified_gmt":"2024-02-07T20:50:42","slug":"timeit-python","status":"publish","type":"post","link":"https:\/\/ioflood.com\/blog\/timeit-python\/","title":{"rendered":"timeit() Python Function Usage Guide (With Examples)"},"content":{"rendered":"
\n
\"Python<\/figure>\n<\/div>\n

Ever found yourself trying to measure the execution time of your Python code? Don’t worry, you’re not alone. Python’s built-in module timeit<\/code> is here to the rescue. Just as a stopwatch times your laps, timeit<\/code> helps you time your code snippets with precision.<\/p>\n

This comprehensive guide is your one-stop-shop to mastering the use of timeit<\/code> in Python. It takes you on a journey from understanding its basic use to exploring advanced techniques. Let’s dive in and explore the power of timeit<\/code> in Python.<\/p>\n

TL;DR: How Do I Use the timeit Module in Python?<\/h2>\n

\n The timeit<\/code> module in Python is a built-in tool that allows you to accurately measure the execution time of your Python code. Here’s a quick example of how to use it:\n<\/p><\/blockquote>\n

import timeit\nprint(timeit.timeit('output = 10**2'))\n<\/code><\/pre>\n
This code will print out the time it takes to execute the expression 10**2<\/code>. The timeit<\/code> function is called with a string argument, which is the Python code you want to time. The output you get is the time taken in seconds.<\/p>\n
\n  This is just a glimpse of what timeit<\/code> can do. Read on for a more detailed explanation, advanced usage scenarios, and how to handle common issues in using the timeit<\/code> module in Python.\n<\/p><\/blockquote>\n
Getting Started with timeit in Python<\/h2>\n
The timeit<\/code> module is built into Python, so there’s no need to install anything. To use it, you simply need to import it at the top of your script:<\/p>\n
import timeit\n<\/code><\/pre>\n
The primary function in the timeit<\/code> module is the timeit()<\/code> function. This function takes a string argument, which is the Python code you want to time. It then executes this code and returns the time taken in seconds.<\/p>\n
Let’s see a basic example of how to use the timeit()<\/code> function:<\/p>\n
import timeit\n\nprint(timeit.timeit('output = 10**2'))\n<\/code><\/pre>\n
In this example, we’re timing how long it takes for Python to calculate '10**2'<\/code>. When you run this script, you’ll see a number printed to your console. This number is the time taken, in seconds, for Python to calculate '10**2'<\/code>.<\/p>\n
# Expected output (may vary):\n# 0.023150000000000002\n<\/code><\/pre>\n
This output means that it took approximately 0.02315 seconds to execute the statement '10**2'<\/code>. Remember, the exact output may vary slightly each time you run the script due to variations in CPU load and other factors.<\/p>\n
That’s it! You’ve just used the timeit<\/code> module to measure the execution time of a Python statement. As you continue to use timeit<\/code>, you’ll find that it’s a powerful tool for optimizing your Python code.<\/p>\n
Diving Deeper into Python’s timeit Module<\/h2>\n
As you become more comfortable with timeit<\/code>, you might find yourself wanting to time more complex, multi-line code snippets. Luckily, timeit<\/code> is up to the task.<\/p>\n
To time multi-line code snippets, you can pass a multiline string to the timeit()<\/code> function. Here’s an example:<\/p>\n
import timeit\n\ncode_to_test = \"\"\"\na = [1, 2, 3]\nb = [4, 5, 6]\nc = a + b\n\"\"\"\n\nprint(timeit.timeit(code_to_test))\n<\/code><\/pre>\n
In this example, we’re timing how long it takes Python to concatenate two lists. The timeit()<\/code> function will execute the multi-line string and print the time taken in seconds.<\/p>\n
# Expected output (may vary):\n# 0.13962000000000001\n<\/code><\/pre>\n
This output indicates that it took approximately 0.13962 seconds to execute the multi-line code snippet.<\/p>\n
Repeating Measurements with the repeat() Function<\/h3>\n
Another useful feature of the timeit<\/code> module is the repeat()<\/code> function. This function works similarly to timeit()<\/code>, but instead of running the code once, it runs it multiple times and returns a list of times. Here’s how you can use it:<\/p>\n
import timeit\n\ncode_to_test = \"\"\"\na = [1, 2, 3]\nb = [4, 5, 6]\nc = a + b\n\"\"\"\n\nprint(timeit.repeat(code_to_test, repeat=3))\n<\/code><\/pre>\n
In this example, the repeat()<\/code> function will execute the multi-line string three times and print a list of the three times.<\/p>\n
# Expected output (may vary):\n# [0.13962000000000001, 0.13962000000000001, 0.13962000000000001]\n<\/code><\/pre>\n
Harnessing the Timer Class<\/h3>\n
The timeit<\/code> module also provides a Timer<\/code> class, which you can use to create timer objects. These objects have timeit()<\/code> and repeat()<\/code> methods, allowing you to time code snippets just like the module-level functions. Here’s an example of how to use the Timer<\/code> class:<\/p>\n
import timeit\n\ncode_to_test = \"\"\"\na = [1, 2, 3]\nb = [4, 5, 6]\nc = a + b\n\"\"\"\n\ntimer = timeit.Timer(code_to_test)\nprint(timer.timeit())\n<\/code><\/pre>\n
In this example, we’re creating a Timer<\/code> object with our multi-line string. We then call the timeit()<\/code> method on the Timer<\/code> object, which executes the string and prints the time taken.<\/p>\n
# Expected output (may vary):\n# 0.13962000000000001\n<\/code><\/pre>\n
The Timer<\/code> class is a powerful tool that gives you more control over your timing tests. For instance, you can create multiple Timer<\/code> objects to time different code snippets and compare their performance.<\/p>\n
Exploring Alternatives to timeit in Python<\/h2>\n
While timeit<\/code> is a powerful module for measuring execution time, Python provides other tools that you might find useful. One such tool is the perf_counter()<\/code> function in the time<\/code> module.<\/p>\n
Timing with perf_counter()<\/h3>\n
The perf_counter()<\/code> function returns the value (in fractional seconds) of a performance counter. It’s useful for timing the duration of a program or a specific code block. Here’s an example of how to use it:<\/p>\n
import time\n\nstart_time = time.perf_counter()\n\n# Code to time\na = [1, 2, 3]\nb = [4, 5, 6]\nc = a + b\n\nend_time = time.perf_counter()\ntotal_time = end_time - start_time\n\nprint(f'Total execution time: {total_time} seconds')\n<\/code><\/pre>\n
In this example, we’re using perf_counter()<\/code> to record the start time and end time of a code block. We then subtract the start time from the end time to get the total execution time.<\/p>\n
# Expected output (may vary):\n# Total execution time: 0.000106000000000106 seconds\n<\/code><\/pre>\n
Weighing the Pros and Cons<\/h3>\n
While perf_counter()<\/code> can be a handy tool, it’s not always the best choice. Here are some things to consider:<\/p>\n