numpy task5排序搜索计数及集合操作

排序，搜索和计数

排序

• numpy.sort(a[, axis=-1, kind=‘quicksort’, order=None])；
  • axis：排序沿数组的轴方向；
  • kind：排序的算法（快排，混排，堆排）；
  • order：排序的字段名

import numpy as np

# np.random.seed()
x= np.random.rand(5,5)*10
x = np.around(x,2)
print(x)
print('+++++++++++')
y = np.sort(x)
print(y)

[[1.97 2.45 1.35 4.73 6.86]
[0.34 3.94 1.94 6.29 2.03]
[0.66 1.91 4.47 9.75 1.48]
[1.36 9. 4.22 2.39 1.11]
[2.42 3.77 4.97 3.11 7.09]]
+++++++++++
[[1.35 1.97 2.45 4.73 6.86]
[0.34 1.94 2.03 3.94 6.29]
[0.66 1.48 1.91 4.47 9.75]
[1.11 1.36 2.39 4.22 9. ]
[2.42 3.11 3.77 4.97 7.09]]

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

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

• numpy.argsort(a[, axis=-1, kind=‘quicksort’, order=None])排序后返回索引值

x = np.random.randint(0,10,10)
print(x,'原数组')
print('+++++++++++')
print(np.argsort(x),'排序后数组的索引')
print('+++++++++++')
print(x[np.argsort(x)],'排序后的数组')

[4 4 2 6 9 2 6 7 6 0] 原数组
+++++++++++
[9 2 5 0 1 3 6 8 7 4] 排序后数组的索引
+++++++++++
[0 2 2 4 4 6 6 6 7 9] 排序后的数组

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

x = np.random.rand(5,5)*10
x = np.around(x,2)
print(x,'原数组')
index = np.lexsort([x[:,0]])
print(index,'升序排序后的索引')
print(x[index],'升序排序后的数组')

[[5.5 2.66 3.25 9.25 5.12]
[5.38 9.07 3.2 4.3 8.49]
[8.95 4.58 9.09 4.91 5.95]
[5.19 9.85 7.69 2. 9.32]
[1.6 1.17 9.12 6.72 2.52]] 原数组
[4 3 1 0 2] 升序排序后的索引
[[1.6 1.17 9.12 6.72 2.52]
[5.19 9.85 7.69 2. 9.32]
[5.38 9.07 3.2 4.3 8.49]
[5.5 2.66 3.25 9.25 5.12]
[8.95 4.58 9.09 4.91 5.95]] 升序排序后的数组

x = np.array([1,5,1,4,3,4,4])
y = np.array([9,4,0,4,0,2,1])
a = np.lexsort([x])
b = np.lexsort([y])
print(a,'以x序列排序')
print(b,'以y序列排序')
z = np.lexsort([x,y])
print(z,'排序会根据最后一个字段作为主要排序序列')

[0 2 4 3 5 6 1] 以x序列排序
[2 4 6 5 1 3 0] 以y序列排序
[2 4 6 5 3 1 0] 排序会根据最后一个字段作为主要排序序列

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

# 以索引是 kth 的元素为基准，将元素分成两部分，即大于该元素的放在其后面，小于该元素的放在其前面，这里有点类似于快排。
x = np.random.randint(1, 30, [8, 3])
print(x,'原数组')

y = np.sort(x, axis=0)
print(y,'排序后的数组')

z = np.argpartition(x, kth=2, axis=0)
print(z,'利用索引kth为基准排序后的数组')

[[11 1 18]
[21 25 12]
[24 1 9]
[21 9 12]
[12 16 1]
[16 18 13]
[15 27 17]
[19 2 13]] 原数组
[[11 1 1]
[12 1 9]
[15 2 12]
[16 9 12]
[19 16 13]
[21 18 13]
[21 25 17]
[24 27 18]] 排序后的数组
[[0 0 4]
[4 2 2]
[6 7 1]
[3 3 3]
[1 4 0]
[5 5 5]
[2 6 6]
[7 1 7]] 利用索引kth为基准排序后的数组

• numpy.argpartition(a, kth, axis=-1, kind=‘introselect’, order=None) 同上函数，区别在于返回值是索引

搜索

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

x=np.random.rand(5,5)*10
x=np.around(x,2)
print(x,'原数组')
print(np.argmax(x),'最大数的序列号')
print(np.argmin(x),'最小数的序列号')

[[5.74 7.49 9.57 3.47 9.98]
[4.76 5.7 4.9 8.46 3.97]
[2.63 8.26 6.47 7. 5.24]
[0.75 0.95 9.49 3.22 4.38]
[5.28 3.45 2.25 9.78 1.97]] 原数组
4 最大数的序列号
15 最小数的序列号

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

x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
print(x,'原数组')

print(x.shape)  # (3, 3)
print(x.ndim)  # 2

y = np.nonzero(x)
print(y,'分别从两个维度标记了原数组中4个非零数的索引位置')

[[3 0 0]
[0 4 0]
[5 6 0]] 原数组
(3, 3)
2
(array([0, 1, 2, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64)) 分别从两个维度标记了原数组中4个非零数的索引位置

• numpy.where(condition, [x=None, y=None]) 条件筛选

import numpy as np

x = np.array([[0, 1, 2],
              [0, 2, 4],
              [0, 3, 6]])
y = np.where(x < 4, x, -1)
print(y,'满足条件的数字不变，不满足条件的数字变为-1')

[[ 0 1 2]
[ 0 2 -1]
[ 0 3 -1]] 满足条件的数字不变，不满足条件的数字变为-1

• 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, 15)
print(y,'第一个满足条件的索引值')
print('+++++++++++')
x = np.array([0, 1, 5, 9, 11, 18, 26, 33])
np.random.shuffle(x)
print(x,'打乱顺序后的数组')  

x_sort = np.argsort(x)
print(x_sort,'排序后的索引值') 

y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], sorter=x_sort)
print(y,'从左往右找满足条件的索引值')  

y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], side='right', sorter=x_sort)
print(y,'从右往左找满足条件的索引值') 

5 第一个满足条件的索引值
+++++++++++
[ 1 33 5 0 18 9 26 11] 打乱顺序后的数组
[3 0 2 5 7 4 6 1] 排序后的索引值
[0 0 4 5 7 8] 从左往右找满足条件的索引值
[0 1 5 5 8 8] 从右往左找满足条件的索引值

计数

• numpy.count_nonzero(a, axis=None) 返回非零元素个数

x = np.count_nonzero([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]])
print(x,'统计所有非零元素个数')

x = np.count_nonzero([[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]], axis=0)
print(x,'按行统计非零元素个数')

5 统计所有非零元素个数
[1 1 1 1 1] 按行统计非零元素个数

集合操作

构造集合

• numpy.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)
  • return_index=True 表示返回新列表元素在旧列表中的位置。
  • return_inverse=True 表示返回旧列表元素在新列表中的位置。
  • return_counts=True 表示返回新列表元素在旧列表中出现的次数。

import numpy as np

x = np.unique([1, 1, 3, 2, 3, 3])
print(x)

[1 2 3]

布尔运算

• 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)
print(test[mask])

[ True False True False True]
[0 2 0]

求两个集合的交集

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

x = np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
print(x)

[1 3]

求两个集合的并集

• 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]

求两个集合的异或

• setxor1d(ar1, ar2, assume_unique=False)

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]