正如其他答案所提到的，对于python 3.7+，字典是按定义排序的。我们可以继承abc.collections.MutableSet或typing，而不是继承OrderedDict。MutableSet使用字典的键来存储我们的值。

import itertools
import typing

T = typing.TypeVar("T")

class OrderedSet(typing.MutableSet[T]):
    """A set that preserves insertion order by internally using a dict."""

    def __init__(self, iterable: typing.Iterator[T]):
        self._d = dict.fromkeys(iterable)

    def add(self, x: T) -> None:
        self._d[x] = None

    def discard(self, x: T) -> None:
        self._d.pop(x, None)

    def __contains__(self, x: object) -> bool:
        return self._d.__contains__(x)

    def __len__(self) -> int:
        return self._d.__len__()

    def __iter__(self) -> typing.Iterator[T]:
        return self._d.__iter__()

    def __str__(self):
        return f"{{{', '.join(str(i) for i in self)}}}"

    def __repr__(self):
        return f"<OrderedSet {self}>"

然后:

x = OrderedSet([1, 2, -1, "bar"])
x.add(0)
assert list(x) == [1, 2, -1, "bar", 0]

我在一个小库中添加了这些代码和一些测试，所以任何人都可以安装它。

虽然有点晚了，但我已经编写了一个类setlist作为集合扩展的一部分，它完全实现了Sequence和Set

>>> from collections_extended import setlist
>>> sl = setlist('abracadabra')
>>> sl
setlist(('a', 'b', 'r', 'c', 'd'))
>>> sl[3]
'c'
>>> sl[-1]
'd'
>>> 'r' in sl  # testing for inclusion is fast
True
>>> sl.index('d')  # so is finding the index of an element
4
>>> sl.insert(1, 'd')  # inserting an element already in raises a ValueError
ValueError
>>> sl.index('d')
4

GitHub: https://github.com/mlenzen/collections-extended

文档:http://collections-extended.lenzm.net/en/latest/

皮皮 https://pypi.python.org/pypi/collections-extended

有一个pip库是这样做的:

pip install ordered-set

然后你可以使用它:

from ordered_set import OrderedSet

PyPI上的实现

虽然其他人指出Python中还没有插入顺序保留集的内置实现，但我觉得这个问题缺少一个答案，它说明了在PyPI上可以找到什么。

这些是套餐:

有序集(基于Python) orderedset(基于Cython) collections-extended 波顿(在iterutils下。IndexedSet面向) Oset(最后更新于2012年)

其中一些实现是基于Raymond Hettinger发布到ActiveState的配方，在这里的其他回答中也提到了这个配方。

一些差异

有序集(版本1.1) 优点:O(1)用于索引查找(例如my_set[5]) Oset(版本0.1.3) 优点:O(1)用于移除(物品) 缺点:显然O(n)用于索引查找

这两个实现都有O(1)用于add(item)和__contains__(item) (my_set中的项目)。

答案是否定的，但是您可以使用集合。OrderedDict来自Python标准库，其中只有键(值为None)，用于相同的目的。

更新:从Python 3.7(和CPython 3.6)开始，标准dict保证保留顺序，并且比OrderedDict性能更好。(但是，为了向后兼容性，特别是可读性，您可能希望继续使用OrderedDict。)

下面是一个示例，说明如何使用dict作为有序集，在保留顺序的同时过滤掉重复项，从而模拟有序集。使用dict类方法fromkeys()创建一个dict，然后简单地要求返回keys()。

>>> keywords = ['foo', 'bar', 'bar', 'foo', 'baz', 'foo']

>>> list(dict.fromkeys(keywords))
['foo', 'bar', 'baz']

更新:这个答案在Python 3.7已经过时了。请参阅上面jrc的回答以获得更好的解决方案。出于历史原因，我将保留这个答案。

有序集在功能上是有序字典的一种特殊情况。

字典的键是唯一的。因此，如果忽略有序字典中的值(例如，将它们赋值为None)，那么本质上是有序集。

从Python 3.1和2.7开始，就有了collections.OrderedDict。下面是OrderedSet的一个示例实现。(注意，只有少数方法需要定义或重写:集合。有序字典和集合。让我们来做繁重的工作。

import collections

class OrderedSet(collections.OrderedDict, collections.MutableSet):

    def update(self, *args, **kwargs):
        if kwargs:
            raise TypeError("update() takes no keyword arguments")

        for s in args:
            for e in s:
                 self.add(e)

    def add(self, elem):
        self[elem] = None

    def discard(self, elem):
        self.pop(elem, None)

    def __le__(self, other):
        return all(e in other for e in self)

    def __lt__(self, other):
        return self <= other and self != other

    def __ge__(self, other):
        return all(e in self for e in other)

    def __gt__(self, other):
        return self >= other and self != other

    def __repr__(self):
        return 'OrderedSet([%s])' % (', '.join(map(repr, self.keys())))

    def __str__(self):
        return '{%s}' % (', '.join(map(repr, self.keys())))
    
    difference = property(lambda self: self.__sub__)
    difference_update = property(lambda self: self.__isub__)
    intersection = property(lambda self: self.__and__)
    intersection_update = property(lambda self: self.__iand__)
    issubset = property(lambda self: self.__le__)
    issuperset = property(lambda self: self.__ge__)
    symmetric_difference = property(lambda self: self.__xor__)
    symmetric_difference_update = property(lambda self: self.__ixor__)
    union = property(lambda self: self.__or__)