Summary  
This chapter covers basic indexing in one-dimensional arrays, demonstrating how to access elements using positive and negative indices and how to use those indexed elements in computations.

General domain of usage  
Numerical computing

Elke **NumPy** array bevat elementen en hun respectievelijke indexen. Hier ligt de focus op indexen 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.

In de onderstaande afbeelding worden de positieve indexen weergegeven in **groen**, terwijl de negatieve indexen in **rood** worden getoond:

Zoals je kunt zien, heeft elk element in de array zowel een **positieve** als een **negatieve** index. Indexering in arrays lijkt in feite op indexering in lijsten.

## Elementen benaderen via indexen

Om een element via zijn index te benaderen, geef je de index van dit element op tussen **rechte haken**, bijvoorbeeld: `array[2]`.

Als een opgegeven index buiten het bereik valt, wordt er een `IndexError` opgegooid. Let hier dus goed op.

Opmerking

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

In feite zijn positieve en negatieve indexering gewoon twee methoden om elementen van een array te benaderen, en ze werken **op dezelfde manier** functioneel.

Het is gebruikelijk om het eerste element van de array te benaderen met een positieve index (`0`) en het laatste element met een negatieve index (`-1`).

Aangezien de elementen van je array gewoon **getallen** zijn, kun je er allerlei bewerkingen op uitvoeren die je ook met gewone getallen zou doen:

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 heb je het gemiddelde berekend van het **eerste** en het **laatste** element van je array.

Samengevat is indexering essentieel voor het benaderen, wijzigen of extraheren van specifieke elementen of deelverzamelingen van gegevens, wat **efficiënte en nauwkeurige manipulatie** van array-inhoud mogelijk maakt.

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

Ontgrendel het volledige potentieel van Python's meest essentiële bibliotheek voor numerieke berekeningen, NumPy. Deze uitgebreide cursus is ontworpen om je van een basiskennis naar een gevorderd niveau van vaardigheid in NumPy te brengen. Of je nu data scientist, ingenieur, onderzoeker of ontwikkelaar bent, het beheersen van NumPy is essentieel voor efficiënte datamanipulatie, wetenschappelijk rekenen en machine learning.

Ontdek de toepassingen van NumPy en begrijp waarom het een van de populairste bibliotheken is voor numerieke berekeningen. Leer de verschillende manieren om arrays te maken en te initialiseren om efficiënt aan diverse databehoeften te voldoen.

Ontdek hoe u specifieke elementen en deelverzamelingen in NumPy-arrays kunt benaderen met behulp van indexnotatie. Leer om conditionele indexering toe te passen om gegevens te filteren en ontbrekende waarden efficiënt te beheren.

NumPy biedt veel ingebouwde functies voor het uitvoeren van veelvoorkomende arraybewerkingen. Leer hoe u deze tools kunt toepassen om gegevens efficiënt te transformeren, aggregeren en analyseren zonder repetitieve code te schrijven.

Leer hoe u wiskundige bewerkingen efficiënt uitvoert op NumPy-arrays. Pas deze bewerkingen toe om realistische problemen op te lossen en krijg een dieper inzicht in hoe gevectoriseerde berekeningen numerieke analyses versnellen.

Basisindexering

Elementen benaderen via indexen

Oplossing