Ce qui serait un “gelé dict” l'être?

Python n'est pas un builtin frozendict type. Il s'avère que ce ne serait pas utile de trop souvent (même si ce serait probablement encore être utile le plus souvent frozenset est).

La raison la plus courante de vouloir un tel type est quand memoizing appels de fonction pour les fonctions avec des inconnus d'arguments. La solution la plus courante pour stocker un hashable équivalent d'une dict (où les valeurs sont hashable) est quelque chose comme tuple(sorted(kwargs.iteritems())).

Cela dépend du tri de ne pas être un peu fou. Python ne peut pas franchement promesse de tri va en résulter quelque chose de raisonnable ici. (Mais il ne peut pas vous promettre beaucoup d'autre, donc ne vous en faites pas trop.)

Vous pourrait assez facilement faire une sorte de wrapper qui fonctionne un peu comme un dict. Il pourrait ressembler à quelque chose comme

import collections

class FrozenDict(collections.Mapping):
    """Don't forget the docstrings!!"""

    def __init__(self, *args, **kwargs):
        self._d = dict(*args, **kwargs)
        self._hash = None

    def __iter__(self):
        return iter(self._d)

    def __len__(self):
        return len(self._d)

    def __getitem__(self, key):
        return self._d[key]

    def __hash__(self):
        # It would have been simpler and maybe more obvious to 
        # use hash(tuple(sorted(self._d.iteritems()))) from this discussion
        # so far, but this solution is O(n). I don't know what kind of 
        # n we are going to run into, but sometimes it's hard to resist the 
        # urge to optimize when it will gain improved algorithmic performance.
        if self._hash is None:
            self._hash = 0
            for pair in self.iteritems():
                self._hash ^= hash(pair)
        return self._hash

Il devrait fonctionner à merveille:

>>> x = FrozenDict(a=1, b=2)
>>> y = FrozenDict(a=1, b=2)
>>> x is y
False
>>> x == y
True
>>> x == {'a': 1, 'b': 2}
True
>>> d = {x: 'foo'}
>>> d[y]
'foo'

En supposant que les clés et les valeurs du dictionnaire sont eux-mêmes immuables (par exemple des chaînes de caractères) puis:

>>> d
{'forever': 'atones', 'minks': 'cards', 'overhands': 'warranted', 
 'hardhearted': 'tartly', 'gradations': 'snorkeled'}
>>> t = tuple((k, d[k]) for k in sorted(d.keys()))
>>> hash(t)
1524953596

Voici le code que j'ai utilisé. Je sous-classé frozenset. Les avantages sont les suivants.

1. C'est vraiment un objet immuable. Pas de s'appuyer sur le bon comportement des futurs utilisateurs et de développeurs.
2. Il est facile de convertir des aller-retour entre régulière d'un dictionnaire et d'une gelée de dictionnaire. FrozenDict(orig_dict) --> congelés dictionnaire. dict(frozen_dict) --> régulièrement dict.

Mise à jour Jan 21 2015: Le morceau de code que j'ai posté en 2014 utilisé une boucle for pour trouver une clé de correspondance. C'était incroyablement lent. Maintenant j'ai mis en place une application qui tire profit de frozenset de fonctions de hachage. Les paires clé-valeur sont stockés dans des conteneurs spéciaux où la __hash__ et __eq__ fonctions sont basées sur la clé uniquement. Ce code a aussi été officiellement unité testée, contrairement à ce que j'ai posté ici en août 2014.

MIT de style de licence.

if 3 / 2 == 1:
version = 2
elif 3 / 2 == 1.5:
version = 3
def col(i):
''' For binding named attributes to spots inside subclasses of tuple.'''
g = tuple.__getitem__
@property
def _col(self):
return g(self,i)
return _col
class Item(tuple):
''' Designed for storing key-value pairs inside
a FrozenDict, which itself is a subclass of frozenset.
The __hash__ is overloaded to return the hash of only the key.
__eq__ is overloaded so that normally it only checks whether the Item's
key is equal to the other object, HOWEVER, if the other object itself
is an instance of Item, it checks BOTH the key and value for equality.
WARNING: Do not use this class for any purpose other than to contain
key value pairs inside FrozenDict!!!!
The __eq__ operator is overloaded in such a way that it violates a
fundamental property of mathematics. That property, which says that
a == b and b == c implies a == c, does not hold for this object.
Here's a demonstration:
[in]  >>> x = Item(('a',4))
[in]  >>> y = Item(('a',5))
[in]  >>> hash('a')
[out] >>> 194817700
[in]  >>> hash(x)
[out] >>> 194817700
[in]  >>> hash(y)
[out] >>> 194817700
[in]  >>> 'a' == x
[out] >>> True
[in]  >>> 'a' == y
[out] >>> True
[in]  >>> x == y
[out] >>> False
'''
__slots__ = ()
key, value = col(0), col(1)
def __hash__(self):
return hash(self.key)
def __eq__(self, other):
if isinstance(other, Item):
return tuple.__eq__(self, other)
return self.key == other
def __ne__(self, other):
return not self.__eq__(other)
def __str__(self):
return '%r: %r' % self
def __repr__(self):
return 'Item((%r, %r))' % self
class FrozenDict(frozenset):
''' Behaves in most ways like a regular dictionary, except that it's immutable.
It differs from other implementations because it doesn't subclass "dict".
Instead it subclasses "frozenset" which guarantees immutability.
FrozenDict instances are created with the same arguments used to initialize
regular dictionaries, and has all the same methods.
[in]  >>> f = FrozenDict(x=3,y=4,z=5)
[in]  >>> f['x']
[out] >>> 3
[in]  >>> f['a'] = 0
[out] >>> TypeError: 'FrozenDict' object does not support item assignment
FrozenDict can accept un-hashable values, but FrozenDict is only hashable if its values are hashable.
[in]  >>> f = FrozenDict(x=3,y=4,z=5)
[in]  >>> hash(f)
[out] >>> 646626455
[in]  >>> g = FrozenDict(x=3,y=4,z=[])
[in]  >>> hash(g)
[out] >>> TypeError: unhashable type: 'list'
FrozenDict interacts with dictionary objects as though it were a dict itself.
[in]  >>> original = dict(x=3,y=4,z=5)
[in]  >>> frozen = FrozenDict(x=3,y=4,z=5)
[in]  >>> original == frozen
[out] >>> True
FrozenDict supports bi-directional conversions with regular dictionaries.
[in]  >>> original = {'x': 3, 'y': 4, 'z': 5}
[in]  >>> FrozenDict(original)
[out] >>> FrozenDict({'x': 3, 'y': 4, 'z': 5})
[in]  >>> dict(FrozenDict(original))
[out] >>> {'x': 3, 'y': 4, 'z': 5}   '''
__slots__ = ()
def __new__(cls, orig={}, **kw):
if kw:
d = dict(orig, **kw)
items = map(Item, d.items())
else:
try:
items = map(Item, orig.items())
except AttributeError:
items = map(Item, orig)
return frozenset.__new__(cls, items)
def __repr__(self):
cls = self.__class__.__name__
items = frozenset.__iter__(self)
_repr = ', '.join(map(str,items))
return '%s({%s})' % (cls, _repr)
def __getitem__(self, key):
if key not in self:
raise KeyError(key)
diff = self.difference
item = diff(diff({key}))
key, value = set(item).pop()
return value
def get(self, key, default=None):
if key not in self:
return default
return self[key]
def __iter__(self):
items = frozenset.__iter__(self)
return map(lambda i: i.key, items)
def keys(self):
items = frozenset.__iter__(self)
return map(lambda i: i.key, items)
def values(self):
items = frozenset.__iter__(self)
return map(lambda i: i.value, items)
def items(self):
items = frozenset.__iter__(self)
return map(tuple, items)
def copy(self):
cls = self.__class__
items = frozenset.copy(self)
dupl = frozenset.__new__(cls, items)
return dupl
@classmethod
def fromkeys(cls, keys, value):
d = dict.fromkeys(keys,value)
return cls(d)
def __hash__(self):
kv = tuple.__hash__
items = frozenset.__iter__(self)
return hash(frozenset(map(kv, items)))
def __eq__(self, other):
if not isinstance(other, FrozenDict):
try:
other = FrozenDict(other)
except Exception:
return False
return frozenset.__eq__(self, other)
def __ne__(self, other):
return not self.__eq__(other)
if version == 2:
#Here are the Python2 modifications
class Python2(FrozenDict):
def __iter__(self):
items = frozenset.__iter__(self)
for i in items:
yield i.key
def iterkeys(self):
items = frozenset.__iter__(self)
for i in items:
yield i.key
def itervalues(self):
items = frozenset.__iter__(self)
for i in items:
yield i.value
def iteritems(self):
items = frozenset.__iter__(self)
for i in items:
yield (i.key, i.value)
def has_key(self, key):
return key in self
def viewkeys(self):
return dict(self).viewkeys()
def viewvalues(self):
return dict(self).viewvalues()
def viewitems(self):
return dict(self).viewitems()
#If this is Python2, rebuild the class
#from scratch rather than use a subclass
py3 = FrozenDict.__dict__
py3 = {k: py3[k] for k in py3}
py2 = {}
py2.update(py3)
dct = Python2.__dict__
py2.update({k: dct[k] for k in dct})
FrozenDict = type('FrozenDict', (frozenset,), py2)

Vous pouvez utiliser frozendict de utilspie paquet comme:

>>> from utilspie.collectionsutils import frozendict
>>> my_dict = frozendict({1: 3, 4: 5})
>>> my_dict  # object of `frozendict` type
frozendict({1: 3, 4: 5})
# Hashable
>>> {my_dict: 4}
{frozendict({1: 3, 4: 5}): 4}
# Immutable
>>> my_dict[1] = 5
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/Users/mquadri/workspace/utilspie/utilspie/collectionsutils/collections_utils.py", line 44, in __setitem__
self.__setitem__.__name__, type(self).__name__))
AttributeError: You can not call '__setitem__()' for 'frozendict' object

Que par la document:

frozendict(dict_obj): Accepte obj dict type et retourne un hashable et immuable dict

Le principal inconvénient de namedtuple est qu'il doit être spécifié avant de l'utiliser, donc c'est moins pratique pour un seul cas d'utilisation.

Cependant, il existe une solution pratique qui peut être utilisée pour traiter de nombreux cas. Disons que vous voulez avoir un immuable équivalent de la suite dict:

MY_CONSTANT = {
'something': 123,
'something_else': 456
}

Cela peut être émulé comme ceci:

from collections import namedtuple
MY_CONSTANT = namedtuple('MyConstant', 'something something_else')(123, 456)

Il est même possible d'écrire une fonction auxiliaire pour automatiser ce:

def freeze_dict(data):
from collections import namedtuple
keys = sorted(data.keys())
frozen_type = namedtuple(''.join(keys), keys)
return frozen_type(**data)
a = {'foo':'bar', 'x':'y'}
fa = freeze_dict(data)
assert a['foo'] == fa.foo

Bien sûr, cela ne fonctionne que pour les plats à dicts, mais il ne devrait pas être trop difficile à mettre en œuvre une version récursive.

Une autre option est le MultiDictProxy classe à partir de la multidict paquet.

En l'absence de la langue native de l'aide, vous pouvez soit le faire vous-même ou utiliser une solution existante. Heureusement Python rend simple pour étendre hors de leur base implémentations.

class frozen_dict(dict):
def __setitem__(self, key, value):
raise Exception('Frozen dictionaries cannot be mutated')
frozen_dict = frozen_dict({'foo': 'FOO' })
print(frozen['foo']) # FOO
frozen['foo'] = 'NEWFOO' # Exception: Frozen dictionaries cannot be mutated
# OR
from types import MappingProxyType
frozen_dict = MappingProxyType({'foo': 'FOO'})
print(frozen_dict['foo']) # FOO
frozen_dict['foo'] = 'NEWFOO' # TypeError: 'mappingproxy' object does not support item assignment