[Python] Numpy Referenz, Extraktion, Kombination

Geben Sie einen Ort an, auf den zugegriffen werden soll

Im Falle einer Dimension

Geben Sie mit "X [Index]" an. Der Index der ersten Daten ist 0. (Im Fall von Matlab ist es 1, also verwirrend)

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

Wenn Sie die letzten Daten zählen und angeben möchten, verwenden Sie "X [-index]". Es muss nicht "X [len (X) -1]" wie die C-Sprache sein. Der Index der letzten Daten ist -1, und wenn Sie ihn von Anfang an angeben, beginnt er bei 0, sodass er etwas verwirrend ist.

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

Bei zwei Dimensionen

Geben Sie bei mehreren Dimensionen jede an, indem Sie sie durch ein Komma (,) trennen. Die Spezifikationsmethode ist dieselbe wie für eindimensional.

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

Zugriff durch Angabe eines Bereichs

Im Falle einer Dimension

Geben Sie für den Zugriff durch Angabe des Bereichs "X [Start: Ende: Schritt]" an. Beachten Sie, dass das Ende derzeit nicht enthalten ist. (Ende ist in Matlab enthalten.) Wenn Start weggelassen wird, ist es von Anfang an, wenn Ende weggelassen wird, ist es das Ende, und wenn Schritt weggelassen wird, ist Schritt 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]

Für Start und Ende kann ein negativer Index angegeben werden. Wenn der Schritt auf Minus gesetzt ist, werden die Daten vom Ende erfasst.

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]

Bei zwei Dimensionen

Geben Sie bei mehreren Dimensionen jede an, indem Sie sie durch ein Komma (,) trennen. Die Spezifikationsmethode ist dieselbe wie für eindimensional.

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]]

Zeilen extrahieren

Die Ergebnisse der drei Methoden X [Zeile], X [Zeile,] und X [Zeile ,:] sind gleich. X [row,] wird jedoch nicht empfohlen, da X [, col] beim Extrahieren der später beschriebenen Spalten nicht verwendet werden kann. Der Zeilenteil kann an einer Stelle oder in einem Bereich angegeben werden.

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]

Spalten extrahieren

Die durch X [:, col] angegebene Spalte kann extrahiert werden, das extrahierte Ergebnis ist jedoch ein eindimensionales Numpy-Array, wie unten gezeigt. Wie bei Matlab wird eine Spalte beim Extrahieren zu einem Spaltenvektor, sodass Sie sie so wie sie ist für die Matrixberechnung verwenden können. Im Fall von Numpy ist das extrahierte Ergebnis ein eindimensionales Numpy-Array. Seien Sie also vorsichtig, wenn Sie dieses Ergebnis für Matrixoperationen verwenden.

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

Extrahieren Sie Daten, die die Bedingungen erfüllen

Wenn X <3 ist, wird ein Numpy-Array zurückgegeben, in dem der Teil, der die Bedingung erfüllt, True ist und der Teil, der die Bedingung nicht erfüllt, False ist.

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)

Wenn Sie "X [X <3]" oder "X [X% 2 == 0]" setzen, wird der Wert des Teils zurückgegeben, der die Bedingung erfüllt.

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])

Schreiben Sie Daten neu, die die Bedingungen erfüllen

Wenn "X [X% 2 == 0] = 0" ist, wird nur der True-Teil neu geschrieben.

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]]

Das Innere von [] muss kein Ausdruck sein, aber es kann sich um ein Numpy-Array handeln, dessen Umschreibort True ist.

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]]

Ruft die angegebenen Zeilen- und Spaltenwerte ab.

Bei der Angabe einer Zeile

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]])

Bei der Angabe einer Spalte

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

Der Fall, in dem die Zeile angegeben wird, und der Fall, in dem die Spalte angegeben wird, werden wie folgt kombiniert. Dabei werden die Daten der 1. Zeile und 0. Spalte sowie der 3. Zeile und 2. Spalte herausgenommen.

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

Verwenden Sie np.ix_ wie unten gezeigt, um die Daten in der 1. oder 3. Zeile sowie in der 0. und 2. Spalte abzurufen. np.ix_ gibt ein Tupel eines numpy-Arrays zurück, das Zeilen- und Spaltennummern enthält.

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]]))

Extrahieren Sie Positionen ungleich Null

Für Matlab wird find verwendet, für numpy wird ungleich Null () verwendet. Alternativ kann es np.where sein.

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])

Kombinieren Sie numpy Arrays.

Vertikal kombinieren

benutze 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]])

Seitwärts verbinden

benutze hstack

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

Wenn X und Y zu Spaltenvektoren gemacht und horizontal verbunden werden, wird dies wie folgt.

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]])

Vorsichtsmaßnahmen für die Transponierung eines eindimensionalen Numpy-Arrays

X.transponieren sieht gut aus, aber das Transponieren eines eindimensionalen Numpy-Arrays bringt nichts. Sie können es zu einem Spaltenvektor machen, indem Sie es zweidimensional machen und dann transponieren. transponieren bedeutet transponieren.

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]])

Bilder kombinieren

Das Verbinden von Matrizen kann auch zum Zusammenkleben von Bildern verwendet werden.

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