Introduction à l'indexation dans NumPy

Introduction

Bienvenue ! Maintenant que vous savez comment créer des tableaux NumPy, il est temps d'apprendre à accéder et manipuler les données qu'ils contiennent. Dans ce laboratoire, vous explorerez l'indexation – la méthode principale pour accéder et modifier les données dans les tableaux NumPy.

Approfondir ce que vous avez appris

Dans le laboratoire précédent, vous avez appris :

• Comment créer des tableaux à l'aide de diverses fonctions NumPy
• La différence entre les tableaux et les listes Python
• Les dimensions des tableaux (1D, 2D, 3D) et les types de données

Maintenant, vous apprendrez à :

• Accéder à des éléments individuels ou à des groupes d'éléments
• Extraire des lignes, des colonnes ou des régions spécifiques des tableaux
• Utiliser des techniques de sélection avancées pour le filtrage de données complexes
• Modifier les données des tableaux par indexation

Pourquoi l'indexation est importante

L'indexation est fondamentale pour la manipulation des données car elle vous permet de :

• Extraire des sous-ensembles de données pour l'analyse
• Modifier des valeurs spécifiques dans de grands ensembles de données
• Filtrer des données en fonction de conditions
• Effectuer des opérations vectorisées sur des éléments sélectionnés

Ces compétences sont essentielles pour toute tâche d'analyse de données ou de calcul scientifique en Python.

Indexation et découpage de base dans les tableaux 1D

Maintenant que vous savez comment créer des tableaux, apprenons à accéder à leur contenu. Tout votre travail dans ce laboratoire sera effectué dans le fichier indexing_practice.py.

Comprendre l'indexation des tableaux

Indexation basée sur zéro

Comme les listes Python, les tableaux NumPy utilisent l'indexation basée sur zéro. Cela signifie :

• Le premier élément est à l'index 0
• Le deuxième élément est à l'index 1
• Et ainsi de suite...

Visualisation des indices de tableau

Pour un tableau x = [10, 20, 30, 40, 50] :

Index:  0   1   2   3   4
Valeur: 10  20  30  40  50

Ainsi, x[0] donne 10, x[2] donne 30, etc.

Syntaxe de Slicing

Le slicing vous permet de sélectionner une plage d'éléments avec la syntaxe start:stop:step :

• start : Index où commence le slice (inclus)
• stop : Index où se termine le slice (exclus)
• step : Nombre d'éléments à sauter (optionnel, par défaut 1)

Motifs de slicing courants :

• x[1:4] : Éléments aux indices 1, 2, 3
• x[:3] : Les 3 premiers éléments (indices 0, 1, 2)
• x[2:] : De l'index 2 jusqu'à la fin
• x[::2] : Tous les deux éléments en partant de l'index 0
• x[::-1] : Inverse le tableau entier

Tout d'abord, ouvrez le fichier indexing_practice.py dans l'éditeur. Ensuite, remplacez tout son contenu par le code suivant. Ce code crée un tableau 1D et montre comment accéder à un élément unique et à une tranche d'éléments.

import numpy as np

## Crée un tableau 1D avec les nombres de 0 à 9
x = np.arange(10)
print("Tableau original :", x)

## Accède à un élément unique à l'index 2
element = x[2]
print("Élément à l'index 2 :", element)

## Tranche le tableau de l'index 1 jusqu'à l'index 7 (exclus), avec un pas de 2
a_slice = x[1:7:2]
print("Tranche de 1 à 7 avec un pas de 2 :", a_slice)

Après avoir ajouté le code à indexing_practice.py, enregistrez le fichier. Exécutez maintenant le script depuis le terminal en tapant la commande suivante :

python indexing_practice.py

Vous devriez voir la sortie suivante, qui affiche le tableau original, l'élément à l'index spécifié et la tranche résultante.

Tableau original : [0 1 2 3 4 5 6 7 8 9]
Élément à l'index 2 : 2
Tranche de 1 à 7 avec un pas de 2 : [1 3 5]

Indexation des tableaux multidimensionnels

Passons maintenant aux tableaux qui ont plus d'une dimension. C'est là que NumPy brille vraiment par rapport aux listes Python !

Penser en plusieurs dimensions

Tableaux 2D comme des tables

Un tableau 2D est comme une feuille de calcul ou une table :

• Les lignes constituent la première dimension (horizontale)
• Les colonnes constituent la deuxième dimension (verticale)
• Vous spécifiez les indices de ligne et de colonne : tableau[ligne, colonne]

Visualisation de l'indexation 2D

Pour un tableau 2D :

tableau = [[10, 20, 30],
           [40, 50, 60],
           [70, 80, 90]]

Indices :     0,0  0,1  0,2
              1,0  1,1  1,2
              2,0  2,1  2,2

• tableau[0, 0] → 10 (première ligne, première colonne)
• tableau[1, 2] → 60 (deuxième ligne, troisième colonne)
• tableau[2, 1] → 80 (troisième ligne, deuxième colonne)

Sélection de lignes ou colonnes entières

• tableau[0] ou tableau[0, :] → toute la première ligne [10, 20, 30]
• tableau[:, 1] → toute la deuxième colonne [20, 50, 80]
• C'est beaucoup plus pratique que les listes Python imbriquées !

Pratiquons cela avec un tableau bidimensionnel (2D). Mettez à jour votre fichier indexing_practice.py avec le code ci-dessous. Ce script crée un tableau 3x4 et montre comment accéder à un élément unique et à une ligne entière.

import numpy as np

## Crée un tableau 2D (3 lignes, 4 colonnes)
x = np.arange(12).reshape(3, 4)
print("Tableau 2D original :\n", x)

## Accède à l'élément à la ligne 1, colonne 2
element = x[1, 2]
print("\nÉlément à (1, 2) :", element)

## Accède à toute la première ligne (index de ligne 0)
first_row = x[0]
print("\nPremière ligne :", first_row)

Enregistrez le fichier et exécutez-le à nouveau depuis le terminal :

python indexing_practice.py

La sortie affichera le tableau 2D et les parties spécifiques que vous avez sélectionnées.

Tableau 2D original :
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

Élément à (1, 2) : 6

Première ligne : [0 1 2 3]

Indexation avancée

Le slicing de base fonctionne bien pour les régions contiguës, mais parfois vous avez besoin de sélections plus complexes. NumPy propose deux techniques puissantes d'indexation avancée :

Indexation par Tableau d'Entiers (Integer Array Indexing)

Sélectionnez des éléments arbitraires en fournissant un tableau d'indices. C'est comme choisir des éléments spécifiques dans une liste en utilisant leurs positions.

Exemple concret : Vous avez des notes d'examen et vous souhaitez vérifier les notes des étudiants aux positions 3, 7 et 12 :

scores = np.array([85, 92, 78, 95, 88, 76, 91, 89, 84, 93, 87, 90, 82])
student_positions = [3, 7, 12]  ## Étudiants qui vous intéressent
selected_scores = scores[student_positions]  ## [95, 89, 82]

Indexation par Tableau Booléen (Masquage)

Sélectionnez des éléments en fonction de conditions. Créez un "masque" de valeurs Vrai/Faux, puis utilisez-le pour filtrer le tableau.

Exemple concret : Filtrez les notes de réussite (≥ 80) d'une classe :

scores = np.array([85, 92, 78, 95, 88, 76, 91, 89, 84, 93])
passing_mask = scores >= 80  ## [True, True, False, True, True, False, True, True, True, True]
passing_scores = scores[passing_mask]  ## [85, 92, 95, 88, 91, 89, 84, 93]

Pourquoi c'est important

• Indexation par entiers : Parfait pour échantillonner des points de données spécifiques
• Indexation booléenne : Idéal pour le filtrage de données et les sélections conditionnelles
• Les deux créent des copies (pas des vues), donc les modifications n'affectent pas le tableau original

Essayons les deux. Remplacez le contenu de indexing_practice.py par le code suivant :

import numpy as np

## --- Indexation par Tableau d'Entiers ---
x = np.arange(10, 0, -1)
print("Tableau pour l'indexation par entiers :", x)

## Sélectionne les éléments aux indices 3, 3, 1 et 8
selected_elements = x[np.array([3, 3, 1, 8])]
print("Éléments sélectionnés avec un tableau d'entiers :", selected_elements)


## --- Indexation par Tableau Booléen ---
y = np.array([1., -1., -2., 3.])
print("\nTableau pour l'indexation booléenne :", y)

## Crée un masque booléen pour les éléments négatifs
mask = y < 0
print("Masque booléen (y < 0) :", mask)

## Sélectionne les éléments où la condition est Vraie
negative_elements = y[mask]
print("Éléments où y < 0 :", negative_elements)

Enregistrez le fichier et exécutez le script :

python indexing_practice.py

Votre sortie devrait démontrer comment l'indexation par entiers et l'indexation booléenne fonctionnent pour sélectionner des données spécifiques de vos tableaux.

Tableau pour l'indexation par entiers : [10  9  8  7  6  5  4  3  2  1]
Éléments sélectionnés avec un tableau d'entiers : [7 7 9 2]

Tableau pour l'indexation booléenne : [ 1. -1. -2.  3.]
Masque booléen (y < 0) : [False  True  True False]
Éléments où y < 0 : [-1. -2.]

Assignation de valeurs aux tableaux indexés

L'indexation ne sert pas seulement à lire des données, elle est également puissante pour modifier des données. Vous pouvez utiliser n'importe quelle méthode d'indexation du côté gauche de l'opérateur d'affectation (=) pour changer des éléments spécifiques.

Broadcasting : Rendre les Formes Compatibles

Lors de l'attribution de valeurs à des tableaux indexés, NumPy utilise le broadcasting pour rendre les formes compatibles. C'est l'une des fonctionnalités les plus puissantes de NumPy !

Règles de Broadcasting

NumPy peut automatiquement étendre les tableaux plus petits pour qu'ils correspondent aux tableaux plus grands lors de l'affectation, en suivant ces règles :

1. Une seule valeur à plusieurs éléments : Une valeur peut être attribuée à de nombreuses positions
2. Petit tableau à une sélection plus grande : Tant que les dimensions sont compatibles

Exemples de Broadcasting dans l'Attribution

## Une seule valeur à un slice
arr = np.array([1, 2, 3, 4, 5])
arr[1:4] = 99  ## [1, 99, 99, 99, 5]

## Tableau à un slice correspondant
arr = np.array([1, 2, 3, 4, 5])
arr[1:4] = [10, 20, 30]  ## [1, 10, 20, 30, 5]

## Indexation booléenne avec broadcasting
arr = np.array([1, 2, 3, 4, 5])
arr[arr % 2 == 0] = -1  ## Remplace tous les nombres pairs par -1

Notes Importantes

• Le broadcasting ne fonctionne que lorsque les formes sont compatibles
• La forme de la valeur attribuée doit pouvoir "rentrer" dans la sélection indexée
• C'est beaucoup plus efficace que de parcourir les éléments manuellement en boucle

Mettez à jour votre fichier indexing_practice.py avec le code suivant pour voir cela en action.

import numpy as np

## --- Attribution d'une seule valeur à un slice ---
x = np.arange(10)
print("Tableau original :", x)

## Attribue la valeur 99 aux éléments de l'index 2 à 4
x[2:5] = 99
print("Après attribution de 99 au slice [2:5] :", x)


## --- Attribution de valeurs basées sur une condition booléenne ---
y = np.arange(10)
print("\nTableau original :", y)

## Attribue la valeur -1 à tous les nombres pairs
y[y % 2 == 0] = -1
print("Après attribution de -1 aux nombres pairs :", y)

Enregistrez le fichier et exécutez-le depuis le terminal :

python indexing_practice.py

La sortie montrera les tableaux avant et après la modification, démontrant la puissance de cette fonctionnalité pour la manipulation de données.

Tableau original : [0 1 2 3 4 5 6 7 8 9]
Après attribution de 99 au slice [2:5] : [ 0  1 99 99 99  5  6  7  8  9]

Tableau original : [0 1 2 3 4 5 6 7 8 9]
Après attribution de -1 aux nombres pairs : [-1  1 -1  3 -1  5 -1  7 -1  9]

Résumé

Dans ce laboratoire, vous avez appris les techniques essentielles pour l'indexation des tableaux NumPy. Vous avez commencé par l'accès aux éléments uniques et le slicing de base dans les tableaux 1D, similaires aux listes Python. Vous êtes ensuite passé à l'indexation des tableaux multidimensionnels pour sélectionner des éléments et des sous-tableaux spécifiques. Enfin, vous avez exploré l'indexation avancée à l'aide de tableaux d'entiers et booléens, et vous avez appris à utiliser ces méthodes de sélection puissantes pour modifier les données au sein d'un tableau. Ces compétences sont fondamentales pour une manipulation et une analyse efficaces des données en Python avec NumPy.