## NumPy’s where() Function with Multiple Conditions

NumPy is a powerful library for scientific computing with Python. It provides a convenient way to manipulate and analyze large datasets, allowing you to perform complex operations with ease.

One of the most commonly used functions in NumPy is the `where()`

function, which allows you to select specific values from an array based on given conditions. This article will cover how to use the `where()`

function with multiple conditions, specifically with OR and AND keywords, and how to select values less than 5 or greater than 20 from a NumPy array.

### 1. Method 1: Use where() with OR

The `where()`

function with OR is used to select values that meet one or more given conditions. For example, suppose you have a NumPy array with values ranging from 1 to 30 and you only want to select values that are less than five or greater than 20.

You can achieve this by using the `where()`

function with the OR keyword. Here’s an example code snippet that demonstrates how to do this:

```
import numpy as np
arr = np.arange(1, 31)
result = np.where((arr < 5) | (arr > 20))
print(result)
```

In this code snippet, we first import the NumPy library and create a NumPy array with values ranging from 1 to 30. We then apply the `where()`

function with the OR keyword to select values that are either less than 5 or greater than 20.

The resulting array is then printed to the console. The output would look like this:

```
(array([ 0, 1, 2, 3, 21, 22, 23, 24, 25, 26, 27, 28, 29]),)
```

As you can see, the result is a tuple containing an array with the selected indices that meet the given conditions.

### 2. Method 2: Use where() with AND

The `where()`

function with AND is used to select values that meet multiple conditions. For example, suppose you have a NumPy array with values ranging from 1 to 30 and you only want to select values that are greater than five and less than 20.

You can achieve this by using the `where()`

function with the AND keyword. Here’s an example code snippet:

```
import numpy as np
arr = np.arange(1, 31)
result = np.where((arr > 5) & (arr < 20))
print(result)
```

In this code snippet, we create the same NumPy array as before and apply the `where()`

function with the AND keyword to select values that are both greater than 5 and less than 20. The resulting array is then printed to the console.

### The output would look like this:

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

As you can see, the result is a tuple containing an array with the selected indices that meet the given conditions.

### 3. Selecting values less than 5 or greater than 20

Now let’s focus on a specific use case where we want to select values less than 5 or greater than 20 from a NumPy array. The first step is to create the NumPy array:

```
import numpy as np
arr = np.array([1, 9, 15, 25, 30])
```

In this example, we have manually created the NumPy array with specific values. The array consists of values ranging from 1 to 30, but we only want to select values less than five and greater than 20.

Here’s how to do it using the `where()`

function with the OR keyword:

```
import numpy as np
arr = np.array([1, 9, 15, 25, 30])
result = np.where((arr < 5) | (arr > 20))
print(result)
```

### The output would look like this:

```
(array([0, 3, 4]),)
```

As you can see, the `where()`

function with the OR keyword has selected the values that are less than 5 or greater than 20. The resulting array contains the indices of the selected values, which are 0, 3, and 4.

In conclusion, the `where()`

function is a versatile tool in NumPy that allows you to select specific values from an array based on given conditions. With the OR keyword, you can select values that meet one or more given conditions, while the AND keyword allows you to select values that meet multiple conditions.

These functions are useful in the analysis of large datasets, saving you a lot of time and effort in the process. 3) Method 2: Use where() with AND

The `where()`

function with AND is used to select values that meet multiple conditions.

This method is particularly useful when you want to select values that fall within a specific range of values. For example, suppose you have a NumPy array with values ranging from 1 to 30, and you only want to select values that are greater than 5 and less than 20.

You can achieve this by using the `where()`

function with the AND keyword. Here’s an example code snippet that demonstrates how to do this:

```
import numpy as np
arr = np.arange(1, 31)
result = np.where((arr > 5) & (arr < 20))
print(result)
```

In this code snippet, we create a NumPy array with values ranging from 1 to 30, and we apply the `where()`

function with the AND keyword to select values that are both greater than 5 and less than 20. The resulting array is then printed to the console.

### The output would look like this:

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

As you can see, the result is a tuple containing an array with the selected indices that meet the conditions given. Using this method, you can easily select values from a NumPy array that fall within a certain range.

The select values can be used in further analysis or calculations that require only specific subsets of the data. It is important to note that the `where()`

function with the AND keyword is only effective if both conditions are true for the values in the array.

If one of the conditions is false, the value will not be included in the selected values array. Additionally, the `size()`

function can be useful when working with the `where()`

function.

The `size()`

function returns the number of elements in an array or a given axis. Suppose you want to find the number of values in the selected array.

You can do this by using the `size()`

function on the resulting array:

```
import numpy as np
arr = np.arange(1, 31)
result = np.where((arr > 5) & (arr < 20))
selected_values = arr[result]
selected_values_size = np.size(selected_values)
print(selected_values)
print(selected_values_size)
```

In this code snippet, we first create a NumPy array with values ranging from 1 to 30, and we apply the `where()`

function with the AND keyword to select values that are both greater than 5 and less than 20. We then create a new variable that stores the selected values array.

Finally, we use the `size()`

function to get the number of elements in the selected array. The output would look like this:

```
[ 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
14
```

As you can see, the output now includes both the selected values array and the size of the array. In this way, you can apply the `where()`

function with AND keyword to select specific values from NumPy array that fall within a given range.

It provides a highly efficient method to filter and manipulates data more easily, saving a lot of time and effort over traditional coding methods.

### 4. Additional Resources

NumPy is a vast library with a wide range of capabilities that extends far beyond the `where()`

function. If you want to learn more about NumPy, the best place to start is by taking an online course.

### Here are some additional resources that can help:

- NumPy user guide: This guide provides an in-depth explanation of NumPy features and usage.
- NumPy official documentation: This is the official documentation of the NumPy library. It includes a comprehensive guide, reference material, and examples for the NumPy library.
- Coursera: Coursera offers several courses that cover NumPy and its associated libraries.

These courses can help you gain a deep understanding of Python programming and NumPy.

In conclusion, the `where()`

function in NumPy is a powerful tool that can help you select specific values from an array based on certain conditions. When used with the OR keyword, you can select values that meet one or more conditions, while the AND keyword allows you to select values that meet multiple conditions.

These functions are useful in the analysis of large datasets, saving time and effort, and providing more accurate data analytics. Additionally, several resources are available for those interested in delving deeper into the world of NumPy to become more efficient users of the library.

NumPy’s `where()`

function is a powerful tool for selecting specific values from an array based on given conditions. By using the function with OR and AND keywords, one can easily select values that meet given conditions.

The AND keyword is especially useful for selecting values that fall within a specific range by combining multiple conditions. The `size()`

function can also help in finding the number of selected elements in an array.

In conclusion, these NumPy functions are crucial for data analysis and can help streamline the process of working with large data sets. Learning the function’s proper use will help users become more efficient in data analysis.