Numpy组队学习第五次打卡

13 排序，搜索和计数

排序

1. 返回复制的排序array

numpy.sort(a[, axis=-1, kind='quicksort', order=None])

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

2. 返回array的indices

 numpy.argsort(a[, axis=-1, kind='quicksort', order=None])

3. 按照keys的序列间接稳定的排序

numpy.lexsort(keys[, axis=-1])

序列中的最后一个键用于主排序顺序，倒数第二个键用于辅助排序顺序，依此类推。keys参数必须是可以转换为相同形状的数组的对象序列。如果为keys参数提供了2D数组，则将其行解释为排序键，并根据最后一行，倒数第二行等进行排序。

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]]
index = np.lexsort([x[:, 0]]) 
print(index) 
# [2 0 1 3 4] 
y = x[index] print(y) 
# [[0.01 4.23 0.19 1.73 9.27] 
# [2.32 7.54 9.78 1.73 6.22] 
# [6.93 5.17 9.28 9.76 8.25] 
# [7.99 4.97 0.88 7.32 4.29] 
# [9.05 0.07 8.95 7.9 6.99]]

4. 返回array的分段副本

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

以索引是 kth 的元素为基准，将元素分成两部分，即大于该元素的放在其后面，小于该元素的放在其前面。

5. 返回array分段的索引

 numpy.argpartition(a, kth, axis=-1, kind='introselect', order=None)

import numpy as np 
np.random.seed(100) 
x = np.random.randint(1, 30, [8, 3]) 
print(x) 
# [[ 9 25 4] 
# [ 8 24 16] 
# [17 11 21] 
# [ 3 22 3] 
# [ 3 15 3] 
# [18 17 25] 
# [16 5 12] 
# [29 27 17]]

y = np.argsort(x, axis=0) 
print(y) 
# [[3 6 3] 
# [4 2 4] 
# [1 4 0] 
# [0 5 6] 
# [6 3 1] 
# [2 1 7] 
# [5 0 2] 
# [7 7 5]]

z = np.argpartition(x, kth=2, axis=0) 
print(z) 
# [[3 6 3] 
# [4 2 4] 
# [1 4 0] 
# [0 3 2] 
# [2 1 1] 
# [5 5 5] 
# [6 0 6] 
# [7 7 7]]

13.2 搜索

1. 返回沿轴最大值的索引

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

2. 返回沿轴最小值的索引

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

3. 返回非零元素是索引

numppy.nonzero(a)

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

import numpy as np 
x = np.array([[[0, 1], [1, 0]], [[0, 1], [1, 0]], [[0, 0], [1, 0]]]) 
print(x) 
# [[[0 1] 
# [1 0]] 
#
# [[0 1] 
# [1 0]] 
#
# [[0 0] 
# [1 0]]]

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

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

4. 根据条件返回选择的元素

numpy.where(condition, [x=None, y=None])

只有 condition ，没有 x 和 y ，则输出满足条件 (即非0) 元素的坐标 (等价于 numpy.nonzero )。

import numpy as np
x = np.array([[11, 12, 13, 14, 15], 
			  [16, 17, 18, 19, 20], 
			  [21, 22, 23, 24, 25], 
			  [26, 27, 28, 29, 30], 
			  [31, 32, 33, 34, 35]]) 
y = np.where(x > 25) 
print(y) 
# (array([3, 3, 3, 3, 3, 4, 4, 4, 4, 4], dtype=int64), array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4], dtype=int64)) 

print(x[y]) 
# [26 27 28 29 30 31 32 33 34 35] 

y = np.nonzero(x > 25) 
print(y) 
# (array([3, 3, 3, 3, 3, 4, 4, 4, 4, 4], dtype=int64), array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4], dtype=int64)) 
print(x[y]) 
# [26 27 28 29 30 31 32 33 34 35]

5. 查找插入元素后保持顺序的索引

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 对应元素为升序。

import numpy as np 
x = np.array([0, 1, 5, 9, 11, 18, 26, 33]) 
np.random.shuffle(x) 
print(x) # [33 1 9 18 11 26 0 5] 

x_sort = np.argsort(x) 
print(x_sort) # [6 1 7 2 4 3 5 0] 

y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], sorter=x_sort) 
print(y) # [0 0 4 5 7 8]

y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], side='right', sorter=x_sort) 
print(y) # [0 1 5 5 8 8]

13.3 计数

1. 计算数组中非零值的数量

numpy.count_nonzero(a, axis=None)

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]

14 集合操作

14.1 构造集合

1. 查找array中唯一的元素

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.array([[1, 1], [2, 3]]) 
u = np.unique(x) 
print(u) # [1 2 3] 

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

x = np.array(['a', 'b', 'b', 'c', 'a']) 
u, index = np.unique(x, return_index=True) 
print(u) # ['a' 'b' 'c'] 
print(index) # [0 1 3] 
print(x[index]) # ['a' 'b' 'c'] 

x = np.array([1, 2, 6, 4, 2, 3, 2]) 
u, index = np.unique(x, return_inverse=True) 
print(u) # [1 2 3 4 6] 
print(index) # [0 1 4 3 1 2 1] 
print(u[index]) # [1 2 6 4 2 3 2] 

u, count = np.unique(x, return_counts=True) 
print(u) # [1 2 3 4 6]
print(count) # [1 3 1 1 1]

布尔运算

1. 测试一维数组的每个元素都存在于第二个数组中

numpy.in1d(ar1, ar2, assume_unique=False, invert=False)

前面的数组是否包含于后面的数组，返回布尔值。返回的值是针对第一个参数的数组的，所以维数和第一个参数一致，布尔值与数组的元素位置也一一对应。

2. 求集合的交集

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

求两个数组的唯一化+求交集+排序函数。

import numpy as np 
from functools import reduce 
x = np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1]) 
print(x) # [1 3] 

x = np.array([1, 1, 2, 3, 4]) 
y = np.array([2, 1, 4, 6]) 
xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True) 
print(x_ind) # [0 2 4] 
print(y_ind) # [1 0 2] 
print(xy) # [1 2 4] 
print(x[x_ind]) # [1 2 4] 
print(y[y_ind]) # [1 2 4]
x = reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) 
print(x) # [3]

3. 求集合的并集

numpy.union1d(ar1, ar2)

计算两个集合的并集，唯一化并排序。

import numpy as np 
from functools import reduce 
x = np.union1d([-1, 0, 1], [-2, 0, 2]) 
print(x) # [-2 -1 0 1 2] 
x = reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) 
print(x) # [1 2 3 4 6]

4. 求集合的差集

numpy.setdiff1d(ar1, ar2, assume_unique=False)

集合的差，即元素存在于第一个函数不存在于第二个函数中。

5. 求集合的异或

setxor1d(ar1, ar2, assume_unique=False)

集合的对称差，即两个集合的交集的补集。简言之，就是两个数组中各自独自拥有的元素的集合