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

Nyt kun osaat hakea alkioita 1D-taulukoista, on aika oppia indeksointia **korkeamman ulottuvuuden** taulukoissa.

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.

Tämä on `2x3`-taulukko, mikä tarkoittaa, että siinä on `2` **1D-taulukkoa** pitkin **akselia 0**, ja jokaisessa näistä 1D-taulukoista on `3` alkiota pitkin **akselia 1**.

Alla olevat kuvat havainnollistavat positiivista ja negatiivista indeksointia 2D-taulukoissa (taulukon arvot on esitetty **mustalla**, positiiviset indeksit **vihreällä** ja negatiiviset indeksit **punaisella**):

## Alkioiden hakeminen 2D-taulukoista

1D-taulukoissa alkiot haettiin määrittämällä alkion indeksi **hakasulkeissa**. Jos teemme saman 2D-taulukoissa, saamme **1D-taulukon** annetulla indeksillä, mikä voi olla juuri se mitä tarvitsemme.

Jos kuitenkin haluamme hakea tietyn alkion **sisäisestä** 1D-taulukosta, tulee määrittää 1D-taulukon indeksi (**akselilla 0**) ja sen alkion indeksi (**akselilla 1**), esim. `array[0, 1]`. Voimme myös kirjoittaa `array[0][1]` kuten Pythonin `list`-rakenteessa, mutta tämä on **tehottomampaa**, koska haku suoritetaan **kahdesti** jokaista indeksiä kohden yhden sijaan.

Jos annettu indeksi on taulukon ulkopuolella, syntyy `IndexError`-virhe, joten ole tarkkana tämän kanssa.

Huomio

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

Alla oleva kuva esittää tehtävässä käytetyn `stock_prices`-taulukon rakennetta:

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

Avaa Pythonin tärkeimmän numeerisen laskennan kirjaston, NumPyn, koko potentiaali. Tämä kattava kurssi on suunniteltu viemään sinut aloittelijan tasolta edistyneeksi NumPy-osaajaksi. Olitpa sitten data-analyytikko, insinööri, tutkija tai kehittäjä, NumPyn hallinta on olennaista tehokkaaseen datan käsittelyyn, tieteelliseen laskentaan ja koneoppimiseen.

Tutustu NumPyn käyttökohteisiin ja ymmärrä, miksi se on yksi suosituimmista kirjastoista numeeriseen laskentaan. Opiskele erilaisia tapoja luoda ja alustaa taulukoita erilaisten tietotarpeiden tehokkaaseen käsittelyyn.

Opi, kuinka NumPy-taulukoiden yksittäisiin alkioihin ja osajoukkoihin päästään käsiksi indeksimerkinnän avulla. Tutustu ehdollisen indeksoinnin käyttöön tietojen suodattamisessa ja puuttuvien arvojen hallinnassa tehokkaasti.

NumPy tarjoaa monia sisäänrakennettuja funktioita yleisten taulukko-operaatioiden suorittamiseen. Opi käyttämään näitä työkaluja datan muuntamiseen, aggregointiin ja analysointiin tehokkaasti ilman toistuvaa koodia.

Opi suorittamaan matemaattisia operaatioita tehokkaasti NumPy-taulukoilla. Sovella näitä operaatioita todellisten ongelmien ratkaisemiseen ja syvennä ymmärrystäsi siitä, miten vektorisoidut laskutoimitukset nopeuttavat numeerista analyysiä.

Moniulotteinen indeksointi

2D-taulukoiden indeksointi

Alkioiden hakeminen 2D-taulukoista

Ratkaisu