NumPy Mask 2d Array
- Create Mask or 2d Boolean Array With NumPy in Python
- Create Mask With Python Logical Operators
- Create Mask With NumPy Logical Function
We go to learn with this explanation about what is the mask or Boolean array. We also learn how to create a 2d mask with logical P1ython operators and NumPy logical function in python.
Create Mask or 2d Boolean Array With NumPy in Python
We start with some array where we apply some condition, and then we generate a mask
or a Boolean array. For example, let’s think about just an array of integers shown below, and then we apply this condition, which is less than five.
The resulting Boolean array would be the same shape as the input array, and it would just be an element-by-element application of the condition. In this case, 8 is less than 5, so that is false, 2 is less than 5, that is true, 1 is less than 5 true, and so on.
Sometimes it represents mask by 0-1, and the false represents 0 and 1 represents true.
Create Mask With Python Logical Operators
We’ll jump into the code by importing numpy
and create a variable called My_2DArray
, which is populated with a Python 2d list using a numpy
array.
import numpy as np
My_2DArray = np.array([[-12, -31, 5], [7, 0, -9]])
print(My_2DArray)
Output:
[[-12 -31 5]
[ 7 0 -9]]
Let’s have an example to demonstrate mask
. We are creating a new variable called zero_mod_array
, which takes the values where My_2DArray
is divisible by 7 using the %
operator.
We select all elements in the array where the remainder after division by 7 equals zero.
Code:
import numpy as np
My_2DArray = np.array([[-12, -31, 5], [7, 0, -9]])
zero_mod_array = 0 == (My_2DArray % 7)
print(zero_mod_array)
After executing, we see that we have created an array of Boolean values. If we look at the first element of an array that is -12 is not divisible by 7, and the next one is also not, but the first element in the second list is 7, which is divisible by 7, and the second element 0 is also divisible by 7.
Therefore, both elements are True
except for other elements because all elements are not divisible by 7, which is why we got False
values on their positions.
Output:
[[False False False]
[ True True False]]
In this following example, we are creating a variable called Sun_array
, and these would be essential elements of Boolean mask arrays. We are taking My_2DArray
and indexing it with the results we created in zero_mod_array
.
Code:
import numpy as np
My_2DArray = np.array([[-12, -31, 5], [7, 0, -9]])
zero_mod_array = 0 == (My_2DArray % 7)
Sun_array = My_2DArray[zero_mod_array]
print(Sun_array)
Output:
[7 0]
Let’s use Sun_array
as a mask array to index itself, selecting the elements within Sun_array
that are greater than 0 and creating a new array that only contains the positive elements.
Sun_array[Sun_array > 0]
In our Sun_array
only one element is greater than 7 array([7])
. If we examine the Sun_array
, we will see that the values are unchanged; it is still an array([7, 0])
.
Create Mask With NumPy Logical Function
Let’s examine an alternative method to accomplish the same task. In a particular way, we will use NumPy logical operators.
First, we will create a variable called mod_test
, which will assign the results of the remainder operator as we did above.
We will do something similar and create another variable called positive_test
, and this time we will assign the values where My_2DArray
is greater than zero, which means it will indicate the Boolean values after applying the condition on every element of My_2DArray
.
We’ll create another variable called combined_test
and which uses the logical_and()
function and it takes mod_test
and positive_test
as arguments.
Code:
import numpy as np
My_2DArray = np.array([[-12, -31, 5], [7, 0, -9]])
mod_test = 0 == (My_2DArray % 7)
positive_test = My_2DArray > 0
combined_test = np.logical_and(mod_test, positive_test)
print(combined_test)
After execution, we see the perfect Boolean values, and it contains only one value that corresponds to the array.
Output:
[[False False False]
[ True False False]]
We can use combined_test
to index our original array and get the same value we achieved above.
Code:
import numpy as np
My_2DArray = np.array([[-12, -31, 5], [7, 0, -9]])
mod_test = 0 == (My_2DArray % 7)
positive_test = My_2DArray > 0
combined_test = np.logical_and(mod_test, positive_test)
print(My_2DArray[combined_test])
Output:
[7]
This is how we can mask the NumPy 2d array using two techniques to achieve the same result.
Hello! I am Salman Bin Mehmood(Baum), a software developer and I help organizations, address complex problems. My expertise lies within back-end, data science and machine learning. I am a lifelong learner, currently working on metaverse, and enrolled in a course building an AI application with python. I love solving problems and developing bug-free software for people. I write content related to python and hot Technologies.
LinkedIn