在列表中去除重复项

下面的代码是用于在列表中去除重复项的简单方法

def remove_duplicates(x):
    a = []
    for i in x:
        if i not in a:
            a.append(i)
    return a

print remove_duplicates([1,2,2,3,3,4])

它返回 [1,2,3,4]

这是与回复中列出的其他解决方案相比最快的pythonic解决方案。
利用短路求值的实现细节，可以使用列表推导式，这是足够快的。visited.add(item)始终返回None作为结果，这被评估为False，因此or的右侧总是这样一个表达式的结果。
自己计时吧。

def deduplicate(sequence):
    visited = set()
    adder = visited.add  # get rid of qualification overhead
    out = [adder(item) or item for item in sequence if item not in visited]
    return out

def remove_duplicates(A):
   [A.pop(idx) for idx,elem in enumerate(A) if A.count(elem)!=1]
   return A

一个用于去除重复项的列表推导式。

如果您想删除重复项（原地编辑而不返回新列表），而不使用内置的set、dict.keys、uniqify和counter，请勾选此项。

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]
>>> for i in t:
...     if i in t[t.index(i)+1:]:
...         t.remove(i)
... 
>>> t
[3, 1, 2, 5, 6, 7, 8]

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

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

我认为将其转换为集合是去除重复项的最简单方法:

list1 = [1,2,1]
list1 = list(set(list1))
print list1

我没有看到关于不可哈希值的答案，这里是一个一行代码、n log n时间复杂度、仅使用标准库的答案：

list(map(operator.itemgetter(0), itertools.groupby(sorted(items))))

或者作为生成器函数：

def unique(items: Iterable[T]) -> Iterable[T]:
    """For unhashable items (can't use set to unique) with a partial order"""
    yield from map(operator.itemgetter(0), itertools.groupby(sorted(items)))

这里有很多答案使用了 set(..)（如果元素是可哈希的，则速度较快），或者列表（缺点是它会导致 O(n²) 算法）。
我提出的函数是一种混合型函数：我们对于可哈希的物品使用 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']

因此，它是一个可以在任何可迭代对象上工作并过滤出唯一值的筛选器，无论这些值是否可哈希。
它有一个假设：如果一个对象是可哈希的，而另一个对象不是，那么这两个对象永远不相等。严格来说，这种情况可能会发生，但这很少见。

另一个解决方案可能是这样的。将列表转换为字典，以项目为键，索引为值，然后打印字典键。

>>> lst = [1, 3, 4, 2, 1, 21, 1, 32, 21, 1, 6, 5, 7, 8, 2]
>>>
>>> dict_enum = {item:index for index, item in enumerate(lst)}
>>> print dict_enum.keys()
[32, 1, 2, 3, 4, 5, 6, 7, 8, 21]

你可以简单地使用集合来完成这个操作。 步骤1：获取列表中不同的元素
步骤2：获取列表中共同的元素
步骤3：将它们组合起来。

In [1]: a = ["apples", "bananas", "cucumbers"]

In [2]: b = ["pears", "apples", "watermelons"]

In [3]: set(a).symmetric_difference(b).union(set(a).intersection(b))
Out[3]: {'apples', 'bananas', 'cucumbers', 'pears', 'watermelons'}