Boolean and fancy indexing

Boolean arrays

A Boolean array is a numpy array with Boolean (True/False) values. Such array can be obtained by applying a logical operator to another numpy array:

import numpy as np

# create a 4x4 array of integers
a = np.arange(16).reshape(4, 4)
a

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

# test which elements of a are greated than 5
large_values = (a > 5)
large_values

array([[False, False, False, False],
       [False, False,  True,  True],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True]])

# test which elements of a are even
even_values = (a%2 == 0)
even_values

array([[ True, False,  True, False],
       [ True, False,  True, False],
       [ True, False,  True, False],
       [ True, False,  True, False]])

# another 4x4 array
b = np.reshape(np.arange(21, 5, -1), (4, 4))
b

array([[21, 20, 19, 18],
       [17, 16, 15, 14],
       [13, 12, 11, 10],
       [ 9,  8,  7,  6]])

# test which elements of a are greater than the corresponding elements of b
equals = (a > b)
equals

array([[False, False, False, False],
       [False, False, False, False],
       [False, False, False,  True],
       [ True,  True,  True,  True]])

Logical operations on Boolean arrays

Boolean arrays can be combined using logical operators:

operator	meaning
~	negation (logical “not”)
&	logical “and”
|	logical “or”

# test which elements of a are not divisible by 3
b = ~(a%3 == 0)

print(f"a=\n{a}\n")
print(f"b=\n{b}")

a=
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

b=
[[False  True  True False]
 [ True  True False  True]
 [ True False  True  True]
 [False  True  True False]]

# test which elements of a are divisible by either 2 or 3
c = (a%2 == 0) | (a%3 == 0)

print(f"a=\n{a}\n")
print(f"c=\n{c}")

a=
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

c=
[[ True False  True  True]
 [ True False  True False]
 [ True  True  True False]
 [ True False  True  True]]

# test which elements of a are divisible by both 2 and 3
d = (a%2 == 0) & (a%3 == 0)

print(f"a=\n{a}\n")
print(f"d=\n{d}")

a=
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]

d=
[[ True False False False]
 [False False  True False]
 [False False False False]
 [ True False False False]]

Indexing with Boolean arrays

Boolean arrays can be used to select elements of other numpy arrays. If a is any numpy array and b is a boolean array of the same dimensions then a[b] selects all elements of a for which the corresponding value of b is True.

# create a 4x4 array of integers
a = np.reshape(np.arange(16), (4, 4))
a

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

# test which elements of a are even
b = (a%2 == 0)
b

array([[ True, False,  True, False],
       [ True, False,  True, False],
       [ True, False,  True, False],
       [ True, False,  True, False]])

# select all even elements of the array a
a[b]

array([ 0,  2,  4,  6,  8, 10, 12, 14])

We can use Boolean indexing to modify elements of an array based on a logical condition:

# set values of all even elements of the array to 100
a[a%2 == 0] = 100
a

array([[100,   1, 100,   3],
       [100,   5, 100,   7],
       [100,   9, 100,  11],
       [100,  13, 100,  15]])

In the next example we create two numpy arrays, x and y, and then use Boolean indexing to set all entries of x that are smaller that the corresponding entries of y to -1:

# create two 3x3 arrays of random numbers
rng = np.random.default_rng(0)
x = rng.random((3, 3))
y = rng.random((3, 3))

print(f"x=\n{x}\n")
print(f"y=\n{y}")

x=
[[0.63696169 0.26978671 0.04097352]
 [0.01652764 0.81327024 0.91275558]
 [0.60663578 0.72949656 0.54362499]]

y=
[[0.93507242 0.81585355 0.0027385 ]
 [0.85740428 0.03358558 0.72965545]
 [0.17565562 0.86317892 0.54146122]]

x[x < y] = -1
x

array([[-1.        , -1.        ,  0.04097352],
       [-1.        ,  0.81327024,  0.91275558],
       [ 0.60663578, -1.        ,  0.54362499]])

Fancy indexing

Fancy indexing is a feature of numpy arrays that lets us provide a list of indices to an array instead of a single index. This selects all array elements with indices on the list.

# create an array of 10 integers randomly selected from the range 0 <= x < 100
rng = np.random.default_rng(0)
a = rng.integers(0, 100, 10)
a

array([85, 63, 51, 26, 30,  4,  7,  1, 17, 81])

# select array elements with index 1, 5, and 6
a[[1, 5, 6]]

array([63,  4,  7])

Fancy indexing works with multidimensional arrays as well:

b = np.arange(20).reshape(4, 5)
b

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

# select rows 1 and 3
b[[1, 3]]

array([[ 5,  6,  7,  8,  9],
       [15, 16, 17, 18, 19]])

# select columns 0,1, and 4
b[:, [0, 1, 4]]

array([[ 0,  1,  4],
       [ 5,  6,  9],
       [10, 11, 14],
       [15, 16, 19]])

Given a 2-dimensional array b the code b[[1, 2, 3], [1, 4, 4]] selects elements b[1,1], b[2,4], and b[3,4]:

b[[1, 2, 3], [1, 4, 4]]

array([ 6, 14, 19])

Just as with other indexing schemes, we can use fancy indexing to modify several entries of an array at once:

b[[1, 2, 3], [1, 4, 4]] = 1000
b

array([[   0,    1,    2,    3,    4],
       [   5, 1000,    7,    8,    9],
       [  10,   11,   12,   13, 1000],
       [  15,   16,   17,   18, 1000]])

Fancy indexing can be mixed with other forms of indexing. For example, we can apply fancy indexing to one axis of an array, and slicing to the second axis:

b = np.arange(20).reshape(4, 5)
b

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])

# select elements which are in rows 1, 3 and columns 0-3
b[[1, 3], :3]

array([[ 5,  6,  7],
       [15, 16, 17]])

Fancy indexing example

Here is an example of how fancy indexing can be used in practice. Lets say that we have a numpy array that in the first column gives student id numbers, and in the second column their exam scores:

rng = np.random.default_rng(0)
exam_scores = np.array([np.arange(5000, 5010), rng.integers(0, 100, 10)]).T
exam_scores

array([[5000,   85],
       [5001,   63],
       [5002,   51],
       [5003,   26],
       [5004,   30],
       [5005,    4],
       [5006,    7],
       [5007,    1],
       [5008,   17],
       [5009,   81]])

Assume that we want to sort rows of this array in increasing order of exam scores. Applying the numpy argsort() function to the score column we obtain an array that shows how row indices should be arranged to give such ordering:

indices = np.argsort(exam_scores[:, 1])
indices

array([7, 5, 6, 8, 3, 4, 2, 1, 9, 0])

Fancy indexing lets us apply this to sort the array with exam scores:

exam_scores[indices]

array([[5007,    1],
       [5005,    4],
       [5006,    7],
       [5008,   17],
       [5003,   26],
       [5004,   30],
       [5002,   51],
       [5001,   63],
       [5009,   81],
       [5000,   85]])