异常教程

Python 获取列表中重复的元素（手把手讲解）

更新时间:

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

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

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

在 Python 编程中，列表（List）是一种常用的数据结构，能够灵活地存储和操作多个元素。然而，当列表中出现重复元素时，如何高效地识别并提取这些重复项，成为开发者需要解决的常见问题。无论是处理用户输入的数据、分析日志文件，还是优化算法逻辑，掌握“Python 获取列表中重复的元素”这一技能，都能显著提升编程效率。本文将从基础到进阶，系统性地讲解多种实现方法，并通过代码示例和实际案例，帮助读者理解不同场景下的最佳实践。

一、理解问题：什么是列表中的重复元素？

在开始技术讲解前，我们需要明确几个核心概念：

  1. 重复元素的定义：列表中出现两次或更多次的元素，例如列表 [1, 2, 2, 3] 中的 2 是重复元素。
  2. 重复元素的存储形式：元素可以是数字、字符串、元组等不可变类型，但列表本身不可哈希，无法直接作为元素比较。
  3. 重复元素的目标操作：可能需要仅获取重复元素的列表，或统计每个元素的重复次数。

比喻：可以将列表想象成一个抽屉，里面存放着不同颜色的球。当抽屉中某些球的颜色出现多次时，我们的任务就是找出这些“重复颜色的球”，并可能统计每种颜色出现的次数。

二、基础方法：通过遍历与嵌套循环实现

对于编程新手，最直观的解决方案可能是通过循环遍历列表，并逐个比较元素是否重复。

方法一：双重循环遍历

原理：外层循环遍历每个元素，内层循环检查该元素是否在后续位置重复出现。

def find_duplicates(lst):
    duplicates = []
    length = len(lst)
    for i in range(length):
        for j in range(i + 1, length):
            if lst[i] == lst[j] and lst[i] not in duplicates:
                duplicates.append(lst[i])
    return duplicates  

my_list = [3, 5, 2, 5, 7, 3, 8]
print(find_duplicates(my_list))  # 输出：[5, 3]

缺点：时间复杂度为 O(n²)，当列表规模较大时效率低下。

方法二：利用列表的 count() 方法

原理：遍历列表元素，若元素的 count() 大于 1，则记录该元素。

def find_duplicates(lst):
    duplicates = []
    for item in lst:
        if lst.count(item) > 1 and item not in duplicates:
            duplicates.append(item)
    return duplicates  

my_list = ["apple", "banana", "apple", "cherry", "banana"]
print(find_duplicates(my_list))  # 输出：["apple", "banana"]

缺点：count() 方法本身是线性时间操作，因此整体时间复杂度仍为 O(n²)。

三、进阶方法：使用集合（Set）与字典（Dictionary）

通过更高效的数据结构（如集合和字典），可以显著降低时间复杂度。

方法三：集合与计数器

原理：利用集合的无重复性，结合字典统计元素出现的次数。

def find_duplicates(lst):
    element_count = {}
    duplicates = []
    for item in lst:
        if item in element_count:
            element_count[item] += 1
        else:
            element_count[item] = 1
    for key, value in element_count.items():
        if value > 1:
            duplicates.append(key)
    return duplicates  

numbers = [10, 20, 20, 30, 10, 40]
print(find_duplicates(numbers))  # 输出：[10, 20]

优化点：时间复杂度为 O(n)，空间复杂度为 O(n)，适合处理大规模数据。

方法四：使用 collections 模块的 Counter

原理：Python 标准库中的 Counter 类专门用于统计可哈希对象的出现次数。

from collections import Counter  

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

words = ["hello", "world", "hello", "python", "world"]
print(find_duplicates(words))  # 输出：["hello", "world"]

优势：代码简洁，且 Counter 内部实现了高效的哈希表结构，时间复杂度仍为 O(n)。

四、高级技巧：利用生成器与集合运算

对于追求代码简洁性的开发者，可以结合生成器表达式和集合操作实现更紧凑的解决方案。

方法五：集合差集与生成器

原理：通过集合的差集操作，提取重复元素。

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

mixed_list = [True, False, True, "False", False]
print(find_duplicates(mixed_list))  # 输出：[True, False]

关键点：通过维护两个集合（seen 记录已出现元素，duplicates 记录重复元素），实现 O(n) 的时间复杂度。

五、特殊场景与扩展应用

场景一：获取重复元素及其出现次数

若需要不仅知道哪些元素重复，还想了解具体出现次数，可以返回字典格式的结果：

def get_duplicates_info(lst):
    from collections import defaultdict
    count_dict = defaultdict(int)
    for item in lst:
        count_dict[item] += 1
    return {k: v for k, v in count_dict.items() if v > 1}

data = [1, 2, 2, 3, 3, 3]
print(get_duplicates_info(data))  # 输出：{2: 2, 3: 3}

场景二：处理嵌套列表或复杂对象

当元素是列表或对象时，需确保其可哈希。例如，元组是可哈希的，而列表不是：

nested_list = [[1, 2], [3, 4], [1, 2]]
tuples = [tuple(item) for item in nested_list]
print(find_duplicates(tuples))  # 输出：[(1, 2)]

六、性能对比与选择建议

下表对比了不同方法的优缺点，帮助开发者根据实际需求选择：

方法时间复杂度空间复杂度适用场景
双重循环遍历O(n²)O(1)小规模列表，追求代码简洁性
列表 count() 方法O(n²)O(1)简单场景，无需额外存储空间
自定义字典计数O(n)O(n)大规模数据，需高效处理
CounterO(n)O(n)需要统计详细次数的场景
集合差集操作O(n)O(n)仅需获取重复元素列表

七、常见问题与解决方案

问题 1：如何区分大小写敏感的字符串重复？

在处理字符串时，默认比较是区分大小写的。若需忽略大小写，可以统一转换为小写：

strings = ["Apple", "apple", "Banana", "BANANA"]
lowercase_list = [s.lower() for s in strings]
print(find_duplicates(lowercase_list))  # 输出：["apple", "banana"]

问题 2：如何保留重复元素的原始顺序？

当前方法返回的结果可能无序。若需按首次出现顺序排列，可以结合列表推导式：

def ordered_duplicates(lst):
    seen = set()
    dup = []
    for item in lst:
        if item in seen:
            dup.append(item)
        else:
            seen.add(item)
    # 去除重复的重复项（如连续多个重复）
    return list(dict.fromkeys(dup))

print(ordered_duplicates([2, 3, 2, 4, 3, 3]))  # 输出：[2, 3]

八、总结与延伸

本文系统性地讲解了 Python 中获取列表重复元素的多种方法，从基础的循环遍历到高效的集合与字典操作，再到特殊场景的解决方案，覆盖了不同层次开发者的需求。通过实际代码示例和性能对比，读者可以快速选择适合自身项目的方案。

对于希望进一步提升技能的开发者，建议：

  1. 学习更多关于 哈希表 和 数据结构优化 的知识；
  2. 探索 Pandas 库 处理大规模数据时的去重方法；
  3. 实践 单元测试，确保代码在复杂输入下（如空列表、全重复元素）的鲁棒性。

掌握“Python 获取列表中重复的元素”不仅是解决单一问题，更是理解数据结构与算法优化的关键一步。通过持续练习与实践，开发者能够更自信地应对编程中的各类挑战。

最新发布

查看更多文章