Unlike programming in C++, where loops are extremely efficient, the loops in Python are notoriously slow. Usually we need a lot of workarounds to eliminate loops in Python to achieve high performance. In my opinion, numpy can make loop unnecessary in at least 80 percent of scenarios. In this post, I demonstrate some common scenarios where proper numpy techniques can reduce the amount of code and improve performance. I would recommend that every time someone finds it necessary to write loops in Python for scientific computation, he/she should refer to the documentation of numpy/scipy or stackoverflow to see if there is built-in functions to help eliminate loops. Surprisingly, such functions usually exist (because we usually underestimate the number of APIs in numpy/scipy).

Make use of numpy APIs

numpy provides a number of useful APIs for general scientific computation. Here I list some of the functions that I use most often. This is just a glimpse of the enormous amount of all APIs.

  • np.mean, np.var
  • np.searchsorted: binary search
  • np.clip, np.pad
  • np.intersect1d, np.union1d, np.setdiff1d

Assigning values for multi-dimensional arrays

Suppose we have a 3-dimensional array arr3 (essentially an image), which is defined by:

arr3 = np.zeros((100, 100, 3), np.uint8)

If we want to assign all elements with a particular value, we can do the following:

arr3.fill(255)

If we want to assign each pixel with a particular RGB tuple, we can do the following:

arr3[:, :, :] = [125, 200, 50]

The test case for following scenarios

Assume the test case is given as below:

import numpy as np

# makes it possible to reproduce results
np.random.seed(0x1a2b3c4d)
# random array of size 100
arr = np.random.randint(-2, 10, 100)

Suppose there is a predicate Pred for each element, which is given by:

def Pred(x):
    return x < 0

Looking for elements that satisfy the predicate

We would like to apply this predicate to all elements and output those elements that satisfy the predicate. The most naive way of doing it is:

indices = []

# note that the len(arr) and arr.size can be different
# for multi-dimensional arrays
for index in range(arr.size):
    if(Pred(arr[index])):
        indices.append(index)

We can eliminate this loop by writing:

indices = np.where(Pred(arr))[0]

It is a simple one-liner that achieves the same result at much higher speed. The np.where function returns the indices of True elements in an array. When it is given a dimensional array, its output would be arrays, each containing the index of a True element of that dimension. Therefore, the columns of the output would be the coordinate of a True element. That is why the subscript [0] is needed here. In fact, if the predicate takes such a simple form, we can rewrite the code into:

indices = np.where(arr < 0)[0]

Replacing elements that satisfy the predicate

Now we would like to replace all elements that satisfy the predicate with a certain value (for example, 100). I will not provide the naive code here. The elegant way of doing it is:

arr[Pred(arr)] = 100

Replacing elements according to a “dictionary”

Assume that there is an array of nonnegative integers, where each element has a corresponding item in a “dictionary”. An example is shown as below:

arr = np.random.randint(0, 10, 20)
dictionary = ['zero', 'one', 'two', 'three',
     'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']

We need to replace the elements of arr by their corresponding elements in dictionary. It can be done in the following way:

dictionary = np.asarray(dictionary, dtype = object)
result = dictionary[arr]

A possible content of arr and its corresponding result is shown as below.

>>> arr
[4 7 2 7 3 6 6 8 7 6 4 6 3 3 9 6 4 0 2 2]
>> result
['four' 'seven' 'two' 'seven' 'three' 'six' 'six' 'eight' 'seven' 'six'
 'four' 'six' 'three' 'three' 'nine' 'six' 'four' 'zero' 'two' 'two']