In Python you can write different pieces of codes to perform the same task. However, writing an efficient code, which consumes less CPU cycles and is light on memory, is crucial for production-grade applications. A poorly written code can make your application take longer to respond to user inputs. There are several ways to measure code quality, like finding the time complexity via big o notation and calculating the memory occupied by the code. One of the ways to measure the code quality is to calculate the time it takes to complete its execution. In this article, you’ll see different ways to measure the execution time of a Python script.

There are three main methods to find the execution time of a Python script:

1. Using the time module
2. Using the timeit module
3. Using the %%time command (Only in Jupyter Notebook)

To test these three methods, we’ll write two functions that calculate the factorial of a number passed to it as a parameter.

In the script below, the `cal_fact()` function uses recursive calls to calculate the factorial of a number.

``````def cal_fact(n):
if n == 1:
return n
else:
return n * cal_fact(n-1)``````

In our next script, we define another function `cal_fact2()` which uses simple iterations to calculate the factorial of a number passed to it as a parameter value.

``````def cal_fact2(n):
if n == 1:
return n
else:
result = 1
for i in range(2,n+1):
result = result * i
return result``````

We’re going to use these two functions in the next sections, where we’ll exercise the three methods for finding the execution times. Though both the functions perform the same task, you’ll see that their execution times will differ.

## Finding the Execution Time using Python time Module

The first method to find the execution time of a Python script is via the `time()` method of the time module. Basically, you need to call the `time()` method before the code starts. The `time()` method of the time module returns the current system time. Next, you call the `time()` method again after the code completes execution. Finally, you subtract the time value calculated before the start of the code from the time value calculated after the code completes execution. That’s simple enough, right?

The following script calculates the execution time for the `cal_fact()` function for calculating the factorial of 2500.

``````# import the builtin time module
import time

# Grab Currrent Time Before Running the Code
start = time.time()

cal_fact(2500)

# Grab Currrent Time After Running the Code
end = time.time()

#Subtract Start Time from The End Time
total_time = end - start
print("\n"+ str(total_time))``````

Output:

``0.004949808120727539``

NOTE: If you get a RecursionError: maximum recursion depth exceeded in comparison, you may need to reduce the 2500 to a number less than 1020.

The output shows that the system took 0.00494 seconds to execute the `cal_fact()` function for calculating the factorial of 2500. That’s pretty fast!

Similarly, the following script calculates the execution time of the `cal_fact2()` function when a parameter value of 2500 is passed to it.

``````# import the builtin time module
import time

# Grab Currrent Time Before Running the Code
start = time.time()

cal_fact2(2500)

# Grab Currrent Time After Running the Code
end = time.time()

#Subtract Start Time from The End Time
total_time = end - start
print("\n"+ str(total_time))``````

Output:

``0.0019457340240478516``

The output shows that `cal_fact2()` was even faster, taking only 0.00194 seconds to find the factorial of 2500.

The time module is useful when you want to calculate the execution time of large scripts. If the execution time of a particular piece of code is a tiny fraction of second, the time module will return 0.0 because the time taken by a code to complete its execution is too insignificant to be measured using the `time()` method.

Let’s see an example. Instead of calculating factorial of 2500, lets find the factorial of a smaller number, 100, using the `cal_fact()` method. Run the following script.

``````# import the builtin time module
import time

# Grab Currrent Time Before Running the Code
start = time.time()

cal_fact(100)

# Grab Currrent Time After Running the Code
end = time.time()

#Subtract Start Time from The End Time
total_time = end - start
print("\n"+ str(total_time))``````

Output:

``0.0``

The output returns 0.0. Though the code actually took some time to execute, the `time()` function could not measure it because the difference between the time before and after the execution of the `cal_fact()` function is too insignificant.

Similarly, you can run the `cal_fact2()` function to calculate the factorial of 100, and you’ll again see that the execution time is 0.0.

When the execution time of a code is too insignificant to be measured, you can use the Python timeit module. instead.

Want to do more with Python?

Yes, show me more free Python tips

## Finding the Execution Time using Python timeit Module

The timeit module in Python is a default Python module whose sole job is to calculate the execution time of a Python script. The following script imports the timeit module.

``import timeit``

To find the execution time of a code using the timeit module, you need to pass the call to the function that you want to execute, as a first parameter value to the `timeit()` fuction. The function call should be passed in a string format. The second parameter value is the function that is to be executed. The third parameter is the number of iterations for the execution of the function.

In the following script, you pass the function call in the form of a multiline string to the statement variable. The function body for the `cal_func()` is passed to the setup variable.

```statement = '''
cal_fact(100)
'''

setup = '''
def cal_fact(n):
if n == 1:
return n
else:
return n * cal_fact(n-1)
'''
```

Finally, the statement and setup variables are passed to the `timeit()` function of the timeit module. The function is executed for a million times.

``print(timeit.timeit(statement, setup, number = 1000000))``

Output:

``23.135807499999828``

The output shows that, it takes 23.13 seconds to run the `cal_func()` function a million times to find the factorial of 100.

Let’s now find the factorial of 100, with 1 million iterations, using the `cal_fact2()` function. We’ll again make use of the `timeit()` function.

```statement2 = '''
cal_fact2(100)
'''

setup2 = '''
def cal_fact2(n):
if n == 1:
return n
else:
result = 1
for i in range(2,n+1):
result = result * i
return result
'''
```
``print(timeit.timeit(statement2, setup2, number = 1000000))``

Output:

``10.493902499999876``

The output shows that the `cal_fact2()` method took 10.49 seconds, which shows that the `cal_fact2()` is about twice as fast as the `cal_fact()` function.

## Finding the Execution Time using Python %%time command

If you run your code in the Jupyter Notebook, you have a third option for calculating how long it takes your Python code to run. Simply add the `%%timeit` command in the Jupyter Notebook cell that contains your code. The `%%timeit` command should be the first command in a cell. For instance, the following script measures the execution time of the `cal_fact()` function for calculating the factorial of 100.

``````%%timeit
cal_fact(100)``````

Output:

``18.4 µs ± 1.03 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)``

The output shows that the code took an average of 18.4 microsecond to run. By default, %%timeit module runs your python script one hundred thousand times to determine its run time.

Similarly, you can calculate the execution time for `cal_fact2()` function as follows:

``````%%timeit
cal_fact2(100)``````

Output:

``10.5 µs ± 3.51 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)``

The `cal_fact2()` function took 10.5 microseconds to calculate the factorial of 100, though it had a bit higher standard deviation. Still, the %%timeit technique confirms that `cal_fact2()` is much faster than our recursive `cal_fact()` function.

Want to do more with Python?