Summary: You can evaluate the execution time of your code by saving the timestamps using time.time() at the beginning and the end of your code. Then, you can find the difference between the start and the end timestamps that results in the total execution time.
[toc]
Problem: Given a Python program; how will you measure the elapsed time ( the time taken by the code to complete execution)?
Consider the following snippet:
import time
def perimeter(x):
time.sleep(5)
return 4 * x
def area(x):
time.sleep(2)
return x * x
p = perimeter(8)
print("Perimeter: ", p)
a = area(8)
print("Area: ", a)- Challenges:
- How will you find the time taken by each function in the above program to execute?
- How will you compute the total time elapsed by the entire code?
Tidbit: sleep() is a built-in method of the time module in Python that is used to delay the execution of your code by the number of seconds specified by you.
Now, let us conquer the given problem and dive into the solutions.
Method 1: Using time.time()
time.time() is a function of the time module in Python that is used to get the time in seconds since the epoch. It returns the output, i.e., the time elapsed, as a floating-point value.
The code:
import time
def perimeter(x):
time.sleep(5)
return 4 * x
def area(x):
time.sleep(2)
return x * x
begin = time.time()
start = time.time()
p = perimeter(8)
end = time.time()
print("Perimeter: ", p)
print("Time Taken by perimeter(): ", end - start)
start = time.time()
a = area(8)
end = time.time()
print("Area: ", a)
print("Time Taken by area(): ", end - start)
end = time.time()
print("Total time elapsed: ", end - begin)Output:
Perimeter: 32 Time Taken by Perimeter(): 5.0040647983551025 Area: 64 Time Taken by area(): 2.0023691654205322 Total time elapsed: 7.006433963775635
Approach:
➤ Keep track of the time taken by each function by saving the time stamp at the beginning of each function with the help of a start variable and using the time() method.
➤ Similarly, the end time, i.e., the timestamp at which a function completes its execution, is also tracked with the help of the time() function at the end of each function.
➤ Finally, the difference between the end and the start time gives the total time taken by a particular function to execute.
➤ To find the total time taken by the entire program to complete its execution, you can follow a similar approach by saving the time stamp at the beginning of the program and the time stamp at the end of the program and then find their difference.
Discussion: If you are working on Python 3.3 or above, then another option to measure the elapsed time is perf_counter or process_time, depending on the requirements. Prior to Python 3.3, you could have used time.clock, however, it has been currently deprecated and is not recommended.
Method 2: Using time.perf_counter()
In Python, the perf_counter() function from the time module is used to calculate the execution time of a function and gives the most accurate time measure of the system. The function returns the system-wide time and also takes the sleep time into account.
import time
def perimeter(x):
time.sleep(5)
return 4 * x
def area(x):
time.sleep(2)
return x * x
begin = time.perf_counter()
start = time.perf_counter()
p = perimeter(8)
end = time.perf_counter()
print("Perimeter: ", p)
print("Time Taken by perimeter(): ", end - start)
start = time.perf_counter()
a = area(8)
end = time.perf_counter()
print("Area: ", a)
print("Time Taken by area(): ", end - start)
end = time.perf_counter()
print("Total time elapsed: ", end - begin)Output:
Perimeter: 32 Time Taken by perimeter(): 5.0133558 Area: 64 Time Taken by are(): 2.0052768 Total time elapsed: 7.0189293
Caution: The perf_counter() function not only counts the time elapsed along with the sleep time, but it is also affected by other programs running in the background on the system. Hence, you must keep this in mind while using perf_counter for performance measurement. It is recommended that if you utilize the perf_counter() function, ensure that you run it several times so that the average time would give an accurate estimate of the execution time.
Method 3: Using time.process_time()
Another method from the time module used to estimate the execution time of the program is process_time(). The function returns a float value containing the sum of the system and the user CPU time of the program. The major advantage of the process_time() function is that it does not get affected by the other programs running in the background on the machine, and it does not count the sleep time.
import time
def perimeter(x):
time.sleep(5)
return 4 * x
def area(x):
time.sleep(2)
return x * x
begin = time.process_time()
start = time.process_time()
p = perimeter(8)
end = time.process_time()
print("Perimeter: ", p)
print("Time Taken by perimeter(): ", end - start)
start = time.process_time()
a = area(8)
end = time.process_time()
print("Area: ", a)
print("Time Taken by area(): ", end - start)
end = time.process_time()
print("Total time elapsed: ", end - begin)Output:
Perimeter: 32 Time Taken by perimeter(): 5.141000000000173e-05 Area: 64 Time Taken by area(): 4.1780000000005146e-05 Total time elapsed: 0.00029919000000000473
Method 4: Using timeit Module
timeit is a very handy module that allows you to measure the elapsed time of your code. A major advantage of using the timeit module is its ability to measure and execute lambda functions wherein you can specify the number of executions as an argument.
Note: The timeit module turns off the garbage collection process temporarily while calculating the execution time.
Let us dive into the different methods of this module to understand how you can use it to measure execution time within your code.
4.1 Using timeit.timeit()
Example 1: In the following example, we will have a look at a lambda function being executed with the help of the timeit module such that we will be specifying the number of times this anonymous function will be executed and then calculate the time taken to execute it.
import timeit
count = 1
def foo(x):
global count
print(f'Output for call{count} = {x * 3}')
count += 1
a = timeit.timeit(lambda: foo(8), number=3)
print("Time Elapsed: ", a)Output:
Output for call1 = 24 Output for call2 = 24 Output for call3 = 24 Time Elapsed: 6.140000000000312e-05
Explanation: After importing the timeit module, you can call the lambda function within the timeit.timeit() function as a parameter and also specify the number of times the function will be called with the help of the second parameter, i.e., number. In this case, we are calling the lambda function three times and printing the output generated by the function every time. Finally, we displayed the total time elapsed by the function.
4.2 Using timeit.repeat
Even though the above method allowed us to calculate the execution time of a lambda function, it is not safe to say that the value evaluated by the timeit() function was accurate. To get a more accurate result, you can record multiple values of execution time and then find their mean to get the best possible outcome. This is what timeit.repeat() function allows you to do.
Example:
import timeit
count = 1
def foo(x):
global count
print(f'Output for call{count} = {x * 3}')
count += 1
a = timeit.repeat(lambda: foo(8), number=1, repeat=3)
print(a)
s = 0
for i in a:
s = s + i
print("Best Outcome: ", s)Output:
Output for call1 = 24 Output for call2 = 24 Output for call3 = 24 [5.160000000001275e-05, 1.3399999999996748e-05, 1.0399999999993748e-05] Best Outcome: 7.540000000000324e-05
4.3 Using timeit.default_timer()
Instead of using timeit.timeit() function, we can also use the timeit.default_timer(), which is a better option as it provides the best clock available based on the platform and Python version you are using, thereby generating more accurate results. Using timeit.default_timer() is quite similar to using time.time().
Example:
import timeit
import time
def perimeter(x):
time.sleep(5)
return 4 * x
def area(x):
time.sleep(2)
return x * x
begin = timeit.default_timer()
start = timeit.default_timer()
p = perimeter(8)
end = timeit.default_timer()
print("Perimeter: ", p)
print("Time Taken by Perimeter(): ", end - start)
start = timeit.default_timer()
a = area(8)
end = timeit.default_timer()
print("Area: ", a)
print("Time Taken by Perimeter(): ", end - start)
end = timeit.default_timer()
print("Total time elapsed: ", end - begin)Output:
Perimeter: 32 Time Taken by Perimeter(): 5.0143883 Area: 64 Time Taken by Perimeter(): 2.0116591 Total time elapsed: 7.0264410999999996
Methdo 5: Using datetime.datetime.now()
The elapsed time can also be calculated using the DateTime.datetime.now() function from the datetime module in Python. The output of the method is represented as days, hours, and minutes. However, the disadvantage of this method is that it is slower than the timeit() module since calculating the difference in time is also included in the execution time.
Example:
import datetime
import time
def perimeter(x):
time.sleep(5)
return 4 * x
def area(x):
time.sleep(2)
return x * x
begin = datetime.datetime.now()
start = datetime.datetime.now()
p = perimeter(8)
end = datetime.datetime.now()
print("Perimeter: ", p)
print("Time Taken by Perimeter(): ", end - start)
start = datetime.datetime.now()
a = area(8)
end = datetime.datetime.now()
print("Area: ", a)
print("Time Taken by Perimeter(): ", end - start)
end = datetime.datetime.now()
print("Total time elapsed: ", end - begin)Output:
Perimeter: 32 Time Taken by Perimeter(): 0:00:05.003221 Area: 64 Time Taken by Perimeter(): 0:00:02.011262 Total time elapsed: 0:00:07.014483
Conclusion
Thus to sum things up, you can use one of the following modules in Python to calculate the elapsed time of your code:
- The time module
- The timeit module
- The datetime module
With that, we come to the end of this tutorial, and I hope you found it helpful. Please subscribe and stay tuned for more interesting articles.
Here’s a list of highly recommended tutorials if you want to dive deep into the execution time of your code and much more: