本文探讨了多种Python中去除列表重复元素的方法，包括使用集合、列表理解、递归、pandas库以及利用OrderedDict和字典特性等，同时比较了不同方法的效率。
是否有内置的程序在保留顺序的同时从Python列表中删除重复项？ 我知道我可以使用集合来删除重复项，但这会破坏原始顺序。 我也知道我可以这样滚动自己：
def uniq(input):
output = []
for x in input:
if x not in output:
output.append(x)
return output
但是如果可能的话，我想利用一个内置的或更Pythonic的习惯用法。
相关问题： 在Python中，从列表中删除重复项以使所有元素在保持顺序唯一的同时最快的算法是什么？
#1楼
您可以引用列表理解，因为它是由符号“ _ [1]”构建的。
例如，以下函数通过引用元素的列表理解来唯一化元素列表，而不更改其顺序。
def unique(my_list):
return [x for x in my_list if x not in locals()['_[1]']]
演示：
l1 = [1, 2, 3, 4, 1, 2, 3, 4, 5]
l2 = [x for x in l1 if x not in locals()['_[1]']]
print l2
输出：
[1, 2, 3, 4, 5]
#2楼
sequence = ['1', '2', '3', '3', '6', '4', '5', '6']
unique = []
[unique.append(item) for item in sequence if item not in unique]
唯一→ ['1', '2', '3', '6', '4', '5']
#3楼
我想如果您想维持订单，
您可以尝试以下方法：
list1 = ['b','c','d','b','c','a','a']
list2 = list(set(list1))
list2.sort(key=list1.index)
print list2
或者类似地，您可以执行以下操作：
list1 = ['b','c','d','b','c','a','a']
list2 = sorted(set(list1),key=list1.index)
print list2
您也可以这样做：
list1 = ['b','c','d','b','c','a','a']
list2 = []
for i in list1:
if not i in list2:
list2.append(i)`
print list2
也可以这样写：
list1 = ['b','c','d','b','c','a','a']
list2 = []
[list2.append(i) for i in list1 if not i in list2]
print list2
#4楼
编辑2016
正如Raymond所指出的那样 ，在Python 3.5+中，其中OrderedDict是用C实现的，列表理解方法将比OrderedDict慢（除非您实际上需要列表的末尾-即使如此，仅当输入非常短时）。 因此，3.5+的最佳解决方案是OrderedDict 。
重要编辑2015
正如@abarnert所指出的那样， more_itertools库（ pip install more_itertools ）包含一个unique_everseen函数，该函数旨在解决此问题而not seen.add在列表理解中造成任何不可读的 （ not seen.add ） 突变 。 这也是最快的解决方案：
>>> from more_itertools import unique_everseen
>>> items = [1, 2, 0, 1, 3, 2]
>>> list(unique_everseen(items))
[1, 2, 0, 3]
只需导入一个简单的库，就不会有黑客入侵。 这来自itertools配方unique_everseen的实现，如下所示：
def unique_everseen(iterable, key=None):
"List unique elements, preserving order. Remember all elements ever seen."
# unique_everseen('AAAABBBCCDAABBB') --> A B C D
# unique_everseen('ABBCcAD', str.lower) --> A B C D
seen = set()
seen_add = seen.add
if key is None:
for element in filterfalse(seen.__contains__, iterable):
seen_add(element)
yield element
else:
for element in iterable:
k = key(element)
if k not in seen:
seen_add(k)
yield element
在Python 2.7+ ，
可接受的通用习惯用法
（可以使用但并未针对速度进行优化，我现在将使用unique_everseen ）用于此collections.OrderedDict ：
运行时间： O（N）
>>> from collections import OrderedDict
>>> items = [1, 2, 0, 1, 3, 2]
>>> list(OrderedDict.fromkeys(items))
[1, 2, 0, 3]
看起来比：
seen = set()
[x for x in seq if x not in seen and not seen.add(x)]
并且没有利用丑陋的hack ：
not seen.add(x)
它依赖于set.add是始终就返回None的就地方法的事实，因此not None求值结果not None True 。
但是请注意，尽管破解解决方案具有相同的运行时复杂度O（N），但其原始速度更快。
#5楼
借用在为列表定义Haskell的nub函数时使用的递归思想，这将是一种递归方法：
def unique(lst):
return [] if lst==[] else [lst[0]] + unique(filter(lambda x: x!= lst[0], lst[1:]))
例如：
In [118]: unique([1,5,1,1,4,3,4])
Out[118]: [1, 5, 4, 3]
我尝试使用它来增加数据量，并看到了次线性时间复杂度（不确定，但建议对于正常数据应该很好）。
In [122]: %timeit unique(np.random.randint(5, size=(1)))
10000 loops, best of 3: 25.3 us per loop
In [123]: %timeit unique(np.random.randint(5, size=(10)))
10000 loops, best of 3: 42.9 us per loop
In [124]: %timeit unique(np.random.randint(5, size=(100)))
10000 loops, best of 3: 132 us per loop
In [125]: %timeit unique(np.random.randint(5, size=(1000)))
1000 loops, best of 3: 1.05 ms per loop
In [126]: %timeit unique(np.random.randint(5, size=(10000)))
100 loops, best of 3: 11 ms per loop
我也认为很有趣的是，其他操作可以很容易地将其推广到唯一性。 像这样：
import operator
def unique(lst, cmp_op=operator.ne):
return [] if lst==[] else [lst[0]] + unique(filter(lambda x: cmp_op(x, lst[0]), lst[1:]), cmp_op)
例如，您可以传入一个函数，该函数使用舍入的概念将其舍入为相同的整数，就好像它是“相等”是出于唯一性目的一样，如下所示：
def test_round(x,y):
return round(x) != round(y)
然后unique（some_list，test_round）将提供列表的唯一元素，其中唯一性不再意味着传统的相等性（这是通过使用任何基于集合或基于dict-key的方法来解决的），而是意味着对于每个可能舍入到的整数K，只有第一个舍入到K的元素，例如：
In [6]: unique([1.2, 5, 1.9, 1.1, 4.2, 3, 4.8], test_round)
Out[6]: [1.2, 5, 1.9, 4.2, 3]
#6楼
_sorted_一个numpy数组的相对有效方法：
b = np.array([1,3,3, 8, 12, 12,12])
numpy.hstack([b[0], [x[0] for x in zip(b[1:], b[:-1]) if x[0]!=x[1]]])
输出：
array([ 1, 3, 8, 12])
#7楼
对于另一个非常老的问题的另一个非常晚的答案：
itertools配方使用seen设置技术具有执行此功能的功能，但是：
- 处理标准
key功能。 - 不使用不雅观的骇客。
- 通过预绑定
seen.add而不是查找N次来优化循环。 （f7也会执行此操作，但某些版本则不会。） - 通过使用
ifilterfalse优化循环，因此您只需要遍历Python中的唯一元素，而不必遍历所有元素。 （当然，您仍然可以在ifilterfalse对所有它们进行迭代，但这是在C中，并且速度更快。）
它实际上比f7快吗？ 这取决于您的数据，因此您必须对其进行测试并查看。 如果您最终想要一个列表，则f7使用listcomp，在这里没有办法做到这一点。 （您可以直接append而不是yield ，也可以将生成器输入到list函数中，但没有一个可以跟listcomp内的LIST_APPEND一样快。）无论如何，通常不会挤出几微秒的时间与拥有一个易于理解，可重用，已经编写的函数一样重要，当您要装饰时，该函数不需要DSU。
与所有食谱一样，它也可以在more-iterools 。
如果您只希望没有key情况，可以将其简化为：
def unique(iterable):
seen = set()
seen_add = seen.add
for element in itertools.ifilterfalse(seen.__contains__, iterable):
seen_add(element)
yield element
#8楼
您可以进行某种丑陋的列表理解技巧。
[l[i] for i in range(len(l)) if l.index(l[i]) == i]
#9楼
l = [1,2,2,3,3,...]
n = []
n.extend(ele for ele in l if ele not in set(n))
生成器表达式使用集合的O（1）查找来确定是否在新列表中包括元素。
#10楼
5倍速减少变体但更复杂
>>> l = [5, 6, 6, 1, 1, 2, 2, 3, 4]
>>> reduce(lambda r, v: v in r[1] and r or (r[0].append(v) or r[1].add(v)) or r, l, ([], set()))[0]
[5, 6, 1, 2, 3, 4]
说明：
default = (list(), set())
# use list to keep order
# use set to make lookup faster
def reducer(result, item):
if item not in result[1]:
result[0].append(item)
result[1].add(item)
return result
>>> reduce(reducer, l, default)[0]
[5, 6, 1, 2, 3, 4]
#11楼
一个简单的递归解决方案：
def uniquefy_list(a):
return uniquefy_list(a[1:]) if a[0] in a[1:] else [a[0]]+uniquefy_list(a[1:]) if len(a)>1 else [a[0]]
#12楼
如果您通常使用pandas ，并且美学优先于性能，那么请考虑内置函数pandas.Series.drop_duplicates ：
import pandas as pd
import numpy as np
uniquifier = lambda alist: pd.Series(alist).drop_duplicates().tolist()
# from the chosen answer
def f7(seq):
seen = set()
seen_add = seen.add
return [ x for x in seq if not (x in seen or seen_add(x))]
alist = np.random.randint(low=0, high=1000, size=10000).tolist()
print uniquifier(alist) == f7(alist) # True
定时：
In [104]: %timeit f7(alist)
1000 loops, best of 3: 1.3 ms per loop
In [110]: %timeit uniquifier(alist)
100 loops, best of 3: 4.39 ms per loop
#13楼
这将保留订单并在O（n）时间运行。 基本上，这个想法是在发现重复的地方创建一个孔，并将其沉入底部。 利用读写指针。 每当发现重复项时，只有读指针前进，写指针停留在重复项上以覆盖它。
def deduplicate(l):
count = {}
(read,write) = (0,0)
while read < len(l):
if l[read] in count:
read += 1
continue
count[l[read]] = True
l[write] = l[read]
read += 1
write += 1
return l[0:write]
#14楼
不使用导入的模块或集的解决方案：
text = "ask not what your country can do for you ask what you can do for your country"
sentence = text.split(" ")
noduplicates = [(sentence[i]) for i in range (0,len(sentence)) if sentence[i] not in sentence[:i]]
print(noduplicates)
给出输出：
['ask', 'not', 'what', 'your', 'country', 'can', 'do', 'for', 'you']
#15楼
在Python 2.7中 ，从迭代器中删除重复项并同时保持其原始顺序的新方法是：
>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']
在Python 3.5中 ，OrderedDict具有C实现。 我的时间表明，这是Python 3.5各种方法中最快也是最短的。
在Python 3.6中 ，常规字典变得有序且紧凑。 （此功能适用于CPython和PyPy，但在其他实现中可能不存在）。 这为我们提供了一种在保留订单的同时进行重复数据删除的最快方法：
>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']
在Python 3.7中 ，保证常规dict在所有实现中都排序。 因此，最短，最快的解决方案是：
>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']
对@max的响应：移至3.6或3.7并使用常规dict而不是OrderedDict之后 ，就无法以任何其他方式真正击败性能。 该词典非常密集，几乎可以无开销地转换为列表。 目标列表的大小预先设置为len（d），这样可以保存列表推导中发生的所有调整大小。 同样，由于内部键列表很密集，因此指针的复制几乎快如列表副本。
#16楼
只是要从外部模块1添加这种功能的另一种（非常有效的）实现： iteration_utilities.unique_everseen ：
>>> from iteration_utilities import unique_everseen
>>> lst = [1,1,1,2,3,2,2,2,1,3,4]
>>> list(unique_everseen(lst))
[1, 2, 3, 4]
时机
我做了一些计时（Python 3.6），这些计时表明它比我测试过的所有其他替代方案都快，包括OrderedDict.fromkeys ， f7和more_itertools.unique_everseen ：
%matplotlib notebook
from iteration_utilities import unique_everseen
from collections import OrderedDict
from more_itertools import unique_everseen as mi_unique_everseen
def f7(seq):
seen = set()
seen_add = seen.add
return [x for x in seq if not (x in seen or seen_add(x))]
def iteration_utilities_unique_everseen(seq):
return list(unique_everseen(seq))
def more_itertools_unique_everseen(seq):
return list(mi_unique_everseen(seq))
def odict(seq):
return list(OrderedDict.fromkeys(seq))
from simple_benchmark import benchmark
b = benchmark([f7, iteration_utilities_unique_everseen, more_itertools_unique_everseen, odict],
{2**i: list(range(2**i)) for i in range(1, 20)},
'list size (no duplicates)')
b.plot()
并确保我也进行了更多重复的测试，以检查是否有所不同：
import random
b = benchmark([f7, iteration_utilities_unique_everseen, more_itertools_unique_everseen, odict],
{2**i: [random.randint(0, 2**(i-1)) for _ in range(2**i)] for i in range(1, 20)},
'list size (lots of duplicates)')
b.plot()
还有一个仅包含一个值：
b = benchmark([f7, iteration_utilities_unique_everseen, more_itertools_unique_everseen, odict],
{2**i: [1]*(2**i) for i in range(1, 20)},
'list size (only duplicates)')
b.plot()
在所有这些情况下， iteration_utilities.unique_everseen函数是最快的（在我的计算机上）。
此iteration_utilities.unique_everseen功能还可以在输入（但是具有处理unhashable值O(n*n)性能，而不是O(n)当值是可哈希性能）。
>>> lst = [{1}, {1}, {2}, {1}, {3}]
>>> list(unique_everseen(lst))
[{1}, {2}, {3}]
1免责声明：我是该软件包的作者。
#17楼
不要踢死马（这个问题很老，已经有很多好的答案了），但是这里有一种使用熊猫的解决方案，在很多情况下都非常快，而且使用起来很简单。
import pandas as pd
my_list = [0, 1, 2, 3, 4, 1, 2, 3, 5]
>>> pd.Series(my_list).drop_duplicates().tolist()
# Output:
# [0, 1, 2, 3, 4, 5]
#18楼
在这里，您有一些选择： http : //www.peterbe.com/plog/uniqifiers-benchmark
最快的：
def f7(seq):
seen = set()
seen_add = seen.add
return [x for x in seq if not (x in seen or seen_add(x))]
为什么seen.add seen_add分配给seen_add而不是仅仅调用seen.add呢？ Python是一种动态语言，因此解析seen.add每个迭代比解析局部变量的开销更大。 seen.add可能在迭代之间进行了更改，并且运行时不够智能，无法排除这种情况。 为了安全起见，它必须每次检查对象。
如果您打算在同一数据集上大量使用此功能，则最好使用有序集： http : //code.activestate.com/recipes/528878/
O （1）每个操作的插入，删除和成员检查。
（额外的小注释： seen.add()始终返回None ，因此or以上仅是尝试进行集合更新的一种方法，而不是逻辑测试的组成部分。）
#19楼
from itertools import groupby
[ key for key,_ in groupby(sortedList)]
该列表甚至不必排序 ，充分的条件是将相等的值分组在一起。
编辑：我认为“保留顺序”意味着该列表实际上是有序的。 如果不是这种情况，那么MizardX的解决方案就是正确的解决方案。
社区编辑：但是，这是“将重复的连续元素压缩为单个元素”的最优雅的方法。
#20楼
在Python 3.7及更高版本中， 保证字典记住其键插入顺序。 这个问题的答案总结了当前的状况。
因此， OrderedDict解决方案变得过时了，没有任何导入语句，我们可以简单地发出：
>>> lst = [1, 2, 1, 3, 3, 2, 4]
>>> list(dict.fromkeys(lst))
[1, 2, 3, 4]
#21楼
就地方法
此方法是二次方的，因为我们对列表的每个元素都进行了线性查找（为此，由于del ，我们必须增加重新排列列表的成本）。
也就是说，如果我们从列表的末尾开始并朝着原点进行操作，则可以删除子列表左侧的每个术语，就可以进行操作
代码中的这个想法很简单
for i in range(len(l)-1,0,-1):
if l[i] in l[:i]: del l[i]
实施的简单测试
In [91]: from random import randint, seed
In [92]: seed('20080808') ; l = [randint(1,6) for _ in range(12)] # Beijing Olympics
In [93]: for i in range(len(l)-1,0,-1):
...: print(l)
...: print(i, l[i], l[:i], end='')
...: if l[i] in l[:i]:
...: print( ': remove', l[i])
...: del l[i]
...: else:
...: print()
...: print(l)
[6, 5, 1, 4, 6, 1, 6, 2, 2, 4, 5, 2]
11 2 [6, 5, 1, 4, 6, 1, 6, 2, 2, 4, 5]: remove 2
[6, 5, 1, 4, 6, 1, 6, 2, 2, 4, 5]
10 5 [6, 5, 1, 4, 6, 1, 6, 2, 2, 4]: remove 5
[6, 5, 1, 4, 6, 1, 6, 2, 2, 4]
9 4 [6, 5, 1, 4, 6, 1, 6, 2, 2]: remove 4
[6, 5, 1, 4, 6, 1, 6, 2, 2]
8 2 [6, 5, 1, 4, 6, 1, 6, 2]: remove 2
[6, 5, 1, 4, 6, 1, 6, 2]
7 2 [6, 5, 1, 4, 6, 1, 6]
[6, 5, 1, 4, 6, 1, 6, 2]
6 6 [6, 5, 1, 4, 6, 1]: remove 6
[6, 5, 1, 4, 6, 1, 2]
5 1 [6, 5, 1, 4, 6]: remove 1
[6, 5, 1, 4, 6, 2]
4 6 [6, 5, 1, 4]: remove 6
[6, 5, 1, 4, 2]
3 4 [6, 5, 1]
[6, 5, 1, 4, 2]
2 1 [6, 5]
[6, 5, 1, 4, 2]
1 5 [6]
[6, 5, 1, 4, 2]
In [94]:
#22楼
消除序列中的重复值，但保留其余项目的顺序。 使用通用生成器功能。
# for hashable sequence
def remove_duplicates(items):
seen = set()
for item in items:
if item not in seen:
yield item
seen.add(item)
a = [1, 5, 2, 1, 9, 1, 5, 10]
list(remove_duplicates(a))
# [1, 5, 2, 9, 10]
# for unhashable sequence
def remove_duplicates(items, key=None):
seen = set()
for item in items:
val = item if key is None else key(item)
if val not in seen:
yield item
seen.add(val)
a = [ {'x': 1, 'y': 2}, {'x': 1, 'y': 3}, {'x': 1, 'y': 2}, {'x': 2, 'y': 4}]
list(remove_duplicates(a, key=lambda d: (d['x'],d['y'])))
# [{'x': 1, 'y': 2}, {'x': 1, 'y': 3}, {'x': 2, 'y': 4}]
#23楼
zmk的方法使用列表理解，它非常快速，但自然保持顺序。 对于区分大小写的字符串，可以轻松对其进行修改。 这也保留了原始情况。
def DelDupes(aseq) :
seen = set()
return [x for x in aseq if (x.lower() not in seen) and (not seen.add(x.lower()))]
紧密相关的功能是：
def HasDupes(aseq) :
s = set()
return any(((x.lower() in s) or s.add(x.lower())) for x in aseq)
def GetDupes(aseq) :
s = set()
return set(x for x in aseq if ((x.lower() in s) or s.add(x.lower())))
#24楼
如果您需要一支班轮，那么这可能会有所帮助：
reduce(lambda x, y: x + y if y[0] not in x else x, map(lambda x: [x],lst))
...应该可以，但是如果我错了，请纠正我
#25楼
对于没有可散列的类型（例如列表列表），基于MizardX：
def f7_noHash(seq)
seen = set()
return [ x for x in seq if str( x ) not in seen and not seen.add( str( x ) )]
#26楼
MizardX的答案很好地总结了多种方法。
这是我在大声思考时想到的：
mylist = [x for i,x in enumerate(mylist) if x not in mylist[i+1:]]
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
