如何实现有序的默认字典？

Question

我想将collections 中的OrderedDict() 和defaultdict() 组合在一个对象中，这应该是一个有序的，默认为dict。
这可能吗？

Answer 1

以下内容（使用 this recipe 的修改版本）对我有用：

from collections import OrderedDict, Callable

class DefaultOrderedDict(OrderedDict):
    # Source: http://stackoverflow.com/a/6190500/562769
    def __init__(self, default_factory=None, *a, **kw):
        if (default_factory is not None and
           not isinstance(default_factory, Callable)):
            raise TypeError('first argument must be callable')
        OrderedDict.__init__(self, *a, **kw)
        self.default_factory = default_factory

    def __getitem__(self, key):
        try:
            return OrderedDict.__getitem__(self, key)
        except KeyError:
            return self.__missing__(key)

    def __missing__(self, key):
        if self.default_factory is None:
            raise KeyError(key)
        self[key] = value = self.default_factory()
        return value

    def __reduce__(self):
        if self.default_factory is None:
            args = tuple()
        else:
            args = self.default_factory,
        return type(self), args, None, None, self.items()

    def copy(self):
        return self.__copy__()

    def __copy__(self):
        return type(self)(self.default_factory, self)

    def __deepcopy__(self, memo):
        import copy
        return type(self)(self.default_factory,
                          copy.deepcopy(self.items()))

    def __repr__(self):
        return 'OrderedDefaultDict(%s, %s)' % (self.default_factory,
                                               OrderedDict.__repr__(self))

Answer 2

这是另一种可能性，灵感来自Raymond Hettinger's super() Considered Super，在 Python 2.7.X 和 3.4.X 上进行了测试：

from collections import OrderedDict, defaultdict

class OrderedDefaultDict(OrderedDict, defaultdict):
    def __init__(self, default_factory=None, *args, **kwargs):
        #in python3 you can omit the args to super
        super(OrderedDefaultDict, self).__init__(*args, **kwargs)
        self.default_factory = default_factory

如果您查看课程的 MRO（又名 help(OrderedDefaultDict)），您会看到：

class OrderedDefaultDict(collections.OrderedDict, collections.defaultdict)
 |  Method resolution order:
 |      OrderedDefaultDict
 |      collections.OrderedDict
 |      collections.defaultdict
 |      __builtin__.dict
 |      __builtin__.object

意思是当OrderedDefaultDict的一个实例被初始化时，它遵循OrderedDict的init，但是这个又会在调用__builtin__.dict之前调用defaultdict的方法，这正是我们想要。

Answer 3

如果您想要一个不需要类的简单解决方案，您可以使用OrderedDict.<strong>setdefault</strong>(<em>key, default=None</em>) 或OrderedDict.<strong>get</strong>(<em>key, default=None</em>)。如果你只从几个地方获取/设置，比如在一个循环中，你可以轻松地设置默认值。

totals = collections.OrderedDict()

for i, x in some_generator():
    totals[i] = totals.get(i, 0) + x

setdefault 的列表更容易：

agglomerate = collections.OrderedDict()

for i, x in some_generator():
    agglomerate.setdefault(i, []).append(x)

但如果你多次使用它，最好设置一个类，就像在其他答案中一样。

Answer 4

如果您的用例像我的一样简单，并且您不一定想将 DefaultOrderedDict 类实现的复杂性添加到您的代码中，这是另一个解决方案。

from collections import OrderedDict

keys = ['a', 'b', 'c']
items = [(key, None) for key in keys]
od = OrderedDict(items)

（None 是我想要的默认值。）

请注意，如果您的要求之一是动态插入具有默认值的新键，则此解决方案将不起作用。简单性的权衡。

2017 年 3 月 13 日更新 - 我了解到这个用例的便利功能。与上面相同，但您可以省略 items = ... 行，只需：

od = OrderedDict.fromkeys(keys)

输出：

OrderedDict([('a', None), ('b', None), ('c', None)])

如果你的键是单个字符，你可以只传递一个字符串：

OrderedDict.fromkeys('abc')

这与上面两个示例的输出相同。

您还可以将默认值作为第二个参数传递给OrderedDict.fromkeys(...)。

Answer 5

另一种简单的方法是使用字典get 方法

>>> from collections import OrderedDict
>>> d = OrderedDict()
>>> d['key'] = d.get('key', 0) + 1
>>> d['key'] = d.get('key', 0) + 1
>>> d
OrderedDict([('key', 2)])
>>> 

Answer 6

@zeekay 答案的更简单版本是：

from collections import OrderedDict

class OrderedDefaultListDict(OrderedDict): #name according to default
    def __missing__(self, key):
        self[key] = value = [] #change to whatever default you want
        return value

Answer 7

一个基于@NickBread 的简单而优雅的解决方案。 有一个稍微不同的 API 来设置工厂，但好的默认值总是很好。

class OrderedDefaultDict(OrderedDict):
    factory = list

    def __missing__(self, key):
        self[key] = value = self.factory()
        return value

Answer 8

受此线程上其他答案的启发，您可以使用类似的东西，

from collections import OrderedDict

class OrderedDefaultDict(OrderedDict):
    def __missing__(self, key):
        value = OrderedDefaultDict()
        self[key] = value
        return value

我想知道在 missing 方法中初始化同一类的另一个对象是否有任何缺点。

Answer 9

我测试了默认字典，发现它也已排序！ 也许这只是一个巧合，但无论如何你都可以使用 sorted 函数：

sorted(s.items())

我觉得比较简单