Numpy Comparison/Logical Operations

NumPy provides several comparison and logical operations that can be performed on NumPy arrays.

NumPy's comparison operators allow for element-wise comparison of two arrays.

Similarly, logical operators perform boolean algebra, which is a branch of algebra that deals with True and False statements.

First we'll discuss comparison operations and then about logical operations in NumPy.

NumPy Comparison Operators

NumPy provides various element-wise comparison operators that can compare the elements of two NumPy arrays.

Here's a list of various comparison operators available in NumPy.

Next, we'll see examples of these operators.

Example 1: NumPy Comparison Operators

import numpy as np

array1 = np.array([1, 2, 3])
array2 = np.array([3, 2, 1])

# less than operator
result1 = array1 < array2
print("array1 < array2:",result1)    # Output: [ True False False]

# greater than operator
result2 = array1 > array2
print("array1 > array2:",result2)    # Output: [False False  True]

# equal to operator
result3 = array1 == array2
print("array1 == array2:",result3)    # Output: [False  True False]

Output

array1 < array2: [ True False False]
array1 > array2: [False False  True]
array1 == array2: [False  True False]

Here, we can see that the output of the comparison operators is also an array, where each element is either True or False based on the array element's comparison.

NumPy Comparison Functions

NumPy also provides built-in functions to perform all the comparison operations.

For example, the less() function returns True if each element of the first array is less than the corresponding element in the second array.

Here's a list of all built-in comparison functions.

Next, we will see an example of all these functions.

Example 2: NumPy Comparison Functions

import numpy as np

array1 = np.array([9, 12, 21])
array2 = np.array([21, 12, 9])

# use of less()
result = np.less(array1, array2)
print("Using less():",result)    # Output: [ True False False]

# use of less_equal()
result = np.less_equal(array1, array2)
print("Using less_equal():",result)     # Output: [ True  True False]

# use of greater()
result = np.greater(array1, array2)
print("Using greater():",result)    # Output: [False False  True]

# use of greater_equal()
result = np.greater_equal(array1, array2)
print("Using greater_equal():",result)    # Output: [False  True  True]

# use of equal()
result = np.equal(array1, array2)
print("Using equal():",result)    # Output: [False  True False]

# use of not_equal()
result = np.not_equal(array1, array2)
print("Using not_equal():",result)    # Output: [ True False  True]

Output

Using less(): [ True False False]
Using less_equal(): [ True  True False]
Using greater(): [False False  True]
Using greater_equal(): [False  True  True]
Using equal(): [False  True False]
Using not_equal(): [ True False  True]

NumPy Logical Operations

As mentioned earlier, logical operators perform Boolean algebra; a branch of algebra that deals with True and False statements.

Logical operations are performed element-wise. For example, if we have two arrays x1 and x2 of the same shape, the output of the logical operator will also be an array of the same shape.

Here's a list of various logical operators available in NumPy:

Next, we will see examples of these operators.

Example 3: NumPy Logical Operations

import numpy as np

x1 = np.array([True, False, True])
x2 = np.array([False, False, True])

# Logical AND
print(np.logical_and(x1, x2)) # Output: [False False  True]

# Logical OR
print(np.logical_or(x1, x2)) # Output: [ True False  True]

# Logical NOT
print(np.logical_not(x1)) # Output: [False  True False]

Here, we have performed logical operations on two arrays, x1 and x2, containing boolean values.

It demonstrates the logical AND, OR, and NOT operations using np.logical_and(), np.logical_or(), and np.logical_not() respectively.