这里有一个例子，返回没有重复的列表，保持顺序。不需要任何外部导入。

def GetListWithoutRepetitions(loInput):
    # return list, consisting of elements of list/tuple loInput, without repetitions.
    # Example: GetListWithoutRepetitions([None,None,1,1,2,2,3,3,3])
    # Returns: [None, 1, 2, 3]

    if loInput==[]:
        return []

    loOutput = []

    if loInput[0] is None:
        oGroupElement=1
    else: # loInput[0]<>None
        oGroupElement=None

    for oElement in loInput:
        if oElement<>oGroupElement:
            loOutput.append(oElement)
            oGroupElement = oElement
    return loOutput

到目前为止，我看到的所有保持顺序的方法要么使用朴素比较(时间复杂度最多为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]]))] 

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

删除重复项

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

集合。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

(放大)

这里有很多答案使用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']

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

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

检查字符串'a'和'b'

clean_list = []
    for ele in raw_list:
        if 'b' in ele or 'a' in ele:
            pass
        else:
            clean_list.append(ele)

使用set:

a = [0,1,2,3,4,3,3,4]
a = list(set(a))
print a

使用unique:

import numpy as np
a = [0,1,2,3,4,3,3,4]
a = np.unique(a).tolist()
print a