Let's import the built-in random Python module and NumPy:

>>> import random
    import numpy as np

We generate two Python lists, x and y, each one containing 1 million random numbers between 0 and 1:

>>> n = 1000000
    x = [random.random() for _ in range(n)]
    y = [random.random() for _ in range(n)]
>>> x[:3], y[:3]
([0.926, 0.722, 0.962], [0.291, 0.339, 0.819])

Let's compute the element-wise sum of all of these numbers: the first element of x plus the first element of y, and so on. We use a for loop in a list comprehension:

>>> z = [x[i] + y[i] for i in range(n)]
    z[:3]
[1.217, 1.061, 1.781]

How long does this computation take? IPython defines a handy %timeit magic command to quickly evaluate the time taken by a single statement:

>>> %timeit [x[i] + y[i] for i in range(n)]
101 ms ± 5.12 ms per loop (mean ± std. dev. of 7 runs,
    10 loops each)

Now we will perform the same operation with NumPy. NumPy works on multidimensional arrays, so we need to convert our lists to arrays. The np.array() function does just that:

>>> xa = np.array(x)
    ya = np.array(y)
>>> xa[:3]
array([ 0.926,  0.722,  0.962])

The xa and ya arrays contain the exact same numbers that our original lists, x and y, contained. Those lists were instances of the list built-in class, while our arrays are instances of the ndarray NumPy class. These types are implemented very differently in Python and NumPy. In this example, we will see that using arrays instead of lists leads to drastic performance improvements.

To compute the element-wise sum of these arrays, we don't need to do a for loop anymore. In NumPy, adding two arrays means adding the elements of the arrays component-by-component. This is the standard mathematical notation in linear algebra (operations on vectors and matrices):

>>> za = xa + ya
    za[:3]
array([ 1.217,  1.061,  1.781])

We see that the z list and the za array contain the same elements (the sum of the numbers in x and y).

Let's compare the performance of this NumPy operation with the native Python loop:

>>> %timeit xa + ya
1.09 ms ± 37.3 µs per loop (mean ± std. dev. of 7 runs,
    1000 loops each)

With NumPy, we went from 100 ms down to 1 ms to compute one million additions!

Now we will compute something else: the sum of all elements in x or xa. Although this is not an element-wise operation, NumPy is still highly efficient here. The pure Python version uses the built-in sum() function on an iterable. The NumPy version uses the np.sum() function on a NumPy array:

>>> %timeit sum(x)  # pure Python
3.94 ms ± 4.44 µs per loop (mean ± std. dev. of 7 runs
    100 loops each)
>>> %timeit np.sum(xa)  # NumPy
298 µs ± 4.62 µs per loop (mean ± std. dev. of 7 runs,
    1000 loops each)

We also observe a significant speedup here.

Let's perform one last operation: computing the arithmetic distance between any pair of numbers in our two lists (we only consider the first 1000 elements to keep computing times reasonable). First, we implement this in pure Python with two nested for loops:

>>> d = [abs(x[i] - y[j])
         for i in range(1000)
         for j in range(1000)]
>>> d[:3]
[0.635, 0.587, 0.106]

Now, we use a NumPy implementation, bringing out two slightly more advanced notions. First, we consider a two-dimensional array (or matrix). This is how we deal with the two indices, i and j. Second, we use broadcasting to perform an operation between a 2D array and 1D array. We will give more details in the How it works... section.

>>> da = np.abs(xa[:1000, np.newaxis] - ya[:1000])
>>> da
array([[ 0.635,  0.587,  ...,  0.849,  0.046],
       [ 0.431,  0.383,  ...,  0.646,  0.158],
       ...,
       [ 0.024,  0.024,  ...,  0.238,  0.566],
       [ 0.081,  0.033,  ...,  0.295,  0.509]])
>>> %timeit [abs(x[i] - y[j]) \
             for i in range(1000) \
             for j in range(1000)]
134 ms ± 1.79 ms per loop (mean ± std. dev. of 7 runs,
    1000 loops each)
>>> %timeit np.abs(xa[:1000, np.newaxis] - ya[:1000])
1.54 ms ± 48.9 µs per loop (mean ± std. dev. of 7 runs
    1000 loops each)

Here again, we observe a significant speedup.