如果你有少量的元素在你的两个初始列表上，你想做集差操作，而不是使用集合。OrderedDict使实现复杂化，使其可读性较差，您可以使用:

# initial lists on which you want to do set difference
>>> nums = [1,2,2,3,3,4,4,5]
>>> evens = [2,4,4,6]
>>> evens_set = set(evens)
>>> result = []
>>> for n in nums:
...   if not n in evens_set and not n in result:
...     result.append(n)
... 
>>> result
[1, 3, 5]

它的时间复杂度不是很好，但它很简洁，易于阅读。

基于Sven的回答，我发现使用集合。OrderedDict像这样帮助我完成你想要的，并允许我添加更多的项目到dict:

import collections

x=[1,2,20,6,210]
z=collections.OrderedDict.fromkeys(x)
z
OrderedDict([(1, None), (2, None), (20, None), (6, None), (210, None)])

如果你想添加项目，但仍然把它当作一个集合，你可以这样做:

z['nextitem']=None

你可以在dict上执行类似z.keys()的操作并获得集合:

list(z.keys())
[1, 2, 20, 6, 210]

正如在其他答案中指出的那样，集合是不保留元素顺序的数据结构(和数学概念)

然而，通过使用集合和字典的组合，你可以实现任何你想要的-尝试使用这些片段:

# save the element order in a dict:
x_dict = dict(x,y for y, x in enumerate(my_list) )
x_set = set(my_list)
#perform desired set operations
...
#retrieve ordered list from the set:
new_list = [None] * len(new_set)
for element in new_set:
   new_list[x_dict[element]] = element

有趣的是，人们总是用“现实问题”来开理论科学定义的玩笑。

如果设置有顺序，首先需要解决以下问题。 如果你的列表有重复的元素，当你把它变成一个集合时，顺序应该是什么?如果我们合并两个集合，顺序是什么?如果我们在相同的元素上相交两个不同顺序的集合是什么顺序?

另外，set在搜索特定键时要快得多，这在set操作中非常好(这就是为什么你需要set，而不是list)。

如果您真的关心索引，只需将其保存为列表即可。如果您仍然想对许多列表中的元素执行set操作，最简单的方法是为每个具有相同键的列表创建一个字典，并创建一个list值，其中包含原始列表中键的所有索引。

def indx_dic(l):
    dic = {}
    for i in range(len(l)):
        if l[i] in dic:
            dic.get(l[i]).append(i)
        else:
            dic[l[i]] = [i]
    return(dic)

a = [1,2,3,4,5,1,3,2]
set_a  = set(a)
dic_a = indx_dic(a)

print(dic_a)
# {1: [0, 5], 2: [1, 7], 3: [2, 6], 4: [3], 5: [4]}
print(set_a)
# {1, 2, 3, 4, 5}

我们可以使用集合。计数器:

# tested on python 3.7
>>> from collections import Counter
>>> lst = ["1", "2", "20", "6", "210"]

>>> for i in Counter(lst):
>>>     print(i, end=" ")
1 2 20 6 210 

>>> for i in set(lst):
>>>     print(i, end=" ")
20 6 2 1 210

在数学中，有集和有序集(oset)。

set:唯一元素的无序容器(已实现) oset:唯一元素的有序容器

在Python中，只有集合是直接实现的。我们可以用常规字典键(3.7+)来模拟偏移量。

鉴于

a = [1, 2, 20, 6, 210, 2, 1]
b = {2, 6}

Code

oset = dict.fromkeys(a).keys()
# dict_keys([1, 2, 20, 6, 210])

Demo

删除复制，保留插入顺序。

list(oset)
# [1, 2, 20, 6, 210]

字典键上类似set的操作。

oset - b
# {1, 20, 210}

oset | b
# {1, 2, 5, 6, 20, 210}

oset & b
# {2, 6}

oset ^ b
# {1, 5, 20, 210}

细节

注意:无序结构并不排除有序元素。相反，维持秩序并不能得到保证。例子:

assert {1, 2, 3} == {2, 3, 1}                    # sets (order is ignored)

assert [1, 2, 3] != [2, 3, 1]                    # lists (order is guaranteed)

人们可能会很高兴地发现，列表和多集(mset)是两种更迷人的数学数据结构:

list:允许复制的有序元素容器(已实现) mset:允许复制的无序元素容器(NotImplemented)*

总结

Container | Ordered | Unique | Implemented
----------|---------|--------|------------
set       |    n    |    y   |     y
oset      |    y    |    y   |     n
list      |    y    |    n   |     y
mset      |    n    |    n   |     n*  

多重集可以通过collections.Counter()间接模拟，这是一个类似字典的多重度(计数)映射。