numpy_5排序-搜索-计数

排序

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

y = np.sort(x)
print(y)
# [[1.73 2.32 6.22 7.54 9.78]
#  [5.17 6.93 8.25 9.28 9.76]
#  [0.01 0.19 1.73 4.23 9.27]
#  [0.88 4.29 4.97 7.32 7.99]
#  [0.07 6.99 7.9  8.95 9.05]]

y = np.sort(x, axis=0)
print(y)
# [[0.01 0.07 0.19 1.73 4.29]
#  [2.32 4.23 0.88 1.73 6.22]
#  [6.93 4.97 8.95 7.32 6.99]
#  [7.99 5.17 9.28 7.9  8.25]
#  [9.05 7.54 9.78 9.76 9.27]]

y = np.sort(x, axis=1)
print(y)
# [[1.73 2.32 6.22 7.54 9.78]
#  [5.17 6.93 8.25 9.28 9.76]
#  [0.01 0.19 1.73 4.23 9.27]
#  [0.88 4.29 4.97 7.32 7.99]
#  [0.07 6.99 7.9  8.95 9.05]]

[[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]]
[[1.73 2.32 6.22 7.54 9.78]
 [5.17 6.93 8.25 9.28 9.76]
 [0.01 0.19 1.73 4.23 9.27]
 [0.88 4.29 4.97 7.32 7.99]
 [0.07 6.99 7.9  8.95 9.05]]
[[0.01 0.07 0.19 1.73 4.29]
 [2.32 4.23 0.88 1.73 6.22]
 [6.93 4.97 8.95 7.32 6.99]
 [7.99 5.17 9.28 7.9  8.25]
 [9.05 7.54 9.78 9.76 9.27]]
[[1.73 2.32 6.22 7.54 9.78]
 [5.17 6.93 8.25 9.28 9.76]
 [0.01 0.19 1.73 4.23 9.27]
 [0.88 4.29 4.97 7.32 7.99]
 [0.07 6.99 7.9  8.95 9.05]]

import numpy as np

dt = np.dtype([('name', 'S10'), ('age', np.int64)])
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)]

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

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]

[6 1 8 5 5 4 1 2 9 1]
[1 6 9 7 5 3 4 0 2 8]
[1 1 1 2 4 5 5 6 8 9]
[8 2 0 3 4 5 7 1 6 9]
[9 8 6 5 5 4 2 1 1 1]

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

y = np.argsort(x)
print(y)
# [[3 0 4 1 2]
#  [1 0 4 2 3]
#  [0 2 3 1 4]
#  [2 4 1 3 0]
#  [1 4 3 2 0]]

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

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

y = np.array([np.take(x[i], np.argsort(x[i])) for i in range(5)])  
#numpy.take(a, indices, axis=None, out=None, mode='raise')沿轴从数组中获取元素。
print(y)
# [[1.73 2.32 6.22 7.54 9.78]
#  [5.17 6.93 8.25 9.28 9.76]
#  [0.01 0.19 1.73 4.23 9.27]
#  [0.88 4.29 4.97 7.32 7.99]
#  [0.07 6.99 7.9  8.95 9.05]]

[[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]]
[[3 0 4 1 2]
 [1 0 4 2 3]
 [0 2 3 1 4]
 [2 4 1 3 0]
 [1 4 3 2 0]]
[[2 4 2 0 3]
 [0 2 3 2 0]
 [1 3 4 3 4]
 [3 1 1 4 1]
 [4 0 0 1 2]]
[[3 0 4 1 2]
 [1 0 4 2 3]
 [0 2 3 1 4]
 [2 4 1 3 0]
 [1 4 3 2 0]]
[[1.73 2.32 6.22 7.54 9.78]
 [5.17 6.93 8.25 9.28 9.76]
 [0.01 0.19 1.73 4.23 9.27]
 [0.88 4.29 4.97 7.32 7.99]
 [0.07 6.99 7.9  8.95 9.05]]

# 按照第一列的升序或者降序对整体数据进行排序。
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]]

index = np.lexsort([-1 * x[:, 0]])
print(index)
# [4 3 1 0 2]

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

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]

[0 2 4 3 5 6 1]
[1 1 3 4 4 4 5]
[2 4 6 5 1 3 0]
[0 0 1 2 4 4 9]
[2 0 4 6 5 3 1]
[1 1 3 4 4 4 5]
[2 4 6 5 3 1 0]
[0 0 1 2 4 4 9]

# 以索引是 kth 的元素为基准，将元素分成两部分，即大于该元素的放在其后面，小于该元素的放在其前面，这里有点类似于快排。
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.sort(x, axis=0)
print(y)
# [[ 3  5  3]
#  [ 3 11  3]
#  [ 8 15  4]
#  [ 9 17 12]
#  [16 22 16]
#  [17 24 17]
#  [18 25 21]
#  [29 27 25]]

z = np.partition(x, kth=2, axis=0)
print(z)
# [[ 3  5  3]
#  [ 3 11  3]
#  [ 8 15  4]
#  [ 9 22 21]
#  [17 24 16]
#  [18 17 25]
#  [16 25 12]
#  [29 27 17]]

[[ 9 25  4]
 [ 8 24 16]
 [17 11 21]
 [ 3 22  3]
 [ 3 15  3]
 [18 17 25]
 [16  5 12]
 [29 27 17]]
[[ 3  5  3]
 [ 3 11  3]
 [ 8 15  4]
 [ 9 17 12]
 [16 22 16]
 [17 24 17]
 [18 25 21]
 [29 27 25]]
[[ 3  5  3]
 [ 3 11  3]
 [ 8 15  4]
 [ 9 22 21]
 [17 24 16]
 [18 17 25]
 [16 25 12]
 [29 27 17]]

# 选取每一列第三小的数
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=2, axis=0)
print(z)
print(z[2])
# [ 8 15  4]

[[ 9 25  4]
 [ 8 24 16]
 [17 11 21]
 [ 3 22  3]
 [ 3 15  3]
 [18 17 25]
 [16  5 12]
 [29 27 17]]
[[ 3  5  3]
 [ 3 11  3]
 [ 8 15  4]
 [ 9 22 21]
 [17 24 16]
 [18 17 25]
 [16 25 12]
 [29 27 17]]
[ 8 15  4]

# 选取每一列第三大的数据
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)
print(z[-3])
# [17 24 17]

[[ 9 25  4]
 [ 8 24 16]
 [17 11 21]
 [ 3 22  3]
 [ 3 15  3]
 [18 17 25]
 [16  5 12]
 [29 27 17]]
[[ 8  5  3]
 [ 3 11  3]
 [ 3 15  4]
 [ 9 17 12]
 [16 22 16]
 [17 24 17]
 [18 25 21]
 [29 27 25]]
[17 24 17]

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

[[ 9 25  4]
 [ 8 24 16]
 [17 11 21]
 [ 3 22  3]
 [ 3 15  3]
 [18 17 25]
 [16  5 12]
 [29 27 17]]
[[3 6 3]
 [4 2 4]
 [1 4 0]
 [0 5 6]
 [6 3 1]
 [2 1 7]
 [5 0 2]
 [7 7 5]]
[[3 6 3]
 [4 2 4]
 [1 4 0]
 [0 3 2]
 [2 1 1]
 [5 5 5]
 [6 0 6]
 [7 7 7]]

# 选取每一列第三小的数的索引
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=2, axis=0)
print(z[2])
# [1 4 0]

[[ 9 25  4]
 [ 8 24 16]
 [17 11 21]
 [ 3 22  3]
 [ 3 15  3]
 [18 17 25]
 [16  5 12]
 [29 27 17]]
[1 4 0]

# 选取每一列第三大的数的索引
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]

[[ 9 25  4]
 [ 8 24 16]
 [17 11 21]
 [ 3 22  3]
 [ 3 15  3]
 [18 17 25]
 [16  5 12]
 [29 27 17]]
[2 1 7]

搜索

# 返回沿轴最大的索引值
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]]

y = np.argmax(x)
print(y)  # 2    沿着展平数组进行搜索


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

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

[[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]]
2
[4 0 0 1 2]
[2 3 4 0 0]

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

y = np.argmin(x)
print(y)  # 10

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

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

[[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]]
10
[2 4 2 0 3]
[3 1 0 2 1]

# 针对一维数组
import numpy as np

x = np.array([0, 2, 3])
print(x)  # [0 2 3]
print(x.shape)  # (3,)
print(x.ndim)  # 1

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

[0 2 3]
(3,)
1
(array([1, 2]),)
[[1 2]]
(1, 2)
2
[[1]
 [2]]
[2 3]

# 二维数组
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]]

[[3 0 0]
 [0 4 0]
 [5 6 0]]
(3, 3)
2
(array([0, 1, 2, 2]), array([0, 1, 0, 1]))
[[0 1 2 2]
 [0 1 0 1]]
(2, 4)
2
[3 4 5 6]
[[0 0]
 [1 1]
 [2 0]
 [2 1]]

# 三维数组
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]

[[[0 1]
  [1 0]]

 [[0 1]
  [1 0]]

 [[0 0]
  [1 0]]]
(3, 2, 2)
3
[[0 0 1 1 2]
 [0 1 0 1 1]
 [1 0 1 0 0]]
(3, 5)
2
(array([0, 0, 1, 1, 2]), array([0, 1, 0, 1, 1]), array([1, 0, 1, 0, 0]))
[1 1 1 1 1]

# nonzero()将布尔数组转换成整数数组进行操作。
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]

[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[False False False]
 [ True  True  True]
 [ True  True  True]]
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
[4 5 6 7 8 9]
[4 5 6 7 8 9]

# numpy.where()满足条件condition，输出x，不满足输出y。
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]]

[0 1 2 3 4 5 6 7 8 9]
[ 0  1  2  3  4 50 60 70 80 90]
[[ 0  1  2]
 [ 0  2 -1]
 [ 0  3 -1]]

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]

(array([5, 6, 7]),)
[6 7 8]
(array([5, 6, 7]),)
[6 7 8]
(array([3, 3, 3, 3, 3, 4, 4, 4, 4, 4]), array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4]))
[26 27 28 29 30 31 32 33 34 35]
(array([3, 3, 3, 3, 3, 4, 4, 4, 4, 4]), array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4]))
[26 27 28 29 30 31 32 33 34 35]

# numpy.searchsorted()
import numpy as np

x = np.array([0, 1, 5, 9, 11, 18, 26, 33])
y = np.searchsorted(x, 15)
print(y)  # 5

y = np.searchsorted(x, 15, side='right')
print(y)  # 5

y = np.searchsorted(x, -1)
print(y)  # 0

y = np.searchsorted(x, -1, side='right')
print(y)  # 0

y = np.searchsorted(x, 35)
print(y)  # 8

y = np.searchsorted(x, 35, side='right')
print(y)  # 8

y = np.searchsorted(x, 11)
print(y)  # 4

y = np.searchsorted(x, 11, side='right')
print(y)  # 5

y = np.searchsorted(x, 0)
print(y)  # 0

y = np.searchsorted(x, 0, side='right')
print(y)  # 1

y = np.searchsorted(x, 33)
print(y)  # 7

y = np.searchsorted(x, 33, side='right')
print(y)  # 8

5
5
0
0
8
8
4
5
0
1
7
8

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]

[0 0 4 5 7 8]
[0 1 5 5 8 8]

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]

[ 1  0 26  9 33 11 18  5]
[1 0 7 3 5 6 2 4]
[0 0 4 5 7 8]
[0 1 5 5 8 8]

计数

# 返回数组中的非0元素的个数
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]

4
5
[1 1 1 1 1]
[2 3]

集合操作

# 找出数组中的唯一值并返回已排序的结果
import numpy as np

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

x = sorted(set([1, 1, 3, 2, 3, 3]))
print(x)  # [1, 2, 3]

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 2 3]
[1, 2, 3]
[1 2 3]
[[1 0 0]
 [2 3 4]]
['a' 'b' 'c']
[0 1 3]
['a' 'b' 'c']
[1 2 3 4 6]
[0 1 4 3 1 2 1]
[1 2 6 4 2 3 2]
[1 2 3 4 6]
[1 3 1 1 1]

# 前面的数组是否包含于后面的数组，返回布尔值。返回的值是针对第一个参数的数组的，所以维数和第一个参数一致，布尔值与数组的元素位置也一一对应。
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]

[ True False  True False  True]
[0 2 0]
[False  True False  True False]
[1 5]

# 求两个数组的唯一化+求交集+排序函数
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]

[1 3]
[0 2 4]
[1 0 2]
[1 2 4]
[1 2 4]
[1 2 4]
[3]

# 计算两个集合的并集，唯一化并排序
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
'''

[-2 -1  0  1  2]
[1 2 3 4 6]





'\nfunctools.reduce(function, iterable[, initializer])\n将两个参数的 function 从左至右积累地应用到 iterable 的条目，\n以便将该可迭代对象缩减为单一的值。 \n例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 是计算 ((((1+2)+3)+4)+5) 的值。 \n左边的参数 x 是积累值而右边的参数 y 则是来自 iterable 的更新值。 \n如果存在可选项 initializer，它会被放在参与计算的可迭代对象的条目之前，\n并在可迭代对象为空时作为默认值。 如果没有给出 initializer 并且 iterable 仅包含一个条目，则将返回第一项。\n\n大致相当于：\ndef reduce(function, iterable, initializer=None):\n    it = iter(iterable)\n    if initializer is None:\n        value = next(it)\n    else:\n        value = initializer\n    for element in it:\n        value = function(value, element)\n    return value\n'

# 集合的差，即元素存在于第一个函数不存在于第二个函数中。
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]

[1 2]

# 集合的对称差，即两个集合的交集的补集。简言之，就是两个数组中各自独自拥有的元素的集合。
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]

[1 2 5 6]

练习

# 如何通过第n列对一个数组进行排序
Z = np.random.randint(0,10,(3,3))
print (Z)


print (Z[Z[:,2].argsort()])

[[0 3 9]
 [4 3 6]
 [3 2 6]]
[[4 3 6]
 [3 2 6]
 [0 3 9]]

#  对x的列进行排序，先按照最后一行排序，假如两数相等则按照倒数第二行排序
import numpy as np

x=np.array([[1,2,3,4],[1,4,3,3]])
print(x)
y=np.lexsort(x,axis=0)
display(y)
display(x[:,y])

[[1 2 3 4]
 [1 4 3 3]]



array([0, 2, 3, 1])



array([[1, 3, 4, 2],
       [1, 3, 3, 4]])

# 取出每一列比第三大的数字小的数
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=2, axis=0)
y=np.array([[ x[z[i,j],j]for j in range(3)]for i in range(2)])
print(y)

np.partition(x, kth=2, axis=0)[:2]

[[ 9 25  4]
 [ 8 24 16]
 [17 11 21]
 [ 3 22  3]
 [ 3 15  3]
 [18 17 25]
 [16  5 12]
 [29 27 17]]
[[ 3  5  3]
 [ 3 11  3]]





array([[ 3,  5,  3],
       [ 3, 11,  3]])

# 从arr中提取所有奇数。
import numpy as np

arr = np.arange(10)

# 方法1
index = np.where(arr % 2 == 1)
print(arr[index])
# [1 3 5 7 9]

# 方法2
x = arr[arr % 2 == 1]
print(x)
# [1 3 5 7 9]

[1 3 5 7 9]
[1 3 5 7 9]

# 将arr中的偶数元素替换为0。
import numpy as np

arr = np.arange(10)
index = np.where(arr % 2 == 0)
arr[index] = 0
print(arr)
# [0 1 0 3 0 5 0 7 0 9]

[0 1 0 3 0 5 0 7 0 9]

# 将 arr 中的所有偶数元素替换为0，而不改变arr。
import numpy as np

arr = np.arange(10)

# 方法1
x = np.where(arr % 2 == 0, 0, arr)
print(x)
# [0 1 0 3 0 5 0 7 0 9]
print(arr)
# [0 1 2 3 4 5 6 7 8 9]

# 方法2
x = np.copy(arr)
x[x % 2 == 0] = 0
print(x)
# [0 1 0 3 0 5 0 7 0 9]
print(arr)
# [0 1 2 3 4 5 6 7 8 9]

[0 1 0 3 0 5 0 7 0 9]
[0 1 2 3 4 5 6 7 8 9]
[0 1 0 3 0 5 0 7 0 9]
[0 1 2 3 4 5 6 7 8 9]

# 获取给定数组a中前5个最大值的位置。
import numpy as np

np.random.seed(100)
a = np.random.uniform(1, 50, 20)
print(a)
# [27.62684215 14.64009987 21.80136195 42.39403048  1.23122395  6.95688692
#  33.86670515 41.466785    7.69862289 29.17957314 44.67477576 11.25090398
#  10.08108276  6.31046763 11.76517714 48.95256545 40.77247431  9.42510962
#  40.99501269 14.42961361]

# 方法1
b = np.argsort(a)
print(b)
print(b[-5:])
# [18  7  3 10 15]

# 方法2
b = np.sort(a)
b = np.where(a >= b[-5])
print(b)
# (array([ 3,  7, 10, 15, 18], dtype=int64),)

# 方法3
b = np.argpartition(a, kth=-5)
print(b[-5:])
# [18  7  3 10 15]

[27.62684215 14.64009987 21.80136195 42.39403048  1.23122395  6.95688692
 33.86670515 41.466785    7.69862289 29.17957314 44.67477576 11.25090398
 10.08108276  6.31046763 11.76517714 48.95256545 40.77247431  9.42510962
 40.99501269 14.42961361]
[ 4 13  5  8 17 12 11 14 19  1  2  0  9  6 16 18  7  3 10 15]
[18  7  3 10 15]
(array([ 3,  7, 10, 15, 18]),)
[18  7  3 10 15]

# 删除一维numpy数组中所有NaN值
import numpy as np

a = np.array([1, 2, 3, np.nan, 5, 6, 7, np.nan])
b = np.isnan(a)
c = np.where(np.logical_not(b))
print(a[c])
# [1. 2. 3. 5. 6. 7.]

[1. 2. 3. 5. 6. 7.]

# 获取给定数组a中比7大的数有多少
a=np.random.uniform(1, 50, 10)
print(a)
# len(a)-np.searchsorted(a,7,side='right')
count = 0
for i in a[np.where(a > 7)]:
    count+=1
print(count)

[22.153505   47.06146116 41.06481956 17.46948556  9.59511223 19.26877027
  1.27873686 13.36889132 39.98746292  1.74749359]
8

# 获取数组a和数组b之间的公共项。
import numpy as np

a = np.array([1, 2, 3, 2, 3, 4, 3, 4, 5, 6])
b = np.array([7, 2, 10, 2, 7, 4, 9, 4, 9, 8])
x = np.intersect1d(a, b)
print(x)  # [2 4]

[2 4]

# 从数组a中删除数组b中的所有项
import numpy as np

a = np.array([1, 2, 3, 4, 5])
b = np.array([5, 6, 7, 8, 9])
x = np.setdiff1d(a, b)
print(x)  # [1 2 3 4]

[1 2 3 4]