Summary  
This chapter explains how to access individual elements, rows, and columns in multidimensional arrays by specifying indices for each axis, including the use of positive and negative indexing.  

General domain of usage  
Financial data analysis

Nu när du kan komma åt element i endimensionella arrayer är det dags att lära sig om indexering i **högdimensionella** arrayer.

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.

Detta är en `2x3` array, vilket innebär att den består av `2` **endimensionella arrayer** längs **axel 0**, och var och en av dessa endimensionella arrayer har `3` element längs **axel 1**.

Bilderna nedan förtydligar positiv och negativ indexering i 2D-arrayer (arrayvärden visas i **svart**, och index visas i **grönt** för positiva index och **rött** för negativa index):

## Åtkomst till element i 2D-arrayer

I 1D-arrayer hämtade vi element genom att ange index för elementet inom **hakparenteser**. Om vi gör samma sak i 2D-arrayer får vi en **1D-array** vid det angivna indexet, vilket kan vara precis vad vi behöver.

Om vi däremot vill hämta ett specifikt element i en **inre** 1D-array, ska vi ange index för 1D-arrayen (längs **axel 0**) och index för dess element (längs **axel 1**), t.ex. `array[0, 1]`. Vi kan också skriva `array[0][1]` som vi gör med Python-`list`, men detta är **mindre effektivt** eftersom sökningen utförs **två gånger** för varje index istället för en gång.

Om ett angivet index är utanför gränserna kastas ett `IndexError`, så var uppmärksam på detta.

Observera

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

Bilden nedan visar strukturen för arrayen `stock_prices` som används i uppgiften:

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

Lås upp den fulla potentialen hos Pythons mest grundläggande bibliotek för numerisk beräkning, NumPy. Denna omfattande kurs är utformad för att ta dig från nybörjarnivå till avancerad kompetens i NumPy. Oavsett om du är data scientist, ingenjör, forskare eller utvecklare är det avgörande att behärska NumPy för effektiv datamanipulering, vetenskapliga beräkningar och maskininlärning.

Utforska användningsområdena för NumPy och förstå varför det är ett av de mest populära biblioteken för numerisk beräkning. Lär dig de olika sätten att skapa och initiera arrayer för att effektivt hantera olika databehov.

Upptäck hur du får åtkomst till specifika element och delmängder i NumPy-arrayer med hjälp av indexnotation. Lär dig att använda villkorsbaserad indexering för att filtrera data och hantera saknade värden effektivt.

NumPy tillhandahåller många inbyggda funktioner för att utföra vanliga arrayoperationer. Lär dig hur du använder dessa verktyg för att effektivt transformera, aggregera och analysera data utan att skriva repetitiv kod.

Lär dig hur du utför matematiska operationer effektivt på NumPy-arrayer. Använd dessa operationer för att lösa verkliga problem och få en djupare förståelse för hur vektoriserade beräkningar påskyndar numerisk analys.

Multidimensionell indexering

Indexering av 2D-arrayer

Åtkomst till element i 2D-arrayer

Lösning