Summary
This chapter explains how to access and slice elements in multidimensional arrays using positive and negative indexing, showing how to retrieve individual items, entire rows, or entire columns in a 2D array.

General domain of usage
Scientific computing

Ahora que puedes acceder a elementos en arreglos unidimensionales, es momento de aprender sobre la indexación en arreglos de **mayor dimensión**.

Watch this video for a clear, step-by-step visual explanation of multidimensional indexing in NumPy. You'll see how to index 2D arrays, use both positive and negative indices, and access specific elements efficiently. The video demonstrates practical examples that reinforce your understanding of how to work with higher-dimensional arrays in NumPy.

Este es un arreglo `2x3`, lo que significa que consta de `2` **arreglos unidimensionales** a lo largo del **eje 0**, y cada uno de estos arreglos unidimensionales tiene `3` elementos a lo largo del **eje 1**.

Las imágenes a continuación aclararán el indexado positivo y negativo en arreglos 2D (los valores del arreglo se muestran en **negro**, y los índices se muestran en **verde** para índices positivos y en **rojo** para índices negativos):

## Acceso a elementos en arreglos 2D
En los arreglos 1D, se accede a los elementos especificando el índice del elemento entre **corchetes**. Si haces lo mismo en arreglos 2D, obtendrás un **arreglo 1D** en el índice especificado, lo cual puede ser exactamente lo que necesitas.

Sin embargo, si deseas obtener un elemento particular de un arreglo 1D **interno**, debes especificar el índice del arreglo 1D (a lo largo del **eje 0**) y el índice de su elemento (a lo largo del **eje 1**), por ejemplo, `array[0, 1]`. También podrías escribir `array[0][1]` como se hace con una `list` de Python, pero esto es **menos eficiente** ya que realiza la búsqueda **dos veces** por cada índice en lugar de una sola vez.

Si un índice especificado está fuera de rango, se lanza un `IndexError`, así que ten cuidado con eso.

Nota

import numpy as np
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
# Accessing the first element (1D array) with positive index
print(array_2d[0])
# Accessing the second element of the first 1D array with positive index
print(array_2d[0, 1])
# Accessing the last element of the last 1D array with negative index
print(array_2d[-1, -1])

La imagen a continuación muestra la estructura del arreglo `stock_prices` utilizado en la tarea:

import unittest
import importlib.util
import numpy as np


def _dynamic_test(test_case, condition, success_message, failure_message):
    """Codefinity-style result output"""
    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):
        # Імпортуємо user_code
        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.stock_prices = np.array([
            [150, 130, 140, 150, 160],
            [210, 220, 230, 240, 250],
            [310, 320, 330, 340, 350],
            [410, 420, 430, 440, 450],
            [510, 520, 530, 540, 550]
        ])

    def test_first_company_prices(self):
        """1. Retrieve all stock prices of the first company using positive index"""
        ok = hasattr(self.m, "first_company_prices")
        arr = getattr(self.m, "first_company_prices", None)
        type_ok = isinstance(arr, np.ndarray)
        expected = self.stock_prices[0]
        val_ok = type_ok and np.array_equal(arr, expected)
        shape_ok = type_ok and arr.shape == (5,)
        _dynamic_test(
            self,
            ok and type_ok and shape_ok and val_ok,
            "first_company_prices retrieved correctly",
            "first_company_prices incorrect",
        )

    def test_third_company_second_day(self):
        """2. Retrieve third company second day price using positive indices"""
        ok = hasattr(self.m, "third_company_second_day_price")
        val = getattr(self.m, "third_company_second_day_price", None)
        expected = self.stock_prices[2, 1]
        type_ok = isinstance(val, (int, np.integer))
        value_ok = type_ok and val == expected
        _dynamic_test(
            self,
            ok and type_ok and value_ok,
            "third_company_second_day_price retrieved correctly",
            "third_company_second_day_price incorrect",
        )

    def test_last_company_last_day(self):
        """3. Retrieve last company last day price using negative indices"""
        ok = hasattr(self.m, "last_company_last_day_price")
        val = getattr(self.m, "last_company_last_day_price", None)
        expected = self.stock_prices[-1, -1]
        type_ok = isinstance(val, (int, np.integer))
        value_ok = type_ok and val == expected
        _dynamic_test(
            self,
            ok and type_ok and value_ok,
            "last_company_last_day_price retrieved correctly",
            "last_company_last_day_price incorrect",
        )


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 Multidimensional

Indexación de arreglos 2D

Acceso a elementos en arreglos 2D

Solución