Note: This article has already featured on geeksforgeeks.org

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 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 running time of small code snippets.
• timeit runs your snippet of code millions of time (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):
        mylist.append(sqrt(x))
'''

# 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]
        else:
            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)

    # priniting 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)

    # priniting minimum exec. time
    print('Linear search time: {}'.format(min(times)))  

if __name__ == "__main__":
    linear_time()
    binary_time()

• The output of above program will be the minimum value in the list times.
  This is how a sample output looks like:
  
• 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.
Happy coding! 🙂