NumPy-排序搜索计数集合
import numpy as np
x=np.random.randint(1,10,10)
print(x)
[2 2 6 2 6 4 2 3 1 6]
x = np.random.rand(5, 5) * 10
x = np.around(x, 2)
print(x)
[[8.68 2.14 3.02 1.86 7.85]
[1.76 5.14 6.52 4.49 7.2 ]
[8.16 7.3 2.34 2.37 7.31]
[1.58 9.48 0.14 9.29 6.6 ]
[9.18 4.98 9.1 0.7 7.94]]
y=np.sort(x)#每行元素自己排序
print(y)
[[1.86 2.14 3.02 7.85 8.68]
[1.76 4.49 5.14 6.52 7.2 ]
[2.34 2.37 7.3 7.31 8.16]
[0.14 1.58 6.6 9.29 9.48]
[0.7 4.98 7.94 9.1 9.18]]
print(np.sort(x,axis=0))#每列元素各自排序
print(np.sort(x,axis=1))#每行元素各自排序
[[1.58 2.14 0.14 0.7 6.6 ]
[1.76 4.98 2.34 1.86 7.2 ]
[8.16 5.14 3.02 2.37 7.31]
[8.68 7.3 6.52 4.49 7.85]
[9.18 9.48 9.1 9.29 7.94]]
[[1.86 2.14 3.02 7.85 8.68]
[1.76 4.49 5.14 6.52 7.2 ]
[2.34 2.37 7.3 7.31 8.16]
[0.14 1.58 6.6 9.29 9.48]
[0.7 4.98 7.94 9.1 9.18]]
x = np.random.randint(0, 10, 10)
print(x)
y=np.argsort(x)#返回排序(升序)后的数组索引下标
z=np.argsort(-x)#降序
print(y)
print(x[y])
print(z)
print(x[z])
[2 2 2 2 0 6 1 7 8 5]
[4 6 0 1 2 3 9 5 7 8]
[0 1 2 2 2 2 5 6 7 8]
[8 7 5 9 0 1 2 3 6 4]
[8 7 6 5 2 2 2 2 1 0]
x=np.array([[1,2],[0,2]])
y=np.nonzero(x)
print(y,type(y))
z=np.transpose(y)
print(z)
(array([0, 0, 1], dtype=int64), array([0, 1, 1], dtype=int64))
[[0 0]
[0 1]
[1 1]]
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)
print(b)
[0 2 4 3 5 6 1]
[0 1 3 5 6 2 4]
集合：
numpy.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None) Find the unique elements of an array.
return_index=True 表示返回新列表元素在旧列表中的位置。
return_inverse=True表示返回旧列表元素在新列表中的位置。
return_counts=True表示返回新列表元素在旧列表中出现的次数。
numpy.in1d(ar1, ar2, assume_unique=False, invert=False) Test whether each element of a 1-D array is also present in a second array.
前面的数组是否包含于后面的数组，返回布尔值。返回的值是针对第一个参数的数组的，所以维数和第一个参数一致，布尔值与数组的元素位置也一一对应。
求两个集合的交集：
numpy.intersect1d(ar1, ar2, assume_unique=False, return_indices=False) Find the intersection of two arrays.
Return the sorted, unique values that are in both of the input arrays.
//求两个数组的唯一化+求交集+排序函数。
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]
求两个集合的并集：
numpy.union1d(ar1, ar2) Find the union of two arrays.
Return the unique, sorted array of values that are in either of the two input arrays.
//计算两个集合的并集，唯一化并排序。
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]
'''
functools.reduce(function, iterable[, initializer])
将两个参数的 function 从左至右积累地应用到 iterable 的条目，以便将该可迭代对象缩减为单一的值。 例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 是计算 ((((1+2)+3)+4)+5) 的值。 左边的参数 x 是积累值而右边的参数 y 则是来自 iterable 的更新值。 如果存在可选项 initializer，它会被放在参与计算的可迭代对象的条目之前，并在可迭代对象为空时作为默认值。 如果没有给出 initializer 并且 iterable 仅包含一个条目，则将返回第一项。
大致相当于：
def reduce(function, iterable, initializer=None):
it = iter(iterable)
if initializer is None:
value = next(it)
else:
value = initializer
for element in it:
value = function(value, element)
return value
'''
求两个集合的差集：
numpy.setdiff1d(ar1, ar2, assume_unique=False) Find the set difference of two arrays.
Return the unique values in ar1 that are not in ar2.
//集合的差，即元素存在于第一个函数不存在于第二个函数中。
import numpy as np
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) Find the set exclusive-or of two arrays.
//集合的对称差，即两个集合的交集的补集。简言之，就是两个数组中各自独自拥有的元素的集合。
import numpy as np
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]