NumPy学习9

今天学习了NumPy排序和搜索功能

17, NumPy排序和搜索功能

numpy_test9.py :

import numpy as np

'''
17, NumPy排序和搜索功能

NumPy 提供了多种排序函数， 这些排序函数可以实现不同的排序算法。

排序算法特征主要体现在以下四个方面：执行速度，最坏情况下的复杂度，所需的工作空间以及算法的稳定性。下表列举了三种排序算法：
NumPy排序算法
种类	               速度	    最坏复杂度	   工作空间	    稳定性
quicksort（快速排序）	1	    O(n^2)	        0	        不稳定
mergesort（归并排序）	2	    O(n * log(n)）	~n/2	    稳定
heapsort（堆排序）	    3	    O(n * log(n))	0	        不稳定
'''

'''
(1) numpy.sort()
numpy.sort() 对输入数组执行排序，并返回一个数组副本。它具有以下参数：
numpy.sort(a, axis, kind, order)

参数说明：
a：要排序的数组；
axis：沿着指定轴进行排序，如果没有指定 axis，默认在最后一个轴上排序，若 axis=0 表示按列排序，axis=1 表示按行排序；
kind：默认为 quicksort（快速排序）；
order：若数组设置了字段，则 order 表示要排序的字段。
'''
print("----17, NumPy排序和搜索功能----")
print("----(1) numpy.sort()----")
arr1 = np.array([[3, 7, 12], [9, 1, 15]])
print('arr1 : ', arr1)
# 调用sort()函数
print('np.sort(arr1) : ', np.sort(arr1))
# 按列排序：
print('np.sort(arr1, axis=0) : ', np.sort(arr1, axis=0))
# 设置在sort函数中排序字段
datatype = np.dtype([('name',  'S10'),('age',  int)])
arr2 = np.array([("zhangsan", 21), ("lisi", 25), ("wanger", 17), ("chenjiu", 27)], dtype=datatype)
# 打印arr2数组
print('arr2 : ', arr2)
# 按 age 字段排序
print("np.sort(arr2, order='age') : ", np.sort(arr2, order='age'))
'''
arr1 :  [[ 3  7 12]
 [ 9  1 15]]
np.sort(arr1) :  [[ 3  7 12]
 [ 1  9 15]]
np.sort(arr1, axis=0) :  [[ 3  1 12]
 [ 9  7 15]]
arr2 :  [(b'zhangsan', 21) (b'lisi', 25) (b'wanger', 17) (b'chenjiu', 27)]
np.sort(arr2, order='age') :  [(b'wanger', 17) (b'zhangsan', 21) (b'lisi', 25) (b'chenjiu', 27)]
'''

'''
(2) numpy.argsort()
argsort() 沿着指定的轴，对输入数组的元素值进行排序，并返回排序后的元素索引数组。
'''
print("----(2) numpy.argsort()----")
arr3 = np.array([78, 24, 85, 32])
print('arr3 : ', arr3)
sort_ind = np.argsort(arr3)
print("打印排序元素索引值：", sort_ind)
# 使用索引数组对原数组排序
sort_a = arr3[sort_ind]
print("打印排序数组")
for i in sort_ind:
    print(arr3[i], end=" ")
print("\n-------------------\n")
'''
arr3 :  [78 24 85 32]
打印排序元素索引值： [1 3 0 2]
打印排序数组
24 32 78 85
'''

'''
(3) numpy.lexsort()
numpy.lexsort() 按键序列对数组进行排序，它返回一个已排序的索引数组，类似于 numpy.argsort()。
'''
print("----(3) numpy.lexsort()----")
a = np.array(['a', 'b', 'c', 'd', 'e'])
b = np.array([23, 40, 120, 25, 123])
print('a : ', a)
print('b : ', b)
ind = np.lexsort((a, b))
# 打印排序元素的索引数组
print('ind : ', ind)
# 使用索引数组对数组进行排序
for i in ind:
    print(a[i], b[i])
print("\n-------------------\n")
'''
a :  ['a' 'b' 'c' 'd' 'e']
b :  [ 23  40 120  25 123]
打印排序元素的索引数组：
ind :  [0 3 1 2 4]
使用索引数组对原数组进行排序：
a 23
d 25
b 40
c 120
e 123
'''

'''
(4) numpy.nonzero()
该函数从数组中查找非零元素的索引位置。
'''
print("----(4) numpy.nonzero()----")
arr4 = np.array([14, 50, 260, 0, 32, 231])
print('arr4 : ', arr4)
print("打印非0元素的索引位置:", arr4.nonzero())
'''
arr4 :  [ 14  50 260   0  32 231]
打印非0元素的索引位置: (array([0, 1, 2, 4, 5], dtype=int64),)
'''

'''
(5) numpy.where()
numpy.where() 的返回值是满足了给定条件的元素索引值。
'''
print("----(5) numpy.where()----")
arr5 = np.array([12, 90, 380, 12, 211])
print('arr5 : ', arr5)
print('np.where(arr5 > 12) : ', np.where(arr5 > 12))
print('np.where(arr5 < 100) : ', np.where(arr5 < 100))
'''
arr5 :  [ 12  90 380  12 211]
np.where(arr5 > 12) :  (array([1, 2, 4], dtype=int64),)
np.where(arr5 < 100) :  (array([0, 1, 3], dtype=int64),)
'''

'''
(6) numpy.extract()
该函数的返回值是满足了给定条件的元素值.
'''
print("----(6) numpy.extract()----")
arr6 = np.array([16, 32, 25, 13, 21])
print('arr6 : ', arr6)
# 设置条件选择偶数元素
condition = np.mod(arr6,2) == 0
# 输出布尔值数组
print('condition : ', condition)
# 按condition提取满足条件的元素值
print('np.extract(condition, arr6) : ', np.extract(condition, arr6))
'''
arr6 :  [16 32 25 13 21]
condition :  [ True  True False False False]
np.extract(condition, arr6) :  [16 32]
'''

'''
(7) numpy.argmax()
该函数返回最大值的的索引.
'''
print("----(7) numpy.argmax()----")
arr7 = np.array([[3, 4, 7], [8, 2, 1], [5, 9, 6]])
print('arr7 : ', arr7)
# argmax() 函数
print('np.argmax(arr7) : ', np.argmax(arr7))
# 将数组以一维展开
print('arr7.flatten() : ', arr7.flatten())
# 沿轴 0 的最大值索引：
maxindex0 = np.argmax(arr7, axis=0)
print('maxindex0 : ', maxindex0)
# 沿轴 1 的最大值索引
maxindex1 = np.argmax(arr7, axis=1)
print('maxindex1 : ', maxindex1)
'''
arr7 :  [[3 4 7]
         [8 2 1]
         [5 9 6]]
np.argmax(arr7) :  7
arr7.flatten() :  [3 4 7 8 2 1 5 9 6]
maxindex0 :  [1 2 0]
maxindex1 :  [2 0 1]
'''

'''
(8) numpy.argmin()
该函数返回最小值的索引。
'''
print("----(8) numpy.argmin()----")
arr8 = np.array([[3, 4, 8], [4, 2, 1], [7, 9, 6]])
print('arr8 : ', arr8)
# 调用 argmin()函数
minindex = np.argmin(arr8)
print('minindex : ', minindex)
# 展开数组中的最小值：
print('arr8.flatten() : ', arr8.flatten())
print('arr8.flatten()[minindex] : ', arr8.flatten()[minindex])
# 沿轴 0 的最小值索引：
maxindex0 = np.argmin(arr8, axis=0)
print('maxindex0 : ', maxindex0)
# 沿轴 1 的最小值索引：
minindex1 = np.argmin(arr8, axis=1)
print('minindex1 : ', minindex1)
'''
arr8 :  [[3 4 8]
         [4 2 1]
         [7 9 6]]
minindex :  5
arr8.flatten() :  [3 4 8 4 2 1 7 9 6]
arr8.flatten()[minindex] :  1
maxindex0 :  [0 1 1]
minindex1 :  [0 2 2]
'''