如何实现一个有序的，默认字典?

以下(使用这道菜的修改版本)适用于我:

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

如果你的用例像我的用例一样简单，并且你不一定想在你的代码中添加DefaultOrderedDict类实现的复杂性，那么这里有另一个解决方案可以考虑。

from collections import OrderedDict


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

(None是我想要的默认值。)

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

更新3/13/17 -我了解到这个用例的一个方便函数。与上面相同，但你可以省略items = ...行，只需:

od = OrderedDict.fromkeys(keys)

输出:

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

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

OrderedDict.fromkeys('abc')

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

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

下面是另一种可能性，受到Raymond Hettinger的超级()被认为超级的启发，在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的方法，这正是我们想要的。

@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

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

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)

但如果你多次使用它，可能最好建立一个类，就像其他答案一样。

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

sorted(s.items())

我认为这样更简单

class OrderedDefaultDict(OrderedDict):
factory = list


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

另一种简单的方法是使用字典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)])
>>>

受到这篇文章中其他答案的启发，你可以使用这样的东西，

from collections import OrderedDict


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

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