Indexation, tranches et indexation avancée
Accédez aux éléments des tableaux et modifiez-les grâce à des techniques d’indexation avancées.
Indexation, tranches et indexation avancée est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.
Indexation de base
Accédez aux éléments avec des indices entiers commençant à zéro. Les indices négatifs comptent à partir de la fin. Les tableaux multidimensionnels utilisent des indices séparés par des virgules.
import numpy as np
arr = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(arr[0, 2]) # 3
print(arr[-1, -1]) # 9
print(arr[1]) # [4 5 6]Découpage
La syntaxe de découpage start:stop:step renvoie une vue. Elle s’applique indépendamment à chaque dimension.
import numpy as np
m = np.arange(16).reshape(4,4)
print(m[1:3, 1:3])
# [[5 6]
# [9 10]]
print(m[::2, ::2]) # every other row and columnIndexation booléenne (masquage)
Fournissez un tableau booléen de même forme pour sélectionner les éléments dont la valeur est True.
import numpy as np
arr = np.array([1, -2, 3, -4, 5])
mask = arr > 0
print(mask) # [ True False True False True]
print(arr[mask]) # [1 3 5]
arr[~mask] = 0 # set negatives to 0
print(arr) # [1 0 3 0 5]Indexation avancée avec des tableaux d’entiers
Fournissez un tableau d’indices entiers pour sélectionner plusieurs éléments précis.
import numpy as np
arr = np.array([10, 20, 30, 40, 50])
idx = np.array([0, 2, 4])
print(arr[idx]) # [10 30 50]
# 2-D fancy indexing:
m = np.arange(9).reshape(3,3)
print(m[[0,2], [0,2]]) # [m[0,0], m[2,2]] = [0, 8]np.where pour sélectionner selon des indices
np.where(condition) (avec un seul argument) renvoie les indices pour lesquels la condition vaut True.
import numpy as np
arr = np.array([5, 2, 8, 1, 9])
idx = np.where(arr > 4)[0]
print(idx) # [0 2 4]
print(arr[idx]) # [5 8 9]np.take et np.put
np.take(arr, indices) sélectionne des éléments (l’indexation à plat est prise en charge). np.put(arr, indices, values) insère des valeurs.
import numpy as np
arr = np.array([10, 20, 30, 40])
print(np.take(arr, [1, 3])) # [20 40]
np.put(arr, [0, 2], [99, 88])
print(arr) # [99 20 88 40]np.nonzero
np.nonzero(arr) renvoie un tuple de tableaux — un par dimension — contenant les indices des éléments non nuls.
import numpy as np
arr = np.array([[0,1,0],[2,0,3]])
rows, cols = np.nonzero(arr)
print(rows, cols) # [0 1 1] [1 0 2]Indexation avec des points de suspension
... (les points de suspension) s’étend en autant de : que nécessaire pour couvrir les dimensions restantes.
import numpy as np
arr = np.ones((2,3,4,5))
print(arr[0, ..., 2].shape) # (3, 4) — first dim=0, last dim=2
print(arr[..., 0].shape) # (2, 3, 4) — last dim=0np.ix_ pour l’indexation externe
np.ix_ construit un maillage ouvert à partir de plusieurs séquences à une dimension pour effectuer une indexation avancée de type produit externe.
import numpy as np
m = np.arange(25).reshape(5,5)
rows = [0, 2, 4]
cols = [1, 3]
print(m[np.ix_(rows, cols)])
# [[ 1 3]
# [11 13]
# [21 23]]Affecter des valeurs avec une indexation avancée
Vous pouvez affecter des valeurs directement à une sélection obtenue par indexation avancée.
import numpy as np
arr = np.zeros(5)
arr[[1, 3]] = [10, 20]
print(arr) # [ 0. 10. 0. 20. 0.]
# Broadcast a scalar:
arr[[0, 2, 4]] = 99
print(arr) # [99. 10. 99. 20. 99.]Différence entre vue et copie lors de l’indexation
Indexation de base ou par découpage → vue (une modification change l’original). Indexation avancée ou booléenne → copie (une modification ne change PAS l’original).
import numpy as np
arr = np.arange(5)
view = arr[1:4] # view
view[0] = 99
print(arr) # [0 99 2 3 4]
copy = arr[[1,2,3]] # fancy → copy
copy[0] = 0
print(arr) # unchangedVérification rapide
L’indexation booléenne ou avancée renvoie-t-elle une vue ou une copie ?
Récapitulatif
Utilisez [row, col] pour les éléments uniques, start:stop:step pour les découpages (vues), les tableaux booléens pour le masquage (copies) et les tableaux d’entiers pour l’indexation avancée (copies). Utilisez np.where pour obtenir les indices et np.ix_ pour les maillages externes.
Questions Fréquemment Posées
La leçon « Indexation, tranches et indexation avancée » est-elle gratuite ?
Oui — le texte complet de « Indexation, tranches et indexation avancée » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Indexation, tranches et indexation avancée » ?
Accédez aux éléments des tableaux et modifiez-les grâce à des techniques d’indexation avancées. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Python Academy ?
Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Indexation, tranches et indexation avancée » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?
Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Tableaux NumPy et dtypes
- Opérations sur les tableaux et broadcasting
- Indexation, tranches et indexation avancée
- Algèbre linéaire avec NumPy