[Python] Numpy Daten sortieren

Sort numpy.sort(a, axis=-1, kind='quicksort', order=None)

Im Falle einer Dimension

Verwenden Sie sort, um in aufsteigender Reihenfolge zu sortieren. Wenn Sie in absteigender Reihenfolge bestellen möchten, verwenden Sie [:: -1] wie unten gezeigt.

In [3]: x = np.random.randint(0, 100, size=10)

In [4]: print x
[63 82 80 93 65 96 97 75  2 61]

In [5]: print np.sort(x)
[ 2 61 63 65 75 80 82 93 96 97]

In [6]: print np.sort(x)[::-1]
[97 96 93 82 80 75 65 63 61  2]

Für mehrdimensionale

Geben Sie für mehrdimensional an, welche Achsendaten sortiert werden sollen. Wenn nicht angegeben, ist dies die letzte Achse.

In [7]: x = np.random.randint(0, 100, size=(2,10))

In [8]: print x
[[43 70 88 99  0 83 51 17 19 58]
 [11 89 94 11  8 28  9 54 74 67]]

In [9]: print np.sort(x)
[[ 0 17 19 43 51 58 70 83 88 99]
 [ 8  9 11 11 28 54 67 74 89 94]]

In [10]: print np.sort(x,axis=0)
[[11 70 88 11  0 28  9 17 19 58]
 [43 89 94 99  8 83 51 54 74 67]]

Wenn Sie absteigende Reihenfolge verwenden möchten, verwenden Sie [:: -1] wie in der ersten Dimension.

In [11]: print x
[[43 70 88 99  0 83 51 17 19 58]
 [11 89 94 11  8 28  9 54 74 67]]

In [12]: print np.sort(x)[:,::-1]
[[99 88 83 70 58 51 43 19 17  0]
 [94 89 74 67 54 28 11 11  9  8]]

In [13]: print np.sort(x,axis=0)[::-1]
[[43 89 94 99  8 83 51 54 74 67]
 [11 70 88 11  0 28  9 17 19 58]]

argsort numpy.argsort(a, axis=-1, kind='quicksort', order=None) Wenn Sie die tatsächlichen Daten nicht sortieren möchten, verwenden Sie argsort und es wird ein Index zurückgegeben.

Für eine Dimension

Sortierte Daten können mithilfe des von argsort für x [index] erhaltenen Index erstellt werden. Wenn Sie es in absteigender Reihenfolge machen möchten, können Sie den Index invertieren.

In [14]: x = np.random.randint(0, 100, size=10)

In [15]: print x
[16 52 64 37 50 68  5 87 99 69]

In [16]: print np.argsort(x)
[6 0 3 4 1 2 5 9 7 8]

In [17]: print x[np.argsort(x)]
[ 5 16 37 50 52 64 68 69 87 99]

In [18]: print x[np.argsort(x)[::-1]]
[99 87 69 68 64 52 50 37 16  5]

Für mehrdimensionale

Bei mehreren Dimensionen entspricht dies im Wesentlichen einer Dimension. Selbst wenn der erhaltene Index so verwendet wird, wie er als x [Index] ist, funktioniert er nicht Es ist gut, sie einzeln zu übergeben und die Daten wie unten gezeigt abzurufen.

In [31]: x = np.random.randint(0, 100, size=(2,10))

In [32]: print x
[[31 72 21 18 47 33 88 12 92 19]
 [55 62 19 69 43 65 95 28 20 33]]

In [33]: index = np.argsort(x)

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

In [35]: print np.array([x[0,index[0,:]],x[1,index[1,:]]])
[[12 18 19 21 31 33 47 72 88 92]
 [19 20 28 33 43 55 62 65 69 95]]

In [36]: print np.array([x[0,index[0,::-1]],x[1,index[1,::-1]]])
[[92 88 72 47 33 31 21 19 18 12]
 [95 69 65 62 55 43 33 28 20 19]]

transpose numpy.transpose(a, axes=None)

Wenn Sie transponierte Daten wünschen, verwenden Sie transponieren oder T. Die erhaltenen Daten haben eine umgekehrte Achse. Beispielsweise ist im Fall von 2D-Daten A der transponierte TA wie folgt. TA[x,y] = A[y,x] Es wird auf die gleiche Weise für 3 oder mehr Dimensionen konvertiert. TA[x,y,z] = A[z,y,x]

In [38]: x = np.array([[0,1,2]])

In [39]: print x
[[0 1 2]]

In [40]: print x.T
[[0]
 [1]
 [2]]

In [41]: x = np.array(range(4)).reshape(2,2)

In [42]: print x
[[0 1]
 [2 3]]

In [43]: print x.transpose()
[[0 2]
 [1 3]]

Das Folgende ist der Fall von 3D, und Sie können sehen, dass der gleiche Wert erhalten werden kann, indem Sie den Index invertieren und übergeben.

In [44]: x = np.array(range(8)).reshape(2,2,2)

In [45]: xT = x.T

In [46]: print 'x', x
x [[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]

In [47]: print 'x.T', xT
x.T [[[0 4]
  [2 6]]

 [[1 5]
  [3 7]]]

In [48]: idx = np.array([[i//4,(i//2)%2,i%2] for i in range(8)])

In [49]: x[idx[:,0],idx[:,1],idx[:,2]]
Out[49]: array([0, 1, 2, 3, 4, 5, 6, 7])

In [50]: xT[idx[:,2],idx[:,1],idx[:,0]]
Out[50]: array([0, 1, 2, 3, 4, 5, 6, 7])

Bei Angabe der zu sortierenden Reihenfolge

Bei der Transponierung können Sie die Reihenfolge der zu sortierenden Achsen angeben.

Das Folgende ist ein Beispiel für die Konvertierung in der Größenordnung von 2,0,1. Dies ist effektiv, wenn die Bilddaten des verschachtelten Arrays, das mit RGBRGB ausgerichtet ist, in ein Ebenenarray wie R, G, B konvertiert werden.

In [53]: print x
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]

In [54]: print x.transpose(2,0,1)
[[[0 2]
  [4 6]]

 [[1 3]
  [5 7]]]

In [63]: I = sp.misc.imread('./data/SIDBA/Lenna.bmp')

In [64]: r, g, b = I.transpose(2,0,1)

In [65]: np.sum(np.abs(r - I[:,:,0])) + np.sum(np.abs(g - I[:,:,1])) + np.sum(np.abs(b - I[:,:,2]))
Out[65]: 0

import matplotlib.pyplot as plt
import matplotlib.cm as cm

fig, axes = plt.subplots(ncols=4, figsize=(12,8))
axes[0].set_title('color')
axes[0].imshow(I)
axes[0].get_xaxis().set_visible(False)
axes[0].get_yaxis().set_visible(False)

axes[1].set_title('R')
axes[1].imshow(r, cmap=cm.Greys_r, vmin=0,vmax=255)
axes[1].get_xaxis().set_visible(False)
axes[1].get_yaxis().set_visible(False)

axes[2].set_title('G')
axes[2].imshow(g, cmap=cm.Greys_r, vmin=0,vmax=255)
axes[2].get_xaxis().set_visible(False)
axes[2].get_yaxis().set_visible(False)

axes[3].set_title('B')
axes[3].imshow(b, cmap=cm.Greys_r, vmin=0,vmax=255)
axes[3].get_xaxis().set_visible(False)
axes[3].get_yaxis().set_visible(False)

roll numpy.roll(a, shift, axis=None) Drehen Sie die Elemente des Arrays

Für eine Dimension

In [88]: x = np.arange(10)

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

In [90]: print np.roll(x, 1)
[9 0 1 2 3 4 5 6 7 8]

In [91]: print np.roll(x, -1)
[1 2 3 4 5 6 7 8 9 0]

Für mehrdimensionale

Die zu drehende Achse kann nach Achse ausgewählt werden. Wenn nichts angegeben ist, wird es abgeflacht und dann gedreht, um zur ursprünglichen Form zurückzukehren.

In [92]: x = np.arange(20).reshape(2,10)

In [93]: print x
[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]]

In [94]: print np.roll(x, 2)
[[18 19  0  1  2  3  4  5  6  7]
 [ 8  9 10 11 12 13 14 15 16 17]]

In [95]: print np.roll(x, 1, axis=0)
[[10 11 12 13 14 15 16 17 18 19]
 [ 0  1  2  3  4  5  6  7  8  9]]

In [96]: print np.roll(x, 1, axis=1)
[[ 9  0  1  2  3  4  5  6  7  8]
 [19 10 11 12 13 14 15 16 17 18]]

rollaxis numpy.rollaxis(a, axis, start=0)

Sortieren Sie die Größe jeder Dimension von a ex.) Wenn a 2D und 3x4 ist, dann 4x3.

Die Bewegung besteht darin, die Achse in die Startposition zu bewegen.

Es ist schwer intuitiv zu verstehen, aber wenn Sie die Verarbeitung einzeln aufteilen, ist die Verarbeitung wie folgt.

Wenn a.shape 4 Dimensionen von (3,4,5,6) ist np.rollaxis(a, axis=3, start=1)

1. axes = list(range(a.ndim)) ... [0,1,2,3]
2. axes.remove(axis) ... [0,1,2]
3. axes.insert(start, axis) ... [0,3,1,2]
4. return a.transpose(axes) ... a.shape (3,6,4,5)

Dies ist der Vorgang, bei dem die Größe der Achse der Dimension herausgenommen und an die Startposition gesetzt wird.

In [15]: x = np.arange(3*4*5*6).reshape(3,4,5,6)

In [16]: print x.shape
(3, 4, 5, 6)

In [17]: print np.rollaxis(x, 3, 1).shape
(3, 6, 4, 5)

Wenn a.shape 4 Dimensionen von (3,4,5,6) ist np.rollaxis(a, axis=1, start=3)

1. axes = list(range(a.ndim)) ... [0,1,2,3]
2. axes.remove(axis) ... [0,2,3]
3. Achsen einfügen (Start, Achse) ... [0,2,1,3] ... Seien Sie vorsichtig, wo Sie einfügen
4. return a.transpose(axes) ... a.shape (3,5,4,6)

print np.rollaxis(x, 1, 3).shape
(3, 5, 4, 6)

swapaxes numpy.swapaxes(a, axis1, axis2)

Achse1 und Achse2 tauschen

In [4]: x = np.arange(3*4).reshape(3,4)

In [5]: x
Out[5]: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

In [6]: y = np.swapaxes(x,0,1)

In [7]: y
Out[7]: 
array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])