numpy(排序，搜索和计数,集合操作)

排序

• np.sort

(array,axis= ,kind='quicksort ',order=None)

axis:0按列，1按行，-1沿最后的轴排序

kind：排序的算法 有快排’quicksort’、混排’mergesort’、堆排’heapsort’

order：可指定字段排序

• np.argsort

  进行间接排序，并返回索引值

x = np.random.randint(0, 10, 10)
[7 5 9 8 3 4 6 0 7 1]
y=np.argsort(x) 当取-x时则是从大到小排序
[7 9 4 5 1 6 0 8 3 2] 索引值
[0 1 3 4 5 6 7 7 8 9] 排序结果
           

• np.lexsort(array[ , axis=])

返回的是一个索引数组，用于多个列排序的顺序

keys参数必须是可以转换为相同形状的数组的对象序列

按照第一列的升序或者降序对整体数据进行排序

一维度：
x = np.array([1, 5, 1, 4, 3, 4, 4])
[1 5 1 4 3 4 4]
a = np.lexsort([-1*x])
[5 4 4 4 3 1 1]
a = np.lexsort([x])
[1 1 3 4 4 4 5]

二维度：
x = np.array([[1, 5, 1, 4, 3, 4, 4], 
[9, 4, 0, 4, 0, 2, 1], 
[4, 2, 3, 4, 5, 6, 7]])

[[1 5 1 4 3 4 4]
 [9 4 0 4 0 2 1]
 [4 2 3 4 5 6 7]]
 index=np.lexsort([x[:,0]]) 从小到大 [0 2 1]
 
 [[1 5 1 4 3 4 4]
 [4 2 3 4 5 6 7]
 [9 4 0 4 0 2 1]]
 
index=np.lexsort([-1*x[:,0]])从大到小 [1 2 0]

[[9 4 0 4 0 2 1]
 [4 2 3 4 5 6 7]
 [1 5 1 4 3 4 4]]
 
           

• np.partition(a, kth, axis=-1, kind=‘introselect’, order=None)

  索引是以kth为基准，将数组分成两部分，大于在下面，小于在上面

x = np.random.randint(1, 30, [5, 3])
[[19 16  3]
 [11 23 27]
 [27 10  6]
 [16 10 16]
 [11 14 18]]

z = np.partition(x, kth=1, axis=0)
注：在两区间内的值不分大小
[[14 10 19]
 [ 3  3 19]
 [12 19 27]
 [27 16 12]
 [16 25 19]]
 此时将数组按照列排列，且以[12 10 19]每一列第二小的数作为基准，
[[ 3  3 12]
 [12 10 19]
 [14 19 27]
 [27 16 19]
 [16 25 19]]
 该操作可理解为：
 np.sort(x,axis=0) 进行按列排列
 [[ 3  3 12]
 [12 10 19]
 [14 16 19]
 [16 19 19]
 [27 25 27]]
 z[1]=[12 10 19] 基准
           

• np.argpartition(a, kth, axis=-1, kind=‘introselect’, order=None)

逻辑与上同但获取的是索引值，也是对索引值进行间接排序

x = np.random.randint(1, 30, [5, 3])
[[29  2  9]
 [23 29 13]
 [ 9  1 21]
 [ 1 14 25]
 [21 17  8]]
 
 z=np.argpartition(x,kth=1,axis=0)
 
 [[3 2 4]
 [2 0 0]
 [1 1 2]
 [0 3 3]
 [4 4 1]]

操作解释：
b=np.argsort(x,axis=0)
[[3 2 4]
 [2 0 0]
 [4 3 1]
 [1 4 2]
 [0 1 3]]
 
z[1]=[2 0 0]
           

搜索

• np.argmax(a[, axis=None, out=None])

  返回沿轴的最大值的索引

x = np.array([1, 5, 1, 4, 3, 4, 4])
y=np.argmax(x)
1
           

• np.argmin(a[, axis=None, out=None])

  返回沿轴的最小值的索引

x = np.array([1, 5, 1, 4, 3, 4, 4])
y=np.argmin(x)
0
           

• np.nonzero(a)

  返回非零元素的下标

  1.只有非0元素会有索引值

  2.每一个array均是从一个维度上来描述索引值。比如，如果a是一个二维数组，第一个array从行维度来描述索引值；第二个array就从列维度来描述

  3.a[nonzero(a)]得到a中的非零值

x = np.array([1, 5, 1, 4, 0,3, 4, 4,0])
[1 5 1 4 0 3 4 4 0]
y=np.nonzero(x)
(array([0, 1, 2, 3, 5, 6, 7], dtype=int64),)非0的索引值
x=x[y]
[1 5 1 4 3 4 4] 所有非0元素的值
           

• np.where(condition, [x=None, y=None])

  根据条件返回从x或y中选择的元素

1.当有x,y时满足条件condition，输出x，不满足输出y：
x = np.array([1, 5, 1, 4, 0,3, 4, 4,0])
y=np.where(x<2,x,2)
[1 2 1 2 0 2 2 2 0]
2.当只有condition，没有x和y时，输出满足条件元素的下标（等价于numpy.nonzero）
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = np.where(x > 5)
(array([5, 6, 7], dtype=int64),)
x[y]=[6,7,8]
           

计数

numpy.count_nonzero()：计数数组a中非零值的数量

x = np.array([1, 5, 1, 4, 0,3, 4, 4,0])
y=np.count_nonzero(x)
7
           

集合操作

• 构造集合numpy.unique(ar) 返回数组中唯一的元素

  1.return_index=True ：返回新列表元素在旧列表中的位置。

  2.return_inverse=True：返回旧列表元素在新列表中的位置。

  3.return_counts=True：返回新列表元素在旧列表中出现的次数

x = np.unique([1, 1, 3, 2, 3, 3],return_index=True,return_inverse=True,return_counts=True)

(array([1, 2, 3]), array([0, 3, 2], dtype=int64), array([0, 0, 2, 1, 2, 2], dtype=int64), array([2, 1, 3], dtype=int64))
           

• numpy.in1d(ar1, ar2)判断前数组是否包含于后数组并返回布尔值
• 求交集numpy.intersect1d(ar1, ar2)
• 求并集numpy.union1d(ar1, ar2)
• 求差集，即元素存在于第一个函数不存在于第二个函数中numpy.setdiff1d(ar1, ar2)
• 求异或setxor1d(ar1, ar2, assume_unique=False)