1. 首页
  2. 文章中心
  3. python

05 Numpy排序搜索计数及集合操作排序，搜索和计数集合操作

119 阅读 0 评论
我是靠谱客的博主 稳重吐司，这篇文章主要介绍05 Numpy排序搜索计数及集合操作排序，搜索和计数集合操作，现在分享给大家，希望可以做个参考。

排序，搜索和计数

排序

numpy.sort()

  • numpy.sort(a[, axis=-1, kind='quicksort', order=None]) Return a sorted copy of an array.
    • axis：排序沿数组的（轴）方向，0表示按行，1表示按列，None表示展开来排序，默认为-1，表示沿最后的轴排序。
    • kind：排序的算法，提供了快排’quicksort’、混排’mergesort’、堆排’heapsort’， 默认为‘quicksort’。
    • order：排序的字段名，可指定字段排序，默认为None。

【例】

复制代码
1
2
3
4
5
6
7
8
9
10
import numpy as np
dt = np.dtype([('name', 'S10'), ('age', np.int)])
a = np.array([("Mike", 21), ("Nancy", 25), ("Bob", 17), ("Jane", 27)], dtype=dt)
b = np.sort(a, order='name')
print(b)
# [(b'Bob', 17) (b'Jane', 27) (b'Mike', 21) (b'Nancy', 25)]
b = np.sort(a, order='age')
print(b)
# [(b'Bob', 17) (b'Mike', 21) (b'Nancy', 25) (b'Jane', 27)]

numpy.argsort()

  • numpy.argsort(a[, axis=-1, kind='quicksort', order=None]) Returns the indices that would sort an array.
  • 排序后，想用元素的索引位置替代排序后的实际结果。

【例】对数组沿给定轴执行间接排序，并使用指定排序类型返回数据的索引数组。这个索引数组用于构造排序后的数组。

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import numpy as np
np.random.seed(20200612)
x = np.random.randint(0, 10, 10)
print(x)
# [6 1 8 5 5 4 1 2 9 1]
y = np.argsort(x)
print(y)
# [1 6 9 7 5 3 4 0 2 8]
print(x[y])
# [1 1 1 2 4 5 5 6 8 9]
y = np.argsort(-x)
print(y)
# [8 2 0 3 4 5 7 1 6 9]
print(x[y])
# [9 8 6 5 5 4 2 1 1 1]

numpy.lexsort()

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

【例】

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import numpy as np
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)
# [0 2 4 3 5 6 1]
print(x[a])
# [1 1 3 4 4 4 5]
print(b)
# [2 4 6 5 1 3 0]
print(y[b])
# [0 0 1 2 4 4 9]
z = np.lexsort([y, x])
print(z)
# [2 0 4 6 5 3 1]
print(x[z])
# [1 1 3 4 4 4 5]
z = np.lexsort([x, y])
print(z)
# [2 4 6 5 3 1 0]
print(y[z])
# [0 0 1 2 4 4 9]

numpy.partition()

  • numpy.partition(a, kth, axis=-1, kind='introselect', order=None) Return a partitioned copy of an array.

Creates a copy of the array with its elements rearranged in such a way that the value of the element in k-th position is in the position it would be in a sorted array. All elements smaller than the k-th element are moved before this element and all equal or greater are moved behind it. The ordering of the elements in the two partitions is undefined.

【例】以索引是第k大的元素为基准，将元素分成两部分，即大于该元素的放在其后面，小于该元素的放在其前面，这里有点类似于快排。

【例】选取每一列第三大的数据

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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]]
z = np.partition(x, kth=-3, axis=0)
print(z[-3])
# [17 24 17]

numpy.argpartition()

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

Perform an indirect partition along the given axis using the algorithm specified by the kind keyword. It returns an array of indices of the same shape as a that index data along the given axis in partitioned order.

【例】选取每一列第三大的数的索引

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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]]
z = np.argpartition(x, kth=-3, axis=0)
print(z[-3])
# [2 1 7]

搜索

numpy.argmax()

  • numpy.argmax(a[, axis=None, out=None])Returns the indices of the maximum values along an axis.

numpy.argmin()

  • numpy.argmin(a[, axis=None, out=None])Returns the indices of the minimum values along an axis.

numpy.nonzero()

  • numpy.nonzero(a) Return the indices of the elements that are non-zero.

，其值为非零元素的下标在对应轴上的值。

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

【例】二维数组

复制代码
1
2
3
4
5
6
7
8
9
10
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
36
import numpy as np
x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
print(x)
# [[3 0 0]
#
[0 4 0]
#
[5 6 0]]
print(x.shape)
# (3, 3)
print(x.ndim)
# 2
y = np.nonzero(x)
print(y)
# (array([0, 1, 2, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64))
print(np.array(y))
# [[0 1 2 2]
#
[0 1 0 1]]
print(np.array(y).shape)
# (2, 4)
print(np.array(y).ndim)
# 2
y = x[np.nonzero(x)]
print(y)
# [3 4 5 6]
y = np.transpose(np.nonzero(x))
print(y)
# [[0 0]
#
[1 1]
#
[2 0]
#
[2 1]]

【例】nonzero()将布尔数组转换成整数数组进行操作。

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import numpy as np
x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(x)
# [[1 2 3]
#
[4 5 6]
#
[7 8 9]]
y = x > 3
print(y)
# [[False False False]
#
[ True
True
True]
#
[ True
True
True]]
y = np.nonzero(x > 3)
print(y)
# (array([1, 1, 1, 2, 2, 2], dtype=int64), array([0, 1, 2, 0, 1, 2], dtype=int64))
y = x[np.nonzero(x > 3)]
print(y)
# [4 5 6 7 8 9]
y = x[x > 3]
print(y)
# [4 5 6 7 8 9]

numpy.where()

  • numpy.where(condition, [x=None, y=None]) Return elements chosen from x or y depending on condition.

【例】满足条件condition，输出x，不满足输出y。

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import numpy as np
x = np.arange(10)
print(x)
# [0 1 2 3 4 5 6 7 8 9]
y = np.where(x < 5, x, 10 * x)
print(y)
# [ 0
1
2
3
4 50 60 70 80 90]
x = np.array([[0, 1, 2],
[0, 2, 4],
[0, 3, 6]])
y = np.where(x < 4, x, -1)
print(y)
# [[ 0
1
2]
#
[ 0
2 -1]
#
[ 0
3 -1]]

【例】只有condition，没有x和y，则输出满足条件 (即非0) 元素的坐标 (等价于numpy.nonzero)。这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标。

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import numpy as np
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
y = np.where(x > 5)
print(y)
# (array([5, 6, 7], dtype=int64),)
print(x[y])
# [6 7 8]
y = np.nonzero(x > 5)
print(y)
# (array([5, 6, 7], dtype=int64),)
print(x[y])
# [6 7 8]
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]

numpy.searchsorted()

  • numpy.searchsorted(a, v[, side='left', sorter=None]) Find indices where elements should be inserted to maintain order.
    • a：一维输入数组。当sorter参数为None的时候，a必须为升序数组；否则，sorter不能为空，存放a中元素的index，用于反映a数组的升序排列方式。
    • v：插入a数组的值，可以为单个元素，list或者ndarray。
    • side：查询方向，当为left时，将返回第一个符合条件的元素下标；当为right时，将返回最后一个符合条件的元素下标。
    • sorter：一维数组存放a数组元素的 index，index 对应元素为升序。

【例】

复制代码
1
2
3
4
5
6
7
8
9
import numpy as np
x = np.array([0, 1, 5, 9, 11, 18, 26, 33])
y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35])
print(y)
# [0 0 4 5 7 8]
y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], side='right')
print(y)
# [0 1 5 5 8 8]

【例】

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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]

计数

numpy.count_nonzero()

  • numpy.count_nonzero(a, axis=None) Counts the number of non-zero values in the array a.

【例】返回数组中的非0元素个数。

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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]

集合操作

构造集合

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

Returns a boolean array the same length as ar1 that is True where an element of ar1 is in ar2 and False otherwise.

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

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import numpy as np
test = np.array([0, 1, 2, 5, 0])
states = [0, 2]
mask = np.in1d(test, states)
print(mask)
# [ True False
True False
True]
print(test[mask])
# [0 2 0]
mask = np.in1d(test, states, invert=True)
print(mask)
# [False
True False
True False]
print(test[mask])
# [1 5]

求两个集合的交集：

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

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

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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.

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

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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.

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

复制代码
1
2
3
4
5
6
7
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.

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

复制代码
1
2
3
4
5
6
7
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]

最后

以上就是稳重吐司最近收集整理的关于05 Numpy排序搜索计数及集合操作排序，搜索和计数集合操作的全部内容，更多相关05内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(79)

相关文章

python使用numpy进行排序后返回相应的索引
python使用numpy进行排序后返回相应的索引
LeetCode 870. 优势洗牌（根据数值对索引排序）/ 856. 括号的分数（栈） / 801. 使序列递增的最小交换次数（动态规划）870. 优势洗牌856. 括号的分数801. 使序列递增的最小交换次数
LeetCode 870. 优势洗牌（根据数值对索引排序）/ 856. 括号的分数（栈） / 801. 使序列递增的最小交换次数（动态规划）870. 优势洗牌856. 括号的分数801. 使序列递增的最小交换次数
Numpy 索引 排序
Numpy 索引 排序
NumPy排序、搜索和计数函数NumPy - 排序、搜索和计数函数
NumPy排序、搜索和计数函数NumPy - 排序、搜索和计数函数
05 Numpy排序搜索计数及集合操作排序，搜索和计数集合操作
05 Numpy排序搜索计数及集合操作排序，搜索和计数集合操作
那些年在Opencv遇到过的Mat坑
那些年在Opencv遇到过的Mat坑
NumPy学习笔记（3）--排序与索引
NumPy学习笔记（3）--排序与索引
cvCountNonZero() opencv
cvCountNonZero() opencv

评论列表共有 0 条评论

立即
投稿
返回
顶部