Day05:Numpy排序搜索计数

排序

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

2. numpy.argsort(a[, axis=-1, kind=‘quicksort’, order=None])
   返回对数组进行排序的索引。

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

4. numpy.partition(a,kth,axis=-1,kind=‘introselect’,order=Node)返回数组的分区副本。创建数组的副本，其元素重新排列的方式使元素在k位置的值处于它将在排序数组中的位置。 所有小于k的元素在这个元素之前移动了所有相等或更大的元素都在后面移动。 两个分区中元素的排序未定义。假定一kth元素为基准进行排序，比kth小的排到前面，比kth大的排在后面，有点像快排，也有点像数据结构中的中序遍历，将kth看作是第一个结点，先遍历左子树，后遍历右子树然后进行排序。

5. numpy.argpartition(a,kth,axis=-1,kind=‘introselect’,order=Node)使用该类关键字指定的算法沿给定轴执行间接分区, 它返回一个形状与a相同的索引数组，该索引数据沿给定轴按分区顺序排列。

import numpy as np
np.random.seed(20201029)
x=np.random.rand(3,3)*5#5以内的随机数
x=np.around(x,2)
print(x)
#[[4.69 4.33 2.87]
# [1.89 1.81 4.99]
# [2.85 2.4  2.72]]
y=np.sort(x)
print(y)
#[[2.87 4.33 4.69]
# [1.81 1.89 4.99]
# [2.4  2.72 2.85]]
y=np.argsort(x)
print(y)
#[[2 1 0]
# [1 0 2]
# [1 2 0]]
y=np.sort(x,axis=0)#axis=1是行排列
print(y)
#[[1.89 1.81 2.72]
# [2.85 2.4  2.87]
# [4.69 4.33 4.99]]
y=np.argsort(x,axis=0)
print(y)
#[[1 1 2]
# [2 2 0]
# [0 0 1]]
index=np.lexsort([x[:,0]])#[:,0]第一列的全部元素
print(index)
#[1 2 0]
y=x[index]
print(y)
#[[1.89 1.81 4.99]
# [2.85 2.4  2.72]
# [4.69 4.33 2.87]]
index=np.lexsort([-1*x[:,0]])#逆序
print(index)
#[0 2 1]
y=x[index]
print(y)
#[[4.69 4.33 2.87]
# [2.85 2.4  2.72]
# [1.89 1.81 4.99]]

partition()函数

import numpy as np
np.random.seed(100)
x=np.random.randint(1,50,[8,3])
print(x)
#[[ 9 25  4]
# [40 24 16]
# [49 11 31]
# [35  3 35]
# [15 35 49]
# [25 16 37]
# [44 17 10]
# [30 23  3]]
y=np.sort(x,axis=0)
print(y)
#[[ 9  3  3]
# [15 11  4]
# [25 16 10]
# [30 17 16]
# [35 23 31]
# [40 24 35]
# [44 25 37]
# [49 35 49]]
z=np.partition(x,kth=2,axis=0)
print(z)
#[[ 9  3  3]
# [15 11  4]
# [25 16 10]
# [35 25 35]
# [40 35 49]
# [49 24 37]
# [44 17 31]
# [30 23 16]]
z=np.argpartition(x,kth=2,axis=0)
print(z)
#[[0 3 7]
# [4 2 0]
# [5 5 6]
# [3 0 3]
# [1 4 4]
# [2 1 5]
# [6 6 2]
# [7 7 1]]
z = np.partition(x, kth=2, axis=0)
print(z[2])#三列中第三小的数
#[25 16 10]
z=np.argpartition(x,kth=2,axis=0)
print(z[2])#三列中第三小的数的索引
#[5 5 6]

搜索

1. numpy.argmax(a[, axis=None, out=None])返回沿轴的最大值的索引。
2. numpy.argmin(a[,axis=None,out=None]) 返回沿轴的最小值的索引。
3. numpy.nonzero(a)返回非零元素的索引。（1.只有 a 中非零元素才会有索引值，那些零值元素没有索引值。
   2.返回一个长度为 a.ndim 的元组（tuple），元组的每个元素都是一个整数数组（array）。
   3.每一个array均是从一个维度上来描述其索引值。比如，如果 a 是一个二维数组，则tuple包含两个array，第一个array从行维度来描述索引值；第二个array从列维度来描述索引值。
   4.该np.transpose(np.nonzero(x))函数能够描述出每一个非零元素在不同维度的索引值。
   5.通过 a[nonzero(a)] 得到所有 a 中的非零值。）

一维数组

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

二维数组

import numpy as np
x=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(x)
print(x.shape)
print(x.ndim)#返回数组的维度
y=np.nonzero(x)
print(y)
print(np.array(y))
print(np.array(y).shape)
print(np.array(y).ndim)
print(np.transpose(y))
#[[1 2 3]
# [4 5 6]
# [7 8 9]]
#(3, 3)
#2
#(array([0, 0, 0, 1, 1, 1, 2, 2, 2], dtype=int64), array([0, 1, 2, 0, #1, 2, 0, 1, 2], dtype=int64))
#[[0 0 0 1 1 1 2 2 2]
# [0 1 2 0 1 2 0 1 2]]
#(2, 9)
#2
#[[0 0]
# [0 1]
# [0 2]
# [1 0]
# [1 1]
# [1 2]
# [2 0]
# [2 1]
# [2 2]]