从python列表中获取唯一值[重复]

['nowplaying', 'PBS', 'PBS', 'nowplaying', 'job', 'debate', 'thenandnow']

#1 楼

首先正确声明您的列表，并以逗号分隔。您可以通过将列表转换为集合来获得唯一值。

mylist = ['nowplaying', 'PBS', 'PBS', 'nowplaying', 'job', 'debate', 'thenandnow']
myset = set(mylist)
print(myset)

如果将其进一步用作列表，则应通过执行以下操作将其转换回列表：

mynewlist = list(myset)

另一种可能性，可能更快的方法是从头开始使用集合而不是列表。那么您的代码应该是：

output = set()
for x in trends:
    output.add(x)
print(output)

正如已经指出的那样，集合不保持原始顺序。如果需要，应该寻找有序的集合实现（有关更多信息，请参见此问题）。

#2 楼

为了与我使用的类型保持一致：

 mylist = list(set(mylist))
 

#3 楼

如果需要保持元素顺序，怎么做：

used = set()
mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = [x for x in mylist if x not in used and (used.add(x) or True)]

以及使用reduce且没有临时used变量的另一种解决方案。

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = reduce(lambda l, x: l.append(x) or l if x not in l else l, mylist, [])

UPDATE-2020年12月-也许是最好的方法！
从python 3.7开始，标准dict保留插入顺序。

在3.7版中进行了更改：保证字典顺序为插入顺序。此行为是3.6版CPython的一个实现细节。

因此这使我们能够使用dict.from_keys进行重复数据删除！

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = list(dict.fromkeys(mylist))

在速度方面-对我而言，它的速度和可读性足以使其成为我最喜欢的新方法！
更新-2019年3月，
还有第三个解决方案，这是一个很好的方法，但是由于.index为O（n）有点慢。

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = [x for i, x in enumerate(mylist) if i == mylist.index(x)]

注意：请记住，我们得到的文字更加可读，脚本的性能更差。除了仅适用于python 3.7+的reduce方法外。对于每个遇到困难的人。我将尝试对它的工作原理以及这里发生的魔术进行更深入的说明；）
，所以她首先问：

我试图了解为什么.append无法正常工作。

它确实可以工作吗

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = reduce(lambda l, x: l+[x] if x not in l else l, mylist, [])
#which can also be writed as:
unique = reduce(lambda l, x: l if x in l else l+[x], mylist, [])

问题在于，我们只是在dict.from_keys变量内部无法获得所需的结果，而只是在unique = [used.append(x) for x in mylist if x not in used]变量内部无法获得所需的结果。这是因为在列表理解期间，unique会修改used变量并返回.append。
因此，为了将结果放入used变量中，并且仍与None使用相同的逻辑，我们需要将这个unique调用移至列表推导的右侧，而仅在左侧返回.append(x) if x not in used。如果我们太天真了，那就去：

import timeit

setup = "mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']"

#10x to Michael for pointing out that we can get faster with set()
timeit.timeit('[x for x in mylist if x not in used and (used.add(x) or True)]', setup='used = set();'+setup)
0.2029558869980974

timeit.timeit('[x for x in mylist if x not in used and (used.append(x) or True)]', setup='used = [];'+setup)
0.28999493700030143

# 10x to rlat for suggesting this approach!   
timeit.timeit('list(dict.fromkeys(mylist))', setup=setup)
0.31227896199925453

timeit.timeit('reduce(lambda l, x: l.append(x) or l if x not in l else l, mylist, [])', setup='from functools import reduce;'+setup)
0.7149233570016804

timeit.timeit('reduce(lambda l, x: l+[x] if x not in l else l, mylist, [])', setup='from functools import reduce;'+setup)
0.7379565160008497

timeit.timeit('reduce(lambda l, x: l if x in l else l+[x], mylist, [])', setup='from functools import reduce;'+setup)
0.7400134069976048

timeit.timeit('[x for i, x in enumerate(mylist) if i == mylist.index(x)]', setup=setup)
0.9154880290006986

我们什么也不会得到回报。外观如下：

>>> used = []
>>> mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
>>> unique = [used.append(x) for x in mylist if x not in used]
>>> print used
[u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow']
>>> print unique
[None, None, None, None, None]

这基本上总是：

当.append位于x时评估为.append，
当None不在False时评估为x。 />
并且在两种情况下（used / None）都将被视为x值，结果将得到一个空列表。 ？有人可能会问。
因为这是Python的短路运算符的工作方式。

表达式used首先计算x；如果x为假，则返回其值
；否则，将评估y并返回结果值。

因此，当不使用False时（即，当其None时），下一部分或表达式将被求值（falsy），并且其值（None）将被返回。
这就是我们想要的，以便从具有重复项的列表中获取唯一元素，我们希望仅当它们遇到第一时间时才将它们x放入新列表中。
，所以我们真的想仅在used不在x and y中时才对x求值，也许如果有一种方法可以将True值转换为used.append(x)，我们会很好，对吗？这是None的第二种运算符开始发挥作用的地方。

表达式.append首先计算x；如果x为true，则返回其值
；否则，将评估y并返回结果值。

我们知道used.append(x)将始终是x，因此，如果我们在他旁边添加一个used，我们将始终获得下一部分。这就是为什么我们这样写：

>>> unique = [x for x in mylist if x not in used and used.append(x)]
>>> print unique
[]

，因此，只有当表达式None的第一部分是truthy时，我们才可以求值short-circuit并得到x or y。

x not in used and None

其中：

将.append(x)附加到falsy上，并在or不在used.append(x)中时返回True。多亏了(x not in used)语句，对True进行了评估，然后返回了reduce。

#4 楼

Python列表：

>>> a = ['a', 'b', 'c', 'd', 'b']

要获取唯一项，只需将其转换为集合（如果需要，您可以将其再次转换回列表）：

>>> b = set(a)
>>> print(b)
{'b', 'c', 'd', 'a'}

#5 楼

您的输出变量是什么类型？

需要Python集。这样声明输出：

output = set()  # initialize an empty set

，您已经准备好使用output.add(elem)添加元素并确保它们是唯一的。

警告：设置不保留列表的原始顺序。

#6 楼

删除重复项的选项可能包括以下通用数据结构：



集合：无序的唯一元素

有序集合：有序的唯一元素

这里是在Python中快速获取任一个的摘要。
选项1-集合（无序）：

from collections import OrderedDict


seq = [u"nowplaying", u"PBS", u"PBS", u"nowplaying", u"job", u"debate", u"thenandnow"]

选项2-Python没有排序的集合，但是这里有一些模仿一个（插入顺序）：

list(set(seq))
# ['thenandnow', 'PBS', 'debate', 'job', 'nowplaying']

list(OrderedDict.fromkeys(seq))
# ['nowplaying', 'PBS', 'job', 'debate', 'thenandnow']

如果使用Python 3.6+，则建议使用最后一个选项。请参阅这篇文章中的更多详细信息。

注意：列出的元素必须是可哈希的。请参阅此博客文章中有关后一个示例的详细信息。此外，请参见R. Hettinger关于相同技术的文章。保留顺序字典是他早期实现之一。另请参阅有关总订购的更多信息。

#7 楼

维护顺序：

# oneliners
# slow -> . --- 14.417 seconds ---
[x for i, x in enumerate(array) if x not in array[0:i]]

# fast -> . --- 0.0378 seconds ---
[x for i, x in enumerate(array) if array.index(x) == i]

# multiple lines
# fastest -> --- 0.012 seconds ---
uniq = []
[uniq.append(x) for x in array if x not in uniq]
uniq

顺序不重要：

# fastest-est -> --- 0.0035 seconds ---
list(set(array))

#8 楼

从列表获取唯一元素

mylist = [1,2,3,4,5,6,6,7,7,8,8,9,9,10]

从集合中使用简单逻辑-集合是项目的唯一列表

mylist=list(set(mylist))

In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

使用简单逻辑

newList=[]
for i in mylist:
    if i not in newList:
        newList.append(i)

In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

使用弹出方法
-> pop删除最后一个或索引的项目并将其显示给用户。视频

k=0
while k < len(mylist):
    if mylist[k] in mylist[k+1:]:
        mylist.pop(mylist[k])
    else:
        k=k+1

In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

使用Numpy

import numpy as np
np.unique(mylist)

In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

参考

#9 楼

如果在代码中使用numpy（这可能是处理大量数据的不错选择），请查看numpy.unique： docs.scipy.org/doc/numpy/reference/generated/numpy.unique.html）

如您所见，numpy不仅支持数字数据，还可以支持字符串数组。当然，结果是一个numpy数组，但没关系，因为它的行为仍然像一个序列：

>>> import numpy as np
>>> wordsList = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
>>> np.unique(wordsList)
array([u'PBS', u'debate', u'job', u'nowplaying', u'thenandnow'], 
      dtype='<U10')

如果您真的想要返回原始的python列表，您始终可以调用list（）。

但是，结果自动排序，如您从上述代码片段中看到的那样。如果需要保留列表顺序，请检查numpy unique而不排序。

#10 楼

set-唯一元素的无序集合。元素列表可以传递给set的构造函数。因此，传递具有重复元素的列表，我们将获得具有唯一元素的设置，并将其转换回列表，然后获得具有唯一元素的列表。关于性能和内存开销我什么也不能说，但是我希望，对于小的列表来说，它并不是那么重要。

简单而简短。

#11 楼

相同顺序的唯一列表仅使用列表压缩。 enumerates的第一个索引。如果第一个索引不是i，则当前迭代的e不是列表中的第一个tuple。

编辑

我应该注意，这不是一个好方法要做到这一点，就性能而言。这只是仅使用列表压缩即可实现的方法。

#12 楼

另外，Counter是获取唯一值和每个值的计数的简单方法：

from collections import Counter
l = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
c = Counter(l)

#13 楼

通过使用Python词典的基本属性：

inp=[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
d={i for i in inp}
print d

输出将是：

set([u'nowplaying', u'job', u'debate', u'PBS', u'thenandnow'])

#14 楼

首先，您给出的示例不是有效列表。

example_list = [u'nowplaying',u'PBS', u'PBS', u'nowplaying', u'job', u'debate',u'thenandnow']

假设上面的示例列表。然后，您可以使用以下配方作为itertools示例文档，该文档可以返回唯一值并按您的要求保留顺序。这里的iterable是example_list

from itertools import ifilterfalse

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

#15 楼

def get_distinct(original_list):
    distinct_list = []
    for each in original_list:
        if each not in distinct_list:
            distinct_list.append(each)
    return distinct_list

#16 楼

set可以帮助您从列表中过滤出重复的元素。它适用于str，int或tuple元素，但是如果您的列表包含dict或其他list元素，那么您最终会遇到TypeError异常。一些（不是全部）不可散列的类型：

def unique_elements(iterable):
    seen = set()
    result = []
    for element in iterable:
        hashed = element
        if isinstance(element, dict):
            hashed = tuple(sorted(element.iteritems()))
        elif isinstance(element, list):
            hashed = tuple(element)
        if hashed not in seen:
            result.append(element)
            seen.add(hashed)
    return result

#17 楼

要从列表中获取唯一值，请使用下面的代码：

trends = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
output = set(trends)
output = list(output)

重要信息：这是可变类型（例如列表或字典）的情况。使用更复杂的代码：

trends = [{'super':u'nowplaying'}, u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
output = set(trends)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: unhashable type: 'dict'

#18 楼

令我惊讶的是，到目前为止没有人给出直接的订单保留答案：
unique(range(10))。要获取列表，只需调用list(unique(sequence))，就像这样：它是O（n）而不是O（n ^ 2），因此可以在很长的列表中正常工作。

#19 楼

除了前面的回答（说您可以将列表转换为集合）之外，您也可以通过这种方式进行操作

br />

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenadnow']
mylist = [i for i in set(mylist)]

尽管订单不会保留。

另一个更简单的答案可能是（不使用集合）

[u'nowplaying', u'job', u'debate', u'PBS', u'thenadnow']

#20 楼

def setlist(lst=[]):
   return list(set(lst))

#21 楼

如果要从列表中获取唯一元素并保持其原始顺序，则可以使用Python标准库中的OrderedDict数据结构：

from collections import OrderedDict

def keep_unique(elements):
    return list(OrderedDict.fromkeys(elements).keys())

elements = [2, 1, 4, 2, 1, 1, 5, 3, 1, 1]
required_output = [2, 1, 4, 5, 3]

assert keep_unique(elements) == required_output

实际上如果使用的Python≥3.6，则可以使用简单的dict来实现以下目的：在这里查看。尽管这“考虑了实现细节，但不应该依赖”。

#22 楼

您可以使用集合。为了清楚起见，我在解释列表和集合之间的区别。
集合是唯一元素的无序集合。列表是元素的有序集合。
因此，

    unicode_list=[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job',u'debate', u'thenandnow']
    list_unique=list(set(unicode_list))
    print list_unique
[u'nowplaying', u'job', u'debate', u'PBS', u'thenandnow']

但是：不要使用列表/集合命名变量。它将导致错误：
EX：在上一个中，使用list而不是unicode_list代替。

list=[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job',u'debate', u'thenandnow']
        list_unique=list(set(list))
        print list_unique
    list_unique=list(set(list))
TypeError: 'list' object is not callable

#23 楼

在代码开头，只需将输出列表声明为空即可：

#24 楼

我检查内容唯一性但保留原始顺序的解决方案：

def getUnique(self):
    notunique = self.readLines()
    unique = []
    for line in notunique: # Loop over content
        append = True # Will be set to false if line matches existing line
        for existing in unique:
            if line == existing: # Line exists ? do not append and go to the next line
                append = False
                break # Already know file is unique, break loop
        if append: unique.append(line) # Line not found? add to list
    return unique

编辑：
通过使用字典键可以更有效检查是否存在而不是对每一行进行整个文件循环，我不会将我的解决方案用于大型设备。

#25 楼

使用set删除重复列表，作为列表返回

def get_unique_list(lst):
        if isinstance(lst,list):
            return list(set(lst))

#26 楼

Set是无序和唯一元素的集合。因此，可以使用以下set来获得唯一列表：

unique_list = list(set([u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']))

#27 楼

我知道这是一个古老的问题，但这是我的独特解决方案：类继承！在UniqueList上附加。由于它继承自列表，因此基本上就像一个列表，因此您可以使用index（）等函数。由于返回true或false，因此可以确定追加成功（唯一项）还是失败（已经在list）。

要从列表中获得项目的唯一列表，请使用for循环将项目添加到UniqueList（然后复制到列表中）。

示例用法代码：

class UniqueList(list):
    def appendunique(self,item):
        if item not in self:
            self.append(item)
            return True
        return False

打印件：

unique = UniqueList()

for each in [1,2,2,3,3,4]:
    if unique.appendunique(each):
        print 'Uniquely appended ' + str(each)
    else:
        print 'Already contains ' + str(each)

复制到列表：

Uniquely appended 1
Uniquely appended 2
Already contains 2
Uniquely appended 3
Already contains 3
Uniquely appended 4

印刷品：

unique = UniqueList()

for each in [1,2,2,3,3,4]:
    unique.appendunique(each)

newlist = unique[:]
print newlist

#28 楼

对于长数组

s = np.empty(len(var))

s[:] = np.nan

for  x in  set(var):

    x_positions = np.where(var==x)

    s[x_positions[0][0]]=x


sorted_var=s[~np.isnan(s)]

#29 楼

尝试使用此功能，它类似于您的代码，但是它是一个动态范围。

def unique(a):

    k=0
    while k < len(a):
        if a[k] in a[k+1:]:
            a.pop(k)
        else:
            k=k+1



    return a

#30 楼

使用以下功能：

def uniquefy_list(input_list):
"""
This function  takes a list as input and return a list containing only unique elements from the input list

"""
output_list=[]
for elm123 in input_list:
    in_both_lists=0
    for elm234 in output_list:
        if elm123 == elm234:
            in_both_lists=1
            break
    if in_both_lists == 0:
        output_list.append(elm123)

return output_list