Summary  
The chapter explains how to perform element-wise comparison operations on arrays and combine them with logical operators to create boolean masks for filtering data.

General domain of usage  
Data analysis and processing

Watch this video to get a clear visual and auditory explanation of how comparison operators and boolean indexing work in NumPy arrays. You'll see practical examples of using operators like `>`, `<`, `==`, and how to combine multiple conditions with `&` (and) and `|` (or). This will help you understand how to filter and select data efficiently in your NumPy workflows.

La mayoría de las condiciones que utilizarás son **comparaciones**, por lo que es importante analizarlas en mayor detalle. Las comparaciones se basan en los siguientes operadores de comparación:
* `>` (mayor que);
* `<` (menor que);
* `>=` (mayor o igual que);
* `<=` (menor o igual que);
* `==` (igual a);
* `!=` (diferente de).

Además, puedes **combinar** múltiples condiciones y comparaciones utilizando los siguientes operadores lógicos:
* `&` (lógico **and**);
* `|` (lógico **or**).

Si al menos una de las condiciones es `True`, entonces `|` devuelve `True`; de lo contrario, devuelve `False`. Si al menos una de las condiciones es `False`, entonces `&` devuelve `False`; de lo contrario, devuelve `True`.

Cada condición debe colocarse entre paréntesis `()` al combinarlas.

Nota

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)])

Observa la siguiente visualización para comprender mejor el código (**cuadros rojos** representan los elementos realmente recuperados):

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

Desbloquea todo el potencial de la biblioteca más esencial de Python para el cálculo numérico, NumPy. Este curso integral está diseñado para llevarte desde un nivel principiante hasta un nivel avanzado de competencia en NumPy. Ya seas científico de datos, ingeniero, investigador o desarrollador, dominar NumPy es fundamental para la manipulación eficiente de datos, el cálculo científico y el aprendizaje automático.

Explora las aplicaciones de NumPy y comprende por qué es una de las bibliotecas más populares para el cálculo numérico. Aprende las diferentes formas de crear e inicializar arreglos para manejar diversas necesidades de datos de manera eficiente.

Descubre cómo acceder a elementos específicos y subconjuntos en arreglos de NumPy utilizando la notación de índices. Aprende a aplicar indexación condicional para filtrar datos y gestionar valores faltantes de manera eficiente.

NumPy ofrece muchas funciones integradas para realizar operaciones comunes con arreglos. Aprenda cómo aplicar estas herramientas para transformar, agregar y analizar datos de manera eficiente sin escribir código repetitivo.

Aprende a realizar operaciones matemáticas de manera eficiente en arreglos de NumPy. Aplica estas operaciones para resolver problemas del mundo real y adquiere una comprensión más profunda de cómo los cálculos vectorizados aceleran el análisis numérico.

Más Sobre Comparaciones

Solución