排序搜索计数及集合操作_搜索记数-CSDN博客

axis：排序沿数组的（轴）方向，0表示按行，1表示按列，None表示展开来排序，默认为-1，表示沿最后的轴排序。
kind：排序的算法，提供了快排’quicksort’、混排’mergesort’、堆排’heapsort’，默认为‘quicksort’。
order：排序的字段名，可指定字段排序，默认为None。

dt = np.dtype([('name', 'S10'), ('age', np.int)])
a = np.array([("Mike", 21), ("Nancy", 25), ("Bob", 17), ("Jane", 27)], dtype=dt)
b = np.sort(a, order='age')
print(b)

[(b'Bob', 17) (b'Mike', 21) (b'Nancy', 25) (b'Jane', 27)]

2.numpy.argsort(a[, axis=-1, kind=‘quicksort’, order=None])

排序后返回原数组排序的索引

x = np.random.randint(0, 10, 10)
print(x)
y = np.argsort(x)
print(x[y])

[2 6 7 0 2 7 3 9 7 3]
[0 2 2 3 3 6 7 7 7 9]

3.numpy.lexsort(keys[, axis=-1])

给数据按照某种指标执行

x = np.random.rand(5, 5) * 10
x = np.around(x, 2)
print(x)
index = np.lexsort([x[:, 0]])
y = x[index]
print(y)

[[7.65 9.76 7.7  2.5  1.97]
 [4.01 1.03 1.87 4.12 7.54]
 [6.6  7.03 5.78 9.37 4.74]
 [5.57 9.88 2.17 7.55 6.86]
 [6.06 5.56 5.08 6.77 6.4 ]]
[[4.01 1.03 1.87 4.12 7.54]
 [5.57 9.88 2.17 7.55 6.86]
 [6.06 5.56 5.08 6.77 6.4 ]
 [6.6  7.03 5.78 9.37 4.74]
 [7.65 9.76 7.7  2.5  1.97]]

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

以索引是 kth 的元素为基准，将元素分成两部分，即大于该元素的放在其后面，小于该元素的放在其前面。

x = np.random.randint(1, 30, [8, 3])
print(x)
z = np.partition(x, kth=2, axis=0)
print(z)

[[ 1 24 19]
 [ 5 28  5]
 [28 23 24]
 [ 6 24 20]
 [15 25  9]
 [23  6 14]
 [17 25 21]
 [28 19 26]]
 
[[ 1  6  5]
 [ 5 19  9]
 [ 6 23 14]
 [28 24 20]
 [15 25 19]
 [23 24 24]
 [17 25 21]
 [28 28 26]]

5.搜索

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

x = np.random.rand(5, 5) * 10
x = np.around(x, 2)
print(x)
y = np.argmax(x,axis=0)
print(y)

[[3.57 4.26 3.06 8.61 6.21]
 [8.79 5.12 0.45 3.52 5.84]
 [5.09 2.55 4.4  4.54 6.32]
 [7.52 0.37 3.64 1.98 0.19]
 [2.31 5.57 7.18 7.02 7.05]]
[1 4 4 0 4]

6.numpy.argmin(a[, axis=None, out=None])

同上，只是寻找最小的

numppy.nonzero(a)

x = np.array([0, 2, 3])
print( np.nonzero(x))

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

7.numpy.where(condition, [x=None, y=None])

满足条件 condition ，输出 x ，不满足输出 y 。只有 condition ，没有 x 和 y ，则输出满足条件 (即非0) 元素的坐标 (等价于 numpy.nonzero )。这里的坐标以tuple的形式给出。

8.numpy.searchsorted(a, v[, side=‘left’, sorter=None])

a：一维输入数组。当 sorter 参数为 None 的时候， a 必须为升序数组；否则， sorter 不能为空，存放 a 中元素的 index ，用于反映 a 数组的升序排列方式。
v：插入 a 数组的值，可以为单个元素， list 或者 ndarray 。
side：查询方向，当为 left 时，将返回第一个符合条件的元素下标；当为 right 时，将返回最后一个符合条件的元素下标。
sorter：一维数组存放 a 数组元素的 index，index 对应元素为升序。

x = np.array([0, 1, 5, 9, 11, 18, 26, 33])
y = np.searchsorted(x, 35, side='right')
print(y) 

8

9.计数

numpy.count_nonzero(a, axis=None)

返回数组中的非0元素个数。

x = np.count_nonzero([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]])
print(x)
5

10.集合操作

构造集合

numpy.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)

return_index=True 表示返回新列表元素在旧列表中的位置。
return_inverse=True 表示返回旧列表元素在新列表中的位置。
return_counts=True 表示返回新列表元素在旧列表中出现的次数。

x = np.array(['a', 'b', 'b', 'c', 'a'])
u, index = np.unique(x, return_index=True)
print(u) 
print(index)

['a' 'b' 'c']
[0 1 3]

11.布尔运算

求包含

numpy.in1d(ar1, ar2, assume_unique=False, invert=False)

test = np.array([0, 1, 2, 5, 0])
states = [0, 2]
mask = np.in1d(test, states)
print(mask)

[ True False True False True]

12.求两个集合的交集

numpy.intersect1d(ar1, ar2, assume_unique=False, return_indices=False)

x = np.array([1, 1, 2, 3, 4])
y = np.array([2, 1, 4, 6])
xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)
print(x_ind) 
print(y_ind) 
print(xy)

[0 2 4]
[1 0 2]
[1 2 4]

13.求两个集合的并集

numpy.union1d(ar1, ar2)

x = np.union1d([-1, 0, 1], [-2, 0, 2])
print(x)
[-2 -1 0 1 2]

求两个集合的差集

numpy.setdiff1d(ar1, ar2, assume_unique=False)

a = np.array([1, 2, 3, 2, 4, 1])
b = np.array([3, 4, 5, 6])
x = np.setdiff1d(a, b)
print(x)
[1 2]

求两个集合的异或

是两个数组中各自独自拥有的元素的集合。

a = np.array([1, 2, 3, 2, 4, 1])
b = np.array([3, 4, 5, 6])
x = np.setxor1d(a, b)
print(x)
[1 2 5 6]