Indexation des tableaux 2D

Question

Comment puis-je faire l'indexation de certains tableaux utilisés comme indices ? J'ai les six tableaux 2D suivants, comme ceci-

array([[2, 0],
   [3, 0],
   [3, 1],
   [5, 0],
   [5, 1],
   [5, 2]])

Je veux utiliser ces tableaux comme indices et mettre la valeur 10 dans les indices correspondants d'une nouvelle matrice vide. Le résultat devrait ressembler à ceci

array([[ 0,  0,  0],
   [ 0,  0,  0],
   [10,  0,  0],
   [10, 10,  0],
   [ 0,  0,  0],
   [10, 10, 10]])

Jusqu'à présent, j'ai essayé ceci

from numpy import*
a = array([[2,0],[3,0],[3,1],[5,0],[5,1],[5,2]])
b = zeros((6,3),dtype ='int32')
b[a] = 10

Mais cela me donne le mauvais résultat.

Answer 1

In [1]: import numpy as np
In [2]: a = np.array([[2,0],[3,0],[3,1],[5,0],[5,1],[5,2]])
In [3]: b = np.zeros((6,3), dtype='int32')

In [4]: b[a[:,0], a[:,1]] = 10

In [5]: b
Out[5]: 
array([[ 0,  0,  0],
       [ 0,  0,  0],
       [10,  0,  0],
       [10, 10,  0],
       [ 0,  0,  0],
       [10, 10, 10]])

---

Pourquoi ça marche :

Si vous indexez b con deux des tableaux numpy dans une affectation,

b[x, y] = z

alors pensez à NumPy comme se déplaçant simultanément sur chaque élément de x et chaque élément de y et chaque élément de z (appelons-les xval , yval y zval ), et en attribuant à b[xval, yval] la valeur zval . Quand z est une constante, "se déplacer sur z renvoie simplement la même valeur à chaque fois.

C'est ce que nous voulons, avec x étant la première colonne de a y y étant la deuxième colonne de a . Ainsi, on choisit x = a[:, 0] y y = a[:, 1] .

b[a[:,0], a[:,1]] = 10

---

Pourquoi b[a] = 10 ne fonctionne pas

Lorsque vous écrivez b[a] Pour créer un nouveau tableau, pensez à NumPy qui crée un nouveau tableau en déplaçant chaque élément de a (appelons chacun d'eux idx ) et en plaçant dans le nouveau tableau la valeur de b[idx] à l'emplacement de idx en a .

idx est une valeur dans a . Il s'agit donc d'un int32. b est de forme (6,3), donc b[idx] est une ligne de b de forme (3,). Par exemple, lorsque idx es

In [37]: a[1,1]
Out[37]: 0

b[a[1,1]] es

In [38]: b[a[1,1]]
Out[38]: array([0, 0, 0])

Alors

In [33]: b[a].shape
Out[33]: (6, 2, 3)

Donc répétons : NumPy crée un nouveau tableau en déplaçant chaque élément de a et en plaçant dans le nouveau tableau la valeur de b[idx] à l'emplacement de idx en a . Comme idx se déplace a un tableau de forme (6,2) sera créé. Mais comme b[idx] est lui-même de forme (3,), à chaque emplacement du tableau de forme (6,2), une valeur de forme (3,) est placée. Le résultat est un tableau de forme (6,2,3).

Maintenant, quand vous faites une mission comme

b[a] = 10

un tableau temporaire de forme (6,2,3) avec des valeurs b[a] est créé, puis l'affectation est effectuée. Puisque 10 est une constante, cette affectation place la valeur 10 à chaque emplacement du tableau de forme (6,2,3). Ensuite, les valeurs du tableau temporaire sont réaffectées dans le tableau suivant b . Voir référence aux documents . Ainsi, les valeurs du tableau de forme (6,2,3) sont recopiées dans le tableau de forme (6,3). b réseau. Les valeurs s'écrasent les unes les autres. Mais l'essentiel est que vous n'obtenez pas les affectations souhaitées.