异常教程

Python 列出一个列表中的所有重复元素（超详细）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

前言：重复元素的现实意义

在编程中，列表（List）是最基础的数据结构之一，它记录着一系列有序的元素。然而，当列表中出现重复元素时，我们可能需要快速定位这些重复项。例如，在电商场景中，用户可能重复下单同一商品；在数据分析中，数据集可能包含重复的观测值。此时，Python 列表重复元素的检测与提取就成为了一个关键技能。本文将从零开始，逐步讲解如何高效实现这一目标，并提供多个实战案例。

一、基础概念：列表与重复元素的定义

1.1 列表的特性

列表是 Python 中可变、有序的容器，支持重复元素。例如，[1, 2, 2, 3] 是一个合法列表，其中 2 出现了两次。列表的索引从 0 开始，且元素可以是任意类型（数字、字符串等）。

1.2 重复元素的判定标准

重复元素的定义是：在列表中出现超过一次的元素。例如：

my_list = [5, "apple", "apple", 3.14, "apple"]

1.3 初级方法：遍历与条件判断

对于编程新手，最直观的方法可能是通过循环遍历列表，记录每个元素的出现次数。例如：

def find_duplicates(lst):  
    duplicates = []  
    seen = set()  # 存储已出现过的元素  
    for item in lst:  
        if item in seen:  
            duplicates.append(item)  
        else:  
            seen.add(item)  
    return duplicates  

print(find_duplicates([1, 2, 2, 3, 3, 3]))  # 输出：[2, 3, 3]

注意：此方法会返回所有重复元素的所有实例（如 3 出现三次会被记录两次）。若需仅保留唯一重复元素，需进一步处理。

二、核心方法：五种实现方案的对比

以下将介绍五种常见方法，从简单到复杂逐步展开。

2.1 方法一：使用字典统计次数

通过字典（Dictionary）记录每个元素的出现次数，最终筛选出次数大于 1 的元素。

def get_duplicates_dict(lst):  
    count_dict = {}  
    for item in lst:  
        count_dict[item] = count_dict.get(item, 0) + 1  
    return [k for k, v in count_dict.items() if v > 1]  

test_list = ["a", "b", "a", "c", "b", "d"]  
print(get_duplicates_dict(test_list))  # 输出：['a', 'b']

优点：逻辑清晰，易于理解；时间复杂度为 O(n)。
缺点：需要额外存储字典的空间。

2.2 方法二：集合（Set）的特性

利用集合的无序、唯一性特性，通过两次遍历找出重复元素：

def find_repeats_set(lst):  
    seen = set()  
    duplicates = set()  
    for item in lst:  
        if item in seen:  
            duplicates.add(item)  
        else:  
            seen.add(item)  
    return list(duplicates)  

print(find_repeats_set([10, 20, 20, 30, 10, 40]))  # 输出：[10, 20]

优点：仅需 O(n) 时间和空间，且结果不含重复值。
缺点：无法获取元素的重复次数。

2.3 方法三：使用 collections.Counter

Python 标准库中的 Counter 类专门用于计数，简化了统计流程：

from collections import Counter  

def duplicates_with_counter(lst):  
    counts = Counter(lst)  
    return [item for item, cnt in counts.items() if cnt > 1]  

print(duplicates_with_counter(["x", "y", "x", "z", "y"]))  # 输出：['x', 'y']

优点：代码简洁，性能优化。
缺点：需导入第三方模块。

2.4 方法四：排序后比较相邻元素

通过排序列表，重复元素会相邻出现，适合内存有限的场景：

def find_duplicates_sorted(lst):  
    sorted_list = sorted(lst)  
    duplicates = []  
    for i in range(1, len(sorted_list)):  
        if sorted_list[i] == sorted_list[i-1]:  
            # 避免重复添加（如连续三个相同元素）  
            if sorted_list[i] not in duplicates:  
                duplicates.append(sorted_list[i])  
    return duplicates  

print(find_duplicates_sorted([5, 3, 3, 5, 2, 5]))  # 输出：[3, 5]

优点：无需额外数据结构，适合小规模列表。
缺点：排序本身需要 O(n log n) 时间，且会改变原始列表顺序。

2.5 方法五：列表推导式与 count() 方法

直接调用列表的 count() 方法，但需注意其时间复杂度：

def duplicates_using_count(lst):  
    return list({x for x in lst if lst.count(x) > 1})  

test_list = [100, 200, 100, 300, 300, 300]  
print(duplicates_using_count(test_list))  # 输出：[100, 300]

注意：count() 方法内部会遍历整个列表，因此总时间复杂度为 O(n²)，仅适合小列表。

三、进阶技巧与性能优化

3.1 时间与空间复杂度分析

方法时间复杂度空间复杂度
字典统计法O(n)O(n)
集合法O(n)O(n)
CounterO(n)O(n)
排序法O(n log n)O(1)
列表推导式+count()O(n²)O(1)

3.2 优化建议

  • 优先选择字典或集合：它们的时间复杂度最优。
  • 避免 count() 的嵌套使用：在大数据量时可能导致性能瓶颈。
  • 考虑元素类型：若列表元素是不可哈希类型（如字典），需改用其他方法。

四、实战案例：复杂场景的解决方案

4.1 案例一：嵌套列表中的重复元素

假设列表元素是字典或列表，需自定义比较逻辑。例如：

nested_list = [  
    {"id": 1, "name": "Alice"},  
    {"id": 2, "name": "Bob"},  
    {"id": 1, "name": "Alice"},  
    {"id": 3, "name": "Charlie"}  
]  

def find_duplicates_nested(lst, key):  
    seen = set()  
    duplicates = []  
    for item in lst:  
        identifier = item[key]  # 根据 key 提取比较字段  
        if identifier in seen:  
            duplicates.append(item)  
        else:  
            seen.add(identifier)  
    return duplicates  

print(find_duplicates_nested(nested_list, "id"))

技巧：通过指定比较字段（如 id），可灵活处理复杂数据结构。

4.2 案例二：区分大小写的字符串处理

若需忽略大小写检测重复（如 "Apple" 和 "apple" 视为相同）：

def case_insensitive_duplicates(lst):  
    lower_counts = Counter()  
    duplicates = []  
    for s in lst:  
        lower_s = s.lower()  
        lower_counts[lower_s] += 1  
        if lower_counts[lower_s] == 2:  # 第二次出现时记录  
            duplicates.append(s)  
    return duplicates  

test_strings = ["Apple", "apple", "Banana", "BANANA"]  
print(case_insensitive_duplicates(test_strings))

五、结论与建议

通过本文的讲解，读者可以掌握 Python 列出一个列表中的所有重复元素 的多种方法，并根据实际场景选择最优方案。总结如下：

  1. 基础方法：适用于理解原理，但可能效率较低。
  2. 高级方法：如 Counter 和字典统计，兼顾性能与代码简洁性。
  3. 复杂场景：需结合具体需求，例如处理嵌套数据或特殊比较逻辑。

建议读者在实际项目中优先使用 collections.Counter 或集合法，同时关注时间与空间的平衡。若列表规模较大（如超过 10^6 元素），需进一步优化算法或采用更高效的数据结构（如位图）。

掌握这一技能后，读者可以轻松应对数据清洗、去重等任务，为后续的算法学习和开发奠定基础。

最新发布

查看更多文章