# Mastering NumPy Array Filtering | A Comprehensive Tutorial 14 | Better4Code

It is a popular Python package for scientific computing called **NumPy array filter**. The ability of NumPy to do filtering on arrays is one of its key capabilities. The practise of removing a subset of elements from an array that meet a specific requirement is known as NumPy array filtering. In this post, we’ll look at some of the possibilities for filtering NumPy arrays as well as how to do it.

**NumPy ****Filtering Arrays**

Boolean indexing is used in Python NumPy array filtering. You may choose entries from an array based on a Boolean condition using the strong feature of Boolean indexing. An array of Booleans is used to provide the condition, where True indicates that a particular element should be chosen and False indicates that it should be excluded. Here’s an illustration:

import numpy as np a = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5, 3]) b = a > 3 print(b)

In this example, we create an array of 10 integers and then use Boolean indexing to create a new array, **b**, that contains True values for elements that are greater than 3 and False values for elements that are less than or equal to 3. The output of this code will be:

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

As you can see, the array **b** contains the same number of elements as the original array a, but with only a subset of the elements selected based on the condition.

**NumPy Array ****Filtering a 2D Array**

**Python Array** Similar to filtering a 1D array, a 2D array may be filtered using Boolean indexing. The only distinction is that you must individually provide the condition for each axis. Here’s an illustration:

c = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]) d = c[c[:, 1] > 5] print(d)

In this instance, we first build a 2D array with 4 rows and 3 columns. Next, using Boolean indexing, we create a new array, d, that only contains the rows when the second column is bigger than 5. This code’s output will be:

[[ 6 7 8] [ 9 10 11]]

As you can see, the resulting array contains only the rows that satisfy the condition.

**VISIT THIS POST: Rust Programming**

**NumPy Array ****Filtering with Functions**

Numerous functions in NumPy are also available for filtering arrays. Where(), which returns the indices of the items that meet a particular requirement, is the most often used function. Here’s a good example:

e = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5, 3]) f = np.where(e > 3) print(f) print(e[f])

In this example, we use the **where()** function to find the indices of the elements in the array e that are greater than 3. We then use these indices to create a new array, f, that contains only the selected elements. The output of this code will be:

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

As you can see, the **where()** function returns a tuple containing the indices of the selected elements. We use these indices to select the elements from the original array.

**NumPy Array ****Filtering with Masks**

Another way to filter NumPy arrays is to use a mask. A mask is an array of Booleans that has the same shape as the array being filtered. The mask is used to select elements from the original array based on whether the corresponding value in the mask is True or False. Here’s an example:

g = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5, 3]) h = np.array([True, False, True, False, True, True, False, True, True, False]) i = g[h] print(i)

In this example, we create an array g of 10 integers and then create a mask h that contains True values for elements that are greater than 3 and False values for elements that are less than or equal to 3. We then use the mask to create a new array, **i**, that contains only the selected elements from the original array **g**. The output of this code will be:

[3 4 5 9 2 6 5]

As you can see, the new array **i** contains only the elements of the original array that correspond to True values in the mask **h**.

**NumPy Array Filtering with Logical Operators**

NumPy also provides logical operators that can be used to create complex conditions for filtering arrays. The logical operators include and (&), or (|), and not (~). Here’s an example:

j = np.array([3, 1, 4, 1, 5, 9, 2, 6, 5, 3]) k = (j > 3) & (j < 7) l = j[k] print(l)

In this example, we create an array **j** of 10 integers and then use the logical operator and (&) to create a new array **k** that contains True values for elements that are greater than 3 and less than 7. We then use the mask to create a new array, **l**, that contains only the selected elements from the original array **j**. The output of this code will be:

[4 5 6 5]

As you can see, the new array l contains only the elements of the original array that satisfy the complex condition.