NumPy efficiency - Python initiation: core language, modern workflows, and scientific applications

Beside some convenient functions for the manipulation of data in arrays of arbitrary dimensions, numpy can be much more efficient than pure Python.

Let us import Numpy and define two utility functions:

import numpy as np


def compute_time_in_second(timeit_result):
    string = timeit_result.stdout
    print(string)
    for line in string.split("\n"):
        words = line.split(" ")
        if len(words) > 1:
            time = float(words[0])
            unit = words[1]

    if unit == "ms":
        time *= 1e-3
    elif unit == "us":
        time *= 1e-6
    elif unit == "ns":
        time *= 1e-9
    return time


def compare_times(string, timeit_python, timeit_numpy):
    time_python = compute_time_in_second(timeit_python)
    time_numpy = compute_time_in_second(timeit_numpy)

    print(string + ": ratio times (Python / NumPy): ", time_python / time_numpy)

n = 200000
python_r_1 = range(n)
python_r_2 = range(n)

numpy_a_1 = np.arange(n)
numpy_a_2 = np.arange(n)

We use the IPython magic commands %%timeit to bench the code in a cell and %%capture to capture the result of %%timeit in a variable.

%%capture timeit_python
%%timeit
# Regular Python
[(x + y) for x, y in zip(python_r_1, python_r_2)]

print(timeit_python)

20.9 ms +- 194 us per loop (mean +- std. dev. of 7 runs, 10 loops each)

%%capture timeit_numpy
%%timeit
# Numpy
numpy_a_1 + numpy_a_2

print(timeit_numpy)

185 us +- 1.44 us per loop (mean +- std. dev. of 7 runs, 10,000 loops each)

compare_times("Additions", timeit_python, timeit_numpy)

20.9 ms +- 194 us per loop (mean +- std. dev. of 7 runs, 10 loops each)

185 us +- 1.44 us per loop (mean +- std. dev. of 7 runs, 10,000 loops each)

Additions: ratio times (Python / NumPy):  112.97297297297297

This shows that when you need to perform mathematical operations on a lot of homogeneous numbers, it is more efficient to use numpy arrays.