[Python] Référence Numpy, extraction, combinaison

Spécifiez un emplacement pour accéder

Dans le cas d'une dimension

Spécifiez avec X [index]. L'index des premières données sera 0. (Dans le cas de Matlab, c'est 1, donc c'est déroutant)

In [1]: import numpy as np

In [2]: X = np.arange(10)

In [3]: print X
[0 1 2 3 4 5 6 7 8 9]

In [4]: print X[0]
0

In [5]: print X[2]
2

Si vous voulez compter les dernières données et les spécifier, utilisez X [-index]. Il n'est pas nécessaire que ce soit X [len (X) -1] comme le langage C. L'index des dernières données est -1, et lorsque vous le spécifiez depuis le début, il commence à 0, donc cela a tendance à être un peu déroutant.

In [6]: print X[-1]
9

Dans le cas de deux dimensions

Dans le cas de plusieurs dimensions, spécifiez chacune en les séparant par une virgule (,). La méthode de spécification est la même que pour unidimensionnel.

In [17]: X = np.arange(25).reshape(5,5)

In [18]: print X
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]

In [19]: print X[3,2]
17

In [20]: print X[-1,-2]
23

Accès en spécifiant une plage

Dans le cas d'une dimension

Pour y accéder en spécifiant la plage, spécifiez comme X [début: fin: étape]. Notez que la fin n'est pas incluse pour le moment. (La fin est incluse dans Matlab.) Si le début est omis, ce sera depuis le début, si la fin est omis, ce sera la fin et si l'étape est omise, l'étape sera 1.

In [7]: print X[1:3]
[1 2]

In [8]: print X[3:]
[3 4 5 6 7 8 9]

In [9]: print X[:3]
[0 1 2]

In [10]: print X[:]
[0 1 2 3 4 5 6 7 8 9]

In [11]: print X[::]
[0 1 2 3 4 5 6 7 8 9]

In [12]: print X[::2]
[0 2 4 6 8]

Un indice négatif peut être spécifié pour le début et la fin. Si step est réglé sur moins, les données seront acquises à partir de la fin.

In [13]: print X[-3:-1]
[7 8]

In [14]: print X[-3:]
[7 8 9]

In [15]: print X[:-3]
[0 1 2 3 4 5 6]

In [16]: print X[::-1]
[9 8 7 6 5 4 3 2 1 0]

Dans le cas de deux dimensions

Dans le cas de plusieurs dimensions, spécifiez chacune en les séparant par une virgule (,). La méthode de spécification est la même que pour unidimensionnel.

In [57]: X = np.arange(25).reshape(5,5)

In [58]: print X
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]

In [59]: print X[1:3,0:2]
[[ 5  6]
 [10 11]]

In [60]: print X[1:3,::-1]
[[ 9  8  7  6  5]
 [14 13 12 11 10]]

Extraire des lignes

Les résultats des trois méthodes X [ligne], X [ligne,] et X [ligne,:] sont les mêmes. Cependant, X [row,] n'est pas recommandé car X [, col] ne peut pas être utilisé lors de l'extraction des colonnes décrites plus loin. La partie de ligne peut être spécifiée à un endroit ou dans une plage.

In [21]: print X[1]
[5 6 7 8 9]

In [22]: print X[1,]
[5 6 7 8 9]

In [23]: print X[1,:]
[5 6 7 8 9]

Extraire les colonnes

La colonne spécifiée par X [:, col] peut être extraite, mais le résultat extrait sera un tableau numpy unidimensionnel comme indiqué ci-dessous. Comme avec Matlab, si vous extrayez une colonne, elle devient un vecteur de colonne, vous pouvez donc l'utiliser pour le calcul matriciel tel quel, Dans le cas de numpy, le résultat extrait sera un tableau numpy à une dimension, donc soyez prudent lorsque vous utilisez ce résultat pour les opérations matricielles.

In [24]: print X[:,1]
[ 1  6 11 16 21]

Extraire les données qui remplissent les conditions

Si X <3, un tableau numpy est renvoyé dans lequel la partie qui satisfait la condition est True et la partie qui ne satisfait pas est False.

In [1]: import numpy as np

In [2]: X = np.arange(24,-1,-1).reshape(5,5)

In [3]: print X
[[24 23 22 21 20]
 [19 18 17 16 15]
 [14 13 12 11 10]
 [ 9  8  7  6  5]
 [ 4  3  2  1  0]]

In [4]: X < 3
Out[4]: 
array([[False, False, False, False, False],
       [False, False, False, False, False],
       [False, False, False, False, False],
       [False, False, False, False, False],
       [False, False,  True,  True,  True]], dtype=bool)

In [5]: X % 2 == 0
Out[5]: 
array([[ True, False,  True, False,  True],
       [False,  True, False,  True, False],
       [ True, False,  True, False,  True],
       [False,  True, False,  True, False],
       [ True, False,  True, False,  True]], dtype=bool)

Si vous définissez X [X <3] ou X [X% 2 == 0], la valeur de la pièce qui satisfait la condition est renvoyée.

In [6]: X[X<3]
Out[6]: array([2, 1, 0])

In [7]: X[X%2==0]
Out[7]: array([24, 22, 20, 18, 16, 14, 12, 10,  8,  6,  4,  2,  0])

Réécrire les données qui remplissent les conditions

Si X [X% 2 == 0] = 0, seule la partie True est réécrite.

In [8]: X[X%2==0]=0

In [9]: print X
[[ 0 23  0 21  0]
 [19  0 17  0 15]
 [ 0 13  0 11  0]
 [ 9  0  7  0  5]
 [ 0  3  0  1  0]]

L'intérieur de [] n'a pas besoin d'être une expression, mais il peut s'agir d'un tableau numpy dont l'emplacement de réécriture est True.

In [10]: X = np.arange(24,-1,-1).reshape(5,5)

In [11]: cond = X%2==0

In [12]: print cond
[[ True False  True False  True]
 [False  True False  True False]
 [ True False  True False  True]
 [False  True False  True False]
 [ True False  True False  True]]

In [13]: X[cond]=0

In [14]: print X
[[ 0 23  0 21  0]
 [19  0 17  0 15]
 [ 0 13  0 11  0]
 [ 9  0  7  0  5]
 [ 0  3  0  1  0]]

Récupère les valeurs de ligne et de colonne spécifiées.

Lors de la spécification d'une ligne

In [34]: X = np.arange(24,-1,-1).reshape(5,5)

In [35]: print X
[[24 23 22 21 20]
 [19 18 17 16 15]
 [14 13 12 11 10]
 [ 9  8  7  6  5]
 [ 4  3  2  1  0]]

In [36]: X[[1,3],:]
Out[36]: 
array([[19, 18, 17, 16, 15],
       [ 9,  8,  7,  6,  5]])

Lors de la spécification d'une colonne

In [37]: X[:,[0,2]]
Out[37]: 
array([[24, 22],
       [19, 17],
       [14, 12],
       [ 9,  7],
       [ 4,  2]])

Le cas où la ligne est spécifiée et le cas où la colonne est spécifiée sont combinés comme suit. Dans ce cas, les données de la 1ère ligne et de la 0ème colonne et de la 3ème ligne et de la 2ème colonne sont supprimées.

In [38]: X[[1,3],[0,2]]
Out[38]: array([19,  7])

Pour récupérer les données de la 1ère ou 3ème ligne et des 0ème et 2ème colonnes, utilisez np.ix_ comme indiqué ci-dessous. np.ix_ renvoie un tuple de tableau numpy contenant les numéros de ligne et de colonne.

In [39]: X[np.ix_([1,3],[0,2])]
Out[39]: 
array([[19, 17],
       [ 9,  7]])

In [40]: np.ix_([1,3],[1,2])
Out[40]: 
(array([[1],
        [3]]), array([[1, 2]]))

Extraire des emplacements non nuls

Pour Matlab, find est utilisé, mais pour numpy, une valeur différente de zéro () est utilisée. Sinon, il peut s'agir de np.where.

In [44]: X = np.arange(24,-1,-1).reshape(5,5)

In [45]: i,j=X.nonzero()

In [46]: print i
[0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4]

In [47]: print j
[0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3]

In [48]: X[i,j]
Out[48]: 
array([24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,
        7,  6,  5,  4,  3,  2,  1])

In [51]: i,j=np.where(X!=0)

In [52]: print i
[0 0 0 0 0 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3 4 4 4 4]

In [53]: print j
[0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3]

In [54]: X[i,j]
Out[54]: 
array([24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,
        7,  6,  5,  4,  3,  2,  1])

Combinez des tableaux numpy.

Combinez verticalement

utiliser vstack

In [76]: X = np.arange(5)

In [77]: Y = np.arange(4,-1,-1)

In [78]: print X
[0 1 2 3 4]

In [79]: print Y
[4 3 2 1 0]

In [80]: np.vstack((X,Y))
Out[80]: 
array([[0, 1, 2, 3, 4],
       [4, 3, 2, 1, 0]])

Joindre latéralement

utiliser hstack

In [81]: np.hstack((X,Y))
Out[81]: array([0, 1, 2, 3, 4, 4, 3, 2, 1, 0])

Lorsque X et Y sont transformés en vecteurs colonnes et connectés horizontalement, cela devient comme suit.

In [82]: X.reshape(len(X),1)
Out[82]: 
array([[0],
       [1],
       [2],
       [3],
       [4]])

In [83]: Y.reshape(len(Y),1)
Out[83]: 
array([[4],
       [3],
       [2],
       [1],
       [0]])

In [84]: np.hstack((X.reshape(len(X),1),Y.reshape(len(Y),1)))
Out[84]: 
array([[0, 4],
       [1, 3],
       [2, 2],
       [3, 1],
       [4, 0]])

Précautions pour la transposition d'un tableau numpy unidimensionnel

X.transpose a l'air bien, mais la transposition d'un tableau numpy unidimensionnel ne fait rien. Vous pouvez en faire un vecteur de colonne en le rendant bidimensionnel puis en le transposant. transposer signifie transposer.

In [87]: X.transpose()
Out[87]: array([0, 1, 2, 3, 4])

In [88]: X.reshape(1,len(X))
Out[88]: array([[0, 1, 2, 3, 4]])

In [89]: X.reshape(1,len(X)).transpose()
Out[89]: 
array([[0],
       [1],
       [2],
       [3],
       [4]])

Combiner des images

Les matrices de jonction peuvent également être utilisées pour coller des images ensemble.

ipython

In [102]: from skimage import data

In [103]: from skimage import io

In [104]: image = data.lena()

In [105]: image.shape
Out[105]: (512, 512, 3)

In [106]: patch1 = image[200:200+32,200:200+32,:]

In [107]: patch2 = image[300:300+32,300:300+32,:]

In [108]: patch12 = np.hstack((patch1,patch2))

image 

patch1

patch2

patch12