Numpy5_排序搜索计数_Datawhale十月组队学习

Numpy学习|排序搜索计数

文章目录

Numpy学习|排序搜索计数
1.排序
2.搜索
3.计数

涉及更改形状、维度；数组组合、拆分、平铺；添加删除操作等

1.排序

numpy.sort(a[, axis=-1, kind=‘quicksort’, order=None]) Return a sorted copy of an array.返回排序后的数组

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

import numpy as np
np.random.seed(20200612)
x = np.random.rand(5, 5) * 10
x = np.around(x, 2)
print(x)
# [[2.32 7.54 9.78 1.73 6.22]
# [6.93 5.17 9.28 9.76 8.25]
# [0.01 4.23 0.19 1.73 9.27]
# [7.99 4.97 0.88 7.32 4.29]
# [9.05 0.07 8.95 7.9 6.99]]
y = np.sort(x, axis=0)
print(y)
# [[0.01 0.07 0.19 1.73 4.29]
# [2.32 4.23 0.88 1.73 6.22]
# [6.93 4.97 8.95 7.32 6.99]
# [7.99 5.17 9.28 7.9 8.25]
# [9.05 7.54 9.78 9.76 9.27]]

用元素的索引位置替代排序后的实际结果，该怎么办呢？

numpy.argsort(a[, axis=-1, kind=‘quicksort’, order=None]) Returns the indices that would sort an array

如何将数据按照某一指标进行排序呢？

numpy.lexsort(keys[, axis=-1]) Perform an indirect stable sort using a sequence of keys.（使用键序列执行间接稳定排序。）
给定多个可以在电子表格中解释为列的排序键，lexsort返回一个整数索引数组，该数组描述了按多个列排序的顺序。序列中的最后一个键用于主排序顺序，倒数第二个键用于辅助排序顺序，依此类推。keys参数必须是可以转换为相同形状的数组的对象序列。如果为keys参数提供了2D数组，则将其行解释为排序键，并根据最后一行，倒数第二行等进行排序。

import numpy as np
x = np.array([1, 5, 1, 4, 3, 4, 4])
a = np.lexsort([x])
print(a)
# [0 2 4 3 5 6 1]
print(x[a])
# [1 1 3 4 4 4 5]

2.搜索

1.numpy.argmax（a [，axis = None，out = None]）返回沿轴的最大值的索引

y = np.argmax(x, axis=0)
print(y)
# [4 0 0 1 2]
y = np.argmax(x, axis=1)
print(y)
# [2 3 4 0 0]

2.numpy.argmin（a [，axis = None，out = None]）返回沿轴的最小值的索引。

3.numppy.nonzero(a) Return the indices of the elements that are non-zero.，其值为非零元素的下标在对应轴上的值。

只有 a 中非零元素才会有索引值，那些零值元素没有索引值。

返回一个长度为 a.ndim 的元组（tuple），元组的每个元素都是一个整数数组（array）。
每一个array均是从一个维度上来描述其索引值。比如，如果 a 是一个二维数组，则tuple包含两个array，第一个array从行维度来描述索引值；第二个array从列维度来描述索引值。
该 np.transpose(np.nonzero(x)) 函数能够描述出每一个非零元素在不同维度的索引值。
通过 a[nonzero(a)] 得到所有 a 中的非零值。

import numpy as np
x = np.array([0, 2, 3])
print(x) # [0 2 3]
print(x.shape) # (3,)
print(x.ndim) # 1
y = np.nonzero(x)
print(y) # (array([1, 2], dtype=int64),)
print(np.array(y)) # [[1 2]]
print(np.array(y).shape) # (1, 2)
print(np.array(y).ndim) # 2
print(np.transpose(y))
# [[1]
# [2]]
print(x[np.nonzero(x)])
#[2, 3]

1.numpy.where(condition, [x=None, y=None]) Return elements chosen from x or y depending on condition .满足条件 condition ，输出 x ，不满足输出 y 。
只有 condition ，没有 x 和 y ，则输出满足条件 (即非0) 元素的坐标 (等价于 numpy.nonzero )。这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标

x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = np.where(x > 5)
print(y)
# (array([5, 6, 7], dtype=int64),)
print(x[y])
# [6 7 8]
y = np.nonzero(x > 5)
print(y)
# (array([5, 6, 7], dtype=int64),)
print(x[y])
# [6 7 8]

numpy.searchsorted(a, v[, side=‘left’, sorter=None]) Find indices where elements should be inserted to maintain order. 查找应在其中插入元素以保持顺序的索引。

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

import numpy as np
x = np.array([0, 1, 5, 9, 11, 18, 26, 33])
y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35])
print(y) # [0 0 4 5 7 8]
y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], side='right')
print(y) # [0 1 5 5 8 8]

3.计数

numpy.count_nonzero（a，axis = None）计算数组a中非零值的数量

import numpy as np
x = np.count_nonzero(np.eye(4))
print(x) # 4
x = np.count_nonzero([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]])
print(x) # 5
x = np.count_nonzero([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]], axis=0)
print(x) # [1 1 1 1 1]
x = np.count_nonzero([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]], axis=1)
print(x) # [2 3]