Numpy the place **a number of situations** allow you to manipulate numerous parts of the **NumPy array** that meet a selected situation. To accomplish this in Python, you should use the NumPy.the place() operate and the & operator to implement a number of situations.

Read on to be taught numerous methods you need to use the NumPy.the place() operate in Python to specify numerous situations.

**Contents**show

## Understanding Numpy Where Multiple Conditions

In Python, **the np.the place() operate i**s among the many strongest capabilities in NumPy. The operate allows you to course of parts primarily based on both a number of situations or a single situation. You can use the operate to return indices or manipulate knowledge each time a situation is met and even course of an array.

### – Syntax

Before diving into np.the place() operate, right here is **a fast have a look at the operate** and the assorted parameters it accepts.

*The syntax for this operate is as follows:*

NumPy.the place(
situation, # If the situation is true, yield a, in any other case b [a, b, ] # The values the situation depends on |

Although the syntax could be a little bit complicated, the next instance will make utilizing this operate quite a bit simpler.

### – Example

Suppose you may have an array with a number of numbers, and also you want to modify numbers. Say you need to multiply numbers utterly divisible by 4 and seven by 10 however divide the remaining by 10. You can accomplish this as follows utilizing **np.the place a number of situations and values**:

import NumPy as np
numbers = np.array([4,5,6,7,8]) numbers=np.the place((numberspercent4==0) | (numberspercent7==0), numbers*10, numbers/10) print(numbers) |

If you run this code, the end result shall be **[40. 0.5 0.6 70. 80. ]**

In this instance, you’re creating an array with the identify numbers and utilizing the logical OR operator to pick out the numbers **that shall be multiplied** by 10 in the event that they meet the situations. For the numbers that don’t meet the situations, they are going to be divided by 10. This is without doubt one of the greatest methods of modifying arrays utilizing situations like within the **np.the place instance **above.

## How To Implement Multiple Conditions in Python

In Python, you may** implement a number of situations utilizing boolean** operators akin to OR or AND. That’s the place this operate in Python involves play. The operate makes it simple to specify a number of situations. However, you can’t use the key phrases ‘or’ or ‘and’ that you just often use for one worth.

*Please observe that it’s important to use the ‘&’ operator or ‘|’ operator for boolean combos.*

**Python NumPy** supplies other ways of utilizing the NumPy.the place() operate to implement a number of situations. Are you interested by implementing a number of situations in Python? Below are among the in style approaches you may depend on utilizing the place operate.

### – Combining Numpy.the place() And & Operator

Using NumPy.the place() operate, you may specify a number of situations in a **single situation**. To do that, you should pair the NumPy.the place() operate with the & operator. You can specify a number of situations inside the **NumPy.the place() operate** by guaranteeing you specify every situation in a pair of parenthesis whereas utilizing the & operator between the situations.

**Example 1: Combining Numpy.the place() With & Operator**

Suppose you may have an array that accommodates a set of numbers, and also you want to choose particular values – say values bigger than 5 however lower than 8. You can specify **a number of situation**s inside the NumPy.the place() operate by including every situation in a pair of parenthesis and including the & operator between the situations as follows:

import NumPy as np
numbers = np.array([4,5,6,7,8]) end result = numbers[np.where((numbers>5) & (numbers<8))] print(end result) |

If you run this code, the output shall be **[6 7].**

The instance above creates an array of integers by the identify **‘numbers’ utilizing the np.array() operate**. Next, you utilized the a number of situations on the array parts utilizing the np.the place() and & operator and saved the outcome within the end result variable. In this instance, you’re utilizing the logical AND operator inside the **np.the place() operate.**

### – Combining Numpy.the place() And | Operator

You may use the logical OR (|) operator to outline **np.the place a number of situations and values. **In Python, this Operator represents a logical OR gate. You can outline a number of situations inside the NumPy.the place() and wrap every situation in a pair of parenthesis, then use the | operator to separate them.

**Example 2: Combining Numpy.the place() And | Operator**

Suppose you may have an array that accommodates a variety of values. You can use the OR operator to **choose integers** which can be both higher than 4 or utterly divisible by 4 utilizing the np.the place() operate and ‘|’ operator. Here is an instance of how one can accomplish this:

import NumPy as np
numbers = np.array([4,5,6,7,8]) end result = numbers[np.where((numbers>4) | (numbers%4==0))] print(end result) |

If you run this code, you’ll get **[4 5 6 7 8].**

### – Combining Numpy.the place() With Numpy.logical_and()

In Python, you may **use NumPy.logical_and() operate** to determine the element-wise reality values of AND gate. To accomplish this, you may embody the operate within the NumPy.the place() operate to set a number of situations.

**Example 3: Combining Numpy.the place() With Numpy.logical_and()**

Say you may have an array with numbers, and also you want to **choose integers** higher than 4 however lower than 8 utilizing the np.the place() and np.logical_and().

*Here is how one can accomplish this.*

import NumPy as np
numbers = np.array([4,5,6,7,8]) end result = numbers[np.where(np.logical_and(numbers>4, numbers<8))] print(end result) |

If you run this code, the output shall be **[5 6 7].**

### – Combining Numpy.the place() With Numpy.logical_or()

Similarly, you need to use the numpy.logical-or() to determine the element-wise reality worth of the OR gate. You can mix it with NumPy.the place() to specify a number of situations.

Here is an** instance of how you are able to do this.** Suppose you may have an array with numbers, however you want to choose numbers higher than 4 or utterly divisible by 4.

*You can accomplish this as follows:*

import NumPy as np
numbers = np.array([4,5,6,7,8]) end result = numbers[np.where(np.logical_or(numbers>4, numbers%4==0))] print(end result) |

If you execute this code, the end result shall be **[4 5 6 7 8].**

### – Using Numpy.the place() To Replace Elements

Python additionally allows you to use NumPy.the place() operate to** exchange parts** provided that a sure situation is met or unmet. Suppose you may have an array of 5 numbers and also you need to replace numbers which can be utterly divisible by 2 with a quantity that’s 3 instances the unique worth.

*Here is an instance of how one can go about it with np.the place a number of situations exchange:*

import NumPy as np
numbers = np.array([4,5,6,7,8]) numbers=np.the place(numberspercent2==0, numbers*3, numbers) print(numbers) |

If you run this code, the end result shall be **[12 5 18 7 24]**

### – Nested Numpy Where Conditions

You may use nested the place situations in Python. Suppose you may have knowledge that you just want to evaluate. You can use the depend on **np.the place nested situations** and **pandas dataframe** to perform this with **np.the place 3 situations **or much more situations.

*Here is an instance of how you are able to do this.*

import NumPy as np
import pandas as pd df=pd.DataFrame({‘Math’:[80,70,80,90],’Science’:[80,78,84,90]}) df[‘Result’] = np.the place((df.Math == 80) & (df.Science == 80), 80, #when… then np.the place((df.Math == 70) & (df.Science == 78), 0, #when… then np.the place((df.Math == 80) & (df.Science == 84), 0, #when… then 90))) #else print(df) |

## Use of Numpy Where Function

The the place operate in Python is a pleasant utility for looking out particular entries that meet sure standards, particularly when looking out in an enormous dataset in any program. This NumPy operate** allows you to search objects inside a NumPy array** that matches your situation.

## Conclusion

In Python, the** Numpy the place() operate** is right for specifying situations and manipulating parts to your liking. In this put up, you may have discovered the best way to use this operate to implement a number of situations. Here is a fast abstract:

- The the place() operate makes it attainable to control knowledge each time a situation or a number of situations are met
- You can accomplish this utilizing the logical AND operator (&) or logical OR operator (|)
- Also, you need to use numpy.logical-and() or numpy.logical-or() to attain this
- As effectively, you may nest a number of the place capabilities to set a number of situations

With this understanding, now you can go forward and** simply create a number of situations** contained in the the place operate in Python.