Sort numpy.sort(a, axis=-1, kind='quicksort', order=None)
Use sort to sort in ascending order. If you want to sort in descending order, use [:: -1] as shown below.
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]
In the case of multidimensional, specify which axis data to sort. If omitted, it will be the last axis.
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]]
If you want to sort in descending order, use [:: -1] as in 1D.
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) If you don't want to sort the actual data, you can use argsort to return the index.
Sorted data can be created by using the index obtained by argsort for x [index]. If you want to sort in descending order, you can invert the index.
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]
In the case of multiple dimensions, it is basically the same as one dimension. However, even if the obtained index is used as it is as x [index], it will not work, so It is good to pass it one by one and retrieve the data as shown below.
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)
If you want transposed data, use transpose or T. The obtained data has an inverted axis. For example, in the case of 2D data A, the transposed TA is as follows. TA[x,y] = A[y,x] It is converted in the same way for 3 dimensions and above. 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]]
The following is the case of 3D, and you can see that the same value can be obtained by inverting the index and passing it.
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])
In transpose, you can specify the order of the axes to sort.
The following is an example when converting in the order of 2,0,1. This is effective when the image data of the Interleaved array that is lined up with RGBRGB is made into a Plane array like R, G, B.
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) Rotate the elements of the array
sign | direction |
---|---|
+ | forward |
- | backward |
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]
The axis can be selected to rotate. If nothing is specified, it will be flattened and then rotated to return to the original shape.
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)
Sort the size of each dimension of a ex.) If a is 2D and 3x4, then 4x3.
The movement is to move the axis to the start position.
It is difficult to understand intuitively, but if you break down the processing one by one, the processing will be as follows.
a. When the shape is 4 dimensions of (3,4,5,6) np.rollaxis(a, axis=3, start=1)
This is the process of taking out the size of the axis th dimension and putting it in the start th.
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)
a. When the shape is 4 dimensions of (3,4,5,6) np.rollaxis(a, axis=1, start=3)
print np.rollaxis(x, 1, 3).shape
(3, 5, 4, 6)
swapaxes numpy.swapaxes(a, axis1, axis2)
Swap axis1 and axis2
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]])
Recommended Posts