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

Elke **NumPy**-array bevat elementen en hun respectievelijke indexen. Hier richten we ons 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 volgende afbeelding worden de positieve indexen weergegeven in **groen**, terwijl de negatieve indexen worden weergegeven in **rood**:

Zoals te zien is, 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 te benaderen via zijn index, 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 toegang te krijgen tot array-elementen, 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 onze array gewoon **getallen** zijn, kunnen we allerlei bewerkingen op hen uitvoeren die we ook met gewone getallen zouden 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 hebben we het gemiddelde berekend van het **eerste** en het **laatste** element van onze array.

Samengevat is indexering essentieel voor het benaderen, wijzigen of extraheren van specifieke elementen of deelverzamelingen van gegevens, wat **efficiënte en nauwkeurige bewerking** 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