如何实现有序的默认字典？-IT科技

摘要：问题描述：我想将OrderedDict()和defaultdict()from合并到collections一个对象中，该对象应为有序的、默认的dict。这可能吗？解决方案 1：以下方法（使用该配方的修改版本）对我有用：from collections import OrderedDict, Callabl...

问题描述：

我想将OrderedDict()和defaultdict()from合并到collections一个对象中，该对象应为有序的、默认的dict。

这可能吗？

解决方案 1：

以下方法（使用该配方的修改版本）对我有用：

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))

解决方案 2：

这是另一种可能性，受到Raymond Hettinger 的 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的初始化，但是这个实例又会defaultdict在调用之前调用的方法__builtin__.dict，这正是我们想要的。

解决方案 3：

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

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)

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

解决方案 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(...)。

解决方案 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)])
>>>

解决方案 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

解决方案 7：

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

class OrderedDefaultDict(OrderedDict):
    factory = list

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

解决方案 8：

defaultdict按 Python 3.7 +（和 CPython 3.6 +）上的插入顺序排序。

解决方案 9：

我创建了稍微修复且更简化的已接受答案的版本，实际适用于 python 3.7。

from collections import OrderedDict
from copy import copy, deepcopy
import pickle
from typing import Any, Callable


class DefaultOrderedDict(OrderedDict):
    def __init__(
            self,
            default_factory: Callable[[], Any],
            *args,
            **kwargs,
    ):
        super().__init__(*args, **kwargs)
        self.default_factory = default_factory

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

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

    def __reduce__(self):
        return type(self), (self.default_factory, ), None, None, iter(self.items())

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

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

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

    def __repr__(self):
        return f'{self.__class__.__name__}({self.default_factory}, {OrderedDict(self).__repr__()})'

而且，如果进行一些测试的话，这可能更为重要。

a = DefaultOrderedDict(list)

# testing default
assert a['key'] == []
a['key'].append(1)
assert a['key'] == [1, ]

# testing repr
assert repr(a) == "DefaultOrderedDict(<class 'list'>, OrderedDict([('key', [1])]))"

# testing copy
b = a.copy()
assert b['key'] is a['key']
c = copy(a)
assert c['key'] is a['key']
d = deepcopy(a)
assert d['key'] is not a['key']
assert d['key'] == a['key']

# testing pickle
saved = pickle.dumps(a)
restored = pickle.loads(saved)
assert restored is not a
assert restored == a

# testing order
a['second_key'] = [2, ]
a['key'] = [3, ]
assert list(a.items()) == [('key', [3, ]), ('second_key', [2, ])]

解决方案 10：

受到该主题中其他答案的启发，您可以使用类似以下方法，

from collections import OrderedDict

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

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