Summary  
This chapter explains how to access and manipulate elements of a one-dimensional array using zero-based positive and negative indexing and demonstrates performing arithmetic calculations on the accessed elements.  

General domain of usage  
Numerical computing

Jedes **NumPy**-Array besitzt Elemente und deren jeweilige Indizes. Hier liegt der Fokus auf Indizes in 1D-Arrays.

This video provides an overview of basic indexing in NumPy. You will learn how positive and negative indices work in 1D arrays, how to access elements using both types of indices, and how to use indexing to perform calculations such as finding averages. The video demonstrates practical examples to help you confidently navigate and manipulate NumPy arrays, reinforcing the key concepts covered in this chapter.

Im folgenden Bild sind die positiven Indizes in **grün** und die negativen Indizes in **rot** dargestellt:

Wie zu sehen ist, besitzt jedes Element im Array sowohl einen **positiven** als auch einen **negativen** Index. Das Indexieren in Arrays ähnelt dem Indexieren in Listen.

## Zugriff auf Elemente über Indizes

Um auf ein Element über seinen Index zuzugreifen, muss der Index dieses Elements in **eckigen Klammern** angegeben werden, z. B. `array[2]`.

Wenn ein angegebener Index außerhalb des gültigen Bereichs liegt, wird ein `IndexError` ausgelöst. Daher ist Vorsicht geboten.

Hinweis

import numpy as np
array = np.array([9, 6, 4, 8, 10])
# Accessing the first element (positive index)
print(f'The first element (positive index): {array[0]}')
# Accessing the first element (negative index)
print(f'The first element (negative index): {array[-5]}')
# Accessing the last element (positive index)
print(f'The last element (positive index): {array[4]}')
# Accessing the last element (negative index)
print(f'The last element (negative index): {array[-1]}')
# Accessing the third element (positive index)
print(f'The third element (positive index): {array[2]}')
# Accessing the third element (negative index)
print(f'The third element (negative index): {array[-3]}')

Tatsächlich sind positives und negatives Indexieren einfach zwei Methoden, um auf Array-Elemente zuzugreifen, und sie funktionieren **auf die gleiche Weise**.

Es ist gängige Praxis, auf das erste Element des Arrays mit einem positiven Index (`0`) und auf das letzte Element mit einem negativen Index (`-1`) zuzugreifen.

Da die Elemente unseres Arrays einfach **Zahlen** sind, können wir alle möglichen Operationen mit ihnen durchführen, wie wir es auch mit normalen Zahlen tun würden:

import numpy as np
array = np.array([9, 6, 4, 8, 10])
# Finding the average between the first and the last element
print((array[0] + array[-1]) / 2)

Hier wurde der Durchschnitt des **ersten** und des **letzten** Elements des Arrays berechnet.

Zusammenfassend ist das Indexieren unerlässlich, um auf bestimmte Elemente oder Teilmengen von Daten zuzugreifen, sie zu verändern oder zu extrahieren, was eine **effiziente und präzise Manipulation** von Array-Inhalten ermöglicht.

import unittest
import importlib.util
import numpy as np


def _dynamic_test(test_case, condition, success_message, failure_message):
    """Codefinity-style result helper"""
    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):
        # Імпортуємо код користувача
        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.arr = np.array([8, 18, 9, 16, 7, 1, 3])
        cls.expected_avg = (cls.arr[0] + cls.arr[3] + cls.arr[-1]) / 3

    def test_average_value(self):
        """4. Correct average calculated"""
        ok = hasattr(self.m, "average")
        val = getattr(self.m, "average", None)
        type_ok = isinstance(val, (int, float, np.floating))
        value_ok = np.isclose(val, self.expected_avg)

        _dynamic_test(
            self,
            ok and type_ok and value_ok,
            "average calculated correctly",
            "average incorrect or missing",
        )

    def test_access_indexes(self):
        """1–3. Accesses first, fourth, and last elements"""
        arr = np.array([8, 18, 9, 16, 7, 1, 3])
        # Виконуємо код користувача повторно, щоб проаналізувати результат
        spec = importlib.util.spec_from_file_location("user_code", "user_code.py")
        m2 = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(m2)
        val = getattr(m2, "average", None)

        # Перевірка: середнє значення має утворюватися саме з arr[0], arr[3], arr[-1]
        used_values = [arr[0], arr[3], arr[-1]]
        possible = np.isclose(val, sum(used_values) / 3)

        _dynamic_test(
            self,
            possible,
            "indexes used correctly (first, fourth, last)",
            "indexes incorrect or not matching task conditions",
        )


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.

Grundlegendes Indexieren

Zugriff auf Elemente über Indizes

Lösung