Summary  
This chapter covers using comparison and logical operators to build boolean masks for filtering array elements.  

General domain of usage  
Data analysis

Most conditions you will use are **comparisons**, so it's important to discuss them in more detail. Comparisons are based on the following comparison operators:
* `>` (greater than);
* `<` (less than);
* `>=` (greater than or equal to);
* `<=` (less than or equal to);
* `==` (equal to);
* `!=` (not equal to).

Moreover, you can **combine** multiple conditions and comparisons using the following logical operators:
* `&` (logical **and**);
* `|` (logical **or**).

If at least one of the conditions is `True`, then `|` returns `True`; otherwise, it returns `False`. If at least one of the conditions is `False`, then `&` returns `False`; otherwise, it returns `True`.

Each condition should be put in parentheses `()` when combining them.

Note

import numpy as np
# Creating an array of integers from 1 to 10 inclusive
array = np.arange(1, 11)
# Retrieving elements greater than or equal to 5 AND less than 9
print(array[(array >= 5) & (array < 9)])
# Retrieving elements less than or equal to 4 AND not equal to 2
print(array[(array != 2) & (array <= 4)])
# Retrieving elements less than 3 OR equal to 8
print(array[(array < 3) | (array == 8)])
# Retrieving elements between 2 inclusive AND 5 inclusive OR equal to 9
print(array[(array >= 2) & (array <= 5) | (array == 9)])

Let's now take a look at the following visualization to understand the code better (**red** squares represent the actual retrieved elements):

import unittest
import importlib.util
import numpy as np
import io
from contextlib import redirect_stdout


def _dynamic_test(test_case, condition, success_message, failure_message):
    """Codefinity-style result messages"""
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        # Імпортуємо код користувача
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        cls.m = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(cls.m)

        # Очікувані результати
        cls.product_ratings = np.array([4, 2, 5, 3, 7, 1])
        cls.expected_filtered = cls.product_ratings[
            (cls.product_ratings >= 3) & (cls.product_ratings != 5)
        ]

    def test_boolean_filter_correctness(self):
        """1. Перевірка правильності булевого фільтра"""
        # Перехоплюємо вивід користувача
        f = io.StringIO()
        with redirect_stdout(f):
            spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
            module = importlib.util.module_from_spec(spec)
            spec.loader.exec_module(module)
        output = f.getvalue().strip()

        # Підготовка очікуваного текстового представлення
        expected_str = np.array2string(self.expected_filtered, separator=' ')
        # Перевіряємо, що всі елементи виведено правильно
        contains_values = all(str(x) in output for x in self.expected_filtered)

        _dynamic_test(
            self,
            contains_values and str(5) not in output and "2" not in output and "1" not in output,
            "Boolean indexing applied correctly",
            "Boolean indexing incorrect or wrong output",
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Develop essential skills for numerical computing using NumPy. Learn how to work with NumPy arrays, create and manipulate multidimensional data, apply indexing and slicing, perform vectorized operations, reshape arrays, use broadcasting, and apply basic linear algebra techniques. The course focuses on practical operations commonly used in data analysis tasks.

More about Comparisons

Soluzione