timeit module: This is a built-in Python module that provides a simple way to measure the execution time of small bits of Python code. You can use the timeit.timeit() function to time the execution of a single line of code or multiple lines wrapped in a function.
For example:
import timeit
def some_function():
# code to be timed
x = [i**2 for i in range(10000)]
print("Time taken by the function:", timeit.timeit(some_function, number=1000), "seconds")
Sure, here’s a simple example that demonstrates how to use the timeit module to measure the execution time of a piece of code:
python
Copy code
import timeit
def some_function():
# code to be timed
x = [i**2 for i in range(10000)]
print(“Time taken by the function:”, timeit.timeit(some_function, number=1000), “seconds”)
In this example, the timeit.timeit() function is used to measure the execution time of the some_function function. The number parameter is used to specify how many times the function should be run. In this case, it’s set to 1000, so the function will be executed 1000 times and the average time will be returned. The output of the code will look like this:
Time taken by the function: 0.17904642399999998 seconds
You can also use timeit to time a single line of code. For example:
import timeit
print("Time taken by the code:", timeit.timeit('x = [i**2 for i in range(10000)]', number=1000), "seconds")
In this case, the timeit.timeit() function is used to measure the execution time of a single line of code. The number parameter is used to specify how many times the code should be run, and the output will be the average time taken to execute the code.
cProfile module: This is a built-in Python module that provides detailed profiling information about your code, including the time spent in each function and how many times each function was called. You can run this module from the command line to profile your code, or you can use it as a library in your code.
This is another built-in Python module that provides detailed profiling information about your code, including the time spent in each function and how many times each function was called. You can run this module from the command line to profile your code, or you can use it as a library in your code.
For example;
import cProfile
def some_function():
# code to be profiled
x = [i**2 for i in range(10000)]
cProfile.run("some_function()")
In this example, the cProfile.run() function is used to profile the some_function function. The output of the code will look something like this:
4 function calls in 0.000 seconds
Ordered by: standard name
ncalls tottime percall cumtime percall filename:lineno(function)
1 0.000 0.000 0.000 0.000 <string>:1(<module>)
1 0.000 0.000 0.000 0.000 profile_example.py:3(some_function)
1 0.000 0.000 0.000 0.000 profile_example.py:4(<listcomp>)
1 0.000 0.000 0.000 0.000 {built-in method builtins.exec}
The output shows the number of calls to each function, the total time spent in each function, and the cumulative time spent in each function and its subfunctions. This information can be used to identify performance bottlenecks and optimize your code.
Note that cProfile generates a lot of output, so it’s best to run it on a small piece of code first, and then scale up as needed.
This is a third-party package that provides line-by-line profiling information for your code. It can be used to find which lines of your code are taking the most time, and to optimize your code accordingly.
First, you need to install line_profiler using pip (pip install line_profiler) and then, you can use the line_profiler decorator to profile a function. For example:
from line_profiler import LineProfiler
def some_function():
# code to be profiled
x = [i**2 for i in range(10000)]
lp = LineProfiler()
lp_wrapper = lp(some_function)
lp_wrapper()
lp.print_stats(
In this example, the LineProfiler class is used to profile the some_function function. The lp_wrapper function is created by passing some_function to the lp instance, and the lp_wrapper function is then executed. Finally, the lp.print_stats() function is used to print the results of the profiling. The output will look something like this:
Timer unit: 1e-06 s
File: <ipython-input-7-1a39a0d7dc68>
Function: some_function at line 5
Line # Hits Time Per Hit % Time Line Contents
==============================================================
5 def some_function():
6 # code to be profiled
7 1000 278032 278.0 97.3 x = [i**2 for i in range(10000)]
The output shows the number of hits (executions) for each line of code, the total time spent on each line, and the percentage of time spent on each line. This information can be used to identify performance bottlenecks and optimize your code.
This is a Linux tool. With perf, you can profile the entire code execution, measure the time taken by individual functions, and determine which functions are taking the most time.
An example:
First, you need to install the Linux perf tool. On Ubuntu, you can do this with:
> sudo apt-get install linux-tools-common
Next, you need to run your Python script with the perf tool, for example:
> perf record -g -F 99 python your_script.py
Finally, you can generate a report of the profile results:
> perf report
In this example, the perf tool is used to profile the your_script.py script. The perf record command is used to start profiling, and the -g option is used to generate call graph information. The -F 99 option is used to specify the sampling frequency (99 Hertz). The perf report command is then used to generate a report of the profile results. The report will show you information such as the function call tree, the number of samples, and the total time spent in each function.
Note that the perf tool is a Linux-specific tool, and is not available on other operating systems. Also, it requires administrative privileges to run.
This is another third-party package that provides detailed information about the memory usage of your code. It can be used to identify memory leaks, monitor memory usage over time, and optimize memory usage in your code.
First, you need to install memory_profiler using “pip install memory_profiler”. Then, you can use the @profile decorator to profile a function. For example:
from memory_profiler import profile
@profile
def some_function():
# code to be profiled
x = [i**2 for i in range(10000)]
some_function()
In this example, the @profile decorator is used to profile the some_function function. The some_function function is then executed, and the memory usage of the function is recorded. Finally, the results of the profiling are printed to the console. The output will look something like this:
Line # Mem usage Increment Line Contents
================================================
4 18.967 MB 0.000 MB @profile
5 def some_function():
6 18.967 MB 0.000 MB x = [i**2 for i in range(10000)]
The output shows the memory usage of each line of code, and the incremental change in memory usage between lines. This information can be used to identify memory leaks and optimize your code.
That’s it we hope that this article was helpful. Let us know if you know any other method to benchmark Python code!
