python中怎么对列表去重？

最常用且高效的方法是使用set()进行去重，适用于元素可哈希且无需保留顺序的场景；若需保留原始顺序，推荐使用dict.fromkeys()（Python 3.7+），其兼具高效性与顺序保持能力；对于不可哈希元素（如列表、字典），则只能通过遍历并逐项比较的方式实现去重，虽性能较低但通用性强。这三种方法分别对应不同需求：set适合大多数常规去重，dict.fromkeys兼顾效率与顺序，手动循环则应对复杂数据类型。性能方面，前两者平均时间复杂度为O(N)，远优于第三种的O(N²)。实际应用中应根据元素类型和顺序要求选择合适方案。

在Python中对列表进行去重，最常用也最直接的方法是利用

set

解决方案

当我们需要从Python列表中移除重复项时，有几种方法可以选择，每种都有其适用场景和考量。我个人在不同情境下会灵活运用它们。

1. 使用

set()

这是最简洁也通常是最高效的方法，尤其适用于列表元素都是可哈希（hashable）类型（如数字、字符串、元组）的情况。

立即学习“Python免费学习笔记（深入）”；

original_list = [1, 2, 2, 3, 4, 4, 5, 1]
unique_list = list(set(original_list))
print(unique_list)
# 输出: [1, 2, 3, 4, 5] (顺序可能与原列表不同)

我的看法：

set

2. 使用

dict.fromkeys()

list()

这个方法利用了字典键的唯一性。

dict.fromkeys()

None

original_list = [1, 2, 2, 3, 4, 4, 5, 1]
unique_list_ordered = list(dict.fromkeys(original_list))
print(unique_list_ordered)
# 输出: [1, 2, 3, 4, 5] (保留了第一次出现的顺序)

我的看法： 这个方法简直是神器！它兼顾了简洁性和效率（内部实现也依赖哈希），同时解决了

set

3. 使用循环和新列表（适用于不可哈希元素或对性能不极致要求时）

当列表包含不可哈希的元素（如其他列表、字典或自定义对象，除非你为它们实现了

__hash__

__eq__

set

dict.fromkeys

original_list = [1, 2, [3, 4], 2, [3, 4], 5]
unique_list_manual = []
for item in original_list:
    if item not in unique_list_manual:
        unique_list_manual.append(item)
print(unique_list_manual)
# 输出: [1, 2, [3, 4], 5] (保留了原始顺序，且适用于不可哈希元素)

我的看法： 这种方法虽然看起来“笨拙”一些，但在处理复杂数据类型时却是最可靠的。它的缺点是性能可能不如基于哈希的方法，因为

item not in unique_list_manual

unique_list_manual

为什么列表去重在Python编程中如此重要？

列表去重远不止是代码上的一个小技巧，它在实际的编程工作中扮演着至关重要的角色。从数据完整性到程序性能，再到用户体验，它的影响无处不在。我经常遇到的情况是，如果不对数据进行去重，后续的逻辑可能会变得异常复杂，甚至出现错误。

想象一下，你正在处理一份用户提交的邮件列表，如果其中有重复的地址，你发出的每一封邮件都可能被发送多次，这不仅浪费资源，还可能让用户感到困扰。或者，你在分析日志文件，统计某个事件的发生次数，如果日志中存在重复的事件记录，你的统计结果就会严重偏离真实情况。

去重能帮助我们：

• 确保数据唯一性与准确性： 这是最直接的好处。无论是数据库记录、API响应还是用户输入，唯一的数据往往是进行正确分析和处理的基础。
• 优化程序性能： 处理一个较小的、无重复的数据集通常比处理一个庞大且包含冗余的数据集要快得多。减少数据量意味着更少的内存占用和更快的计算速度。
• 简化后续逻辑： 当你确信列表中的每个元素都是唯一的时，你可以更自信地编写依赖于此假设的代码，从而避免了为处理重复项而设计的额外复杂逻辑。
• 提升用户体验： 在展示数据给用户时，例如一个选项列表或一个搜索结果，去除重复项能让信息更清晰、更易读，避免混淆。

在我看来，去重是数据清洗（data cleaning）的一个基本环节，就像整理房间一样，把不必要的重复物品清理掉，才能让整个空间更有效率、更整洁。

当处理大型Python列表时，去重有哪些性能考量？

处理大型列表的去重问题，性能就成了不得不考虑的关键因素。不同的去重方法在面对海量数据时，其效率差异会非常显著。我通常会根据列表的规模和元素特性，权衡选择最合适的方案。

标书对比王

标书对比王是一款标书查重工具，支持多份投标文件两两相互比对，重复内容高亮标记，可快速定位重复内容原文所在位置，并可导出比对报告。

58

查看详情

1.

set()

• 平均时间复杂度： O(N)，其中N是列表的长度。这是因为集合的添加操作（以及检查元素是否存在）在平均情况下是常数时间复杂度O(1)。
• 最坏时间复杂度： O(N^2)。在极少数情况下，如果哈希冲突非常严重，或者Python的哈希函数设计不佳，可能会退化到O(N^2)。但在实际应用中，这种情况非常罕见。
• 内存使用： 会创建一个与原始列表大小相近的临时集合对象。对于非常大的列表，这可能是一个内存消耗点。

2.

dict.fromkeys()

• 平均时间复杂度： 同样是O(N)，与

  set()

  登录后复制
  方法类似，因为它也依赖于哈希表。
• 内存使用： 也会创建一个临时字典，其内存占用与

  set

  登录后复制
  类似。

3. 循环加

in

• 时间复杂度： O(N*M)，其中N是原始列表的长度，M是已去重列表的当前长度。在最坏情况下（例如，所有元素都是唯一的），M会逐渐增长到N，导致总时间复杂度接近O(N^2)。
• 内存使用： 除了原始列表，还会创建一个新的列表来存储唯一元素，内存占用与原始列表相似。

总结和建议：

对于大多数情况，基于哈希的

set()

dict.fromkeys()

如果列表非常庞大，比如数百万甚至上亿条记录，并且内存是一个严格的限制，你可能需要考虑流式处理或者使用更专业的库（如Pandas），而不是一次性将所有数据加载到内存中去重。但对于Python内置的数据结构而言，哈希方法依然是首选。

为了验证不同方法的性能差异，我有时会使用Python的

timeit

import timeit

# 准备一个包含大量重复项的列表
list_large = [i for i in range(10000)] * 100 # 100万个元素，1万个唯一值

# 测试 set() 方法
time_set = timeit.timeit("list(set(list_large))", globals={'list_large': list_large}, number=10)
print(f"Set method: {time_set:.4f} seconds")

# 测试 dict.fromkeys() 方法
time_dict_fromkeys = timeit.timeit("list(dict.fromkeys(list_large))", globals={'list_large': list_large}, number=10)
print(f"Dict.fromkeys method: {time_dict_fromkeys:.4f} seconds")

# 测试循环加 in 检查的方法 (对于大列表会非常慢，谨慎运行)
# time_loop = timeit.timeit("""
# unique_list_manual = []
# for item in list_large:
#     if item not in unique_list_manual:
#         unique_list_manual.append(item)
# """, globals={'list_large': list_large}, number=1) # 只运行一次，因为太慢了
# print(f"Loop method: {time_loop:.4f} seconds")

通过这样的测试，你会清晰地看到哈希方法的巨大性能优势。

如何处理不可哈希的列表元素，或者在去重时必须保持原始顺序？

在实际开发中，我们遇到的列表元素并非总是简单的数字或字符串。有时，它们可能是列表、字典或其他自定义对象，而这些类型默认是不可哈希的。同时，在某些业务场景下，列表元素的原始顺序又至关重要。这两种情况都需要我们采取更细致的去重策略。

处理不可哈希的元素：

当列表包含不可哈希的元素时，

set()

dict.fromkeys()

TypeError: unhashable type

# 包含不可哈希列表的列表
list_of_lists = [[1, 2], [3, 4], [1, 2], [5, 6], [3, 4]]

unique_list_of_lists = []
for item in list_of_lists:
    if item not in unique_list_of_lists:
        unique_list_of_lists.append(item)

print(unique_list_of_lists)
# 输出: [[1, 2], [3, 4], [5, 6]]

这里

item not in unique_list_of_lists

__eq__

[1,2] == [1,2]

True

我的思考： 这种方法虽然性能相对较低，但却是处理复杂数据类型的“万能钥匙”。如果你自定义了类，并且希望它们可以去重，你需要确保为这些类正确实现了

__eq__

set

dict.fromkeys

__hash__

在去重时保持原始顺序：

正如前面提到的，

list(set(my_list))

1. list(dict.fromkeys(my_list))

   登录后复制
   (推荐用于可哈希元素)： 这是最优雅且高效的解决方案，前提是你的列表元素都是可哈希的。从Python 3.7开始，字典会保持键的插入顺序，所以这个方法完美地结合了去重和顺序保留。

   original_data = ['apple', 'banana', 'apple', 'orange', 'banana', 'grape']
   ordered_unique_data = list(dict.fromkeys(original_data))
   print(ordered_unique_data)
   # 输出: ['apple', 'banana', 'orange', 'grape']

   登录后复制

2. 循环加

   in

   登录后复制
   检查的方法 (适用于不可哈希元素或作为通用方案)： 这种方法天生就能保持元素的原始插入顺序，因为它是一个接一个地检查并添加到新列表中。

   mixed_list = [1, 'a', [1,2], 1, 'a', {'key': 'value'}, [1,2]]
   ordered_unique_mixed = []
   for item in mixed_list:
       if item not in ordered_unique_mixed:
           ordered_unique_mixed.append(item)
   print(ordered_unique_mixed)
   # 输出: [1, 'a', [1, 2], {'key': 'value'}]

   登录后复制

我的经验之谈： 我不止一次地因为忽略了

set

以上就是python中怎么对列表去重？的详细内容，更多请关注php中文网其它相关文章！