数组去重（unique()）--numpy

1. unique函数功能

返回对数组元素去重，并按升序排序的数组

2. 函数语法与参数

numpy.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None, *, equal_nan=True)
1

2.1 参数：ar

2.1.1 一维数组

import numpy as np

a1 = np.array([1, 2, 1, 4, 5, 6, 2, 7, 2, 8, 4, 3])
u_a1 = np.unique(a1)  # 一维数组去重
print('a1中的唯一值：', u_a1, sep='\n')
1
2
3
4
5

2.1.2 多维数组

a2 = np.random.randint(0, 6, 12).reshape(4, 3)
print('a2:', a2, sep='\n')
u_a2 = np.unique(a2)   # 二维数组去重
print('a2中的唯一值：', u_a2, sep='\n')
1
2
3
4

对于多维数组，不指定轴axis的情况下，会将数组中的所有数据展平（展平为一维数组），然后进行数据去重

2.2 参数： axis

2.2.1 二维数组

a3 = np.array([[1, 2, 1, 2], [3, 4, 4, 4], [1, 2, 2, 2], [3, 4, 4, 4], [2, 4, 2, 4]])
print('a3:', a3, sep='\n')
# 沿指定的轴方向去除数值完全相同的
u_a31 = np.unique(a3, axis=0)
print('a3中axis=0：', u_a31, sep='\n')  # 去除值完全相同行
u_a32 = np.unique(a3, axis=1)
print('a3中axis=1：', u_a32, sep='\n')  # 去除值完全相同列
1
2
3
4
5
6
7

可以看出当指定轴axis=0时，数组将数值完全相同的行保留唯一值(唯一一行)；当axis=1时数组将列取值完全相同的保留唯一值（唯一一列）

2.2.2 三维数组

a4 = np.array([[[1, 2, 1, 2], [3, 4, 4, 4], [1, 2, 2, 2], [3, 4, 4, 4], [2, 4, 2, 4]],
               [[1, 2, 1, 2], [3, 4, 4, 4], [1, 2, 2, 2], [3, 4, 4, 4], [2, 4, 2, 4]]])
print('a4:', a4, sep='\n')
# 沿指定的轴方向去除数值完全相同的轴方向数据
u_a41 = np.unique(a4, axis=0)
print('a4中axis=0：', u_a41, sep='\n')
u_a42 = np.unique(a4, axis=1)
print('a4中axis=1：', u_a42, sep='\n')
u_a43 = np.unique(a4, axis=2)
print('a4中axis=2：', u_a43, sep='\n')
1
2
3
4
5
6
7
8
9
10

当axis取值为0，将数组沿着第一轴的方向去重，得到上述结果，将与第一块相同的第二块进行了删除

当axis=1，沿着将第二轴方向去重，将数值完全相同的行删除并保留一行

当axis=2，沿着第三轴方向去重，将取值完全相同的列进行删除并保留一列

2.3 参数： return_index

2.3.1 一维数组

import numpy as np


# return_index = True
a1 = np.array([1, 2, 1, 4, 5, 6, 2, 7, 2, 8, 4, 3])
a12 = np.unique(a1, return_index=True)  # 结果以元组形式输出
print(a12)

# 解压元组
u_a21, index_a21 = np.unique(a1, return_index=True)   # 二维数组去重
print('a2中的唯一值：', u_a21, sep='\n')
print('唯一值在原数组中首次出现的索引： ', index_a21)

1
2
3
4
5
6
7
8
9
10
11
12
13

return_index=True时，将返回去重排序后的结果数组与首次出现的索引数组，两个数组组合而成的元组，可以将元组解压，分开输出。

2.3.2 二维数组

1) 沿指定轴操作去重

a3 = np.array([[1, 2, 1, 2], [3, 4, 4, 4], [1, 2, 2, 2], [3, 4, 4, 4], [2, 4, 2, 4]])
print('a3:', a3, sep='\n')
# return_index = True
a31, index_a31 = np.unique(a3, axis=0, return_index=True)
print('对a3去重： ', a31, sep='\n')
print('唯一值在原数组中首次出现的索引： ', index_a31)
1
2
3
4
5
6

沿着axis=0方向的数组，索引值为1和索引值为3的完全一致，存在重复，首先会对这两行数据去重，然后按照第一列的数据大小升序排序，得到去重后的数组a3；a3中的第一行【1 2 1 2】在原数组中首次出现的索引为0，【1 2 2 2】在原数组中首次出现的索引为2，【2 4 2 4】在原数组中首次出现的索引为4， 【3 4 4 4】在原数组中首次出现的位置为1，也就是输出的index_a31的值。

2) 不指定去重轴，将数组展开后去重

import numpy as np

a3 = np.array([[1, 2, 1, 2], [3, 4, 4, 4], [1, 2, 5, 6], [3, 4, 4, 4], [2, 4, 7, 8]])
print('a3:', a3, sep='\n')
a31, index_a31 = np.unique(a3, return_index=True)

print('去重后得到唯一值的数组a31: ', a31, sep='\n')
print('唯一值在原数数组中首次出现的索引index_a31： ', index_a31, sep='\n')

1
2
3
4
5
6
7
8
9

在不指定轴axis时，将数组a3展开后去重并按照升序排列，展开方式为先行后列，即：先按行进行，每行结束，开始下一行从左到右展开，如此循环进行至最后。

2.3.3 三维数组

a4 = np.array([[[1, 2, 1, 2], [3, 4, 4, 4], [1, 2, 2, 2], [3, 4, 4, 4], [2, 4, 2, 4]],
               [[1, 2, 1, 2], [3, 4, 4, 4], [1, 2, 2, 2], [3, 4, 4, 4], [2, 4, 2, 4]]])
print('a4:', a4, sep='\n')
a41, index_a41 = np.unique(a4, axis=1, return_index=True)
print('对a4去重： ', a41, sep='\n')
print('唯一值在原数组中初次出现的索引： ', index_a41)
1
2
3
4
5
6

返回的所以列表是，去重后的行在原数组中第一次出现的索引位置，具体可参见上面的二维数组一样。

2.4 return_inverse=True

2.4.1 一维数组

import numpy as np

a1 = np.array([1, 2, 1, 4, 5, 6, 2, 7, 2, 8, 4, 3])
a13 = np.unique(a1, return_index=True, return_inverse=True)  # 结果以元组形式输出
print(a13)
# 解压元组
a13, index_a13, inverse_a13 = np.unique(a1, return_index=True, return_inverse=True)
print('数组a1: ', a1, sep='\n')
print('去重后得到唯一值的数组a13: ', a13, sep='\n')
# print('唯一值在原数组中首次出现的位置index_a13: ', index_a13, sep='\n')
print('数组inverse_a13: ', inverse_a13, sep='\n')


1
2
3
4
5
6
7
8
9
10
11
12
13

参数return_inverse=True时，将返回原始数组a1的各个值在去重后数组a13中的索引位置
对于数组a1,可以根据去重后的数组a13和inverse_a13的索引值还原得到数组a1的值。如：数组a1的第一个值，在去重后的数组a13的索引位置为0，即数值1；数组a1的第二个值，在去重后的数组a13的索引位置为1，即数值2；…数组a1的第十二个值，在去重后的数组a13的索引位置为2，即数值3；

2.4.2 二维数组

1） 指定轴axis

import numpy as np

a3 = np.array([[1, 2, 1, 2], [3, 4, 4, 4], [1, 2, 2, 2], [3, 4, 4, 4], [2, 4, 2, 4]])
a31, inverse_a31 = np.unique(a3, axis=0, return_inverse=True)
print('a3:', a3, sep='\n')
print('去重后得到唯一值的数组a31: ', a31, sep='\n')
print('数组inverse_a31: ', inverse_a31, sep='\n')

1
2
3
4
5
6
7
8

原始数组a3的行对应于去重后的数组a31中的索引分别为【0 3 1 3 2】，通过这个索引对应去a31中找对应的行，可以还原出来数组a3；

2） 不指定axis，将数组展平后去重

import numpy as np

a3 = np.array([[1, 2, 1, 2], [3, 4, 4, 4], [1, 2, 2, 2], [3, 4, 4, 4], [2, 4, 2, 4]])
a31, inverse_a31 = np.unique(a3,  return_inverse=True)
print('a3:', a3, sep='\n')
print('去重后得到唯一值的数组a31: ', a31, sep='\n')
print('数组inverse_a31: ', inverse_a31, sep='\n')
1
2
3
4
5
6
7

2.5 参数： return_counts=True

2.5.1 一维数组

import numpy as np

# 以元组形式输出结果
a1 = np.array([1, 2, 1, 4, 5, 6, 2, 7, 2, 8, 4, 3])
print('数组a1:', a1, sep='\n')
u_a1 = np.unique(a1, return_counts=True)  # 一维数组去重
print('a1中的唯一值：', u_a1, sep='\n')

# 解压元组
u_a1, a1_count = np.unique(a1, return_counts=True)  # 一维数组去重
print('a1中的唯一值：', u_a1, sep='\n')
print('a1中的唯一值计数：', a1_count, sep='\n')
1
2
3
4
5
6
7
8
9
10
11
12

当参数return_counts=True时，输出的结果为去重排序后的数组中各个唯一值在原数组中出现的次数，如下图所示： 数值1在原始数组a1中出出现了两次，对应的计数数组a1_count中的值为2；数值2在原始数组a1中出出现了三次，对应的计数数组a1_count中的值为3.

2.5.2 二维数组

1) 指定轴axis

import numpy as np

a3 = np.array([[1, 2, 1, 2], [3, 4, 4, 4], [1, 2, 5, 6], [3, 4, 4, 4], [2, 4, 7, 8]])
print('a3:', a3, sep='\n')
# 沿指定的轴方向去除数值完全相同的
u_a31, a31_counts = np.unique(a3, axis=0, return_counts=True)
print('a3沿axis=0去重：', u_a31, sep='\n')
print('a3沿axis=0去重后对唯一行计数：', a31_counts, sep='\n')

1
2
3
4
5
6
7
8
9

去重排序后的各行在原始数组中分别出现了1，1，1，2次

2）不指定轴axis

import numpy as np

a3 = np.array([[1, 2, 1, 2], [3, 4, 4, 4], [1, 2, 5, 6], [3, 4, 4, 4], [2, 4, 7, 8]])
print('a3:', a3, sep='\n')
# 沿指定的轴方向去除数值完全相同的
u_a31, a31_counts = np.unique(a3, return_counts=True)
print('a3沿axis=0去重：', u_a31, sep='\n')
print('a3沿axis=0去重后对唯一行计数：', a31_counts, sep='\n')

1
2
3
4
5
6
7
8
9

从结果和上图可知，数值2在原始数组中出现了4次。

3. 返回值

函数的返回值包括以下几部分：

后三个返回值，只有当对应的参数为True时才会返回，默认只返回去重排序后的数组。