python打印输出不在列表中的元素_关于python：如何在列表中打印元素（非重复）...

例如：x=[1,1,1,1,2,2,2,"a","a","a","b","b"]。

我想打印：1,2,"a","b"。

如果列表很长，我甚至不知道列表中有多少种元素呢？

python中有什么函数可以做到这一点吗？或者，如何编写一个for循环来完成它？

你想保持元素的顺序吗？

相关：stackoverflow.com/questions/89178/&hellip；

只使用集合：

x = [1,1,1,1,2,2,2,"a","a","a","b","b"]

uniques = set(x) # the magic!

print uniques # results: set(['a', 1, 2, 'b'])

当然，如果您想要一个列表对象(谢谢@alfasin)：

uniques = list(set(x))

一般来说，编程语言将集合表示为一系列独特的元素(尽管我可以看到，在数学中，这似乎不是一个规则)。

设置

相关有用链接：

为什么一个集合不能有两个相同值的元素？

多集

集合

我想补充一点，OP可以做到：EDOCX1(0；)

你能详细解释一下你的答案吗？这是最好的选择。到文档的链接是可以的，但是答案应该能够独立存在，特别是对于初学者。

@马特莫，你说得对。我已经编辑了我的安莎莉。谢谢！

如果要保持元素在原始列表中出现的顺序，请使用itertools库中的groupby：

>>> import itertools

>>> [k for k, v in itertools.groupby(x)]

[1, 2, 'a', 'b']

这假设相同的元素已经分组在一起，如您的列表中所示(考虑*nix系统中的uniq实用程序)。

注意，groupby要求对输入进行排序。

@Maciejgol：谢谢-我在答案中提出了警告(元素不必按单词的完整意义排序，但相等的值应该分组在一起)。

是的，的确如此；-

这应该有效：

x = [1,1,1,1,2,2,2,"a","a","a","b","b"]

l = []

for item in x:

if (item not in l):

l.append(item)

print(l)

不过，这是O(n^2)，如果x真的很长，速度会很慢。当然，如果短的话，在实践中就不重要了。

简单的列表理解在时间O(n)中工作，假设在两个具有相同值的元素之间没有包含与这两个元素不同值的元素的子序列。

x=[1,1,1,1,2,2,2,"a","a","a","b","b"]

res = [x[i] for i in range(len(x)) if x[i] != x[i-1]]

#If all the elements of the list have the same value.

if len(res) == 0 and len(x) > 0:

res.append(x[0])

print res

出：

[1, 2, 'a', 'b']

如果记忆是一个问题，那么当你填满另一个时，清空其中一个。

your_list = [1,2,1,1,1,1,2,2,2,2,44,4,4,2,2,22,,6,6,5,5,5]

unique_set = set()

while your_list:

unique_set.add(your_list.pop())

如果只希望每个元素出现一次，例如：

输入：[2,2,1,1,3,3,3,1,1]。

输出：[2,1,3]。

用途：

from collections import OrderedDict

answer = OrderedDict(zip(x, xrange(len(x)))).keys()

但如果您希望输出为：[2,1,3,1]，请使用ajcr的答案。

如果你不在乎订单，就用费利普斯马丁斯的答案。

说明：有序的听写是字典，所以它们保持键的唯一性。它们也是按顺序排列的，因此键的顺序是插入顺序。

实际上您需要一个set，因为只有键，没有值，但是没有顺序集。因此，zip用于生成元组列表，然后将该列表作为(键、值)对的列表插入到ordereddict中。xrange(len(x))只是生成一个从0到len(x)的列表(实际上是一个xrange对象，但这里不相关)，但是您可以使用任何长度为len(x)的列表，因为您不关心值。

How can I print the elements (non repetitive) in a list

x=[1,1,1,1,2,2,2,"a","a","a","b","b"]

您要查找的是一个函数，用于获取列表中的唯一元素。一般来说，您需要的是一个set，根据定义，它只包含唯一的元素。

Are there any functions in Python that can do it? Or, how do I write a for loop to do it?

python提供了几种实现这一点的方法，这取决于您的特定需求，其中一种或另一种更合适。以下是几个例子：

# order and selection don't matter

print set(x)

# preserve item order

print dict(zip(x, x)).keys()

# filter, order not preserved

print set(filter(lambda s : True if isinstance(s, str) else False, x))

# filter, preserve order

print (lambda x : [s for s in dict(zip(x,x)).keys() if isinstance(s, str)])(x)

what if the case is that the list is pretty long and I don't even know how many kinds of elements in the list?

理论上，如果您不知道列表中有什么，那么除了查看每个元素之外，没有其他方法了，如果您想确定的话。

如果您对列表有一些了解，比如说您知道每种元素至少有两个，并且按照您的示例中的顺序，您可以跳过一些元素并至少得到列表的近似值。

如果列表很大，这可能很有趣(尽管我怀疑它有什么实际的区别，因为列表已经在内存中)。举个例子：

# c is the number of items that at least appear in sequence. here

# we only touch every other element, so we have reduced the number

# of accesses to x by n/2.

(lambda x, c : set(( x[i] for i in range(0, len(x), c) )))(x, 2)

=> {1, 2, 'a', 'b'}

set确实做到了这一点，尽管它不保留输入列表中显示的顺序。如果要保留此订单，请查看：

def nonRepeats(L):

answer = []

for e in L:

if e not in answer:

answer.append(e)

return answer

现在，这将返回一个非重复元素列表，其顺序与它们在L中出现的顺序相同。

但要注意到if e not in answer。该行检查e是否在answer中(这是一个列表)。我们知道列表中的成员资格测试需要O(n)个时间，也就是说，为了确定元素是否存在于列表中，几乎需要测试列表中的所有元素。这会变得相当昂贵，因为在最坏的情况下，answer可能会增长到L的大小，这使得执行该函数时该行花费O(n^2)时间。

因此，我们可以使这个函数运行得更快(用一点空间成本来抵消时间成本)：

def nonRepeats(L):

seen = set()

answer = []

for e in L:

if e not in seen:

answer.append(e)

return answer

由于seen是set，成员资格测试只需要花费o(1)，这意味着if e not in seen行需要花费函数o(n)时间。现在，进入太空：这个seen装置可能会增长到L的大小。这意味着您将不需要更多的空间作为输入列表的大小来维护seen(因此，如果您试图在内存有限的某种嵌入式系统中使用它，这可能是一个坏主意)。

注意，由于seen是一个set，它是一个散列表，这个解决方案要求输入列表中的所有元素都是可散列的，这并不总是如此(如果输入列表包含一个列表，这个解决方案在其当前形式中就不可用；但是，整数和字符串是可散列的，所以这对于您的用例来说应该是很好的)

如果我们知道这些值是可散列的，并且我们想要第一次出现的顺序，那么我们总是可以执行list(OrderedDict.fromkeys(seq))。

如果打印时元素的顺序无关紧要，请使用集合。

>>> x=[1,1,1,1,2,2,2,"a","a","a","b","b"]

>>> list(set(x))

['a', 1, 2, 'b']

您可以使用for循环：

x=[1,1,1,1,2,2,2,"a","a","a","b","b"]

non_repetitive = []

for item in x:

if item not in non_repetitive:

non_repetitive.append(item)

是的，这是一种简单的方法，

x=[1,1,1,1,2,2,2,"a","a","a","b","b"]

print set(x)

但是，您也可以使用for循环和字典来实现相同的输出，方法是遍历列表并记录存在的不同元素的频率。

dummy_dict = {}

for element in x:

if not element in dummy_dict:

dummy_dict[element] = 1

print dummy_dict.keys()

最好使用字典，因为从dict访问值是在o(1)时间或常量时间内完成的。

上述副本。

与其建议计算频率的算法，不如建议内置的解决方案：collections.Counter。

@A.J.首先发布了这个答案

@马德莫，我说的是费利普斯·马丁斯的答案的复制品：)不是我的。

A.J.OK。不过，在未来，你可能会想更具体一点，你指的是哪一个，因为"以上"并不意味着任何事情-不同的人有不同的排序方式，新的答案被迅速添加。只是一个想法…