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

Varje **NumPy**-array har element och deras respektive index. Här fokuseras på index i endimensionella arrayer.

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.

I följande bild visas de positiva indexen i **grönt**, medan de negativa indexen visas i **rött**:

Som du kan se har varje element i arrayen både ett **positivt** och ett **negativt** index. Faktum är att indexering i arrayer liknar indexering i listor.

## Åtkomst till element via index

För att komma åt ett element via dess index ska du ange indexet för detta element inom **hakparenteser**, t.ex. `array[2]`.

Om ett angivet index är utanför gränserna kastas ett `IndexError`, så var uppmärksam på detta.

Notera

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

Faktum är att positiv och negativ indexering bara är två metoder för att komma åt arrayelement, och de fungerar **på samma sätt** funktionellt.

Det är vanligt att komma åt det första elementet i arrayen med en positiv index (`0`) och det sista elementet med en negativ index (`-1`).

Notering

Eftersom elementen i din array bara är **tal**, kan du utföra alla typer av operationer på dem som du skulle göra med vanliga tal:

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)

Här beräknade du medelvärdet av **första** och **sista** elementet i din array.

Sammanfattningsvis är indexering avgörande för att komma åt, ändra eller extrahera specifika element eller delmängder av data, vilket möjliggör **effektiv och precis hantering** av array-innehåll.

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

Lås upp den fulla potentialen hos Pythons mest grundläggande bibliotek för numerisk beräkning, NumPy. Denna omfattande kurs är utformad för att ta dig från nybörjarnivå till avancerad kompetens i NumPy. Oavsett om du är data scientist, ingenjör, forskare eller utvecklare är det avgörande att behärska NumPy för effektiv datamanipulering, vetenskapliga beräkningar och maskininlärning.

Utforska användningsområdena för NumPy och förstå varför det är ett av de mest populära biblioteken för numerisk beräkning. Lär dig de olika sätten att skapa och initiera arrayer för att effektivt hantera olika databehov.

Upptäck hur du får åtkomst till specifika element och delmängder i NumPy-arrayer med hjälp av indexnotation. Lär dig att använda villkorsbaserad indexering för att filtrera data och hantera saknade värden effektivt.

NumPy tillhandahåller många inbyggda funktioner för att utföra vanliga arrayoperationer. Lär dig hur du använder dessa verktyg för att effektivt transformera, aggregera och analysera data utan att skriva repetitiv kod.

Lär dig hur du utför matematiska operationer effektivt på NumPy-arrayer. Använd dessa operationer för att lösa verkliga problem och få en djupare förståelse för hur vektoriserade beräkningar påskyndar numerisk analys.

Grundläggande Indexering

Åtkomst till element via index

Lösning