Logical operations (and, or, not) in NumPy - Step-by-Step Execution

Concept Flow - Logical operations (and, or, not)

Start with two boolean arrays

↓

Apply 'and' operation element-wise

↓

Apply 'or' operation element-wise

↓

Apply 'not' operation element-wise

↓

Get resulting boolean arrays

↓

End

We start with two boolean arrays and apply logical 'and', 'or', and 'not' operations element-wise to get new boolean arrays.

Execution Sample

NumPy

import numpy as np

A = np.array([True, False, True, False])
B = np.array([True, True, False, False])

and_result = np.logical_and(A, B)
or_result = np.logical_or(A, B)
not_result = np.logical_not(A)

This code creates two boolean arrays and applies logical 'and', 'or', and 'not' operations element-wise.

Execution Table

Step	Operation	Input A	Input B	Result
1	logical_and	[True, False, True, False]	[True, True, False, False]	[True, False, False, False]
2	logical_or	[True, False, True, False]	[True, True, False, False]	[True, True, True, False]
3	logical_not	[True, False, True, False]	N/A	[False, True, False, True]
4	End	N/A	N/A	All operations complete

💡 All logical operations applied element-wise to arrays; execution ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
A	[True, False, True, False]	[True, False, True, False]	[True, False, True, False]	[True, False, True, False]	[True, False, True, False]
B	[True, True, False, False]	[True, True, False, False]	[True, True, False, False]	[True, True, False, False]	[True, True, False, False]
and_result	N/A	[True, False, False, False]	[True, False, False, False]	[True, False, False, False]	[True, False, False, False]
or_result	N/A	N/A	[True, True, True, False]	[True, True, True, False]	[True, True, True, False]
not_result	N/A	N/A	N/A	[False, True, False, True]	[False, True, False, True]

Key Moments - 3 Insights

Why do we use np.logical_and instead of the Python 'and' operator?

Python 'and' does not work element-wise on arrays; np.logical_and applies 'and' to each pair of elements as shown in step 1 of the execution_table.

What happens if the input arrays have different lengths?

Numpy will raise an error because element-wise operations require arrays of the same shape, which is why inputs A and B have the same length in the execution_table.

Why does logical_not only take one input array?

Because 'not' is a unary operation that flips each element's boolean value individually, as shown in step 3 where only input A is used.

Visual Quiz - 3 Questions

Look at the execution_table at step 1, what is the result of logical_and for the third element?

A False

B True

C None

D Error

💡 Hint

Check the third element in the 'Result' column at step 1 in the execution_table.

At which step does the logical_not operation occur?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Operation' column in the execution_table to find where logical_not is applied.

If array B was changed to [False, False, False, False], what would be the result of logical_or at step 2?

A [True, True, True, True]

B [False, False, False, False]

C [True, False, True, False]

D [False, True, False, True]

💡 Hint

Logical_or returns True if either element is True; check variable_tracker for A and B values.

Concept Snapshot

Logical operations in numpy:
- Use np.logical_and(A, B) for element-wise AND
- Use np.logical_or(A, B) for element-wise OR
- Use np.logical_not(A) for element-wise NOT
- Inputs must be boolean arrays of same shape
- Results are boolean arrays of same shape

Full Transcript

This visual execution shows how numpy applies logical operations element-wise on boolean arrays. Starting with two arrays A and B, np.logical_and returns True only where both A and B are True. np.logical_or returns True where either A or B is True. np.logical_not flips each True to False and vice versa in array A. The execution table traces each step and the variable tracker shows how results build up. Key moments clarify why numpy functions are needed instead of Python's built-in operators. The quiz tests understanding of element-wise results and operation order.

Practice

1. Which NumPy function is used to perform a logical AND operation element-wise on two arrays?

easy

A. numpy.logical_and

B. numpy.and_

C. numpy.bitwise_and

D. numpy.logical_or

Solution

1. Step 1: Understand logical AND operation in NumPy

   Logical AND combines two boolean arrays and returns True only where both are True.

2. Step 2: Identify the correct NumPy function

   numpy.logical_and is the function designed for element-wise logical AND on boolean arrays.

3. Final Answer:

   numpy.logical_and -> Option A

4. Quick Check:

   AND operation = numpy.logical_and [OK]

Hint: AND operation in NumPy uses logical_and function [OK]

Common Mistakes:

• Confusing bitwise_and with logical_and
• Using logical_or instead of logical_and
• Using and_ which is not a NumPy function

2. Which of the following is the correct syntax to apply a logical NOT operation on a NumPy array a?

easy

A. numpy.logical_not[]

B. numpy.not(a)

C. numpy.logical_not(a)

D. not numpy.logical(a)

Solution

1. Step 1: Recall the correct function for logical NOT in NumPy

   The function is numpy.logical_not(array) to invert boolean values element-wise.

2. Step 2: Check syntax correctness

   numpy.logical_not(a) uses correct function and parentheses syntax; others are invalid or incorrect.

3. Final Answer:

   numpy.logical_not(a) -> Option C

4. Quick Check:

   NOT operation = numpy.logical_not(array) [OK]

Hint: Use logical_not with parentheses for NOT operation [OK]

Common Mistakes:

• Using numpy.not which does not exist
• Using square brackets instead of parentheses
• Trying to negate with not keyword on arrays

3. What is the output of the following code?

import numpy as np
x = np.array([True, False, True])
y = np.array([False, False, True])
result = np.logical_or(x, y)
print(result)

medium

A. [False False False]

B. [False True True]

C. [True True True]

D. [True False True]

Solution

1. Step 1: Understand logical OR operation element-wise

   logical_or returns True if either element in the pair is True.

2. Step 2: Apply logical_or to each pair in arrays x and y

   Pairs: (True, False) -> True, (False, False) -> False, (True, True) -> True.

3. Final Answer:

   [True False True] -> Option D

4. Quick Check:

   logical_or([True,False,True],[False,False,True]) = [True,False,True] [OK]

Hint: OR is True if any element is True in pair [OK]

Common Mistakes:

• Confusing logical_or with logical_and
• Misreading boolean values in arrays
• Assuming all False if one element is False

4. Identify the error in the following code snippet:

import numpy as np
arr = np.array([True, False, True])
result = arr and np.array([False, True, False])
print(result)

medium

A. np.array should be np.logical_and

B. Using 'and' operator directly on NumPy arrays causes an error

C. Missing parentheses around arrays

D. Arrays must be converted to lists before logical operations

Solution

1. Step 1: Understand Python 'and' operator with arrays

   'and' is a Python keyword that does not work element-wise on arrays; it expects single boolean values.

2. Step 2: Identify correct way to do element-wise logical AND

   Use numpy.logical_and(arr1, arr2) for element-wise AND on arrays.

3. Final Answer:

   Using 'and' operator directly on NumPy arrays causes an error -> Option B

4. Quick Check:

   Python 'and' fails on arrays; use logical_and [OK]

Hint: Use numpy.logical_and, not Python 'and' for arrays [OK]

Common Mistakes:

• Using Python 'and' instead of numpy.logical_and
• Trying to use 'and' without parentheses
• Converting arrays to lists unnecessarily

5. Given two NumPy arrays:

a = np.array([1, 0, 3, 0, 5])
b = np.array([0, 2, 3, 4, 0])

Which code snippet correctly creates a boolean array that is True where a is non-zero AND b is zero?

hard

A. np.logical_and(a != 0, b == 0)

B. np.logical_or(a != 0, b == 0)

C. np.logical_not(np.logical_and(a == 0, b != 0))

D. np.logical_and(a == 0, b == 0)

Solution

1. Step 1: Translate the condition into logical expressions

   We want True where a is not zero AND b is zero, so conditions are a != 0 and b == 0.

2. Step 2: Use numpy.logical_and to combine conditions element-wise

   np.logical_and(a != 0, b == 0) returns True only where both conditions hold.

3. Final Answer:

   np.logical_and(a != 0, b == 0) -> Option A

4. Quick Check:

   AND of (a != 0) and (b == 0) = np.logical_and(a != 0, b == 0) [OK]

Hint: Combine conditions with logical_and for AND filtering [OK]

Common Mistakes:

• Using logical_or instead of logical_and
• Negating conditions incorrectly
• Checking for zeros instead of non-zeros