En Python, vous pouvez utiliser slice [start:stop:step] pour sélectionner une partie d’un objet séquence, comme une liste, une chaîne ou un tuple pour obtenir une valeur ou affecter une autre valeur.
Il est également possible de sélectionner un sous-tableau en le découpant pour le tableau NumPy numpy.ndarray et d’extraire une valeur ou d’attribuer une autre valeur.
Cet article décrit les éléments suivants :
- Bases de coupe
- Secteur pour numpy.one-dimensional darray
- Tranche pour numpy.ndarray multidimensionnel
- vues et copies
- Avec une indexation élégante
Consultez l’article suivant pour savoir comment extraire les lignes et les colonnes qui remplissent les conditions.
Bases de coupe
En Python, vous pouvez utiliser slice [start:stop:step] pour sélectionner une partie d’un objet séquence, comme une liste, une chaîne ou un tuple pour obtenir une valeur ou affecter une autre valeur.
import numpy as np
l = list(range(10))
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l[4:8])
# [4, 5, 6, 7]
print(l[-5:-2])
# [5, 6, 7]
print(l[::-1])
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
Le découpage est une fonction standard en Python. Consultez l’article suivant pour plus d’informations.
Secteur pour numpy.one-dimensional darray
Obtenir un sous-tableau
Le segment pour le numpy.ndarray unidimensionnel est le même que le segment Python de base comme dans l’exemple ci-dessus.
a = np.arange(10)
print(a)
# [0 1 2 3 4 5 6 7 8 9]
print(a[4:8])
# [4 5 6 7]
print(a[-5:-2])
# [5 6 7]
print(a[::-1])
# [9 8 7 6 5 4 3 2 1 0]
Attribuer une autre valeur
Le comportement d’affectation de segment est différent pour list et numpy.ndarray.
Voir l’article suivant pour voir l’attribution à la liste par secteur. Le nombre d’éléments sélectionnés par tranche et le nombre d’éléments à allouer ne doivent pas nécessairement correspondre.
Dans numpy.ndarray, la valeur sur le côté droit est convertie par diffusion et attribuée.
Si le côté droit est une valeur scalaire, tous les éléments sélectionnés par le segment seront remplacés par cette valeur scalaire. Si le côté droit est un tableau unidimensionnel, il sera remplacé par ce tableau.
a[3:6] = 100
print(a)
# [ 0 1 2 100 100 100 6 7 8 9]
a[3:6] = [100, 200, 300]
print(a)
# [ 0 1 2 100 200 300 6 7 8 9]
Lors de l’allocation d’un tableau, si le nombre d’éléments du tableau à allouer et le nombre d’éléments sélectionnés dans la tranche ne correspondent pas, une ValueError est déclenchée.
# a[3:6] = [100, 200, 300, 400]
# ValueError: cannot copy sequence with size 4 to array axis with dimension 3
Il en va de même pour les secteurs pour lesquels l’échelon est spécifié.
a = np.arange(10)
print(a)
# [0 1 2 3 4 5 6 7 8 9]
print(a[2:8:2])
# [2 4 6]
a[2:8:2] = 100
print(a)
# [ 0 1 100 3 100 5 100 7 8 9]
a[2:8:2] = [100, 200, 300]
print(a)
# [ 0 1 100 3 200 5 300 7 8 9]
Tranche pour numpy.ndarray multidimensionnel
Pour numpy.ndarray multidimensionnel, des parties de chaque dimension peuvent être spécifiées séparées par des virgules.
Prenons le tableau à deux dimensions suivant comme exemple.
a = np.arange(12).reshape((3, 4))
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
Obtenir un sous-tableau
Spécifiez des tranches pour chaque dimension séparées par des virgules.
print(a[1:, 1:3])
# [[ 5 6]
# [ 9 10]]
sélectionner des lignes
Vous pouvez sélectionner des lignes en utilisant :. Dans ce cas, la terminaison : peut être omise.
print(a[1:, :])
# [[ 4 5 6 7]
# [ 8 9 10 11]]
print(a[1:])
# [[ 4 5 6 7]
# [ 8 9 10 11]]
Lors de la sélection d’une ligne, si vous spécifiez l’index par la valeur scalaire au lieu du segment, elle sera sélectionnée comme un tableau unidimensionnel, mais si vous sélectionnez une ligne par le segment, elle sera sélectionnée comme un tableau bidimensionnel .
print(a[1])
# [4 5 6 7]
print(a[1].shape)
# (4,)
print(a[1:2])
# [[4 5 6 7]]
print(a[1:2].shape)
# (1, 4)
Soyez prudent dans les cas où la forme est importante, comme les opérations matricielles.
Sélectionner les colonnes
Il en va de même pour la sélection des colonnes. Dans ce cas, le premier : ne peut pas être omis.
print(a[:, 1:3])
# [[ 1 2]
# [ 5 6]
# [ 9 10]]
print(a[:, 1])
# [1 5 9]
print(a[:, 1].shape)
# (3,)
print(a[:, 1:2])
# [[1]
# [5]
# [9]]
print(a[:, 1:2].shape)
# (3, 1)
Vous pouvez utiliser … si : se répète. Voir l’article suivant.
Attribuer une autre valeur
Comme dans le cas d’un numpy.ndarray unidimensionnel, dans l’affectation à un numpy.ndarray multidimensionnel, la valeur du côté droit est castée et affectée.
Lors de l’allocation d’un tableau, une ValueError est déclenchée si le nombre d’éléments du tableau à allouer et le nombre d’éléments correspondants sélectionnés par la tranche ne correspondent pas.
a = np.arange(12).reshape((3, 4))
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
print(a[1:, 1:3])
# [[ 5 6]
# [ 9 10]]
a[1:, 1:3] = 100
print(a)
# [[ 0 1 2 3]
# [ 4 100 100 7]
# [ 8 100 100 11]]
a[1:, 1:3] = [100, 200]
print(a)
# [[ 0 1 2 3]
# [ 4 100 200 7]
# [ 8 100 200 11]]
a[1:, 1:3] = [[100, 200], [300, 400]]
print(a)
# [[ 0 1 2 3]
# [ 4 100 200 7]
# [ 8 300 400 11]]
Il en va de même pour les secteurs pour lesquels l’échelon est spécifié.
a = np.arange(12).reshape((3, 4))
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
print(a[1:, ::2])
# [[ 4 6]
# [ 8 10]]
a[1:, ::2] = 100
print(a)
# [[ 0 1 2 3]
# [100 5 100 7]
# [100 9 100 11]]
a[1:, ::2] = [100, 200]
print(a)
# [[ 0 1 2 3]
# [100 5 200 7]
# [100 9 200 11]]
a[1:, ::2] = [[100, 200], [300, 400]]
print(a)
# [[ 0 1 2 3]
# [100 5 200 7]
# [300 9 400 11]]
vues et copies
Le sous-tableau extrait par la tranche est une vue du tableau d’origine, et la modification des éléments du sous-tableau modifie également les éléments du tableau d’origine.
a = np.arange(12).reshape((3, 4))
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
a_slice = a[1:, 1:3]
print(a_slice)
# [[ 5 6]
# [ 9 10]]
a_slice[0, 0] = 100
print(a_slice)
# [[100 6]
# [ 9 10]]
print(a)
# [[ 0 1 2 3]
# [ 4 100 6 7]
# [ 8 9 10 11]]
Vous pouvez faire une copie d’un sous-tableau en utilisant copy(). La modification des éléments de la copie ne modifie pas les éléments du tableau d’origine.
a = np.arange(12).reshape((3, 4))
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
a_slice_copy = a[1:, 1:3].copy()
print(a_slice_copy)
# [[ 5 6]
# [ 9 10]]
a_slice_copy[0, 0] = 100
print(a_slice_copy)
# [[100 6]
# [ 9 10]]
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
Consultez l’article suivant pour plus d’informations sur les vues et les copies dans numpy.ndarray.
Avec une indexation élégante
Dans NumPy, vous pouvez sélectionner un sous-tableau de numpy.ndarray à l’aide d’une liste d’indices.
Les sous-réseaux peuvent être sélectionnés en combinant une indexation et une découpe sophistiquées.
a = np.arange(12).reshape((3, 4))
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
print(a[[0, 2], 1:3])
# [[ 1 2]
# [ 9 10]]
a[[0, 2], 1:3] = 100
print(a)
# [[ 0 100 100 3]
# [ 4 5 6 7]
# [ 8 100 100 11]]
a[[0, 2], 1:3] = [100, 200]
print(a)
# [[ 0 100 200 3]
# [ 4 5 6 7]
# [ 8 100 200 11]]
a[[0, 2], 1:3] = [[100, 200], [300, 400]]
print(a)
# [[ 0 100 200 3]
# [ 4 5 6 7]
# [ 8 300 400 11]]
Notez que le sous-tableau extrait par indexation élégante est une copie, pas une vue.
a_subset = a[[0, 2], 1:3]
print(a_subset)
# [[100 200]
# [300 400]]
a_subset[0, 0] = -1
print(a_subset)
# [[ -1 200]
# [300 400]]
print(a)
# [[ 0 100 200 3]
# [ 4 5 6 7]
# [ 8 300 400 11]]