np.unique() 进阶指南：从数据去重到特征工程的高效应用

1. 从“去重”到“洞察”：np.unique() 的降维打击

如果你用 Python 处理过数据，尤其是数值型数据，那么numpy库几乎是你绕不开的基石。而在numpy的众多函数中，np.unique()绝对是一个被严重低估的“瑞士军刀”。很多人对它的认知停留在“给数组去重”，这就像把一台超级计算机只用来做加减法。今天，我们就来彻底拆解np.unique()，看看这个看似简单的函数，如何在数据清洗、统计分析、特征工程乃至图像处理中，实现从“去重”到“洞察”的降维打击。

简单来说，np.unique()的核心功能是找出数组中的唯一值（去重）并排序。但它的强大之处在于，它不仅仅返回一个去重后的列表。通过几个关键参数，它能同步返回这些唯一值在原数组中的索引、出现次数，甚至能帮你重构一个“逆索引”数组，让你能轻松地将去重后的结果映射回原始数据。无论是统计一个用户列表里有多少个独立用户，分析一张图片使用了多少种颜色，还是快速计算一个数据集中各个类别的频次，np.unique()都能用一行代码优雅地解决。

这篇文章适合所有使用 Python 进行数据处理的朋友，无论你是刚入门的新手，还是已经写过不少数据分析脚本的老手。我们将从最基础的用法讲起，逐步深入到高级参数和实战场景，并结合我踩过的坑和总结的技巧，让你真正掌握这个高效的工具。你会发现，用好np.unique()，能让你的代码更简洁，运行更高效，数据洞察也更清晰。

2. 基础用法拆解：不止是返回唯一值

让我们先从函数签名开始，理解它的基本能力。np.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)。这个函数的核心输入是ar，即你的输入数组，它可以是任何维度的 numpy 数组，甚至列表、元组等能被转换为数组的序列。

2.1 核心功能：去重与排序

最基础的调用，就是只传入数组。np.unique()会做两件事：1. 找出所有不重复的元素；2. 将这些元素按升序排列。

import numpy as np # 示例1：一维数组 arr_1d = np.array([3, 1, 2, 3, 3, 2, 1, 5]) unique_vals = np.unique(arr_1d) print(unique_vals) # 输出：[1 2 3 5]

这里有一个非常重要的细节：返回的总是排序后的结果。[1, 2, 3, 5]而不是[3, 1, 2, 5]。这个特性在很多时候非常方便，比如你需要将类别数据编码为有序的整数时。但如果你需要保留元素首次出现的顺序，就需要用到return_index参数，我们稍后会讲。

对于多维数组，默认行为（axis=None）是先将数组展平（flatten），再对整个展平后的一维序列进行去重排序。

# 示例2：二维数组，默认展平 arr_2d = np.array([[1, 2, 2], [3, 1, 4]]) unique_vals_flat = np.unique(arr_2d) print(unique_vals_flat) # 输出：[1 2 3 4]

2.2 参数 axis：指定去重维度

axis参数是理解np.unique()对多维数组处理的关键。当axis被指定时，函数将沿着该轴寻找唯一的子数组。

# 示例3：沿行去重（axis=0） arr_2d = np.array([[1, 2, 3], [4, 5, 6], [1, 2, 3], # 与第一行重复 [7, 8, 9]]) unique_rows = np.unique(arr_2d, axis=0) print(unique_rows) # 输出： # [[1 2 3] # [4 5 6] # [7 8 9]] # 重复的第一行被去除了。 # 示例4：沿列去重（axis=1） arr_2d_col = np.array([[1, 2, 1, 2], [3, 4, 3, 4]]) unique_cols = np.unique(arr_2d_col, axis=1) print(unique_cols) # 输出： # [[1 2] # [3 4]] # 第0列和第2列重复，第1列和第3列重复，各保留一列。

这个功能在数据处理中非常实用。例如，你有一个数据集，每一行是一个样本，每一列是一个特征。如果某些样本（行）的所有特征值完全相同，那么它们很可能是重复记录，可以用axis=0快速找出唯一的样本。同样，如果某些特征（列）在所有样本上的值完全一样（例如，一个常数列），这个特征可能没有信息量，可以用axis=1来检查。

注意：axis参数是在numpy 1.13.0版本中引入的。如果你在使用较旧的代码库或环境，需要注意兼容性。使用前可以用print(np.__version__)检查你的 numpy 版本。

3. 高级返回参数：获取元数据，赋能复杂操作

np.unique()的真正威力在于它的return_*系列参数。它们允许你在一次函数调用中，不仅得到唯一值，还能获得关于这些唯一值在原数组中位置的丰富元数据，从而避免后续繁琐的循环查找。

3.1 return_index：定位首次出现位置

return_index=True会返回一个索引数组，指示每个唯一值在原始输入数组中第一次出现的位置。

arr = np.array(['b', 'c', 'a', 'b', 'c', 'a', 'a']) unique_vals, indices = np.unique(arr, return_index=True) print("唯一值:", unique_vals) # ['a' 'b' 'c'] (已排序) print("首次出现索引:", indices) # [2 0 1] # 验证：arr[indices] 应该等于 unique_vals print(arr[indices]) # ['a' 'b' 'c']

应用场景：当你需要去重，但又希望保留某种“原始顺序”时，这个参数就派上用场了。例如，你有一个按时间戳记录的事件列表，里面有很多重复事件类型。你想获取所有出现过的事件类型，但希望按照它们首次出现的时间顺序来排列，而不是按字母排序。这时，你可以结合return_index和索引排序来实现：

event_types = np.array(['login', 'purchase', 'login', 'view', 'purchase', 'logout', 'view']) unique_types, first_indices = np.unique(event_types, return_index=True) # 按照首次出现的索引排序 order_preserved_unique = unique_types[np.argsort(first_indices)] print(order_preserved_unique) # ['login' 'purchase' 'view' 'logout']

3.2 return_inverse：重构原始数组的“地图”

这是最强大也最容易被忽视的参数之一。return_inverse=True会返回一个整数数组inverse，其长度与原始输入数组ar相同。对于ar中的每个元素，inverse中对应位置的值，表示该元素在unique_vals数组中的索引。

换句话说，unique_vals[inverse]能完美地重构出原始数组ar。

arr = np.array([10, 20, 30, 20, 10, 40]) unique_vals, inverse_indices = np.unique(arr, return_inverse=True) print("原始数组:", arr) # [10 20 30 20 10 40] print("唯一值:", unique_vals) # [10 20 30 40] print("逆索引:", inverse_indices) # [0 1 2 1 0 3] # 重构验证 reconstructed = unique_vals[inverse_indices] print("重构数组:", reconstructed) # [10 20 30 20 10 40] print("是否相等:", np.array_equal(arr, reconstructed)) # True

应用场景：数据编码与分组聚合。这是return_inverse的杀手级应用。

1. 标签编码（Label Encoding）：在机器学习中，我们经常需要将字符串类型的分类标签（如‘高’，‘中’，‘低’）转换为整数（如0, 1, 2）。np.unique的return_inverse可以直接完成这个操作，并且保证编码的一致性。

   categories = np.array(['medium', 'high', 'low', 'high', 'low', 'medium']) unique_cats, encoded_labels = np.unique(categories, return_inverse=True) print("类别映射:", dict(zip(unique_cats, range(len(unique_cats))))) # {'high':0, 'low':1, 'medium':2} print("编码结果:", encoded_labels) # [2 0 1 0 1 2]

2. 高效分组统计：结合numpy的聚合函数，可以不用pandas就实现类似groupby的操作。例如，计算每个唯一值的和或均值。

   values = np.array([5.1, 3.5, 5.1, 4.9, 3.5, 3.5]) groups = np.array(['A', 'B', 'A', 'C', 'B', 'B']) # 分组标签 unique_groups, inverse = np.unique(groups, return_inverse=True) # 现在 inverse = [0, 1, 0, 2, 1, 1] # 我们可以利用广播和布尔索引进行分组求和 group_sums = np.zeros(len(unique_groups)) for i in range(len(unique_groups)): group_sums[i] = values[inverse == i].sum() # 更向量化的方式（推荐）： group_sums = np.bincount(inverse, weights=values) print("分组:", unique_groups) # ['A' 'B' 'C'] print("组内和:", group_sums) # [10.2 10.5 4.9]

3.3 return_counts：一键频次统计

return_counts=True直接返回每个唯一值在原始数组中出现的次数，顺序与unique_vals一一对应。

arr = np.array(['apple', 'banana', 'apple', 'orange', 'banana', 'banana']) unique_vals, counts = np.unique(arr, return_counts=True) print("唯一值:", unique_vals) # ['apple' 'banana' 'orange'] print("出现次数:", counts) # [2 3 1] # 可以方便地组合查看 for item, count in zip(unique_vals, counts): print(f"{item}: {count}次")

应用场景：这是数据探索性分析（EDA）中最常用的功能之一。快速查看数据分布、发现异常值（例如，某个类别只有1次出现，可能是录入错误）、计算类别不平衡度等。

# 计算类别不平衡比例 ratios = counts / counts.sum() print("类别占比:", ratios) # [0.33333333 0.5 0.16666667]

3.4 组合使用：一站式获取所有信息

你可以同时指定多个return_*参数，一次性获取所有需要的信息。返回的是一个元组，顺序是：(唯一值数组， 索引数组（可选）， 逆索引数组（可选）， 计数数组（可选）)。

arr = np.array([7, 5, 7, 8, 5, 5]) result = np.unique(arr, return_index=True, return_inverse=True, return_counts=True) unique_vals, indices, inverse, counts = result print(f"唯一值: {unique_vals}") # [5 7 8] print(f"首次出现索引: {indices}") # [1 0 3] -> 5在索引1，7在索引0，8在索引3 print(f"逆索引: {inverse}") # [1 0 1 2 0 0] -> 映射到unique_vals的索引 print(f"计数: {counts}") # [3 2 1] -> 5出现3次，7出现2次，8出现1次

这种“一站式”处理极大地提升了代码的简洁性和运行效率，避免了为获取不同信息而多次调用函数或编写循环。

4. 实战场景与性能陷阱

了解了所有参数后，我们来看看np.unique()在真实场景中如何应用，以及一些需要注意的性能和细节问题。

4.1 场景一：图像颜色量化与调色板提取

假设你有一张RGB图片，存储为一个形状为(height, width, 3)的 numpy 数组。你想知道这张图片一共用了多少种不同的颜色，或者提取出它的调色板（所有唯一颜色）。

# 假设 img 是一个 numpy 数组，形状为 (H, W, 3)， dtype=np.uint8 # 将三维的像素数组重塑为二维 (H*W, 3)，每一行是一个RGB颜色向量 pixels = img.reshape(-1, 3) # 沿着行轴（axis=0）寻找唯一的颜色向量 unique_colors = np.unique(pixels, axis=0) print(f"图像使用了 {len(unique_colors)} 种唯一颜色。") # unique_colors 就是图像的调色板

踩坑提醒：对于大型图像（例如 4K 图片有约 800 万个像素），直接对(8000000, 3)的数组进行np.unique操作可能会消耗大量内存和计算时间。在实际应用中，可能需要先对图像进行下采样，或者使用更专业的图像处理库（如 OpenCV）的颜色量化方法。

4.2 场景二：基于多列的组合键去重

在数据处理中，我们经常需要根据多列（多个字段）的组合来判定数据行是否重复。np.unique的axis参数可以完美处理这种情况，但前提是需要将多列组合成一个结构化数组或视图。

一种更通用的方法是利用pandas的DataFrame.drop_duplicates()。但如果你坚持用纯numpy，可以这样做：

# 假设有一个二维数组 data，形状 (N, M)，我们想根据前两列去重 data = np.array([[1, 10, 'A'], [2, 20, 'B'], [1, 10, 'C'], # 与前两行前两列重复 [3, 30, 'D']]) # 方法：创建一个关于前两列的“视图”，但需要处理成可哈希/可比较的形式 # 技巧：将数值列转换为结构化数据类型 compound_key = data[:, :2].copy().view([('col0', data.dtype), ('col1', data.dtype)]).squeeze() # 现在 compound_key 是一个一维的结构化数组 unique_keys, indices = np.unique(compound_key, return_index=True) unique_rows = data[indices] # 根据首次出现的索引获取唯一的行 print(unique_rows) # 输出： # [[1 10 'A'] # [2 20 'B'] # [3 30 'D']]

注意：这种方法有点“黑魔法”的味道，涉及到numpy的结构化数组和视图，对数据类型有要求，且不易读。对于复杂的多列去重，强烈建议使用 pandas，代码会清晰得多：df.drop_duplicates(subset=[‘col1‘， ‘col2‘])。

4.3 性能考量与替代方案

np.unique()的内部实现包含了排序步骤（这也是它能返回有序结果的原因），其时间复杂度通常是O(N log N)，其中 N 是输入数组的元素数量（或指定轴后的子数组数量）。对于非常大的数组，这可能成为瓶颈。

什么时候需要考虑替代方案？

1. 只需要判断是否有重复，不需要具体值：如果仅仅想知道数组里有没有重复元素，而不关心是哪些元素重复，使用len(np.unique(arr)) == len(arr)是低效的。因为np.unique完成了排序和去重全部工作。一个更快的替代方法是利用 Python 原生集合（set）的哈希特性，但要注意集合是无序的，且对于 numpy 数组需要先转换为列表或使用arr.flatten().tolist()，这也有转换开销。对于一维数组，可以简单比较：len(set(arr)) == len(arr)。
2. 处理超大数组且内存敏感：np.unique默认返回排序后的数组，排序过程可能需要额外内存。如果原始数组已经很大，并且你只需要唯一值而不关心顺序，理论上存在更节省内存的流式算法，但在numpy生态中通常还是用它。
3. 需要保持原始顺序的去重：如前所述，np.unique默认排序。如果你需要保留元素首次出现的顺序，标准做法是结合return_index：

   arr = np.array([‘x‘, ‘a‘, ‘x‘, ‘b‘, ‘a‘]) unique_vals, indices = np.unique(arr, return_index=True) order_preserved = arr[np.sort(indices)] print(order_preserved) # [‘x‘ ‘a‘ ‘b‘]

   但这依然进行了排序操作。对于一维数组，一个纯 Python 的、基于字典插入顺序（Python 3.7+ 字典保证有序）的方法可能在某些情况下更快，但丧失了向量化计算的优势：

   list(dict.fromkeys(arr.tolist()))

核心建议：在绝大多数情况下，np.unique()因其接口的简洁性和功能的全面性，都是首选。只有在性能 profiling 明确显示它是热点，且数据规模极大时，才值得去寻找和实现更复杂的替代方案。

5. 常见错误与疑难解答

即使是一个成熟的函数，在使用中也难免会遇到问题。下面是我总结的几个常见“坑点”。

5.1 数据类型与结构化数组的陷阱

np.unique()对数据类型很敏感。特别是当数组包含浮点数时，直接去重可能会因为浮点精度问题导致意外结果。

# 浮点数精度问题 float_arr = np.array([0.1 + 0.2, 0.3]) print(0.1 + 0.2 == 0.3) # False (浮点运算误差) unique_float = np.unique(float_arr) print(unique_float) # 可能会输出 [0.3, 0.30000000000000004] 两个“不同”的值

解决方案：在比较或去重前，对浮点数进行舍入或使用容差比较。np.unique本身不提供容差参数。一种做法是先四舍五入到指定位数：

decimals = 10 rounded_arr = np.round(float_arr, decimals) unique_rounded = np.unique(rounded_arr)

对于结构化数组（例如，记录数组），np.unique(axis=0)可以正常工作，因为它会比较整个元组（每一行）。但如果你创建视图的方式不对（如前面多列去重的例子），可能会得到意想不到的结果。

5.2 空数组与 NaN 值的处理

• 空数组：np.unique([])会返回一个空的同类型数组array([])。这通常是符合预期的。
• NaN 值：NaN(Not a Number) 在numpy中有一个重要特性：NaN != NaN。这意味着np.unique无法将多个NaN值识别为相同的元素。

arr_with_nan = np.array([1.0, np.nan, 2.0, np.nan, 1.0]) unique_with_nan = np.unique(arr_with_nan) print(unique_with_nan) # 输出可能为：[ 1. 2. nan nan] 两个 nan 都被保留！

解决方案：如果希望将NaN视为相同的值进行去重，需要在调用np.unique前先处理NaN。一种常见方法是用一个不可能出现的值（如np.inf）临时替换NaN，去重后再换回来（如果需要）。更稳健的做法是使用pandas的pd.unique()，它默认会将所有NaN视为相同。

import pandas as pd unique_pandas = pd.unique(arr_with_nan) print(unique_pandas) # 输出：[ 1. 2. nan] (注意：pandas的去重不排序)

5.3 与 pandas.Series.unique() 的对比

pandas的Series.unique()方法也是一个常用的去重工具。它们的主要区别在于：

如何选择：

• 如果你需要排序结果、计数、逆映射等高级功能，或者正在处理纯numpy数组，用np.unique。
• 如果你在处理pandas的Series或DataFrame的一列，并且希望保留原始顺序，用pd.Series.unique()。
• 如果你的数据包含NaN且希望它们被正确去重，pd.Series.unique()行为更符合直觉。

6. 举一反三：在更复杂数据上的应用思路

np.unique()的基本逻辑是“比较和归类”。我们可以将这个思路扩展到更复杂的数据对象上，虽然不能直接调用，但可以借鉴其思想。

例如，你有一个列表，里面包含多个字典，你想找出所有独特的字典（基于键值对完全匹配）。由于字典是不可哈希的（除非是frozenset形式的键值对），不能直接扔进set或np.unique。但你可以先将每个字典转换成一个可哈希的表示，比如排序后的元组序列的元组：

list_of_dicts = [{'a':1, 'b':2}, {'b':2, 'a':1}, {'c':3}] # 前两个字典相同 # 转换为可哈希的表示形式 tuple_reprs = [tuple(sorted(d.items())) for d in list_of_dicts] # 使用np.unique的return_index功能找到唯一字典的索引 _, unique_indices = np.unique(tuple_reprs, axis=0, return_index=True) unique_dicts = [list_of_dicts[i] for i in sorted(unique_indices)] # 按首次出现顺序 print(unique_dicts) # [{'a': 1, 'b': 2}, {'c': 3}]

这个例子展示了np.unique的核心思想——通过定义“唯一性”的判别标准（在这里是转换后的元组），我们可以利用它强大的向量化能力来处理复杂对象。关键在于如何将你的数据有效地转换为numpy能够理解和高效比较的数值形式。

最后，我个人在长期使用中的体会是，np.unique()是我数据预处理工具箱中最常被翻牌的几件工具之一。它的设计体现了numpy哲学：通过提供丰富、一致的接口，将复杂的逻辑封装在简单的函数调用背后。下次当你需要对数据进行归类、统计或编码时，别急着写for循环，先想想np.unique()能不能帮你一行搞定。很多时候，答案都是肯定的。