获得唯一项目集合的常用方法是使用集合。集合是不同对象的无序集合。要从任何可迭代对象创建一个set，只需将其传递给内置的set()函数。如果以后再次需要一个真正的列表，可以类似地将set传递给list()函数。

下面的例子应该涵盖你要做的任何事情:

>>> t = [1, 2, 3, 1, 2, 3, 5, 6, 7, 8]
>>> list(set(t))
[1, 2, 3, 5, 6, 7, 8]
>>> s = [1, 2, 3]
>>> list(set(t) - set(s))
[8, 5, 6, 7]

正如您从示例结果中看到的，原始的顺序没有得到维护。如上所述，集合本身是无序的集合，因此顺序丢失。当将集合转换回列表时，将创建任意顺序。

维持秩序

如果顺序对你来说很重要，那么你就必须使用不同的机制。一个非常常见的解决方案是依赖OrderedDict来保持键在插入期间的顺序:

>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]

从Python 3.7开始，内置字典也保证保持插入顺序，所以如果你使用的是Python 3.7或更高版本(或CPython 3.6)，你也可以直接使用它:

>>> list(dict.fromkeys(t))
[1, 2, 3, 5, 6, 7, 8]

请注意，这可能会有一些开销，首先创建一个字典，然后从它创建一个列表。如果您实际上不需要保留顺序，那么使用集合通常会更好，特别是因为它提供了更多的操作。查看这个问题，了解更多细节和在删除重复项时保留顺序的替代方法。

---

最后请注意，set和OrderedDict/dict解决方案都要求项是可哈希的。这通常意味着它们必须是不可变的。如果你必须处理不可哈希的项(例如列表对象)，那么你将不得不使用一种缓慢的方法，你基本上必须在一个嵌套循环中比较每个项。

在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中，常规字典保证在所有实现中都是有序的。所以，最短最快的解决方案是:

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

不使用set

data=[1, 2, 3, 1, 2, 5, 6, 7, 8]
uni_data=[]
for dat in data:
    if dat not in uni_data:
        uni_data.append(dat)

print(uni_data) 

另一种做法:

>>> seq = [1,2,3,'a', 'a', 1,2]
>> dict.fromkeys(seq).keys()
['a', 1, 2, 3]

为了完整起见，由于这是一个非常流行的问题，toolz库提供了一个独特的函数:

>>> tuple(unique((1, 2, 3)))
(1, 2, 3)
>>> tuple(unique((1, 2, 1, 3)))
(1, 2, 3)

在这个答案中，将有两个部分:两个唯一的解，和一个特定解的速度图。

删除重复项

这些答案大多只删除可哈希的重复项，但这个问题并不意味着它不需要可哈希项，这意味着我将提供一些不需要可哈希项的解决方案。

集合。Counter是标准库中的一个功能强大的工具，可以完美地实现这一点。只有另一种解决方案里面有Counter。然而，该解决方案也仅限于可哈希键。

为了在Counter中允许不可哈希键，我创建了一个Container类，它将尝试获取对象的默认哈希函数，但如果失败，它将尝试其标识函数。它还定义了一个eq和一个散列方法。这应该足以在我们的解决方案中允许不可散列项。不可哈希对象将被视为可哈希对象。但是，这个哈希函数对不可哈希对象使用identity，这意味着两个相等的不可哈希对象将不起作用。我建议您重写它，并将其更改为使用等效可变类型的哈希(例如，如果my_list是一个列表，则使用hash(tuple(my_list))。

我也得到了两个解。另一个解决方案是保持条目的顺序，使用OrderedDict和Counter的子类，命名为'OrderedCounter'。下面是函数:

from collections import OrderedDict, Counter

class Container:
    def __init__(self, obj):
        self.obj = obj
    def __eq__(self, obj):
        return self.obj == obj
    def __hash__(self):
        try:
            return hash(self.obj)
        except:
            return id(self.obj)

class OrderedCounter(Counter, OrderedDict):
     'Counter that remembers the order elements are first encountered'

     def __repr__(self):
         return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))

     def __reduce__(self):
         return self.__class__, (OrderedDict(self),)
    
def remd(sequence):
    cnt = Counter()
    for x in sequence:
        cnt[Container(x)] += 1
    return [item.obj for item in cnt]

def oremd(sequence):
    cnt = OrderedCounter()
    for x in sequence:
        cnt[Container(x)] += 1
    return [item.obj for item in cnt]

Remd为非有序排序，oremd为有序排序。你可以清楚地看出哪个更快，但我还是会解释的。非有序排序稍微快一些，因为它不存储条目的顺序。

现在，我还想展示每个答案的速度比较。我现在就做。

哪个函数是最快的?

为了去除重复，我从几个答案中收集了10个函数。我计算了每个函数的速度，并使用matplotlib.pyplot将其放入一个图形中。

我把它分成三轮画图。hashable是任何可以哈希的对象，unhashable是任何不能哈希的对象。有序序列是保持有序的序列，无序序列不保持有序。现在，这里有更多的术语:

Unordered Hashable适用于任何删除重复项的方法，它不一定要保持顺序。它不需要为不可hashables工作，但它可以。

Ordered Hashable适用于任何保持列表中元素顺序的方法，但它不一定适用于unhashables，但它可以。

Ordered Unhashable是任何保持列表中项目顺序的方法，适用于unhashables。

y轴是花费的秒数。

x轴是函数作用的数字。

我用以下理解为无序哈希和有序哈希生成序列:[list(range(x)) + list(range(x)) for x in range(0,1000,10)]

对于有序的不可哈希对象:[[list(range(y)) + list(range(y)) For y in range(x)] For x in range(0,1000,10)]

请注意，在范围内有一个步骤，因为如果没有它，这将花费10倍的时间。也因为在我个人看来，我认为它可能看起来更容易阅读。

还要注意，图例上的键是我试图猜测的函数实现中最重要的部分。至于哪个功能是最好的还是最差的呢?图表说明了一切。

解决了这个问题，下面是图表。

无序Hashables

(放大)

命令Hashables

(放大)

命令Unhashables

(放大)