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

Chaque tableau **NumPy** possède des éléments et leurs indices respectifs. Ici, nous nous concentrerons sur les indices dans les tableaux 1D.

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.

Dans l'image suivante, les indices positifs sont affichés en **vert**, tandis que les indices négatifs sont affichés en **rouge** :

Comme vous pouvez le voir, chaque élément du tableau possède à la fois un indice **positif** et un indice **négatif**. En fait, l'indexation dans les tableaux est similaire à l'indexation dans les listes.

## Accès aux éléments par indices

Pour accéder à un élément par son indice, il faut spécifier l'indice de cet élément entre **crochets**, par exemple : `array[2]`.

Si un indice spécifié est hors limites, une exception `IndexError` est levée ; il faut donc faire attention à ce point.

Remarque

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

En réalité, l’indexation positive et négative sont simplement deux méthodes pour accéder aux éléments d’un tableau, et elles fonctionnent **exactement de la même manière** sur le plan fonctionnel.

Il est courant d’accéder au premier élément du tableau en utilisant un indice positif (`0`) et au dernier élément en utilisant un indice négatif (`-1`).

Puisque les éléments de notre tableau sont simplement des **nombres**, il est possible d’effectuer toutes sortes d’opérations sur eux, comme on le ferait avec des nombres ordinaires :

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)

Ici, nous avons calculé la moyenne des éléments **premier** et **dernier** de notre tableau.

En résumé, l'indexation est essentielle pour accéder, modifier ou extraire des éléments ou des sous-ensembles spécifiques de données, permettant une **manipulation efficace et précise** du contenu des tableaux.

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

Libérez tout le potentiel de la bibliothèque la plus essentielle de Python pour le calcul numérique, NumPy. Ce cours complet est conçu pour vous faire passer d'une compréhension débutante à un niveau avancé de maîtrise de NumPy. Que vous soyez data scientist, ingénieur, chercheur ou développeur, la maîtrise de NumPy est essentielle pour une manipulation efficace des données, le calcul scientifique et l'apprentissage automatique.

Explorez les applications de NumPy et comprenez pourquoi il s'agit de l'une des bibliothèques les plus populaires pour le calcul numérique. Découvrez les différentes méthodes de création et d'initialisation des tableaux afin de répondre efficacement à divers besoins en données.

Découvrez comment accéder à des éléments spécifiques et à des sous-ensembles dans les tableaux NumPy en utilisant la notation d'index. Apprenez à appliquer l'indexation conditionnelle pour filtrer les données et gérer efficacement les valeurs manquantes.

NumPy propose de nombreuses fonctions intégrées pour effectuer des opérations courantes sur les tableaux. Découvrez comment utiliser ces outils pour transformer, agréger et analyser les données efficacement sans écrire de code répétitif.

Apprenez à effectuer des opérations mathématiques efficacement sur des tableaux NumPy. Appliquez ces opérations pour résoudre des problèmes concrets et acquérez une compréhension approfondie de la manière dont les calculs vectorisés accélèrent l'analyse numérique.

Indexation de base

Accès aux éléments par indices

Solution