How to measure elapsed time in Python?
In Python, we can measure the elapsed time on executing a code segment or a Python script using some built-in Python modules. Here we will cover the usage of time, timeit and datetime module.
Using Python timeit Module to measure elapsed time in Python
Python timeit module is often used to measure the execution time of small code snippets. We can also use the timeit() function, which executes an anonymous function with a number of executions. It temporarily turns off garbage collection while calculating the time of execution.
Example 1: Analyze how to use the timeit module
In this example, we will analyze how to use the timeit module and use it to find the execution time of a lambda expression. The code starts with importing the timeit module, and then we use the timeit() function from the module to find the execution time of the function.
Python3
# importing the module import timeit # define the code statement to test and # calculate the execution time exec_time = timeit.timeit( "print('Hello World!')" ) # printing the execution time in seconds print (exec_time, "secs." ) |
Output:
Hello World! Hello World! Hello World! Hello World! Hello World! ... 1.632629341998836 secs.
Explanation: The above code segment, will print “Hello World” 1000000 times (since default value of number parameter is 1000000). At the end, the code will print the execution time of the given code segment, measured in seconds.
Example 2: Using timeit.timeit() with predefined parameters
In this example, we’ll write a Python code segment having a function, and it’s call as a string and pass it to timeit.timeit() function. We’ll use a predefined number of iterations to count the execution time.
Python3
# importing the module import timeit # code segment to measure code_segment = '''\ import random def execute(n): return n**n execute(random.randint(20, 50)) ''' # execute code segment and find the execution time exec_time = timeit.timeit(code_segment, number = 10 * * 6 ) # printing the execution time in secs. # nearest to 3-decimal places print (f "{exec_time:.03f} secs." ) |
Output:
1.118 secs.
Explanations: In this example, we have defined a Python function and call to the function, everything written as a string representation. We test the running time of the code for 10**6 times and print out the time taken to execute the given function in seconds.
Example 3: How to measure elapsed time using timeit.repeat
We use the timeit.repeat() method instead of timeit.timeit() which takes a repeat parameter and saves you the trouble of creating a loop and storing the values in the array. This helps in getting an average elapsed time value from multiple execution of the same code segment.
Python3
# importing the module import timeit # function to test the execution time def print_square(x): return x * * 2 t_records = timeit.repeat( lambda : print_square( 3 ), number = 10 , repeat = 5 ) # printing the execution time for index, exec_time in enumerate (t_records, 1 ): # printing execution time of code in microseconds m_secs = round (exec_time * 10 * * 6 , 2 ) print (f "Case {index}: Time Taken: {m_secs}µs" ) |
Output:
Case 1: Time Taken: 4.41µs Case 2: Time Taken: 3.15µs Case 3: Time Taken: 3.07µs Case 4: Time Taken: 3.04µs Case 5: Time Taken: 3.08µs
Example 4: How to measure elapsed time using timeit.default_timer()
timeit.default_timer() uses the timeit.perf_counter() to record the timestamp of an instance in nanoseconds, and we can subtract end time from start time to get the execution time duration in nanoseconds.
Python3
# importing the module import timeit # define function def print_square(x): return x * * 2 # record start time t_0 = timeit.default_timer() # call function res = print_square( 11111111 ) # record end time t_1 = timeit.default_timer() # calculate elapsed time and print elapsed_time = round ((t_1 - t_0) * 10 * * 6 , 3 ) print (f "Elapsed time: {elapsed_time} µs" ) |
Output:
Elapsed time: 1.266 µs
Using Python time Module to measure elapsed time in Python
In Python time module, there are different methods to record and find the execution time of a given code segment, we covered the usage of the following methods: time.perf_counter(), time.time_ns(), time.process_time(), time.time()
Example 1: How to measure elapsed time using time.perf_counter()
time.perf_counter() method records the time in seconds time unit. Since our sample function is very simple, so, we need to convert it to micro seconds to get time difference value in readable format.
Python3
# importing the module import time # function to test elapsed time for def print_square(x): return x * * 2 # records start time start = time.perf_counter() # calls the function print_square( 3 ) # record end time end = time.perf_counter() # find elapsed time in seconds ms = (end - start) * 10 * * 6 print (f "Elapsed {ms:.03f} micro secs." ) |
Output:
Elapsed 1.014 micro secs.
Example 2: How to measure elapsed time using time.time_ns()
To measure the elapsed time or execution time of a block of code in nanoseconds, we can use the time.time_ns() function. This follows the same syntax as the time.time() function, like recording the time before and after the lines of the code and then subtracting the values and then printing them to the screen, but it records in nanoseconds instead of seconds.
Python3
# importing the module import time # sample function for testing def print_square(x): return (x * * 2 ) # record start time start = time.time_ns() # calls the function print_square( 3 ) # record end time end = time.time_ns() # printing elapsed time in nanoseconds print ( "Time taken" , end - start, "ns" ) |
Output:
Time taken 2671 ns
Example 3: How to measure elapsed time using time.process_time()
time.process_time() function returns the sum of the system and the user CPU time. This follows the same syntax as the time.time() function, like recording the time before and after the lines of the code and then subtracting the values, and then printing them to the screen.
Python3
# importing the module import time # sample function for testing def print_square(x): return x * * 76567 # record start time start = time.process_time() # calls the function print_square( 125 ) # record end time end = time.process_time() # print elapsed time in seconds print ( "Elapsed time using process_time()" , (end - start) * 10 * * 3 , "ms." ) |
Elapsed time using process_time() 12.583209999999998 ms.
Using Python datetime Module to measure elapsed time in Python
we can also use Python datetime module, we can also record time and find the execution time of a block of code. The process is same as using time.time(), measuring start and end time and then calculating the difference.
Example: How to measure elapsed time using datetime.datetime.now()
Python3
# importing the module from datetime import datetime # sample function for testing def print_square(x): return x * * 2 # record start time (in datetime format) start = datetime.now() # calls the function print_square( 3 ) # record rnd time (in datetime format) end = datetime.now() # print elapsed time in microseconds print ( "Elapsed" , (end - start).total_seconds() * 10 * * 6 , "µs" ) |
Output:
Elapsed 12.0 µs