web-dev-qa-db-fra.com

Puis-je faire un dict ordonné par défaut en Python?

Je voudrais combiner OrderedDict() et defaultdict() de collections dans un objet, qui doit être un ordre ordonné, par défaut. Est-ce possible?

pythondictionary
158
jlconlin

Ce qui suit (en utilisant une version modifiée de cette recette ) fonctionne pour moi:

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

Voici une autre possibilité, inspirée de super () Considered Super de Raymond Hettinger, testée sur Python 2.7.X et 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

Si vous consultez le MRO de la classe (aka, help(OrderedDefaultDict)), vous verrez ceci:

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

ce qui signifie que lorsqu'une instance de OrderedDefaultDict est initialisée, elle reporte l'init de OrderedDict, mais celle-ci appellera à son tour les méthodes de defaultdict avant d'appeler __builtin__.dict, ce qui est précisément ce que nous voulons.

36
avyfain

Voici une autre solution à envisager si votre cas d'utilisation est simple, comme le mien, et que vous ne souhaitez pas nécessairement ajouter la complexité d'une implémentation de classe DefaultOrderedDict à votre code.

from collections import OrderedDict

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

(None est la valeur par défaut souhaitée.)

Notez que cette solution ne fonctionnera pas si l’une de vos exigences consiste à insérer dynamiquement de nouvelles clés avec la valeur par défaut. Un compromis de simplicité. 

Update 3/13/17 - J'ai découvert une fonction pratique pour ce cas d'utilisation. Comme ci-dessus mais vous pouvez omettre la ligne items = ... et simplement:

od = OrderedDict.fromkeys(keys)

Sortie:

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

Et si vos clés sont des caractères simples, vous pouvez simplement passer une chaîne:

OrderedDict.fromkeys('abc')

Cela produit le même résultat que les deux exemples ci-dessus.

Vous pouvez également passer une valeur par défaut comme deuxième argument à OrderedDict.fromkeys(...).

19
Taylor Edmiston

Si vous voulez une solution simple ne nécessitant pas de classe, vous pouvez simplement utiliser OrderedDict.setdefault(key, default=None) ou OrderedDict.get(key, default=None) . Si vous obtenez/définissez seulement à partir de quelques endroits, disons en boucle, vous pouvez facilement définir par défaut.

totals = collections.OrderedDict()

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

C'est encore plus facile pour les listes avec setdefault:

agglomerate = collections.OrderedDict()

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

Mais si vous l'utilisez plus de quelques fois, il est probablement préférable de créer une classe, comme dans les autres réponses.

14
Artyer

Une version simplifiée de la réponse de @zeekay est la suivante:

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
5
Neck Beard

Une autre approche simple consisterait à utiliser la méthode dictionnaire 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)])
>>>
2
snebel29

Une solution simple et élégante reposant sur @NickBread. A une API légèrement différente pour définir l’usine, mais il est toujours agréable d’avoir de bonnes valeurs par défaut.

class OrderedDefaultDict(OrderedDict):
    factory = list

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

Inspiré par d’autres réponses sur ce fil, vous pouvez utiliser quelque chose comme,

from collections import OrderedDict

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

J'aimerais savoir s'il y a des inconvénients à initialiser un autre objet de la même classe dans la méthode missing . 

0
Samarth