Numpy知识点总结

下面一些关于Numpy中排序、搜索和计数，还有一些关于集合的操作的汇总

排序

• numpy.sort()

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

print(np.sort(x))#默认axis=1

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

print(np.sort(x, axis=1))

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

print(np.sort(x, axis=0))

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

#自定义数据结构类型，并按照姓名排序
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()

#对数组沿给定轴执行间接排序，并使用指定排序类型返回数据的索引数组。这个索引数组用于构造排序后的数组。
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]

#二维
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)#默认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.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]]

x

array([[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]])

#根据axis=1进行排序，并输出结果等价于np.sort(x, axis=1)
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]]

• numpy.lexsort()
  用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

这里举一个应用场景：小升初考试，重点班录取学生按照总成绩录取。在总成绩相同时，数学成绩高的优先录取，在总成绩和数学成绩都相同时，按照英语成绩录取…… 这里，总成绩排在电子表格的最后一列，数学成绩在倒数第二列，英语成绩在倒数第三列。

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

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]) # Sort by x, then by y
print(z)

[2 0 4 6 5 3 1]

print(x[z])

[1 1 3 4 4 4 5]

#解释
[(x[i],y[i]) for i in z]

[(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]

z = np.lexsort([x, y])
print(z)

[2 4 6 5 3 1 0]

print(y[z])

[0 0 1 2 4 4 9]

#解释
[(y[i],x[i]) for i in z]

[(0, 1), (0, 3), (1, 4), (2, 4), (4, 4), (4, 5), (9, 1)]

• numpy.partition()

numpy.partition(a, kth, axis=-1, kind=‘introselect’, order=None)
以索引是 kth 的元素为基准，将元素分成两部分，即大于该元素的放在其后面，小于该元素的放在其前面，这里有点类似于快排。

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

#也就是说数值大小小于索引为2的数前面的所有数都排序，但之后的就不排序
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]]

#选取每一列第三小的数
z = np.partition(x, kth=2, axis=0)
print(z[2])

[ 8 15  4]

#选取每一列第三大的数据
z = np.partition(x, kth=-3, axis=0)
z

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

print(z[-3])

[17 24 17]

• numpy.argpartition()

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

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

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

#选取每一列第三大的数的索引
z = np.argpartition(x, kth=-3, axis=0)
print(z[-3])

[2 1 7]

搜索

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

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)#不加axis，默认为把矩阵按照axis=1打平
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]

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

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)#不加axis默认将矩阵按照axis = 1打平
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]

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

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

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

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

[0 2 3]
(3,)
1

y = np.nonzero(x)
print(y)
print(np.array(y)) 
print(np.array(y).shape) 
print(np.array(y).ndim) 
print(np.transpose(y))

(array([1, 2], dtype=int64),)
[[1 2]]
(1, 2)
2
[[1]
 [2]]

print(x[np.nonzero(x)])

[2 3]

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) 
print(x.ndim)

(3, 3)
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)
print(np.array(y).ndim)

(2, 4)
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]]

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

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

• 总结：就是说nonzero()，返回的是数组，源数据是几维的，它返回的就是几个数组，而这几个数组的相同索引对应起来就构成了源数据中非零元素的索引。而np.transpose(np.nonzero(x))就是将之前返回的几个数组中相对应的索引封装成一个二维矩阵

• numpy.where(condition, [x=None, y=None]) Return elements chosen from x or y depending on condition.满足条件condition，输出x，不满足输出y。

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中就包含几个数组，分别对应符合条件元素的各维坐标。

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),)

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

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(x)
print(y)

[ 0  1  5  9 11 18 26 33]
5

y = np.searchsorted(x, -1)
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)#注意此处插入了11，此时x中有两个11

5

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]

#在数组a中插入数组v（并不执行插入操作），返回一个下标列表，这个列表指明了v中对应元素应该插入在a中那个位置上
#searchsorted side的默认模式为left
#当搜索一个元组a中不存在的元素时，side模式不管用，如果这个元素比a的最小值还小，就返回0，如果比a的最大值还大，就返回数组a的长度N
#如果这个不存在的元素位于数组a的中间时，返回比它大的那个元素的位置

#如果搜索的元素存在于数组a中，left方式和right方式的返回值是不同的
#对于left，返回的是与这个元素相等的元素的位置
#对于right，返回的是与这个元素相等的元素的下一个位置
y = np.searchsorted(x, [-1, 0, 11, 15, 33, 35], side='right')
print(y)

[0 1 5 5 8 8]

计数

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

#返回数组中的非0元素个数。
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表示返回新列表元素在旧列表中出现的次数。

#找出数组中的唯一值并返回已排序的结果。
#等价于python中set操作
x = np.unique([1, 1, 3, 2, 3, 3])
x

array([1, 2, 3])

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

[1, 2, 3]

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

array([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)  
print(index) 
print(x[index]) 

['a' 'b' 'c']
[0 1 3]
['a' 'b' 'c']

x = np.array([1, 2, 6, 4, 2, 3, 2])
u, index = np.unique(x, return_inverse=True)
print(u) 
print(index) #返回旧列表元素在新列表中的位置。
print(u[index])

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

u, count = np.unique(x, return_counts=True)
print(u)
print(count)#表示返回新列表元素在旧列表中出现的次数。

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

布尔运算

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

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

#取反
mask = np.in1d(test, states, invert=True)
print(mask)
print(test[mask])

[False  True False  True False]
[1 5]

• 求两个集合的交集：

  numpy.intersect1d(ar1, ar2, assume_unique=False, return_indices=False) Find the intersection of two arrays.

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) #返回交集中元素在x中的索引
print(y_ind)# 返回交集中元素在y中的索引
print(xy) #返回x与y的交集
print(x[x_ind]) 
print(y[y_ind])

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

# 在 Python3 中，reduce() 函数已经被从全局名字空间里移
# 除了，它现在被放置在 functools 模块里，如果想要使
# 用它，则需要通过引入 functools 模块来调用
# reduce() 函数：
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.

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]

• 求两个集合的差集：

  numpy.setdiff1d(ar1, ar2, assume_unique=False) Find the set difference of two arrays.

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

x = np.setdiff1d(b, a)
print(x)

[5 6]

• 求两个集合的异或：

• setxor1d(ar1, ar2, assume_unique=False) Find the set exclusive-or of two arrays.

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