您可以比较集合和列表的长度，并将集合项保存到列表。

if len(t) != len(set(t)):
    t = [x for x in set(t)]
     

有时你需要删除重复的项目，而不需要创建新的列表。例如，列表很大，或者将其作为影子副本保存

from collections import Counter
cntDict = Counter(t)
for item,cnt in cntDict.items():
    for _ in range(cnt-1):
        t.remove(item)

这里有很多答案使用set(..)(考虑到元素是可哈希的，这是快速的)或list(它的缺点是它会导致O(n2)算法。

我建议的函数是一个混合的函数:我们使用set(..)来表示可哈希的项，使用list(..)来表示不可哈希的项。此外，它被实现为一个生成器，例如，我们可以限制项目的数量，或做一些额外的过滤。

最后，我们还可以使用一个key参数来指定元素应以何种方式惟一。例如，如果我们想过滤一个字符串列表，这样输出中的每个字符串都有不同的长度，我们可以使用这个。

def uniq(iterable, key=lambda x: x):
    seens = set()
    seenl = []
    for item in iterable:
        k = key(item)
        try:
            seen = k in seens
        except TypeError:
            seen = k in seenl
        if not seen:
            yield item
            try:
                seens.add(k)
            except TypeError:
                seenl.append(k)

我们现在可以这样使用:

>>> list(uniq(["apple", "pear", "banana", "lemon"], len))
['apple', 'pear', 'banana']
>>> list(uniq(["apple", "pear", "lemon", "banana"], len))
['apple', 'pear', 'banana']
>>> list(uniq(["apple", "pear", {}, "lemon", [], "banana"], len))
['apple', 'pear', {}, 'banana']
>>> list(uniq(["apple", "pear", {}, "lemon", [], "banana"]))
['apple', 'pear', {}, 'lemon', [], 'banana']
>>> list(uniq(["apple", "pear", {}, "lemon", {}, "banana"]))
['apple', 'pear', {}, 'lemon', 'banana']

因此，它是一个唯一性过滤器，可以在任何可迭代对象上工作并过滤出唯一性对象，而不管这些唯一性对象是否可哈希。

它做了一个假设:如果一个对象是可哈希的，而另一个对象不是，这两个对象永远不相等。严格地说，这是可能发生的，尽管它是非常罕见的。

您可以比较集合和列表的长度，并将集合项保存到列表。

if len(t) != len(set(t)):
    t = [x for x in set(t)]
     

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

到目前为止，我看到的所有保持顺序的方法要么使用朴素比较(时间复杂度最多为O(n^2))，要么使用限制于可哈希输入的重载OrderedDicts/set+list组合。下面是一个与哈希无关的O(nlogn)解决方案:

更新增加了关键参数、文档和Python 3兼容性。

# from functools import reduce <-- add this import on Python 3

def uniq(iterable, key=lambda x: x):
    """
    Remove duplicates from an iterable. Preserves order. 
    :type iterable: Iterable[Ord => A]
    :param iterable: an iterable of objects of any orderable type
    :type key: Callable[A] -> (Ord => B)
    :param key: optional argument; by default an item (A) is discarded 
    if another item (B), such that A == B, has already been encountered and taken. 
    If you provide a key, this condition changes to key(A) == key(B); the callable 
    must return orderable objects.
    """
    # Enumerate the list to restore order lately; reduce the sorted list; restore order
    def append_unique(acc, item):
        return acc if key(acc[-1][1]) == key(item[1]) else acc.append(item) or acc 
    srt_enum = sorted(enumerate(iterable), key=lambda item: key(item[1]))
    return [item[1] for item in sorted(reduce(append_unique, srt_enum, [srt_enum[0]]))]