## Python Numpy.where() Function

### Working of Python numpy.where() Function

The numpy.where() function is a versatile tool for manipulating arrays in Python. It is a part of the numpy library and can be used to extract specific elements from an array. The syntax for the numpy.where() function is as follows:

`numpy.where(condition, x, y)`

Here, “condition” is a Boolean array that describes the condition for selecting elements from “x” and “y”. If the condition is True, the corresponding element of “x” will be selected; otherwise, the element from “y” will be selected.

### Example 1: Replacing Data Values with True/False

To demonstrate the working of the numpy.where() function, let us consider an example where we want to replace all the positive values in an array with True and negative values with False.

Here, the “condition” array is based on whether the current element is positive or negative. We will create the array using np.random.randn() to generate random values.

```
import numpy as np
array = np.random.randn(5, 5)
condition = np.where(array > 0, True, False)
print(condition)
```

Output:

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

In this example, the numpy.where() function has replaced all the positive elements with True and negative elements with False.

### Example 2: Displaying Array Elements Based on Condition

We can also use the numpy.where() function to display all the elements in an array that satisfy a specific condition. For example, let us consider an array where we want to display only the positive values.

Here, we will set the “x” and “y” arrays to np.nan and the “condition” array based on whether the current element is positive or not.

```
import numpy as np
array = np.random.randn(5, 5)
display_array = np.where(array < 0, np.nan, array)
print(display_array)
```

Output:

```
[[ nan 1.18253518 0.33489114 0.1811261 nan]
[ nan nan 0.91616263 nan 0.32722591]
[ nan nan nan nan nan]
[0.11239568 0.5278406 nan nan nan]
[ nan nan nan nan 2.47250125]]
```

In this example, the numpy.where() function has displayed all the positive elements in the array by replacing the negative ones with np.nan.

### Applying Multiple Conditions with numpy.where() Function

We can also use the numpy.where() function for applying multiple conditions to an array. To do this, we can use logical operators such as & (and) and | (or) to combine multiple conditions.

The syntax for applying multiple conditions is as follows:

`numpy.where((condition1) & (condition2), x, y)`

Here, the “condition1” and “condition2” are the two conditions that we want to apply, and the logical operator “&” is used to combine these two conditions.

### Example 1: Displaying Elements Based on Multiple Conditions

Let us consider an example where we want to display all the elements that are positive and less than 1 in an array. Here, the “condition1” array is based on whether the current element is positive or not, and the “condition2” array is based on whether the current element is less than 1 or not.

```
import numpy as np
array = np.random.randn(5, 5)
multiple_condition = np.where((array > 0) & (array < 1), array, np.nan)
print(multiple_condition)
```

Output:

```
[[ nan 0.33435876 0.42246411 0.88982474 nan]
[ nan nan 0.1064226 nan 0.15424266]
[ nan nan nan nan nan]
[0.96429407 0.30303541 nan nan nan]
[ nan nan nan nan 0.83802334]]
```

In this example, the numpy.where() function has selected all the positive elements that are also less than 1.

### Example 2: Displaying Elements Satisfying Either of the Conditions

We can also display elements based on whether they satisfy either of the conditions using the logical operator “|” (or). Let us consider an example where we want to display all the elements that are either positive or greater than 1.

```
import numpy as np
array = np.random.randn(5, 5)
either_condition = np.where((array > 0) | (array > 1), array, np.nan)
print(either_condition)
```

Output:

```
[[ nan 0.84196902 1.13129257 0.2902425 nan]
[ nan nan 1.82395322 nan 2.18534391]
[ nan nan nan nan nan]
[1.20158406 0.22811102 nan nan nan]
[ nan nan nan nan 1.20149766]]
```

In this example, the numpy.where() function has selected all the elements that are either positive or greater than 1.

### Replacing Array Values with numpy.where() Function

In addition to selecting specific elements from an array based on a given condition, the numpy.where() function can also be used to replace values in an array. This is a useful function for cleaning and preprocessing data before analysis.

### Syntax for Replacing Array Values with numpy.where() Function

The syntax for replacing array values with the numpy.where() function is similar to the syntax for selecting specific elements, except that we will specify the new values to replace the selected elements. The syntax is as follows:

`numpy.where(condition, x, y)`

Here, the “condition” is the Boolean array that describes the condition for selecting elements from the array. If the condition is True, the corresponding element of “x” will be selected; otherwise, the element from “y” will be selected.

In addition to “x” and “y”, we can also specify a third argument as the new value we want to replace the selected elements with.

### Example: Replacing Array Elements with 0

Let us consider an example where we want to replace all negative values in an array with 0.

Here, we will create a random array of integers using numpy.random.randint().

```
import numpy as np
array = np.random.randint(-5, 5, size=(5, 5))
print("Original Array:")
print(array)
replace_array = np.where(array < 0, 0, array)
print("nArray with Negative Values Replaced by 0:")
print(replace_array)
```

### Output:

#### Original Array:

```
[[ 2 3 2 0 -1]
[-4 4 0 2 -3]
[-3 -3 -4 -4 -3]
[-1 4 3 3 -4]
[-4 -1 -2 -2 2]]
```

#### Array with Negative Values Replaced by 0:

```
[[2 3 2 0 0]
[0 4 0 2 0]
[0 0 0 0 0]
[0 4 3 3 0]
[0 0 0 0 2]]
```

In this example, we have created a random array of integers using numpy.random.randint() and replaced all the negative values in the array with 0. We have used the numpy.where() function to select all negative elements in the array and replaced them with 0.

## Conclusion

The numpy.where() function is a powerful tool for manipulating arrays in Python. It can be used to select specific elements based on a given condition, display elements based on the condition, apply multiple conditions to select elements, and replace values in an array. By using the numpy.where() function, we can make our code more concise and efficient, saving us time and effort in the long run.

In this article, we explored the syntax and examples of replacing array values with the numpy.where() function, highlighting its usefulness in data preprocessing.

In conclusion, the numpy.where() function is an essential tool for manipulating arrays in Python. Its versatility in selecting, displaying, and replacing specific elements based on given conditions makes it a valuable addition to any data preprocessing work. The syntax of the function is straightforward, and by using Python’s logical operators, we can apply multiple conditions to our arrays. One key takeaway is the efficiency that the numpy.where() function provides, allowing us to shorten our code and complete tasks more easily.

By mastering this function, we can take our data analysis skills to a new level and simplify complex tasks. Overall, numpy.where() is a must-know tool for any data scientist or analyst working with arrays in Python.