Python列表去重的20种实现方式
列表（数组）去重是最常见的算法，非常简单，但不同实现方式背后的差异巨大。AI时代，可以不手写代码了，但需要知道代码背后的原理，这样才能更好地指导AI编程。
最简单的思路
新建列表，遍历原列表，当原列表的元素不在新列表的，则添加到新列表中。
def unique(data): |
# 新建list |
new_list = [] |
for item in data: |
# 原list中的项是否存在于新list中，不存在则添加。这是 O(n)操作 |
if item not in new_list: |
new_list.append(item) |
return new_list |
这种写法最直观易懂，但每次not in都要遍历整个new_list，复杂度为 O(n²)。
如何降低复杂度呢？可以从以下角度思考：
- 哈希集合 / 字典：把查询从 O(n) 可压到 O(1)，整体 O(n)
- 先排序：相同元素两两比较再去重，O(nlogn)，但会破坏原顺序
- 函数式 / 递归：写法上换一种风格，适用不同场景，本质仍是上面的方式
相关源码见：GitHub - microwind/algorithms: 🚀AI时代，人人都是算法思想工程师。本项目含各种数据结构与经典算法，充分举例说明，用C/Java/Python/JS/Go/Rust等不同语言实现，一边学算法一边学语言。助您打牢基础，彻底理解编程的本质，以便驾驭和用好AI。 · GitHub
第1类：基础循环（方法1-8）
策略原理：遍历原数组，直接用双重循环或下标比较找出重复项。每一步判断"是否存在"都是 O(n)，整体复杂度 O(n²)。
适用场景：这里主要是展示算法原理，用于教学示例，弄懂编程原理。生产代码不建议使用。
否
是
原列表
取下一个元素
遍历结果列表
是否已存在?
追加到结果
跳过
继续
# 方法1：最基础的线性查找 |
def unique_v1(data): |
new_list = [] |
for item in data: |
# in 在列表上是 O(n) 扫描，整体 O(n²) |
# 该元素不在新list则添加 |
if item not in new_list: |
new_list.append(item) |
return new_list |
# 方法2：用下标遍历 |
def unique_v2(data): |
new_list = [] |
for i in range(len(data)): |
# 与第1种相同，遍历方式换成range，复杂度不变 |
if data[i] not in new_list: |
new_list.append(data[i]) |
return new_list |
# 方法3：列表推导式 |
def unique_v3(data): |
new_list = [] |
# 利用列表推导式的副作用追加元素，写法简化，本质与前面一样 |
[new_list.append(i) for i in data if i not in new_list] |
return new_list |
# 方法4：通过元素首次出现位置判断 |
def unique_v4(data): |
new_list = [] |
for i in range(len(data)): |
# data.index(x) 返回 x 在 data 里第一次出现的下标 |
# 当前下标恰好等于该值时，说明该元素是首次出现，将首次出现的添加到新list |
if i == data.index(data[i]): |
new_list.append(data[i]) |
return new_list |
# 方法5：原地删除（从右往左扫描） |
def unique_v5(data): |
l = len(data) |
while l > 0: |
l -= 1 |
i = l |
while i > 0: |
i -= 1 |
# 在 [0, l) 区间里寻找与 data[l] 相同的元素 |
# 找到就删后面那个，保留前面的 |
if data[i] == data[l]: |
del data[l] |
break |
return data |
# 修改原列表，空间 O(1) |
# 方法6：原地删除（从左往右扫） |
def unique_v6(data): |
l = len(data) |
i = 0 |
while i < l: |
j = i + 1 |
while j < l: |
# 把 data[i] 后面所有等于它的元素删掉 |
if data[i] == data[j]: |
del data[j] |
l -= 1 # 列表变短，长度同步更新 |
else: |
j += 1 |
i += 1 |
return data |
# 方法7：用 try-except 替代 in |
def unique_v7(data): |
new_list = [] |
for item in data: |
try: |
# index 找不到会抛 ValueError |
new_list.index(item) |
except ValueError: |
# 找不到才追加 |
new_list.append(item) |
return new_list |
# 实际上不会这么使用——拿异常处理正常的控制流，性能和可读性都吃亏 |
# 方法8：双层循环+下标判断 |
def unique_v8(data): |
new_list = [] |
for i in range(len(data)): |
j = 0 |
while j <= i: |
# 看 data[i] 在它之前是否出现过 |
if data[i] == data[j]: |
# 只有 j == i（前面都没遇到）时才追加 |
if i == j: |
new_list.append(data[i]) |
break |
j += 1 |
return new_list |
# 内层只跑到 i 而非 n，比较次数约为方法1的一半，但渐进复杂度仍是 O(n²) |
第2类：哈希表（方法9-12）
策略原理：利用dict或set的键（Key）唯一性来记录"已经出现的元素"。哈希结构的查询是 O(1)，因此整体降到 O(n)。代价是需要 O(n) 额外内存空间，且元素必须可哈希——数字、字符串、元组都可以，但 list、dict 这类可变对象不行。
适用场景：日常项目的首选。需要保留原顺序时尤其合适，因为一边查重一边按原序写入结果。
否
是
原列表
取下一个元素
已在 seen 列表中?
seen.add
追加结果
跳过
继续
# 方法9：set 配合 list——工程最常见写法 |
def unique_v9(data): |
seen = set() # set 用于 O(1) 判重 |
result = [] # list 用于保持原顺序 |
for item in data: |
if item not in seen: |
seen.add(item) |
result.append(item) |
return result |
# 方法10：dict.fromkeys()——最佳版本，实际使用首选 |
def unique_v10(data): |
# dict 自 Python 3.7 起保持插入顺序 |
# fromkeys 会自动用相同 key 覆盖，从而完成去重 |
return list(dict.fromkeys(data)) |
# 方法11：filter + 列表，函数式风格 |
def unique_v11(data): |
seen = [] |
# 内部函数 |
def check(item): |
# 闭包捕获 seen |
# 注意 seen 是 list，in 仍是 O(n)，整体仍是 O(n²) |
if item not in seen: |
seen.append(item) |
return True |
return False |
return list(filter(check, data)) |
# 函数式风格，但不纯粹，seen 类型选错了，这里只是为了展示写法 |
# 方法12：filter + 字典，由list改为dict，仍然不是纯函数式 |
def unique_v12(data): |
obj = {} |
def check(item): |
# 用 dict 替代上面的 list，查询变成 O(1) |
if obj.get(item) is None: |
obj[item] = item |
return True |
return False |
return list(filter(check, data)) |
第3类：集合与排序（方法13-16）
策略原理：将list直接转set，或者通过sort()让相同元素挨在一起再去重，从而简化查找逻辑。两种思路都不再保留原有顺序。集合方式 O(n)，排序方式 O(nlogn)，且要求元素可比较。
适用场景：不关心顺序、只关心结果集合的场合，例如统计去重数量、做集合运算、把列表当作"无序集合"使用。
哈希
有序
是
否
原列表
选择策略
转 set
天然去重
排序
相同元素相邻
相邻是否相同?
删后者
保留
结果
# 方法13：set 直接转列表，常见用法 |
def unique_v13(data): |
# 哈希集合天然不重复 |
return list(set(data)) |
# 写法最短，但顺序会被打乱 |
# 方法14：map + filter 组合 |
def unique_v14(data): |
seen = [] |
def mark(item): |
# 第一次见到返回元素本身，后续返回 None |
if item not in seen: |
seen.append(item) |
return item |
return None |
# 先 map 标记，再 filter 把 None 去掉 |
return list(filter(lambda x: x is not None, map(mark, data))) |
# 函数式风格，但 seen 用 list 仍是 O(n²) |
# 方法15：先排序再相邻去重（从右往左删） |
def unique_v15(data): |
data.sort() # 排序后，相同元素会聚到一起 |
l = len(data) |
while l > 0: |
l -= 1 |
# 相邻两两比较，相同就删后面那个 |
if l > 0 and data[l] == data[l-1]: |
del data[l] |
return data |
# 复杂度由 sort 决定，O(nlogn)；元素需要可比较 |
# 方法16：先排序再相邻去重（从左往右删） |
def unique_v16(data): |
data.sort() |
l = len(data) - 1 |
i = 0 |
while i < l: |
if data[i] == data[i+1]: |
del data[i] # 删当前，i 不前进；同时长度减一 |
i -= 1 |
l -= 1 |
i += 1 |
return data |
第4类：函数式与递归（方法17-20）
策略原理：用reduce、外部库或递归换一种表达方式。reduce配合元组累加器可以做到 O(n)，但写法比直接 for 循环晦涩；递归则吃调用栈、numpy 需要库依赖。
适用场景：numpy 适合大规模数值数据；其余几种主要用于练习函数式或递归思维，工程上一般直接用第 2 类。
是
否
是
否
列表 length=n
length <= 1?
返回
检查末尾元素
是否在前面出现
重复?
丢弃末尾
保留末尾
递归处理 length-1
# 方法17：reduce + 元组累加器（函数式风格但能跑到 O(n)） |
import functools |
def unique_v17(data): |
def foo(acc, item): |
# 累加器是一个元组 (result, seen) |
# result 保留首次出现的顺序，seen 用集合实现 O(1) 判重 |
result, seen = acc |
if item in seen: |
return (result, seen) |
# 这里直接修改累加器内部的 list 和 set |
# 严格的纯函数式应返回新对象 (result + [item], seen | {item}) |
# 但那样每步都新建列表/集合，复杂度退回到 O(n²) |
# 在 reduce 内做"受控副作用"，换取 O(n) 的性能 |
seen.add(item) |
result.append(item) |
return (result, seen) |
# 初始累加器是空列表+空集合，最后取 [0] 即得到去重结果 |
return functools.reduce(foo, data, ([], set()))[0] |
# O(n)；保序；本质是用 reduce 重写了方法9的循环 |
# 方法18：调用 numpy.unique |
def unique_v18(data): |
import numpy as np |
# numpy 底层用 C 实现的排序+相邻去重 |
return list(np.unique(np.array(data))) |
# O(nlogn)；不保序；适合大规模数值数据 |
# 方法19：递归+原地删除 |
def unique_v19(data, length=None): |
# 递归退出条件 |
if length is None: |
length = len(data) |
if length <= 1: |
return data |
last_idx = length - 1 |
# 看末尾元素是否在前面出现过 |
is_repeat = False |
for i in range(last_idx): |
if data[i] == data[last_idx]: |
is_repeat = True |
break |
# 重复则删除 |
if is_repeat: |
del data[last_idx] |
# 递归调用，处理前 length-1 项 |
return unique_v19(data, length - 1) |
# 递归深度 = n，大数据会栈溢出，仅作学习用 |
# 方法20：递归+拼接返回（不修改原列表） |
# 递归自后往前逐个调用，当长度为1时终止。与上一个递归不同，这里将不重复的项目作为结果拼接起来 |
def unique_v20(data, length=None): |
if length is None: |
length = len(data) |
if length <= 1: |
return data |
last_idx = length - 1 |
last_item = data[last_idx] |
is_repeat = False |
for i in range(last_idx): |
if data[i] == last_item: |
is_repeat = True |
break |
# 末尾元素重复就丢弃，否则拼到结果末尾 |
result = [] if is_repeat else [last_item] |
# 切片 + 拼接都会产生新列表，空间开销大 |
return unique_v20(data[:last_idx], length - 1) + result |
# 演示如何用递归构造结果，工程上没有实用价值 |