Python Timeit: Measure Execution Time Accurately

Photo of author

Python is a high-level programming language in various applications, from web development and data analysis to scientific computing and artificial intelligence. One feature that makes Python a universal language is its built-in support for timing the execution of code snippets. 

The ‘timeit’ module is a built-in function in Python that provides a simple and efficient way to measure the time needed for the execution of small bits of Python code. It is the simplest way in the Python library. It will also help to check the performance of any code.

Python timeit()

In this article, we will explore the ‘timeit()’ function in detail, covering everything you need to know about using it and what it can do.

See Also: What Are The Key Features Of Python?

What Is The ‘timeit’ Function In Python?

The ‘timeit’ function is a tool that measures the execution time of a small Python code snippet. Python’s standard library includes the ‘timeit’ module of which the ‘timeit’ function forms a part. It is available for use in all Python installations.

The ‘timeit’ function measures the execution time of any Python code, regardless of its complexity. One can also use it to test the performance of individual functions, compare different algorithms, or evaluate the impact of changes to your code.

How To Use The ‘timeit’ Function

Using the ‘timeit’ function is simple. The basic syntax for using the function is as follows:


The ‘stmt’ argument is the code snippet for which one wants to measure the execution time. The ‘setup’ argument is optional and specifies any code that needs execution before running ‘stmt’. The timer argument is optional and allows you to set a different timing function. The number argument is the ‘number’ of times the code snippet should be executed.

The given example shows the usage of the ‘timeit’ function to measure the time needed for the execution of a simple code snippet:

Timeit example

In this example, the code “a = 2 + 2” is executed one million times, and the execution time is measured using the ‘timeit’ function. The console then displays the outcome.

The primary usage of the ‘timeit’ function is to pass a string of code to be executed as an argument. For example, the following code measures the time it takes to execute a print statement:


In this example, the ‘number’ argument specifies the number of times to run the code. The outcome will be more accurate the higher the number, and the output will be the time it took to run the code in seconds.

You can also pass a setup string as a second argument to ‘timeit’, which will be executed before the code. The setup string helps import modules or set up data needed for the execution of the code. For example:


In addition to using ‘timeit’ as a function, you can also use it as a context manager. The context manager provides a convenient way to time a block of code. For example:

Timeit example

The ‘timeit’ module also provides a ‘timer’ class for more advanced usage. The ‘timer’ class allows you to specify the number of loops and the repeat value. The repeat value is the number of times ‘timeit’ will repeat the timing process, and the final result will be the best time among all the repeats.


It is important to note that the ‘timeit’ module does not intend to measure the performance of long-running tasks. Instead, it provides a quick and easy way to measure the execution time of small bits of code.

The Benefits Of Using The ‘timeit’ Function

The ‘timeit’ function provides several benefits when it comes to measuring the execution time of your Python code. Here are a few of the key advantages:

  1. Accurate and reliable measurements: The ‘timeit’ function uses a high-precision timer to measure the execution time of your code, ensuring that the results are accurate and reliable.
  2. Easy to use: The ‘timeit’ function is simple and requires a minimalistic setup, making it a convenient and efficient tool for measuring the performance of your code.
  3. Flexible: The ‘timeit’ function allows you to measure the execution time of any piece of Python code, regardless of its complexity. This makes it a flexible tool for a wide range of use cases.
  4. Repeatable: You may define how often the code snippet should run using the “timeit” function. Thus, making it easy to repeat the measurements and obtain consistent results.


What Is The Use Of The Timeit Function In Python?

You can measure the execution times of the brief bits of Python code using Timeit. To obtain the most accurate estimate for the code execution time, this module runs the code one million times (by default).

What Is The Output Of Timeit In Python?

The time it would take to execute the statement repeatedly would be returned by the Timeit() method. Hence, you can further reduce this output to the average time required to store one item in the dictionary in the production of show results(), transforming the value into the time required per iteration.

When Can You Use Python's Sleep() Function?

You can use the program (or thread) in which sleep() is responsible for suspending execution for a predetermined amount of seconds. The sleep() function can stop the program's execution the whole time unless some signal disrupts it.

How Does Python Create New Directories?

The mkdir() method in Python can create a brand-new directory. This procedure receives the path to the new directory. However, if the complete route is not provided, the new directory is in the current working directory.

How To Split A String In Python?

Split() is the most popular Python technique for dividing text into a list. Hence, this method divides a string into substrings using a delimiter and provides a list of those substrings.

How to test run time in Python?

You can use the time module to determine the time to execute a code. This is a fairly simple method. You can use the time() method to save the timestamp when the code starts running. Similarly, save the ending timestamp using the time() method again. The difference between the timestamps gives you the time taken for execution.

What does time.time () do?

The time.time() method in Python gives you the time since Epoch in seconds. Epoch refers to the start of time and can sometimes vary with regard to the system. On Windows, the epoch is usually 00;00 on January 1, 1970. The epoch varies from platform to platform due to different starting times and methods of handling leap seconds.

What is the difference between Time clock () and time time () in Python?

The varying factor between the Time clock() and Time time() is mainly what they measure. The time clock() function measures elapsed CPU or wall-clock time since the current process started. Alternatively, the time time() function provides you with seconds since the epoch in UTC. Changing the time on your system will generally affect time time () and not the time clock () module.

How do you wait 10 seconds in Python?

In order to wait ten seconds in Python, you can add a time delay in the program code. A time delay is usually added using the sleep() function. You can find this function in the Time module, as it is a built-in feature. Using this function adds a delay to the execution time. You can specify ten seconds of delay.


In conclusion, Python’s ‘timeit’ function is a powerful tool for profiling and optimizing small pieces of code. It provides a simple and productive way to measure the execution time of code. It also offers advanced options for more complex use cases. Whether you are working on improving the performance of your code or want to know how long a specific task takes to run, the ‘timeit’ module is the tool for you.

Leave a Comment