Skip main navigation

Measuring small code snippets with timeit

In this article we discuss how the Python timeit module can help in
measuring very short execution times
© CC-BY-NC-SA 4.0 by CSC - IT Center for Science Ltd.

Measuring very short execution times has some pitfalls that can be avoided with the help of the timeit Python module.

Sometimes one might be interested in measuring the performance of a very
small bit of Python code, such as a single statement or a function call.
Measuring reliably very short execution times can be challenging, and one
needs typically to gather some statistics for error estimates.

In order to avoid common traps in such a measurement, Python standard library
contains the timeit module. The module can be used from the command line,
within a program, or within an interactive interpreter (especially convenient
with IPython) or in Jupyter notebooks. When a code snippet is measured with
timeit, the module takes care of running the snippet several times and
calculating statistics.

Using timeit with IPython

IPython interpreter provides a special magic command %timeit, which will
measure the statement following it using the timeit module. In the
following example, we compare the execution time of sin and cos functions
with the same input:

IPython 6.1.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]: from math import sin, cos

In [2]: %timeit sin(0.2)
68.8 ns ± 0.181 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [3]: %timeit cos(0.2)
71.1 ns ± 1.57 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

As can be seen, with timeit each measurement consist of a huge number of
evaluations (10000000 loops), and the measurent is even repeated multiple
times (7 runs) for better statistics.

Using timeit from command line

The timeit module can be used also from command line. The expression to be
measured is given as string, and possible setup (e.g. module import) is
provided with -s argument:

python3 -m timeit -s "from math import sin" "sin(0.2)"
10000000 loops, best of 3: 0.052 usec per loop

The setup statement (from math import sin) above is executed once initially,
and the actual statement then multiple times.

Whole Python scripts cannot be directly measured, but if the script provides
e.g. a main function it can be measured. For larger entities one might want
to specify also how many times the statement is executed with -n argument:

python3 -m timeit -n 3 -s "from mandel_main import main" "main()"
3 loops, best of 3: 569 msec per loop

In above, a single measurement consists of three evaluations of main and the
measurement is then repeated three times.

The timeit module can be used also directly inside scripts, more information can be found in the Documentation of timeit.

© CC-BY-NC-SA 4.0 by CSC - IT Center for Science Ltd.
This article is from the free online

Python in High Performance Computing

Created by
FutureLearn - Learning For Life

Our purpose is to transform access to education.

We offer a diverse selection of courses from leading universities and cultural institutions from around the world. These are delivered one step at a time, and are accessible on mobile, tablet and desktop, so you can fit learning around your life.

We believe learning should be an enjoyable, social experience, so our courses offer the opportunity to discuss what you’re learning with others as you go, helping you make fresh discoveries and form new ideas.
You can unlock new opportunities with unlimited access to hundreds of online short courses for a year by subscribing to our Unlimited package. Build your knowledge with top universities and organisations.

Learn more about how FutureLearn is transforming access to education