NumPy实现数组的去重unique函数的使用

更新时间：2026年10月30日 09:31:07 作者：知远漫谈

本文系统讲解NumPy中unique函数的核心用法与高级功能,从基础去重到高级索引、计数和多维数组处理,通过丰富示例助你高效清洗数据,提升数据科学工作效率

在数据科学和数值计算的世界中，处理重复数据是一个常见的挑战。无论是清理原始数据集、优化存储空间，还是准备数据分析的输入，去除重复元素都是一个基础而重要的操作。NumPy 作为 Python 中最强大的科学计算库之一，提供了 unique 函数来优雅地解决这个问题。

今天，我们将深入探讨 NumPy 的 unique 函数，从基础概念到高级应用，通过丰富的代码示例和实际场景，帮助你全面掌握这个强大的工具。

什么是 NumPy unique 函数？ 🤔

NumPy 的 unique 函数是专门用于查找数组中唯一元素的强大工具。它不仅可以简单地去除重复元素，还能提供额外的信息，如每个唯一元素的索引位置、返回数组中每个元素对应的唯一元素索引等。

import numpy as np

# 基础用法示例
arr = np.array([1, 2, 2, 3, 3, 3, 4, 5])
unique_elements = np.unique(arr)
print("原数组:", arr)
print("去重后:", unique_elements)

输出结果：

原数组: [1 2 2 3 3 3 4 5]
去重后: [1 2 3 4 5]

unique 函数的基本语法 🔧

让我们先来看看 unique 函数的完整语法：

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

参数详解：

ar: 输入数组
return_index: 如果为 True，返回唯一元素在原数组中的索引
return_inverse: 如果为 True，返回原数组中每个元素对应唯一数组的索引
return_counts: 如果为 True，返回每个唯一元素在原数组中出现的次数
axis: 指定沿着哪个轴进行去重操作（对于多维数组）
equal_nan: 是否将 NaN 值视为相等

基础用法示例 💡

简单去重操作

import numpy as np

# 一维数组去重
arr1d = np.array([5, 2, 8, 2, 1, 8, 9, 5])
result = np.unique(arr1d)
print("一维数组去重:", result)

# 字符串数组去重
str_arr = np.array(['apple', 'banana', 'apple', 'cherry', 'banana'])
unique_str = np.unique(str_arr)
print("字符串数组去重:", unique_str)

# 浮点数数组去重
float_arr = np.array([1.1, 2.2, 1.1, 3.3, 2.2])
unique_float = np.unique(float_arr)
print("浮点数数组去重:", unique_float)

输出结果：

一维数组去重: [1 2 5 8 9]
字符串数组去重: ['apple' 'banana' 'cherry']
浮点数数组去重: [1.1 2.2 3.3]

处理包含 NaN 的数组

# 包含 NaN 的数组
nan_arr = np.array([1, 2, np.nan, 2, 3, np.nan, 4])
unique_with_nan = np.unique(nan_arr)
print("包含 NaN 的数组去重:", unique_with_nan)

# 使用 equal_nan=False
unique_no_nan_equal = np.unique(nan_arr, equal_nan=False)
print("不将 NaN 视为相等:", unique_no_nan_equal)

输出结果：

包含 NaN 的数组去重: [ 1.  2.  3.  4. nan]
不将 NaN 视为相等: [ 1.  2. nan nan  3.  4.]

高级功能探索 🔍

返回索引信息

当设置 return_index=True 时，函数会返回唯一元素在原数组中第一次出现的位置：

arr = np.array([3, 1, 2, 1, 3, 4, 2, 5])
unique_elements, indices = np.unique(arr, return_index=True)

print("原数组:", arr)
print("唯一元素:", unique_elements)
print("首次出现的索引:", indices)

# 创建可视化映射
for i, (element, index) in enumerate(zip(unique_elements, indices)):
    print(f"元素 {element} 首次出现在索引 {index}")

输出结果：

原数组: [3 1 2 1 3 4 2 5]
唯一元素: [1 2 3 4 5]
首次出现的索引: [1 2 0 5 7]
元素 1 首次出现在索引 1
元素 2 首次出现在索引 2
元素 3 首次出现在索引 0
元素 4 首次出现在索引 5
元素 5 首次出现在索引 7

获取逆向映射

return_inverse=True 参数非常有用，它可以告诉我们原数组中的每个元素对应去重后的数组中的哪个位置：

arr = np.array([3, 1, 2, 1, 3, 4, 2])
unique_elements, inverse_indices = np.unique(arr, return_inverse=True)

print("原数组:", arr)
print("唯一元素:", unique_elements)
print("逆向索引:", inverse_indices)

# 验证逆向映射的正确性
print("\n验证逆向映射:")
for i, idx in enumerate(inverse_indices):
    print(f"arr[{i}] = {arr[i]} -> unique_elements[{idx}] = {unique_elements[idx]}")

输出结果：

原数组: [3 1 2 1 3 4 2]
唯一元素: [1 2 3 4]
逆向索引: [2 0 1 0 2 3 1]
验证逆向映射:
arr[0] = 3 -> unique_elements[2] = 3
arr[1] = 1 -> unique_elements[0] = 1
arr[2] = 2 -> unique_elements[1] = 2
arr[3] = 1 -> unique_elements[0] = 1
arr[4] = 3 -> unique_elements[2] = 3
arr[5] = 4 -> unique_elements[3] = 4
arr[6] = 2 -> unique_elements[1] = 2

统计元素出现次数

return_counts=True 可以帮助我们了解每个唯一元素在原数组中出现了多少次：

arr = np.array([1, 2, 2, 3, 3, 3, 4, 5, 5])
unique_elements, counts = np.unique(arr, return_counts=True)

print("原数组:", arr)
print("唯一元素:", unique_elements)
print("出现次数:", counts)

# 创建统计表
print("\n元素出现次数统计:")
for element, count in zip(unique_elements, counts):
    print(f"元素 {element}: 出现 {count} 次")

输出结果：

原数组: [1 2 2 3 3 3 4 5 5]
唯一元素: [1 2 3 4 5]
出现次数: [1 2 3 1 2]
元素出现次数统计:
元素 1: 出现 1 次
元素 2: 出现 2 次
元素 3: 出现 3 次
元素 4: 出现 1 次
元素 5: 出现 2 次

组合多个参数

我们可以同时使用多个参数来获取更全面的信息：

arr = np.array([5, 2, 8, 2, 1, 8, 9, 5, 1])
unique_elements, indices, inverse_indices, counts = np.unique(
    arr, 
    return_index=True, 
    return_inverse=True, 
    return_counts=True
)

print("原数组:", arr)
print("唯一元素:", unique_elements)
print("首次索引:", indices)
print("逆向索引:", inverse_indices)
print("出现次数:", counts)

# 创建综合分析报告
print("\n=== 综合分析报告 ===")
for i, (element, first_idx, count) in enumerate(zip(unique_elements, indices, counts)):
    print(f"元素 {element}: 首次出现于索引 {first_idx}, 总共出现 {count} 次")

输出结果：

原数组: [5 2 8 2 1 8 9 5 1]
唯一元素: [1 2 5 8 9]
首次索引: [4 1 0 2 6]
逆向索引: [2 1 3 1 0 3 4 2 0]
出现次数: [2 2 2 2 1]
=== 综合分析报告 ===
元素 1: 首次出现于索引 4, 总共出现 2 次
元素 2: 首次出现于索引 1, 总共出现 2 次
元素 5: 首次出现于索引 0, 总共出现 2 次
元素 8: 首次出现于索引 2, 总共出现 2 次
元素 9: 首次出现于索引 6, 总共出现 1 次

多维数组的去重操作 📊

对于多维数组，unique 函数的行为取决于 axis 参数的设置。

不指定 axis 参数

当不指定 axis 参数时，多维数组会被展平后再进行去重：

# 二维数组示例
arr_2d = np.array([[1, 2, 3],
                   [2, 3, 4],
                   [1, 2, 3]])

print("原二维数组:")
print(arr_2d)

# 默认行为：展平后去重
unique_flat = np.unique(arr_2d)
print("\n展平后去重:", unique_flat)

输出结果：

原二维数组:
[[1 2 3]
 [2 3 4]
 [1 2 3]]
展平后去重: [1 2 3 4]

指定 axis=0（按行去重）

当我们设置 axis=0 时，会按照每一行作为一个整体来进行去重：

arr_2d = np.array([[1, 2, 3],
                   [2, 3, 4],
                   [1, 2, 3],
                   [5, 6, 7],
                   [2, 3, 4]])

print("原二维数组:")
print(arr_2d)

# 按行去重
unique_rows = np.unique(arr_2d, axis=0)
print("\n按行去重后的结果:")
print(unique_rows)

# 获取更多信息
unique_rows, row_indices, inverse_row_indices, row_counts = np.unique(
    arr_2d, 
    axis=0, 
    return_index=True, 
    return_inverse=True, 
    return_counts=True
)

print("\n=== 行去重详细信息 ===")
print("唯一行:", unique_rows)
print("首次出现的行索引:", row_indices)
print("每行的逆向索引:", inverse_row_indices)
print("每行出现次数:", row_counts)

输出结果：

原二维数组:
[[1 2 3]
 [2 3 4]
 [1 2 3]
 [5 6 7]
 [2 3 4]]
按行去重后的结果:
[[1 2 3]
 [2 3 4]
 [5 6 7]]
=== 行去重详细信息 ===
唯一行: [[1 2 3]
 [2 3 4]
 [5 6 7]]
首次出现的行索引: [0 1 3]
每行的逆向索引: [0 1 0 2 1]
每行出现次数: [2 2 1]

指定 axis=1（按列去重）

类似地，设置 axis=1 会对每一列进行去重操作：

arr_2d = np.array([[1, 2, 1, 3],
                   [4, 5, 4, 6],
                   [7, 8, 7, 9]])

print("原二维数组:")
print(arr_2d)

# 按列去重
unique_cols = np.unique(arr_2d, axis=1)
print("\n按列去重后的结果:")
print(unique_cols)

# 获取详细信息
unique_cols, col_indices, inverse_col_indices, col_counts = np.unique(
    arr_2d, 
    axis=1, 
    return_index=True, 
    return_inverse=True, 
    return_counts=True
)

print("\n=== 列去重详细信息 ===")
print("唯一列索引:", col_indices)
print("每列的逆向索引:", inverse_col_indices)
print("每列出现次数:", col_counts)

输出结果：

原二维数组:
[[1 2 1 3]
 [4 5 4 6]
 [7 8 7 9]]
按列去重后的结果:
[[1 2 3]
 [4 5 6]
 [7 8 9]]
=== 列去重详细信息 ===
唯一列索引: [0 1 3]
每列的逆向索引: [0 1 0 2]
每列出现次数: [2 1 1]

实际应用场景 🎯

数据清洗和预处理

在数据分析项目中，经常需要对原始数据进行清洗。unique 函数在这方面表现出色：

# 模拟用户ID数据，可能存在重复
user_ids = np.array([1001, 1002, 1003, 1001, 1004, 1002, 1005, 1003])

print("原始用户ID数量:", len(user_ids))
print("原始用户ID:", user_ids)

# 去除重复的用户ID
unique_user_ids = np.unique(user_ids)
print("\n去重后用户ID数量:", len(unique_user_ids))
print("去重后用户ID:", unique_user_ids)

# 计算重复率
duplicate_rate = (len(user_ids) - len(unique_user_ids)) / len(user_ids) * 100
print(f"\n重复率: {duplicate_rate:.2f}%")

输出结果：

原始用户ID数量: 8
原始用户ID: [1001 1002 1003 1001 1004 1002 1005 1003]
去重后用户ID数量: 5
去重后用户ID: [1001 1002 1003 1004 1005]
重复率: 37.50%

性能测试对比

让我们比较一下不同方法的性能差异：

import time

# 创建大型数组进行性能测试
large_array = np.random.randint(0, 1000, size=100000)

# 方法1: 使用 NumPy unique
start_time = time.time()
unique_np = np.unique(large_array)
np_time = time.time() - start_time

# 方法2: 使用 Python set
start_time = time.time()
unique_set = list(set(large_array))
set_time = time.time() - start_time

# 方法3: 使用 Python list comprehension (较慢，仅作演示)
start_time = time.time()
unique_list = []
for item in large_array:
    if item not in unique_list:
        unique_list.append(item)
list_time = time.time() - start_time

print(f"数组大小: {len(large_array)}")
print(f"NumPy unique 耗时: {np_time:.6f} 秒")
print(f"Python set 耗时: {set_time:.6f} 秒")
print(f"List comprehension 耗时: {list_time:.6f} 秒")

print(f"\n结果一致性检查:")
print(f"NumPy 和 Set 结果长度相同: {len(unique_np) == len(unique_set)}")

在机器学习中的应用

在机器学习项目中，特征工程阶段经常需要用到去重操作：

# 模拟分类问题中的标签数据
labels = np.array(['cat', 'dog', 'bird', 'cat', 'fish', 'dog', 'bird', 'cat'])

print("原始标签:", labels)
print("样本数量:", len(labels))

# 获取唯一的类别标签
unique_labels, label_indices, label_counts = np.unique(
    labels, 
    return_index=True, 
    return_counts=True
)

print("\n唯一标签:", unique_labels)
print("各类别样本数量:", dict(zip(unique_labels, label_counts)))

# 计算类别分布
total_samples = len(labels)
class_distribution = {label: count/total_samples for label, count in zip(unique_labels, label_counts)}
print("\n类别分布:")
for label, ratio in class_distribution.items():
    print(f"{label}: {ratio:.2%}")

# 检查是否存在类别不平衡问题
imbalance_threshold = 0.3
is_imbalanced = any(ratio < imbalance_threshold for ratio in class_distribution.values())
print(f"\n是否存在类别不平衡: {'是' if is_imbalanced else '否'}")

输出结果：

原始标签: ['cat' 'dog' 'bird' 'cat' 'fish' 'dog' 'bird' 'cat']
样本数量: 8
唯一标签: ['bird' 'cat' 'dog' 'fish']
各类别样本数量: {'bird': 2, 'cat': 3, 'dog': 2, 'fish': 1}
类别分布:
bird: 25.00%
cat: 37.50%
dog: 25.00%
fish: 12.50%
是否存在类别不平衡: 是

处理特殊数据类型 ⚙️

结构化数组去重

NumPy 支持结构化数组，unique 函数也能很好地处理这类复杂数据：

# 定义结构化数组的数据类型
dtype = [('name', 'U10'), ('age', 'i4'), ('score', 'f4')]

# 创建结构化数组
structured_data = np.array([
    ('Alice', 25, 85.5),
    ('Bob', 30, 92.0),
    ('Charlie', 25, 85.5),  # 与 Alice 相同
    ('David', 35, 78.0),
    ('Alice', 25, 85.5),    # 重复 Alice
], dtype=dtype)

print("原始结构化数据:")
for record in structured_data:
    print(record)

# 对整个记录进行去重
unique_records = np.unique(structured_data)
print("\n去重后的结构化数据:")
for record in unique_records:
    print(record)

# 统计重复情况
_, counts = np.unique(structured_data, return_counts=True)
print(f"\n重复记录数量: {len(structured_data) - len(unique_records)}")
print(f"各记录出现次数: {counts}")

输出结果：

原始结构化数据:
('Alice', 25, 85.5)
('Bob', 30, 92.0)
('Charlie', 25, 85.5)
('David', 35, 78.0)
('Alice', 25, 85.5)
去重后的结构化数据:
('Alice', 25, 85.5)
('Bob', 30, 92.0)
('Charlie', 25, 85.5)
('David', 35, 78.0)
重复记录数量: 1
各记录出现次数: [2 1 1 1]

时间序列数据去重

在处理时间序列数据时，去重操作也很常见：

# 创建时间戳数组（模拟重复的时间戳）
timestamps = np.array([
    '2023-01-01T10:00:00',
    '2023-01-01T10:01:00',
    '2023-01-01T10:00:00',  # 重复
    '2023-01-01T10:02:00',
    '2023-01-01T10:01:00',  # 重复
    '2023-01-01T10:03:00'
], dtype='datetime64[s]')

print("原始时间戳:")
for ts in timestamps:
    print(ts)

# 去重时间戳
unique_timestamps = np.unique(timestamps)
print("\n去重后时间戳:")
for ts in unique_timestamps:
    print(ts)

# 分析时间间隔
time_diffs = np.diff(unique_timestamps)
print("\n相邻时间间隔:")
for diff in time_diffs:
    print(f"{diff} 秒")

输出结果：

原始时间戳:
2023-01-01T10:00:00
2023-01-01T10:01:00
2023-01-01T10:00:00
2023-01-01T10:02:00
2023-01-01T10:01:00
2023-01-01T10:03:00

去重后时间戳:
2023-01-01T10:00:00
2023-01-01T10:01:00
2023-01-01T10:02:00
2023-01-01T10:03:00

相邻时间间隔:
60 seconds
60 seconds
60 seconds

错误处理和边界情况 ⚠️

处理空数组

# 空数组的情况
empty_array = np.array([])
try:
    unique_empty = np.unique(empty_array)
    print("空数组去重结果:", unique_empty)
    print("结果类型:", type(unique_empty))
    print("结果形状:", unique_empty.shape)
except Exception as e:
    print(f"错误: {e}")

输出结果：

空数组去重结果: []
结果类型: <class 'numpy.ndarray'>
结果形状: (0,)

处理全相同元素的数组

# 全相同元素的数组
same_elements = np.array([5, 5, 5, 5, 5])
unique_same = np.unique(same_elements)
print("全相同元素数组去重:", unique_same)

# 获取详细信息
unique_elements, indices, inverse_indices, counts = np.unique(
    same_elements,
    return_index=True,
    return_inverse=True,
    return_counts=True
)

print("唯一元素:", unique_elements)
print("首次索引:", indices)
print("逆向索引:", inverse_indices)
print("出现次数:", counts)

输出结果：

全相同元素数组去重: [5]
唯一元素: [5]
首次索引: [0]
逆向索引: [0 0 0 0 0]
出现次数: [5]

处理包含无穷大的数组

# 包含无穷大的数组
inf_array = np.array([1, np.inf, 2, np.inf, 3, -np.inf, 1])
unique_inf = np.unique(inf_array)
print("包含无穷大的数组去重:", unique_inf)

# 检查特殊值
print("是否包含正无穷:", np.isinf(unique_inf).any())
print("是否包含负无穷:", np.isneginf(unique_inf).any())
print("是否包含 NaN:", np.isnan(unique_inf).any())

输出结果：

包含无穷大的数组去重: [-inf   1.   2.   3.  inf]
是否包含正无穷: True
是否包含负无穷: True
是否包含 NaN: False

性能优化技巧 ⚡

内存效率考虑

当处理大型数组时，内存使用是一个重要考虑因素：

import sys

# 创建不同大小的数组进行内存测试
sizes = [1000, 10000, 100000]
for size in sizes:
    # 原始数组
    original_array = np.random.randint(0, size//10, size=size)
    
    # 去重后的数组
    unique_array = np.unique(original_array)
    
    # 计算内存使用
    original_memory = sys.getsizeof(original_array)
    unique_memory = sys.getsizeof(unique_array)
    
    print(f"数组大小: {size}")
    print(f"原始数组内存: {original_memory:,} bytes")
    print(f"去重后内存: {unique_memory:,} bytes")
    print(f"内存节省: {(original_memory - unique_memory)/original_memory*100:.2f}%")
    print("-" * 40)

并行处理大数组

对于超大数组，可以考虑分块处理：

def chunk_unique(arr, chunk_size=10000):
    """
    分块处理大数组的去重操作
    """
    chunks = []
    for i in range(0, len(arr), chunk_size):
        chunk = arr[i:i+chunk_size]
        chunk_unique_vals = np.unique(chunk)
        chunks.append(chunk_unique_vals)
    
    # 合并所有块的结果
    combined = np.concatenate(chunks)
    final_unique = np.unique(combined)
    
    return final_unique

# 测试分块处理
large_array = np.random.randint(0, 10000, size=100000)
regular_unique = np.unique(large_array)
chunked_unique = chunk_unique(large_array)

print("常规去重结果长度:", len(regular_unique))
print("分块去重结果长度:", len(chunked_unique))
print("结果一致性:", np.array_equal(np.sort(regular_unique), np.sort(chunked_unique)))

与其他库的集成 🔄

与 Pandas 的结合使用

虽然 Pandas 有自己的去重方法，但有时仍需要与 NumPy 的 unique 函数配合使用：

import pandas as pd

# 创建 DataFrame
df = pd.DataFrame({
    'A': [1, 2, 2, 3, 3, 3],
    'B': ['x', 'y', 'y', 'z', 'z', 'z'],
    'C': [10, 20, 20, 30, 30, 30]
})

print("原始 DataFrame:")
print(df)

# 使用 Pandas 的 drop_duplicates
pandas_dedup = df.drop_duplicates()
print("\nPandas 去重结果:")
print(pandas_dedup)

# 使用 NumPy unique 处理特定列
unique_values_A, counts_A = np.unique(df['A'], return_counts=True)
print(f"\n列 A 的唯一值及出现次数:")
for val, count in zip(unique_values_A, counts_A):
    print(f"  {val}: {count} 次")

与 Matplotlib 的结合使用

去重后的数据常用于可视化：

import matplotlib.pyplot as plt

# 生成带有重复值的数据
data = np.random.choice(['A', 'B', 'C', 'D'], size=1000, p=[0.1, 0.3, 0.4, 0.2])
# 添加一些重复项
data = np.concatenate([data, data[:100]])  # 人为增加重复

# 去重并统计
unique_items, counts = np.unique(data, return_counts=True)

# 创建条形图
plt.figure(figsize=(10, 6))
plt.bar(unique_items, counts)
plt.title('去重后的数据分布')
plt.xlabel('类别')
plt.ylabel('频次')
plt.show()

print("数据分布统计:")
for item, count in zip(unique_items, counts):
    percentage = count / len(data) * 100
    print(f"{item}: {count} ({percentage:.1f}%)")

最佳实践建议 ✅

1. 根据需求选择合适的参数组合

# 示例：根据不同的业务需求选择不同的参数
def smart_unique_analysis(data, analysis_type='basic'):
    """
    智能去重分析函数
    """
    if analysis_type == 'basic':
        return np.unique(data)
    elif analysis_type == 'with_indices':
        return np.unique(data, return_index=True, return_inverse=True)
    elif analysis_type == 'full':
        return np.unique(data, return_index=True, return_inverse=True, return_counts=True)
    else:
        raise ValueError("Invalid analysis_type")

# 测试不同类型的分析
test_data = np.array([1, 2, 2, 3, 3, 3, 4, 5])
print("基础去重:", smart_unique_analysis(test_data, 'basic'))
print("带索引去重:", smart_unique_analysis(test_data, 'with_indices'))
print("完整分析:", smart_unique_analysis(test_data, 'full'))

2. 处理大数据集的策略

def efficient_unique_large_dataset(data, threshold=100000):
    """
    高效处理大数据集的去重函数
    """
    if len(data) < threshold:
        # 小数据集直接处理
        return np.unique(data)
    else:
        # 大数据集采用分块处理
        print(f"处理大数据集 (大小: {len(data)})...")
        chunk_size = threshold // 10
        chunks = []
        
        for i in range(0, len(data), chunk_size):
            chunk = data[i:i+chunk_size]
            chunk_unique = np.unique(chunk)
            chunks.append(chunk_unique)
        
        # 合并并最终去重
        combined = np.concatenate(chunks)
        return np.unique(combined)

# 测试大数据集处理
large_data = np.random.randint(0, 1000, size=200000)
result = efficient_unique_large_dataset(large_data)
print(f"大数据集去重结果长度: {len(result)}")

3. 错误预防和调试

def safe_unique(data, **kwargs):
    """
    安全的去重函数，包含错误处理
    """
    try:
        # 检查输入数据
        if data is None:
            raise ValueError("输入数据不能为 None")
        
        if len(data) == 0:
            print("警告: 输入为空数组")
            return np.array([]), *[np.array([]) for _ in range(sum(kwargs.values()))]
        
        # 执行去重操作
        result = np.unique(data, **kwargs)
        return result
    
    except Exception as e:
        print(f"去重操作出错: {e}")
        return None

# 测试安全去重函数
print("正常数据测试:")
normal_data = np.array([1, 2, 2, 3, 3, 3])
result = safe_unique(normal_data)
print("结果:", result)

print("\n空数组测试:")
empty_result = safe_unique(np.array([]))
print("结果:", empty_result)

print("\nNone 输入测试:")
none_result = safe_unique(None)
print("结果:", none_result)

总结 🎉

NumPy 的 unique 函数是一个功能强大且灵活的工具，在数据科学和数值计算中发挥着重要作用。通过本文的学习，我们掌握了：

基础用法：简单的去重操作和各种参数的使用
高级功能：返回索引、逆向映射、计数等增强功能
多维数组处理：沿不同轴进行去重操作
实际应用：数据清洗、机器学习、性能优化等场景
特殊情况处理：空数组、特殊数据类型、错误处理等
最佳实践：如何高效地使用这个函数

无论你是数据科学家、机器学习工程师，还是普通的 Python 开发者，掌握 unique 函数都能让你的数据处理工作更加高效和优雅。

记住，选择合适的方法取决于你的具体需求。对于简单的去重任务，基本的 np.unique() 就足够了；而对于复杂的分析任务，合理利用其丰富的参数选项可以大大提升工作效率。

到此这篇关于NumPy实现数组的去重unique函数的使用的文章就介绍到这了,更多相关NumPy 数组去重unique内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Python numpy 点数组去重的实例

使用Python操作ArangoDB的方法步骤
这篇文章主要介绍了使用Python操作ArangoDB的方法步骤，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-02-02
Matlab之使用HeatMap实现画热图
这篇文章主要介绍了Matlab之使用HeatMap实现画热图方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2023-10-10
python爬虫之利用selenium模块自动登录CSDN
这篇文章主要介绍了python爬虫之利用selenium模块自动登录CSDN,文中有非常详细的代码示例,对正在学习python的小伙伴们有很好地帮助,需要的朋友可以参考下
2021-04-04
Python 详解通过Scrapy框架实现爬取CSDN全站热榜标题热词流程
Scrapy是用纯Python实现一个为了爬取网站数据、提取结构性数据而编写的应用框架，用途非常广泛，框架的力量，用户只需要定制开发几个模块就可以轻松的实现一个爬虫，用来抓取网页内容以及各种图片，非常之方便
2021-11-11
Python实现语音转文本的两种方法
这篇文章主要给大家介绍了关于Python实现语音转文本的两种方法,Python提供了许多工具和库来进行这些任务,本文通过实例代码介绍的非常详细,需要的朋友可以参考下
2023-06-06
如何利用pygame实现简单的五子棋游戏
这篇文章主要给大家介绍了关于如何利用pygame实现简单的五子棋游戏的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用pygame具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
2019-12-12
使用Python玩转串口(基于pySerial问题)
这篇文章主要介绍了使用Python玩转串口(基于pySerial问题),具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2023-09-09
Python Pandas实现将嵌套JSON数据转换DataFrame
对于复杂的JSON数据进行分析时,通常的做法是将JSON数据结构转换为Pandas DataFrame,所以本文就来看看将嵌套JSON数据转换为Pandas DataFrame的具体方法吧
2024-01-01
Python 变量类型详解
变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。这篇文章主要介绍了Python 变量类型详解,需要的朋友可以参考下
2018-10-10
Python反射机制实例讲解
本文主要介绍了Python反射机制实例，文中运用了大量的代码讲解Python反射机制，感兴趣的小伙伴一定不要错过这篇文章，可以参考参考
2021-08-08

NumPy实现数组的去重unique函数的使用

目录

什么是 NumPy unique 函数？ 🤔

unique 函数的基本语法 🔧

参数详解：

基础用法示例 💡

简单去重操作

处理包含 NaN 的数组

高级功能探索 🔍

返回索引信息

获取逆向映射

统计元素出现次数

组合多个参数

多维数组的去重操作 📊

不指定 axis 参数

指定 axis=0（按行去重）

指定 axis=1（按列去重）

实际应用场景 🎯

数据清洗和预处理

性能测试对比

在机器学习中的应用

处理特殊数据类型 ⚙️

结构化数组去重

时间序列数据去重

错误处理和边界情况 ⚠️

处理空数组

处理全相同元素的数组

处理包含无穷大的数组

性能优化技巧 ⚡

内存效率考虑

并行处理大数组

与其他库的集成 🔄

与 Pandas 的结合使用

与 Matplotlib 的结合使用

最佳实践建议 ✅

1. 根据需求选择合适的参数组合

2. 处理大数据集的策略

3. 错误预防和调试

总结 🎉

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具