在这里，您有一些替代方案： 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))]

为什么要分配给而不仅仅是打电话？Python 是一种动态语言，解析每次迭代比解析局部变量的成本更高。 可能在迭代之间发生了变化，并且运行时不够智能，无法排除这种情况。为了安全起见，它每次都必须检查对象。seen.addseen_addseen.addseen.addseen.add

如果您计划在同一数据集上大量使用此函数，也许您最好使用有序集：http://code.activestate.com/recipes/528878/

O（1） 每次操作的插入、删除和成员检查。

（小的附加说明：总是返回 ，所以 or 以上只是作为尝试集合更新的一种方式，而不是作为逻辑测试的组成部分。seen.add()None

from itertools import groupby

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

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

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

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

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

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

...应该有效，但如果我错了，请纠正我

对于没有可散列类型（例如列表列表），基于 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 ) )]

MizardX的回答很好地收集了多种方法。

这是我在大声思考时想出的：

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

您可以在通过符号“_[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]

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

我想如果你想维持秩序，

你可以试试这个：

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 

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

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

首先在 PyPy 2.5.0 中引入，并在 CPython 3.6 中作为实现细节采用，在 Python 3.7 中成为语言保证之前，plain 是插入顺序的，甚至比 （也是从 CPython 3.5 开始实现的 C）更有效。因此，到目前为止，最快的解决方案也是最简单的：dictcollections.OrderedDict

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

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

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

Python 3.5（以及所有旧版本，如果性能不重要)

正如 Raymond 所指出的，在用 C 语言实现的 CPython 3.5 中，丑陋的列表理解黑客比（除非你真的需要最后的列表——即使这样，也只有在输入非常短的情况下）。因此，在性能和可读性方面，CPython 3.5 的最佳解决方案相当于 3.6+ 使用普通：OrderedDictOrderedDict.fromkeysOrderedDictdict

>>> 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库 （） 包含一个unique_everseen函数，该函数旨在解决此问题，而不会在列表推导式中出现任何不可读的 （） 突变。这也是最快的解决方案：pip install more_itertoolsnot 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

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

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

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

您有两种选择：

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

2. 使用丑陋的黑客来允许单个 listcomp 检查和更新 a 以跟踪所看到的内容：set

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

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

    not seen.add(x)
   

   它依赖于这样一个事实，即始终返回的就地方法，因此计算结果为 。set.addNonenot NoneTrue

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

借用在定义 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]

使用数组的相对有效的方法：_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])

对于另一个非常古老的问题的另一个很晚的答案：

itertools 配方有一个函数，它使用 set 技术来执行此操作，但是：seen

• 处理标准函数。key
• 不使用不合时宜的黑客。
• 通过预绑定来优化循环，而不是查找 N 次。（ 也这样做，但有些版本不这样做。seen.addf7
• 通过使用 来优化循环，因此您只需遍历 Python 中的唯一元素，而不是所有元素。（当然，你仍然在里面遍历所有这些，但那是在 C 语言中，而且速度要快得多。ifilterfalseifilterfalse

它实际上比？这取决于您的数据，因此您必须对其进行测试并查看。如果你最终想要一个列表，请使用 listcomp，这里没有办法做到这一点。（您可以直接而不是 ing，或者您可以将生成器馈送到函数中，但两者都不能像 listcomp 中的LIST_APPEND一样快。无论如何，通常情况下，挤出几微秒并不像拥有一个易于理解、可重用、已经编写的函数那么重要，当你想要装饰时，它不需要 DSU。f7f7appendyieldlist

与所有食谱一样，它也有更多iterools。

如果你只想要无情况，你可以将其简化为：key

def unique(iterable):
    seen = set()
    seen_add = seen.add
    for element in itertools.ifilterfalse(seen.__contains__, iterable):
        seen_add(element)
        yield element

你可以做一个丑陋的列表理解黑客。

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

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

一个生成器表达式，它使用集合的 O（1） 查找来确定是否在新列表中包含元素。

减少变体速度提高 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]

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

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

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

这将保持秩序并在 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]

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

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

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

只是为了从外部模块¹ 添加此类功能的另一个（非常高性能的）实现：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.fromkeysf7more_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_everseenO(n*n)O(n)

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

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

---

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

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

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]

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

因此，该解决方案变得过时，并且没有任何导入语句，我们可以简单地发出：OrderedDict

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

消除序列中的重复值，但保留其余项的顺序。使用通用发电机功能。

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

这是一种简单的方法：

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

这给出了输出：

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

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 方法将其转换为列表。

一行列表理解：

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

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()

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

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

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

3. 相反，让布景完成它的工作！
请注意，上面的示例只是在预先知道这样做总是会导致集合成员资格增加的情况下调用。它本身永远没有机会拒绝重复;我们的代码片段基本上已经篡夺了这个角色。使用显式的两步测试和设置代码正在剥夺其排除这些重复项的核心能力。set.addsetset

4. 单哈希查找代码：
以下版本将每次迭代的哈希查找次数减少了一半，从两个减少到一个。

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

我将所有相关答案与 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()