# Python Course

Previous Chapter: Creation of Synthetical Test Data
Next Chapter: Matrix Arithmetic

## Numpy: Boolean Indexing

    import numpy as np
    A = np.array([4, 7, 3, 4, 2, 8])
    print(A == 4)

Executing the above code will return the following:

    [ True False False  True False False]

Every element of the Array A is tested, if it is equal to 4. The results of these tests are the Boolean elements of the result array.

Of course, it is also possible to check on "<", "<=", ">" and ">=".

    print(A < 5)

The above code will return the following output:

    [ True False  True  True  True False]

It works also for higher dimensions:

    B = np.array([[42,56,89,65],
                  [99,88,42,12],
                  [55,42,17,18]])
    print(B>=42)

Executing the above code will return the following output:

    [[ True  True  True  True]
     [ True  True  True False]
     [ True  True False False]]

It is a convenient way to threshold images.

    import numpy as np
    A = np.array([
    [12, 13, 14, 12, 16, 14, 11, 10,  9],
    [11, 14, 12, 15, 15, 16, 10, 12, 11],
    [10, 12, 12, 15, 14, 16, 10, 12, 12],
    [ 9, 11, 16, 15, 14, 16, 15, 12, 10],
    [12, 11, 16, 14, 10, 12, 16, 12, 13],
    [10, 15, 16, 14, 14, 14, 16, 15, 12],
    [13, 17, 14, 10, 14, 11, 14, 15, 10],
    [10, 16, 12, 14, 11, 12, 14, 18, 11],
    [10, 19, 12, 14, 11, 12, 14, 18, 10],
    [14, 22, 17, 19, 16, 17, 18, 17, 13],
    [10, 16, 12, 14, 11, 12, 14, 18, 11],
    [10, 16, 12, 14, 11, 12, 14, 18, 11],
    [10, 19, 12, 14, 11, 12, 14, 18, 10],
    [14, 22, 12, 14, 11, 12, 14, 17, 13],
    [10, 16, 12, 14, 11, 12, 14, 18, 11]])
    B = A < 15
    B.astype(np.int)

If we execute the code above, we can expect the following result:

    array([[1, 1, 1, 1, 0, 1, 1, 1, 1],
           [1, 1, 1, 0, 0, 0, 1, 1, 1],
           [1, 1, 1, 0, 1, 0, 1, 1, 1],
           [1, 1, 0, 0, 1, 0, 0, 1, 1],
           [1, 1, 0, 1, 1, 1, 0, 1, 1],
           [1, 0, 0, 1, 1, 1, 0, 0, 1],
           [1, 0, 1, 1, 1, 1, 1, 0, 1],
           [1, 0, 1, 1, 1, 1, 1, 0, 1],
           [1, 0, 1, 1, 1, 1, 1, 0, 1],
           [1, 0, 0, 0, 0, 0, 0, 0, 1],
           [1, 0, 1, 1, 1, 1, 1, 0, 1],
           [1, 0, 1, 1, 1, 1, 1, 0, 1],
           [1, 0, 1, 1, 1, 1, 1, 0, 1],
           [1, 0, 1, 1, 1, 1, 1, 0, 1],
           [1, 0, 1, 1, 1, 1, 1, 0, 1]])

If you have a close look at the previous output, you will see, that it the upper case 'A' is hidden in the array B.

### Fancy Indexing

We will index an array C in the following example by using a Boolean mask. It is called fancy indexing, if arrays are indexed by using boolean or integer arrays (masks). The result will be a copy and not a view.

In our next example, we will use the Boolean mask of one array to select the corresponding elements of another array. The new array R contains all the elements of C where the corresponding value of (A<=5) is True.

    C = np.array([123,188,190,99,77,88,100])
    A = np.array([4,7,2,8,6,9,5])
    R = C[A<=5]
    print(R)

Executing the above code returns the following:

    [123 190 100]

### Indexing with an Integer Array

In the following example, we will index with an integer array:

    C[[0, 2, 3, 1, 4, 1]]

Executing the above code will return the following:

    array([123, 190,  99, 188,  77, 188])

Indices can appear in every order and multiple times!

#### Exercises

Extract from the array np.array([3,4,6,10,24,89,45,43,46,99,100]) with Boolean masking all the number

- which are not divisible by 3

- which are divisible by 5

- which are divisible by 3 and 5

- which are divisible by 3 and set them to 42

#### Solutions

    import numpy as np
    A = np.array([3,4,6,10,24,89,45,43,46,99,100])
    div3 = A[A%3!=0]
    print("Elements of A not divisible by 3:")
    print(div3)
    div5 = A[A%5==0]
    print("Elements of A divisible by 5:")
    print(div5)
    print("Elements of A, which are divisible by 3 and 5:")
    print(A[(A%3==0) & (A%5==0)])
    print("------------------")
    #
    A[A%3==0] = 42
    print("""New values of A after setting the elements of A,
    which are divisible by 3, to 42:""")
    print(A)

Executing the above code returns the following:

    Elements of A not divisible by 3:
    [  4  10  89  43  46 100]
    Elements of A divisible by 5:
    [ 10  45 100]
    Elements of A, which are divisible by 3 and 5:
    [45]
    ------------------
    New values of A after setting the elements of A,
    which are divisible by 3, to 42:
    [ 42   4  42  10  42  89  42  43  46  42 100]

### nonzero and where

There is an ndarray method called nonzero and a numpy method with this name. The two functions are equivalent.

For an ndarray a both numpy.nonzero(a) and a.nonzero() return the indices of the elements of a that are non-zero. The indices are returned as a tuple of arrays, one for each dimension of 'a'. The corresponding non-zero values can be obtained with:

`a[numpy.nonzero(a)]`

    import numpy as np
    a = np.array([[0, 2, 3, 0, 1],
                  [1, 0, 0, 7, 0],
                  [5, 0, 0, 1, 0]])
    print(a.nonzero())

Executing the above code returns the following output:

    (array([0, 0, 0, 1, 1, 2, 2]), array([1, 2, 4, 0, 3, 0, 3]))

If you want to group the indices by element, you can use transpose:

`transpose(nonzero(a))`

A two-dimensional array is returned. Every row corresponds to a non-zero element.

    np.transpose(a.nonzero())

If we execute the Python code above, we can expect the following:

    array([[0, 1],
           [0, 2],
           [0, 4],
           [1, 0],
           [1, 3],
           [2, 0],
           [2, 3]])

The corresponding non-zero values can be retrieved with:

     a[a.nonzero()]

If we execute the Python code above, we will get the following output:

    array([2, 3, 1, 1, 7, 5, 1])

The function 'nonzero' can be used to obtain the indices of an array, where a condition is True. In the following script, we create the Boolean array B >= 42:

    B = np.array([[42,56,89,65],
                  [99,88,42,12],
                  [55,42,17,18]])
    print(B >= 42)

We will get the following output, if we execute the Python code above:

    [[ True  True  True  True]
     [ True  True  True False]
     [ True  True False False]]

np.nonzero(B >= 42) yields the indices of the B where the condition is true:

#### Exercise

Calculate the prime numbers between 0 and 100 by using a Boolean array.

Solution:

    import numpy as np
    is_prime = np.ones((100,), dtype=bool)
    # Cross out 0 and 1 which are not primes:
    is_prime[:2] = 0
    # cross out its higher multiples (sieve of Eratosthenes):
    nmax = int(np.sqrt(len(is_prime)))
    for i in range(2, nmax):
        is_prime[2*i::i] = False
    print(np.nonzero(is_prime))

We can expect the following result, if we execute the code above:

    (array([ 2,  3,  5,  7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
           61, 67, 71, 73, 79, 83, 89, 97]),)

#### Flatnonzero and count_nonzero

similar functions:

- flatnonzero : Return indices that are non-zero in the flattened version of the input array.

- count_nonzero : Counts the number of non-zero elements in the input array.

Previous Chapter: Creation of Synthetical Test Data
Next Chapter: Matrix Arithmetic