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

Nyt kun osaat hakea alkioita yksiulotteisista taulukoista, on aika oppia indeksointi **moniulotteisissa** 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` **yksisuuntaista taulukkoa** pitkin **akselia 0**, ja jokaisessa näistä yksisuuntaisista taulukoista on `3` alkiota pitkin **akselia 1**.

Alla olevat kuvat havainnollistavat positiivista ja negatiivista indeksointia kaksiulotteisissa 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 teet saman 2D-taulukoissa, saat **1D-taulukon** annetulla indeksillä, mikä voi olla juuri haluamasi tulos.

Jos kuitenkin haluat hakea tietyn alkion **sisemmästä** 1D-taulukosta, sinun tulee määrittää 1D-taulukon indeksi (**akselilla 0**) ja sen alkion indeksi (**akselilla 1**), esim. `array[0, 1]`. Voit 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, tapahtuu `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 rakenteen:

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