Skip to content
Related Articles

Related Articles

Improve Article

Timeit in Python with Examples

  • Difficulty Level : Medium
  • Last Updated : 03 Aug, 2021

This article will introduce you to a method of measuring the execution time of your python code snippets. 
We will be using an in-built python library timeit.
This module provides a simple way to find the execution time of small bits of Python code.

Why timeit?  

  • Well, how about using a simple time module? Just save the time before and after the execution of code and subtract them! But this method is not precise as there might be a background process momentarily running which disrupts the code execution and you will get significant variations in the running time of small code snippets.
  • timeit runs your snippet of code millions of times (default value is 1000000) so that you get the statistically most relevant measurement of code execution time!
  • timeit is pretty simple to use and has a command-line interface as well as a callable one.

So now, let’s start exploring this handy library!

The module function timeit.timeit(stmt, setup, timer, number) accepts four arguments: 

  • stmt which is the statement you want to measure; it defaults to ‘pass’.
  • setup which is the code that you run before running the stmt; it defaults to ‘pass’. 
    We generally use this to import the required modules for our code.
  • timer which is a timeit.Timer object; it usually has a sensible default value so you don’t have to worry about it.
  • number which is the number of executions you’d like to run the stmt.

Where the timeit.timeit() function returns the number of seconds it took to execute the code.

Example 1
Let us see a basic example first.  


# importing the required module
import timeit
# code snippet to be executed only once
mysetup = "from math import sqrt"
# code snippet whose execution time is to be measured
mycode = '''
def example():
    mylist = []
    for x in range(100):
# timeit statement
print (timeit.timeit(setup = mysetup,
                     stmt = mycode,
                     number = 10000))
  • The output of above program will be the execution time(in seconds) for 10000 iterations of the code snippet passed to timeit.timeit() function.
    Note: Pay attention to the fact that the output is the execution time of number times iteration of the code snippet, not the single iteration. For a single iteration exec. time, divide the output time by number.
  • The program is pretty straight-forward. All we need to do is to pass the code as a string to the timeit.timeit() function.
  • It is advisable to keep the import statements and other static pieces of code in setup argument.

Example 2
Let’s see another practical example in which we will compare two searching techniques, namely, Binary search and Linear search
Also, here I demonstrate two more features, timeit.repeat function and calling the functions already defined in our program. 


# importing the required modules
import timeit
# binary search function
def binary_search(mylist, find):
    while len(mylist) > 0:
        mid = (len(mylist))//2
        if mylist[mid] == find:
            return True
        elif mylist[mid] < find:
            mylist = mylist[:mid]
            mylist = mylist[mid + 1:]
    return False
# linear search function
def linear_search(mylist, find):
    for x in mylist:
        if x == find:
            return True
    return False
# compute binary search time
def binary_time():
    SETUP_CODE = '''
from __main__ import binary_search
from random import randint'''
    TEST_CODE = '''
mylist = [x for x in range(10000)]
find = randint(0, len(mylist))
binary_search(mylist, find)'''
    # timeit.repeat statement
    times = timeit.repeat(setup = SETUP_CODE,
                          stmt = TEST_CODE,
                          repeat = 3,
                          number = 10000)
    # printing minimum exec. time
    print('Binary search time: {}'.format(min(times)))       
# compute linear search time
def linear_time():
    SETUP_CODE = '''
from __main__ import linear_search
from random import randint'''
    TEST_CODE = '''
mylist = [x for x in range(10000)]
find = randint(0, len(mylist))
linear_search(mylist, find)
    # timeit.repeat statement
    times = timeit.repeat(setup = SETUP_CODE,
                          stmt = TEST_CODE,
                          repeat = 3,
                          number = 10000)
    # printing minimum exec. time
    print('Linear search time: {}'.format(min(times))) 
if __name__ == "__main__":
  • The output of above program will be the minimum value in the list times
    This is how a sample output looks like: 

  • strate below how you can utilize the command lin
  • timeit.repeat() function accepts one extra argument, repeat. The output will be a list of the execution times of all code runs repeated a specified no. of times.
  • In setup argument, we passed: 
from __main__ import binary_search
from random import randint
  • This will import the definition of function binary_search, already defined in the program and random library function randint.
  • As expected, we notice that execution time of binary search is significantly lower than linear search!

Example 3 
Finally, I demonstrate below how you can utilize the command line interface of timeit module:

Here I explain each term individually:  

So, this was a brief yet concise introduction to timeit module and its practical applications. 
Its a pretty handy tool for python programmers when they need a quick glance of the execution time of their code snippets.




My Personal Notes arrow_drop_up
Recommended Articles
Page :