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

Nachdem Sie nun in der Lage sind, Elemente in 1D-Arrays zuzugreifen, ist es an der Zeit, das Indexieren in **höherdimensionalen** Arrays kennenzulernen.

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.

Dies ist ein `2x3`-Array, was bedeutet, dass es aus `2` **1D-Arrays** entlang **Achse 0** besteht, und jedes dieser 1D-Arrays enthält `3` Elemente entlang **Achse 1**.

Die folgenden Abbildungen verdeutlichen das positive und negative Indexieren in 2D-Arrays (Array-Werte sind in **schwarz** dargestellt, Indizes für positive Indizes in **grün** und für negative Indizes in **rot**):

## Zugriff auf Elemente in 2D-Arrays
In 1D-Arrays erfolgt der Zugriff auf Elemente durch Angabe des Index des Elements in **eckigen Klammern**. Wenn Sie dies bei 2D-Arrays tun, erhalten Sie ein **1D-Array** am angegebenen Index, was genau das sein kann, was Sie benötigen.

Wenn Sie jedoch ein bestimmtes Element eines **inneren** 1D-Arrays abrufen möchten, sollten Sie den Index des 1D-Arrays (entlang der **Achse 0**) und den Index seines Elements (entlang der **Achse 1**) angeben, z. B. `array[0, 1]`. Sie könnten auch `array[0][1]` wie bei einer Python-`list` schreiben, aber dies ist **weniger effizient**, da die Suche für jeden Index **zweimal** statt nur einmal durchgeführt wird.

Wenn ein angegebener Index außerhalb des gültigen Bereichs liegt, wird ein `IndexError` ausgelöst. Seien Sie daher vorsichtig.

Hinweis

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

Das folgende Bild zeigt die Struktur des in der Aufgabe verwendeten Arrays `stock_prices`:

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

Entfesseln Sie das volle Potenzial von Pythons wichtigster Bibliothek für numerisches Rechnen, NumPy. Dieser umfassende Kurs ist darauf ausgelegt, Sie von grundlegenden Kenntnissen bis hin zu fortgeschrittener NumPy-Kompetenz zu führen. Ob Datenwissenschaftler, Ingenieur, Forscher oder Entwickler – die Beherrschung von NumPy ist unerlässlich für effiziente Datenmanipulation, wissenschaftliches Rechnen und maschinelles Lernen.

Erkunden Sie die Anwendungen von NumPy und verstehen Sie, warum es eine der beliebtesten Bibliotheken für numerische Berechnungen ist. Lernen Sie die verschiedenen Methoden zur Erstellung und Initialisierung von Arrays kennen, um unterschiedliche Datenanforderungen effizient zu bewältigen.

Erfahren Sie, wie Sie mit Indexnotation auf bestimmte Elemente und Teilmengen in NumPy-Arrays zugreifen. Lernen Sie, bedingte Indizierung anzuwenden, um Daten zu filtern und fehlende Werte effizient zu verwalten.

NumPy bietet viele integrierte Funktionen zur Durchführung gängiger Array-Operationen. Lernen Sie, wie Sie diese Werkzeuge anwenden, um Daten effizient zu transformieren, zu aggregieren und zu analysieren, ohne wiederholten Code schreiben zu müssen.

Erfahren Sie, wie mathematische Operationen effizient auf NumPy-Arrays durchgeführt werden. Wenden Sie diese Operationen an, um reale Probleme zu lösen, und gewinnen Sie ein tieferes Verständnis dafür, wie vektorisierte Berechnungen die numerische Analyse beschleunigen.

Mehrdimensionale Indizierung

Indexierung von 2D-Arrays

Zugriff auf Elemente in 2D-Arrays

Lösung