Summary  
Boolean indexing shows how to apply a boolean mask of the same shape to a 2D array to filter elements based on conditions and return them as a 1D array.

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 2D y de dimensiones superiores funciona de manera similar a los arreglos 1D. 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á **1D**.

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

El **arreglo booleano** a la derecha es el arreglo booleano resultante de estas dos condiciones combinadas. Nuevamente, los elementos en **morado** cumplen las condiciones y los elementos en **verde** no. Así que 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