Summary  
Boolean indexing applies a Boolean mask of the same dimensions as a multi-dimensional array to filter and retrieve only the elements that meet specified conditions, always returning a flattened one-dimensional array of matches.

General domain of usage  
Data analysis

Watch this video to see how boolean indexing works in 2D numpy arrays. You'll learn how to construct boolean conditions, apply them to extract specific elements, and understand the resulting 1D output. Visual examples will help you connect the code to the array's structure, reinforcing how boolean arrays map to your data.

El **indexado booleano** en arreglos de dos o más dimensiones funciona de manera similar a los arreglos unidimensionales. Sin embargo, el arreglo booleano debe tener el **mismo número de dimensiones** que el arreglo original (por ejemplo, 2D para arreglos bidimensionales). El arreglo devuelto, sin embargo, será **unidimensional**.

import numpy as np
array_2d = np.array([
   [1, 2, 3],
   [4, 5, 6],
   [7, 8, 9]
])
# Retrieving elements less than 3 or greater than OR greater than or equal to 8
print(array_2d[(array_2d < 3) | (array_2d >= 8)])

La **matriz booleana** a la derecha es la matriz booleana resultante de estas dos condiciones combinadas. Una vez más, los elementos en **morado** cumplen las condiciones y los elementos en **verde** no. Por lo tanto, al aplicar `array_2d[(array_2d < 3) | (array_2d >= 8)]`, se obtiene un arreglo 1D con los elementos **morados**.

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 formatted feedback"""
    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):
        # Очікувані дані
        cls.city_temperatures = np.array([[12, 18, 25, 14],
                                          [32, 20, 28, 35]])
        cls.expected = cls.city_temperatures[
            (cls.city_temperatures <= 15) | (cls.city_temperatures > 30)
        ]

    def test_boolean_filter_and_print(self):
        """1–2. Boolean indexing applied correctly and printed"""
        # Виконуємо код користувача і перехоплюємо stdout
        f = io.StringIO()
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        module = importlib.util.module_from_spec(spec)
        with redirect_stdout(f):
            spec.loader.exec_module(module)
        output = f.getvalue().strip()

        # Перевірка, що результат містить усі очікувані значення
        expected_values = [str(x) for x in self.expected.flatten()]
        contains_expected = all(val in output for val in expected_values)

        # Перевірка, що вивід не містить інших (зайвих) елементів із початкового масиву
        disallowed = [x for x in self.city_temperatures.flatten() if x not in self.expected]
        contains_disallowed = any(str(x) in output for x in disallowed)

        _dynamic_test(
            self,
            contains_expected and not contains_disallowed,
            "Boolean indexing and print output correct",
            "Boolean indexing incorrect or print output missing/wrong",
        )


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.

Indexación Booleana en Arreglos 2D

Solución