Part_1 排序函数
numpy排序方式主要分为直接排序和间接排序两种。
直接排序是指对数值直接进行排序；
间接排序是指根据一个或多个键对数据集进行排序。
在numpy中：直接排序常用sort()函数，间接排序常用argsort()函数和lexsort()函数
1.sort()函数：
用于返回输入数组的排序副本
格式：numpy.sort(arr[,axis,kind,order])
参数解读：
arr:输入数组
axis：指定沿着某个轴排序数组，axis=0表示按列排序，axis=1表示按行序。默认axis=0
kind：指定排序算法是快速排序（Quicksort），归并排序（Mergesort）或是堆排序（Heapsort），默认为Quicksort
order：如果数组包含字段，则用于指明排序的字段
该函数除了arr参数外，其余参数为可选项
#示例：
import numpy as np
arr=np.array([[4,5,3],[8,1,7]])
print('原数组为：',arr)
a=np.sort(arr) #调用sort()函数
print('sort()函数排序',a)
b=np.sort(arr,axis=0) #沿0轴排序
print('沿轴0排序',b)
c=np.sort(arr,axis=1) #沿1轴排序
print('沿轴1排序',c)
#使用sort函数设置排序字段
dt=np.dtype([('name',np.str_,10),('age',int)])
arr=np.array([('李明',19),('王力',21),('张燕',18)],dtype=dt)
print('按name排序：')
print(np.sort(arr,order='name'))
原数组为： [[4 5 3]
[8 1 7]]
sort()函数排序 [[3 4 5]
[1 7 8]]
沿轴0排序 [[4 1 3]
[8 5 7]]
沿轴1排序 [[3 4 5]
[1 7 8]]
按name排序：
[('张燕', 18) ('李明', 19) ('王力', 21)]
2.argsort()函数
用于使输入数组沿着给定轴执行时间间接排序，并根据指定排序类型返回数据的索引数组，使用该索引数组可以获得排序数据。
argsort()与sort()函数格式相同
#示例：
import numpy as np
arr_x=np.array([4,5,3,8,1,7])
print('原数组为：',arr_x)
#数组排序后的索引数组 按这个索引排序
a=np.argsort(arr_x)
print('调用argsort()函数：\n',a)
#根据索引数组重构排序函数组
print('用循环输出排序数组')
for i in a:
print(arr_x[a])
原数组为： [4 5 3 8 1 7]
调用argsort()函数：
[4 2 0 1 5 3]
用循环输出排序数组
[1 3 4 5 7 8]
[1 3 4 5 7 8]
[1 3 4 5 7 8]
[1 3 4 5 7 8]
[1 3 4 5 7 8]
[1 3 4 5 7 8]
3.lexsort()函数
该函数使用键序列执行间接排序，键可以看做是电子表格的一列，最后一个键是排序的主键，该函数返回一个索引数组。使用该索引数组可以获得排序数据
格式：numpy.lexsort(keys[,axis])
keys:键序列
axis：指定沿某个轴排序数组，为可选项
#示例：
k=('name','age','tel','email')
v=('李明','21','15696663527','liming@163.com')
ind=np.lexsort((k,v))
print('调用lexsort()函数:\n',ind) #按照这个索引排序
print('使用这个索引来获取排序后的数据：')
print([k[i]+","+v[i]for i in ind])
调用lexsort()函数:
[2 1 3 0]
使用这个索引来获取排序后的数据：
['tel,15696663527', 'age,21', 'email,liming@163.com', 'name,李明']
Part_2 去重与重复函数
1.unique()函数
该函数可以返回输入数组中所有不同的值（即去重后的值），按从小到大顺序排列。即unique()函数能够返回由输入数组中的去重后的值组成去重数组，去重数组的索引数组，去重数组的下标和去重值的重复数量等结果。
格式：numpy.unique(arr,return_index,return_inverse,return_counts)
arr:输入的数组，如果不是一维数组会展开
return_index:如果为Ture，返回输入数组中去重数组的索引数组；
return_inverse:如果为True，返回去重数组的下标，它可以重构输入数组
return_counts:如果为True，返回去重数组中的元素在原数组中出现的次数
#示例：
import numpy as np
arr=np.array([3,7,5,6,8,9,7,2,6,2,5,9,10])
print('原数组为：\n',arr)
print('第一个数组去重(去重后的值)数组：')
arr_u=np.unique(arr)
print(arr_u)
print('去重数组的索引数组为：')
u_index=np.unique(arr,return_index=True)
print(u_index)
print('查看原数组中的元素相对于去重数组中的元素的索引值')
print("原数组：\n",arr)
print('用去重数组下标标记原数组中元素：')
arr_u,u_inverse=np.unique(arr,return_inverse=True)
print(u_inverse)
print('使用去重数组下标重构数组:')
print(arr_u[u_inverse])
print('返回去重后的值的重复数量：')
arr_u,u_inverse=np.unique(arr,return_counts=True)
print(u_inverse)
原数组为：
[ 3 7 5 6 8 9 7 2 6 2 5 9 10]
第一个数组去重(去重后的值)数组：
[ 2 3 5 6 7 8 9 10]
去重数组的索引数组为：
(array([ 2, 3, 5, 6, 7, 8, 9, 10]), array([ 7, 0, 2, 3, 1, 4, 5, 12], dtype=int64))
查看原数组中的元素相对于去重数组中的元素的索引值
原数组：
[ 3 7 5 6 8 9 7 2 6 2 5 9 10]
用去重数组下标标记原数组中元素：
[1 4 2 3 5 6 4 0 3 0 2 6 7]
使用去重数组下标重构数组:
[ 3 7 5 6 8 9 7 2 6 2 5 9 10]
返回去重后的值的重复数量：
[2 1 2 2 2 1 2 1]
2.tile()函数
该函数是模板numpy.lib.shape_base中的函数，作用是将一个已有的数组重复一定的次数
格式：numpy.tile(a,reps)
a：指定重复的数组
reps:指定重复的次数
#示例：
arr1=np.array([10,20])
#重复arr1两次
a1=np.tile(arr1,(2))
print(a1)
#重复arr1三次组成数组，数组重复4次
b1=np.tile(arr1,(4,3))
print(b1)
#把42.重复两遍，组成的数组重复三次形成新数组
c1=np.tile(42.0,(3,2))
print(c1)
[10 20 10 20]
[[10 20 10 20 10 20]
[10 20 10 20 10 20]
[10 20 10 20 10 20]
[10 20 10 20 10 20]]
[[42. 42.]
[42. 42.]
[42. 42.]]
3.repeat()函数
格式：numpy.repeat(a,repeats,axis=None)
a:指定需要重复的数组元素
repeat:指定重复的次数
axis:指定沿那个轴重复 axis=0按列重复,axis=1按行重复
#示例：
#重复7.四次，其输出结果为：[7. 7. 7. 7.]
a2=np.repeat(7.,4)
print(a2,"\n")
#定义数组
arr2=np.array([10,20])
#arr2的元素10重复4遍，20重复3遍
b2=np.repeat(arr2,[4,3])
print(b2,"\n")
#定义数组
arr=np.array([[10,20],[30,40]])
print(arr,"\n")
#沿轴0重复数据
c2=np.repeat(arr,[3,2],axis=0)
print(c2,"\n")
#沿轴1重复数据
d2=arr.repeat([3,2],axis=1)
print(d2,"\n")
[7. 7. 7. 7.]
[10 10 10 10 20 20 20]
[[10 20]
[30 40]]
[[10 20]
[10 20]
[10 20]
[30 40]
[30 40]]
[[10 10 10 20 20]
[30 30 30 40 40]]
注意：tile()函数和repeat()函数的主要区别在于，tile()函数是对数组进行重复操作，而repeat()函数是对数组中的每个元素进行重复操做
Part_3 搜索和计数函数
1.argmin(),nanargmin(),argmax(),nanargmax()函数
argmax()和argmin()函数用于沿特定轴返回最大值和最小值元素的索引。
nanargmin(),nanargmax()函数用于沿指定轴返回忽略了nan的最小值和最大值的索引
格式：numpy.argmin(a[,axis=None])
argmin()函数有两个参数：
其中，参数a为输入数组；
axis指定沿哪个轴进行查找操作;
参数axis为可选项
nanargmin(),nanargmax(),argmax()函数与argmin()函数格式相同
#示例：
import numpy as np
arr=np.array([[3,15,2],[30,7,10]])
print('原数组是：\n',arr)
原数组是：
[[ 3 15 2]
[30 7 10]]
1.1 argmax()函数
maxindex=np.argmax(arr)
print('最大索引值为:',maxindex)
maxindex0=np.argmax(arr,axis=0)
print('沿轴0的最大索引：',maxindex0)
maxindex1=np.argmax(arr,axis=1)
print('沿轴1的最大索引：',maxindex1)
最大索引值为: 3
沿轴0的最大索引： [1 0 1]
沿轴1的最大索引： [1 0]
1.2 argmin()函数
minindex=np.argmin(arr)
print('最小索引为：',minindex)
print('展开数组中的最小值',arr.flatten()[minindex])
minindex0=np.argmin(arr,axis=0)
print('沿轴0的最小索引为：',minindex0)
minindex1=np.argmin(arr,axis=1)
print('沿轴1的最小索引为：',minindex1)
最小索引为： 2
展开数组中的最小值 2
沿轴0的最小索引为： [0 1 0]
沿轴1的最小索引为： [2 1]
1.3 nanargmin()函数
arr=np.array([[3,15,2],[30,7,1]],dtype=float)
#设置有nan的值, 在0行1列设置值为nan arr[x,y]，x代表行，y代表列
arr[1,0]=np.nan
print(arr)
minindex=np.nanargmin(arr)
print('最小值索引为：',minindex)
print('展开数组中的最小值',arr.flatten()[minindex])
[[ 3. 15. 2.]
[nan 7. 1.]]
最小值索引为： 5
展开数组中的最小值 1.0
2.nonzero()函数
用于返回输入数组中非0元素的索引
格式：numpy.nonzero(a)
a:输入数组
#示例：
arr=np.array([[3,0,2],[0,1,0]])
print('原数组为：\n',arr)
print('非0元素的个数：',len(arr.nonzero()[0]))
print('nonzero()函数输出结果为：',np.nonzero(arr))
#第一个array表示非零元素所在的行，第二个array表示非零元素所在的
# ，分别取对应位置的值组成非零元素的坐标(比如原数组的3，就是行0列0)
原数组为：
[[3 0 2]
[0 1 0]]
非0元素的个数： 3
nonzero()函数输出结果为： (array([0, 0, 1], dtype=int64), array([0, 2, 1], dtype=int64))
3.where()函数
用于返回数组中满足给定条件x的元素的索引，或者是当给定条件x为True时，返回y数据,否则返回z数据
格式：numpy.where(x[,y,z])
其中x为条件表达式；y为x为True时的取值；z为x为False时的取值
#示例：
arr=np.arange(8).reshape(2,4)
print('原数组为：\n',arr)
x=np.where(arr>4)
print('大于4的元素的索引为：\n',x)
print("用索引来获取满足条件的元素:\n",arr[x])
原数组为：
[[0 1 2 3]
[4 5 6 7]]
大于4的元素的索引为：
(array([1, 1, 1], dtype=int64), array([1, 2, 3], dtype=int64))
用索引来获取满足条件的元素:
[5 6 7]
4.extract()函数
用于返回满足任何条件的元素
格式：numpy.extract(x,a)
x为条件表达式，a为数组
#示例
arr=np.arange(8).reshape(2,4)
print('原数组为：\n',arr)
#定义条件
condition=np.mod(arr,2)==0 #mod()取余:arr除以2的的余数
print('按元素的条件值：\n',condition)
print('使用条件提取元素：')
#extract(a,b) 提取函数，a为提取条件，b为被提取对象
print(np.extract(condition,arr))
原数组为：
[[0 1 2 3]
[4 5 6 7]]
按元素的条件值：
[[ True False True False]
[ True False True False]]
使用条件提取元素：
[0 2 4 6]
5.count_nonzero()函数
可以统计numpy数组中非0元素的格式
格式：numpy.count_nonzero(a)
拓展：len()函数也可以
格式：len(a.nonzero()[0]) #见第2点例题
a为输入数组
#示例：
arr=np.arange(8).reshape(2,4)
a=np.count_nonzero(arr)
print('数组中非0元素的个数为：',a)
数组中非0元素的个数为： 7
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
