# Filter NumPy Array by Index (Easy Tutorial)

In this tutorial, we’ll explore various methods for filtering NumPy arrays by index.

You’ll learn how to handle one-dimensional, two-dimensional, and higher-dimensional NumPy arrays.

The tutorial covers basic methods like using square brackets for indexing, to more advanced techniques involving functions like `np.where()` and `np.take()`

## Filtering 1D NumPy Array by Index

You can use square brackets for specific element selection, slicing for range selection, `np.where()` for boolean index array filtering, and fancy indexing with an index array.

Using Square Brackets to Select Specific Elements by Index

```import numpy as np
data_array = np.array([10, 20, 30, 40, 50])
selected_element = data_array[2]
print(selected_element)
```

Output:

```30
```

Here, we directly access the element at index 2 (third element, as indexing starts from 0) of the data array, resulting in the value 30.

Slicing to Select a Range of Elements

```range_elements = data_array[1:4]
print(range_elements)
```

Output:

```[20 30 40]
```

Slicing allows you to select a range of elements from the array. `[1:4]` means you are selecting elements from index 1 to 3 (end index is exclusive).

Using np.where() to Filter Based on a Boolean Index Array

```filtered_elements = data_array[np.where(data_array > 30)]
print(filtered_elements)
```

Output:

```[40 50]
```

`np.where()` is used to filter elements based on a condition. Here, it filters elements greater than 30.

Filtering with Fancy Indexing Using an Index Array

```index_array = [0, 2, 3]
fancy_indexed_elements = data_array[index_array]
print(fancy_indexed_elements)
```

Output:

```[10 30 40]
```

Fancy indexing involves using an array of indices to select multiple arbitrary elements. `index_array` specifies the indices of elements you wish to select.

## Filtering 2D NumPy Arrays by Index

Filtering 2D NumPy arrays efficiently is crucial for handling multi-dimensional data. In this segment, we explore different techniques to filter 2D arrays by index.

You can use square brackets, boolean indexing, employing `np.where()` on rows or columns, and fancy indexing to filter 2D arrays by index.

Selecting Rows and Columns by Index with Square Brackets

```import numpy as np
data_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
selected_row = data_2d[1]
selected_column = data_2d[:, 2]
print("Selected Row:", selected_row)
print("Selected Column:", selected_column)
```

Output:

```Selected Row: [4 5 6]
Selected Column: [3 6 9]
```

Accessing a specific row is straightforward using the row index. For columns, use `:` to indicate all rows and the column index.

Boolean Indexing on the Rows or Columns

```rows_with_second_column_greater_than_2 = data_2d[data_2d[:, 1] > 2]
print(rows_with_second_column_greater_than_2)
```

Output:

```[[4 5 6]
[7 8 9]]
```

This method filters rows where the second column’s value is greater than 2.

Using np.where() on Rows or Columns

```column_condition = np.where(data_2d[1, :] > 4)
print("Column indices where second row > 4:", column_condition)
```

Output:

```Column indices where second row > 4: (array([1, 2], dtype=int64),)
```

`np.where()` is used to find indices in the second row where the values are greater than 4.

Fancy Indexing on Rows or Columns

```column_indices = [0, 2]
selected_columns = data_2d[:, column_indices]
print(selected_columns)
```

Output:

```[[1 3]
[4 6]
[7 9]]
```

Fancy indexing allows for selecting multiple arbitrary columns based on an array of column indices.

## Filtering Higher Dimensional NumPy Arrays

Filtering higher dimensional NumPy arrays involves methods such as indexing using tuple indices, slicing, boolean indexing, using `np.where()` with axis specification, and fancy indexing along different axes.

Indexing into Specific Axes Using Tuple Indices

```import numpy as np

# Sample 3D data array
data_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]])
specific_element = data_3d[1, 0, 1]
print("Specific Element:", specific_element)
```

Output:

```Specific Element: 6
```

Using tuple indices, you can pinpoint a specific element in a multi-dimensional array.

Slicing Along Different Axes

```sliced_data = data_3d[:, 1, :]
print("Sliced Data:", sliced_data)
```

Output:

```Sliced Data: [[ 3  4]
[ 7  8]
[11 12]]
```

Slicing along different axes allows you to extract sub-arrays. This example extracts the second row from each 2D sub-array.

Applying Boolean Indexing

```filter_mask = data_3d > 7
print(filtered_data)```

Output:

```[ 8 9 10 11 12]
```

Boolean indexing can filter sub-arrays based on conditions applied along a specific axis.

Fancy Indexing Along Different Axes

```indices = (0, 1)
fancy_indexed_data = data_3d[indices]
print("Fancy Indexed Data:", fancy_indexed_data)
```

Output:

```Fancy Indexed Data: [[3 4]]
```

Fancy indexing allows for selecting specific slices along multiple axes using a tuple of indices.

## Using np.take() function

You can use `np.take()` to retrieve elements from NumPy arrays based on specific indices.

```import numpy as np
data_array = np.array([5, 10, 15, 20, 25])
selected_elements = np.take(data_array, [1, 3])
print("Selected Elements using np.take():", selected_elements)
```

Output:

```Selected Elements using np.take(): [10 20]
```

`np.take()` retrieves elements from the array at the given indices, `[1, 3]` in this case.