问题描述：

如何从列表中删除重复项，同时保留顺序？使用集合删除重复项会破坏原始顺序。是否有内置或 Pythonic 习语？

解决方案 1：

这里有一些替代方案： 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？ Python 是一种动态语言，解析seen.add每次迭代比解析局部变量更昂贵。seen.add可能在迭代之间发生变化，而运行时还不够智能，无法排除这种情况。 为了安全起见，它每次都必须检查对象。

如果您打算在同一数据集上大量使用此函数，那么使用有序集可能会更好： http: //code.activestate.com/recipes/528878/

每个操作的插入、删除和成员检查时间为O (1)。

（小补充说明：seen.add()总是返回None，因此or上述内容只是作为尝试设置更新的一种方式，而不是作为逻辑测试的组成部分。）

解决方案 2：

最佳解决方案因 Python 版本和环境限制而异：

Python 3.7+（以及大多数支持 3.6 的解释器，作为实现细节）：

最初在 PyPy 2.5.0 中引入，并在 CPython 3.6 中作为实现细节采用，然后在 Python 3.7 中成为语言保证，plaindict是插入顺序的，甚至比 (也是从 CPython 3.5 开始的 C 实现) 更高效collections.OrderedDict。因此，到目前为止，最快的解决方案也是最简单的：

>>> items = [1, 2, 0, 1, 3, 2]
>>> list(dict.fromkeys(items))  # Or [*dict.fromkeys(items)] if you prefer
[1, 2, 0, 3]

像list(set(items))这样将所有工作都推到 C 层（在 CPython 上），但由于dicts 是按插入顺序排列的，因此dict.fromkeys不会丢失顺序。它比其他任何保序解决方案都慢list(set(items))（通常要多花 50-100%），但要快得多（花费的时间大约是在 listcomp 中使用 s 的黑客攻击set的一半）。

重要提示：（见下文）unique_everseen的解决方案more_itertools在懒惰和对不可散列输入项的支持方面具有一些独特的优势；如果您需要这些功能，那么它是唯一可行的解​​决方案。

Python 3.5（如果性能不是很重要，则所有旧版本）

正如 Raymond指出的那样OrderedDict，在用 C 实现的CPython 3.5 中，丑陋的列表理解 hack 比 更慢OrderedDict.fromkeys（除非你真的需要在末尾使用列表 - 即使这样，也只有在输入非常短的情况下）。因此，在性能和可读性方面，CPython 3.5 的最佳解决方案相当于OrderedDict3.6+ 中使用 plain dict：

>>> from collections import OrderedDict
>>> items = [1, 2, 0, 1, 3, 2]
>>> list(OrderedDict.fromkeys(items))
[1, 2, 0, 3]

在 CPython 3.4 及更早版本中，这会比其他一些解决方案慢，因此如果分析显示您需要更好的解决方案，请继续阅读。

Python 3.4 及更早版本（如果性能至关重要且可以接受第三方模块）

正如@abarnert所说，more_itertools库 ( pip install more_itertools) 包含一个unique_everseen函数，用于解决此问题，而不会在列表推导中产生任何不可读的( 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

但与itertools配方不同的是，它支持不可散列的项目（以性能为代价；如果中的所有元素iterable都是不可散列的，则算法变为O(n²)，而O(n)如果它们都是可散列的）。

重要提示：与此处的所有其他解决方案不同，unique_everseen可以懒惰地使用；峰值内存使用量将是相同的（最终，底层set会增长到相同的大小），但如果您不list验证结果，则只需对其进行迭代，您将能够在找到唯一项目时对其进行处理，而不是等到整个输入都被重复数据删除后再处理第一个唯一项目。

Python 3.4 及更早版本（如果性能至关重要且第三方模块不可用）

您有两个选择：

1. 将配方复制并粘贴到您的代码中，unique_everseen`more_itertools`并按照上面的示例使用它

2. 使用丑陋的黑客来允许单个列表计算检查和更新set以跟踪已经看到的内容：

seen = set()
[x for x in seq if x not in seen and not seen.add(x)]

以依赖丑陋的黑客为代价：

 not seen.add(x)

它依赖于这样一个事实，即set.add是一种始终返回的就地方法，None因此not None计算结果为True。

请注意，上述所有解决方案都是O(n)（保存unique_everseen对不可哈希项的可迭代对象的调用，即O(n²)，而其他解决方案会立即失败TypeError），因此当它们不是最热门的代码路径时，所有解决方案都具有足够的性能。使用哪一个取决于您可以依赖的语言规范/解释器/第三方模块的版本，性能是否至关重要（不要假设它是；通常不是），最重要的是可读性（因为如果维护此代码的人后来情绪激动，那么您的聪明的微优化可能就不值得了）。

解决方案 3：

在 CPython 3.6+ （以及从Python 3.7+开始的所有其他 Python 实现）中，字典是有序的，因此从可迭代对象中删除重复项同时保持其原始顺序的方法是：

>>> list(dict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

在 Python 3.5及以下版本（包括Python 2.7）中，使用OrderedDict。我的计时表明，这是 Python 3.5 中各种方法中最快和最短的方法（当它获得 C 实现时；在 3.5 之前，它仍然是最清晰的解决方案，尽管不是最快的）。

>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys('abracadabra'))
['a', 'b', 'r', 'c', 'd']

解决方案 4：

在Python 3.7及更高版本中，字典保证记住其键的插入顺序。这个问题的答案总结了当前的状况。

因此，该OrderedDict解决方案变得过时，并且无需任何导入语句，我们只需发出：

>>> lst = [1, 2, 1, 3, 3, 2, 4]
>>> list(dict.fromkeys(lst))
[1, 2, 3, 4]

解决方案 5：

并不是要踢死马（这个问题很老了，已经有很多很好的答案），但这里有一个使用熊猫的解决方案，它在很多情况下都非常快，并且使用起来非常简单。

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]

解决方案 6：

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']

解决方案 7：

from itertools import groupby

[key for key, _ in groupby(sortedList)]

该列表甚至不必排序，充分条件是将相等的值组合在一起。

编辑：我假设“保持顺序”意味着列表实际上是有序的。如果不是这样，那么 MizardX 的解决方案是正确的。

社区编辑：然而，这是“将重复的连续元素压缩为单个元素”的最优雅的方式。

解决方案 8：

我认为如果你想维持秩序，

你可以尝试这个：

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 

解决方案 9：

只需从外部模块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函数还可以处理输入中不可散列的值（但是，其性能与值可散列时的性能O(n*n)不同）。O(n)

>>> lst = [{1}, {1}, {2}, {1}, {3}]

>>> list(unique_everseen(lst))
[{1}, {2}, {3}]

1免责声明：我是该软件包的作者。

解决方案 10：

对于另一个非常老的问题的另一个非常晚的回答：

食谱有一个使用设置技术来实现这个功能itertools，seen但是：

• 处理标准key功能。

• 不使用任何不雅的黑客手段。

• seen.add通过预绑定而不是查找 N 次来优化循环。 （f7也可以这样做，但有些版本没有。）

• 通过使用 优化循环ifilterfalse，因此您只需循环遍历 Python 中的唯一元素，而不是所有元素。（ifilterfalse当然，您仍然会在 中迭代所有元素，但这是在 C 中，而且速度要快得多。）

它真的比 快吗f7？这取决于您的数据，因此您必须对其进行测试并查看。如果您最终想要一个列表，f7请使用列表计算，而这里没有办法做到这一点。（您可以直接append代替yielding，也可以将生成器输入list函数，但两者都不能像列表计算中的 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

解决方案 11：

pandas 用户应该查看pandas.unique。

>>> import pandas as pd
>>> lst = [1, 2, 1, 3, 3, 2, 4]
>>> pd.unique(lst)
array([1, 2, 3, 4])

该函数返回一个 NumPy 数组。如果需要，可以使用该tolist方法将其转换为列表。

解决方案 12：

这是一个简单的方法：

list1 = ["hello", " ", "w", "o", "r", "l", "d"]
sorted(set(list1 ), key=list1.index)

输出结果如下：

["hello", " ", "w", "o", "r", "l", "d"]

解决方案 13：

对于非可哈希类型（例如列表列表），基于 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 ) )]

解决方案 14：

减少速度快 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]

解决方案 15：

借用 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) 将提供列表中的唯一元素，其中唯一性不再意味着传统的相等（这通过使用任何基于集合或基于字典键的方法来解决此问题来暗示）而是意味着对于元素可能四舍五入到的每个可能的整数 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]

解决方案 16：

您可以引用列表推导，因为它是由符号“_[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]

解决方案 17：

消除序列中的重复值，但保留剩余项的顺序。使用通用生成器函数。

# 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}]

解决方案 18：

1.这些解决方案都很好...

为了在保留顺序的同时删除重复项，本页其他地方提出了出色的解决方案：

seen = set()
[x for x in seq if not (x in seen or seen.add(x))]

及其变化，例如：

seen = set()
[x for x in seq if x not in seen and not seen.add(x)]

确实很受欢迎，因为它们简单、简约，并且部署了正确的哈希算法以实现最佳效率。关于这些方法的主要抱怨似乎是，将None方法“返回”的不变seen.add(x)值用作逻辑表达式中的常量（因此是多余的/不必要的）值（仅出于其副作用）是黑客行为和/或令人困惑的。

2. ...但他们在每次迭代中都浪费了一次哈希查找。

令人惊讶的是，考虑到关于这个主题的讨论和争论的数量，实际上似乎忽略了代码的重大改进。如图所示，每次“测试和设置”迭代都需要两次哈希查找：第一次测试成员资格x not in seen，然后再次实际添加值seen.add(x)。由于第一个操作保证第二个操作始终成功，因此这里存在浪费的重复工作。而且由于这里的整体技术非常高效，多余的哈希查找很可能最终成为剩余工作中最昂贵的部分。

3. 相反，让set完成其工作！

请注意，上述示例仅set.add在预知这样做将始终导致集合成员增加的情况下调用。set本身永远没有机会拒绝重复项；我们的代码片段基本上已经篡夺了这一角色。使用显式两步测试和设置代码剥夺了set其排除这些重复项的核心能力。

4. 单哈希查找代码：

以下版本将每次迭代的哈希查找次数减少 一半— — 从两次减少到一次。

seen = set()
[x for x in seq if len(seen) < len(seen.add(x) or seen)]

解决方案 19：

我将所有相关答案与perfplot进行了比较，发现，

list(dict.fromkeys(data))

是最快的。这对于小型 numpy 数组也适用。对于较大的 numpy 数组，pandas.unique实际上是最快的。

重现情节的代码：

from collections import OrderedDict
from functools import reduce
from itertools import groupby

import numpy as np
import pandas as pd
import perfplot
from more_itertools import unique_everseen as ue


def dict_fromkeys(data):
    return list(dict.fromkeys(data))


def unique_everseen(data):
    return list(ue(data))


def seen_add(data):
    seen = set()
    seen_add = seen.add
    return [x for x in data if not (x in seen or seen_add(x))]


def ordereddict_fromkeys(data):
    return list(OrderedDict.fromkeys(data))


def pandas_drop_duplicates(data):
    return pd.Series(data).drop_duplicates().tolist()


def pandas_unique(data):
    return pd.unique(data)


def itertools_groupby(data):
    return [key for key, _ in groupby(data)]


def reduce_tricks(data):
    return reduce(
        lambda r, v: v in r[1] and r or (r[0].append(v) or r[1].add(v)) or r,
        data,
        ([], set()),
    )[0]


b = perfplot.bench(
    setup=lambda n: np.random.randint(100, size=n).tolist(),
    kernels=[
        dict_fromkeys,
        unique_everseen,
        seen_add,
        ordereddict_fromkeys,
        pandas_drop_duplicates,
        pandas_unique,
        reduce_tricks,
    ],
    n_range=[2**k for k in range(20)],
)
b.save("out.png")
b.show()

解决方案 20：

如果你需要一个衬垫，那么也许这会有所帮助：

reduce(lambda x, y: x + y if y[0] not in x else x, map(lambda x: [x],lst))

...应该可以，但如果我错了就纠正我

解决方案 21：

MizardX 的答案提供了多种方法的良好集合。

这是我在自言自语时想到的：

mylist = [x for i,x in enumerate(mylist) if x not in mylist[i+1:]]

解决方案 22：

您可以做某种丑陋的列表理解黑客攻击。

[l[i] for i in range(len(l)) if l.index(l[i]) == i]

解决方案 23：

_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])

解决方案 24：

l = [1,2,2,3,3,...]
n = []
n.extend(ele for ele in l if ele not in set(n))

生成器表达式使用集合的 O(1) 查找来确定是否在新列表中包含元素。

解决方案 25：

一个简单的递归解决方案：

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]]

解决方案 26：

这将保留顺序并在 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]

解决方案 27：

x = [1, 2, 1, 3, 1, 4]

# brute force method
arr = []
for i in x:
  if not i in arr:
    arr.insert(x[i],i)

# recursive method
tmp = []
def remove_duplicates(j=0):
    if j < len(x):
      if not x[j] in tmp:
        tmp.append(x[j])
      i = j+1  
      remove_duplicates(i)

      

remove_duplicates()

解决方案 28：

单行列表理解：

values_non_duplicated = [value for index, value in enumerate(values) if value not in values[ : index]]

解决方案 29：

如果您经常使用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

解决方案 30：

不使用导入模块或集合的解决方案：

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']