Combining conditions in NumPy - Step-by-Step Execution

Concept Flow - Combining conditions

Start with array

↓

Apply condition 1

↓

Apply condition 2

↓

Combine conditions with & or |

↓

Use combined condition to filter array

↓

Get filtered result

We start with a data array, apply two conditions, combine them using logical AND (&) or OR (|), then filter the array based on the combined condition.

Execution Sample

NumPy

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
cond = (arr > 2) & (arr < 5)
result = arr[cond]
print(result)

This code filters the array to keep only values greater than 2 and less than 5.

Execution Table

Step	Expression	Evaluation	Result
1	arr = np.array([1, 2, 3, 4, 5])	Create array	[1 2 3 4 5]
2	arr > 2	Check each element > 2	[False False True True True]
3	arr < 5	Check each element < 5	[True True True True False]
4	(arr > 2) & (arr < 5)	Combine with AND	[False False True True False]
5	arr[cond]	Filter array with combined condition	[3 4]
6	print(result)	Output filtered array	[3 4]

💡 All steps complete, filtered array contains elements satisfying both conditions.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
arr	undefined	[1 2 3 4 5]	[1 2 3 4 5]	[1 2 3 4 5]	[1 2 3 4 5]	[1 2 3 4 5]
cond	undefined	undefined	undefined	[False False True True False]	[False False True True False]	[False False True True False]
result	undefined	undefined	undefined	undefined	[3 4]	[3 4]

Key Moments - 2 Insights

Why do we use parentheses around each condition before combining them?

Parentheses ensure each condition is evaluated first before combining with & or |. Without them, Python's operator precedence can cause errors or unexpected results, as shown in step 4 of the execution_table.

What happens if we use 'and' or 'or' instead of '&' or '|' for combining conditions?

'and' and 'or' do not work element-wise on numpy arrays and will raise an error. We must use '&' for AND and '|' for OR to combine boolean arrays element-wise, as in step 4.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the combined condition array?

A [False True False True False]

B [True True True True True]

C [False False True True False]

D [True False True False True]

💡 Hint

Check the 'Result' column at step 4 in the execution_table.

At which step do we filter the original array using the combined condition?

A Step 5

B Step 4

C Step 2

D Step 6

💡 Hint

Look for the step where 'arr[cond]' is used in the execution_table.

If we change the condition to (arr > 3) | (arr == 2), what will the filtered result be?

A [3 4 5]

B [2 4 5]

C [2 3 4]

D [1 2 3]

💡 Hint

Use the logic of OR (|) to combine conditions and check which elements satisfy either condition.

Concept Snapshot

Combining conditions in numpy:
- Use parentheses around each condition.
- Use & for AND, | for OR (element-wise).
- Combine boolean arrays to filter data.
- Example: arr[(arr > 2) & (arr < 5)] filters values between 2 and 5.
- Avoid 'and'/'or' with numpy arrays.

Full Transcript

This lesson shows how to combine conditions in numpy arrays to filter data. We start with an array, create two conditions, and combine them using & (AND) or | (OR). Parentheses are important to group conditions correctly. The combined boolean array is then used to select elements from the original array. We traced each step: creating the array, evaluating each condition, combining them, and filtering the array. Key points include using & and | for element-wise logical operations and avoiding Python's 'and'/'or' with arrays. The filtered result contains only elements that satisfy the combined condition.

Practice

1. Which of the following is the correct way to combine two conditions a > 5 and b < 10 in NumPy to select elements where both are true?

easy

A. Use (a > 5) & (b < 10)

B. Use a > 5 & b < 10 without parentheses

C. Use (a > 5) | (b < 10)

D. Use a > 5 or b < 10

Solution

1. Step 1: Understand combining conditions in NumPy

   NumPy requires each condition to be in parentheses when using & (AND) or | (OR) operators.

2. Step 2: Identify correct syntax for AND condition

   The correct way to combine a > 5 and b < 10 with AND is (a > 5) & (b < 10).

3. Final Answer:

   Use (a > 5) & (b < 10) -> Option A

4. Quick Check:

   Parentheses + & = correct AND condition [OK]

Hint: Always put each condition in parentheses when combining [OK]

Common Mistakes:

• Omitting parentheses around conditions
• Using Python 'and' instead of '&' for arrays
• Using 'or' instead of '|' for arrays

2. Which of the following is the correct syntax to select elements from a NumPy array arr where values are NOT equal to 0 and less than 10?

easy

A. arr[arr != 0 & arr < 10]

B. arr[(arr != 0) & (arr < 10)]

C. arr[(arr != 0) | (arr < 10)]

D. arr[~arr != 0 & arr < 10]

Solution

1. Step 1: Use parentheses for each condition

   Each condition must be enclosed in parentheses: (arr != 0) and (arr < 10).

2. Step 2: Combine with AND operator

   Use & to combine conditions for selecting elements satisfying both.

3. Final Answer:

   arr[(arr != 0) & (arr < 10)] -> Option B

4. Quick Check:

   Parentheses + & + correct conditions = syntax correct [OK]

Hint: Use parentheses around each condition and '&' for AND [OK]

Common Mistakes:

• Missing parentheses causing syntax errors
• Using bitwise NOT (~) incorrectly
• Using Python 'and' instead of '&'

3. Given the code:

import numpy as np
arr = np.array([1, 5, 8, 12, 3, 7])
result = arr[(arr > 3) | (arr == 1)]
print(result)

What is the output?

medium

A. [5 8 12 7]

B. [1 5 8 12 3 7]

C. [5 8 12]

D. [1 5 8 12 7]

Solution

1. Step 1: Evaluate each condition on the array

   arr > 3 is True for 5, 8, 12, 7; arr == 1 is True for 1.

2. Step 2: Combine conditions with OR operator

   Elements where either condition is True are selected: 1, 5, 8, 12, 7.

3. Final Answer:

   [1 5 8 12 7] -> Option D

4. Quick Check:

   OR condition selects 1 and all >3 values [OK]

Hint: OR (|) selects elements matching either condition [OK]

Common Mistakes:

• Forgetting to include elements equal to 1
• Using AND (&) instead of OR (|)
• Misreading the array values

4. What is wrong with this code snippet?

import numpy as np
arr = np.array([2, 4, 6, 8])
filtered = arr[arr > 3 && arr < 8]
print(filtered)

medium

A. Missing parentheses around conditions

B. Using Python 'and' instead of '&'

C. Using '&&' instead of '&' for combining conditions

D. No error, code runs fine

Solution

1. Step 1: Identify operator error

   NumPy uses bitwise operators '&' and '|' for element-wise logical operations, not '&&'.

2. Step 2: Correct operator usage

   Replace '&&' with '&' and add parentheses around each condition.

3. Final Answer:

   Using '&&' instead of '&' for combining conditions -> Option C

4. Quick Check:

   '&&' is invalid in NumPy, use '&' with parentheses [OK]

Hint: Use '&' not '&&' for NumPy condition combining [OK]

Common Mistakes:

• Using '&&' from other languages
• Not adding parentheses around conditions
• Using Python 'and' instead of '&'

5. You have a NumPy array data = np.array([10, 15, 20, 25, 30, 35]). You want to select elements that are either less than 20 or greater than or equal to 30, but NOT equal to 15. Which code correctly filters data?

hard

A. data[((data < 20) | (data >= 30)) & (data != 15)]

B. data[(data < 20) | (data >= 30) & (data != 15)]

C. data[(data < 20) & (data >= 30) & (data != 15)]

D. data[~((data < 20) | (data >= 30) & (data == 15))]

Solution

1. Step 1: Combine OR conditions inside parentheses

   Use (data < 20) | (data >= 30) to select elements less than 20 or greater or equal to 30.

2. Step 2: Exclude elements equal to 15 with AND

   Combine with & (data != 15) to exclude 15.

3. Final Answer:

   data[((data < 20) | (data >= 30)) & (data != 15)] -> Option A

4. Quick Check:

   Parentheses + OR + AND + NOT = correct filter [OK]

Hint: Group OR conditions, then AND with NOT condition [OK]

Common Mistakes:

• Missing parentheses causing wrong precedence
• Using AND instead of OR for first condition
• Incorrect negation of 15