不可变字典，仅用作另一个字典的键

Question

我需要实现一个可散列的字典，这样我就可以使用一个字典作为另一个字典的键。

几个月前我使用了这个实现：Python hashable dicts

但是，我收到一位同事的通知，说“它并不是真正不可变的，因此它不安全。你可以使用它，但它确实让我觉得自己像一只悲伤的熊猫。

所以我开始四处寻找创建一个不可变的。我不需要将“key-dict”与另一个“key-dict”进行比较。它的唯一用途是作为另一个字典的键。

我想出了以下几点：

class HashableDict(dict):
    """Hashable dict that can be used as a key in other dictionaries"""

    def __new__(self, *args, **kwargs):
        # create a new local dict, that will be used by the HashableDictBase closure class
        immutableDict = dict(*args, **kwargs)

        class HashableDictBase(object):
            """Hashable dict that can be used as a key in other dictionaries. This is now immutable"""

            def __key(self):
                """Return a tuple of the current keys"""
                return tuple((k, immutableDict[k]) for k in sorted(immutableDict))

            def __hash__(self):
                """Return a hash of __key"""
                return hash(self.__key())

            def __eq__(self, other):
                """Compare two __keys"""
                return self.__key() == other.__key() # pylint: disable-msg=W0212

            def __repr__(self):
                """@see: dict.__repr__"""
                return immutableDict.__repr__()

            def __str__(self):
                """@see: dict.__str__"""
                return immutableDict.__str__()

            def __setattr__(self, *args):
                raise TypeError("can't modify immutable instance")
            __delattr__ = __setattr__

        return HashableDictBase()

我使用以下方法来测试功能：

d = {"a" : 1}

a = HashableDict(d)
b = HashableDict({"b" : 2})

print a
d["b"] = 2
print a

c = HashableDict({"a" : 1})

test = {a : "value with a dict as key (key a)",
        b : "value with a dict as key (key b)"}

print test[a]
print test[b]
print test[c]

给出：

{'a': 1}
{'a': 1}
以字典为键的值（键 a）
以字典为键的值（键 b）
以 dict 为键的值（键 a）

作为输出

这是我可以使用的满足我要求的“最好的”不可变字典吗？如果没有，有什么更好的解决方案？

Answer 1

如果您只是将它用作另一个dict 的密钥，您可以选择frozenset(mutabledict.items())。如果您需要访问底层映射，则可以将其用作dict 的参数。

mutabledict = dict(zip('abc', range(3)))
immutable = frozenset(mutabledict.items())
read_frozen = dict(immutable)
read_frozen['a'] # => 1

请注意，您还可以将其与派生自 dict 的类结合使用，并使用 frozenset 作为哈希源，同时禁用 __setitem__，如另一个答案中所建议的那样。 （@RaymondHettinger's answer 用于执行此操作的代码）。

Answer 2

Mapping 抽象基类使得这很容易实现：

import collections

class ImmutableDict(collections.Mapping):
    def __init__(self, somedict):
        self._dict = dict(somedict)   # make a copy
        self._hash = None

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

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

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

    def __hash__(self):
        if self._hash is None:
            self._hash = hash(frozenset(self._dict.items()))
        return self._hash

    def __eq__(self, other):
        return self._dict == other._dict

Answer 3

我意识到这已经得到解答，但types.MappingProxyType 是 Python 3.3 的类似实现。关于最初的安全问题，PEP 416 -- Add a frozendict builtin type 中有讨论为什么frozendict 的想法被拒绝了。

Answer 4

为了使您的不可变字典安全，它需要做的就是永远不要更改其哈希值。你为什么不直接禁用__setitem__，如下所示：

class ImmutableDict(dict):
    def __setitem__(self, key, value):
        raise Exception("Can't touch this")
    def __hash__(self):
        return hash(tuple(sorted(self.items())))

a = ImmutableDict({'a':1})
b = {a:1}
print b
print b[a]
a['a'] = 0

脚本的输出是：

{{'a': 1}: 1}
1
Traceback (most recent call last):
  File "ex.py", line 11, in <module>
    a['a'] = 0
  File "ex.py", line 3, in __setitem__
    raise Exception("Can't touch this")
Exception: Can't touch this

Answer 5

这是pip install-able 实现@RaymondHettinger's answer 的链接：https://github.com/pcattori/icicle

只需pip install icicle 即可from icicle import FrozenDict！

更新： icicle 已被弃用，取而代之的是 maps：https://github.com/pcattori/maps（documentation，PyPI）。

Answer 6

看来我发帖迟到了。不知道其他人是否提出了想法。但这是我的看法。 Dict 是不可变的和可散列的。我通过使用引发异常的自定义“_readonly”函数覆盖所有方法，魔术和其他方法，使其不可变。这是在实例化对象时完成的。为了解决无法应用值的问题，我在“__new__”下设置了“哈希”。然后我重写'__hash__'函数。就是这样！

class ImmutableDict(dict):

_HASH = None

def __new__(cls, *args, **kwargs):
    ImmutableDict._HASH = hash(frozenset(args[0].items()))
    return super(ImmutableDict, cls).__new__(cls, args)

def __hash__(self):
    return self._HASH

def _readonly(self, *args, **kwards):
    raise TypeError("Cannot modify Immutable Instance")

__delattr__ = __setattr__ = __setitem__ = pop = update = setdefault = clear = popitem = _readonly

测试：

immutabled1 = ImmutableDict({"This": "That", "Cheese": "Blarg"})

dict1 = {immutabled1: "Yay"}

dict1[immutabled1]

“耶”

dict1

{{'Cheese': 'Blarg', 'This': 'That'}: 'Yay'}

Answer 7

Raymond Hettinger's answer 的变体，通过将 self._dict 包装为 types.MappingProxyType。

class ImmutableDict(collections.Mapping):
    """
    Copies a dict and proxies it via types.MappingProxyType to make it immutable.
    """
    def __init__(self, somedict):
        dictcopy = dict(somedict) # make a copy
        self._dict = MappingProxyType(dictcopy) # lock it
        self._hash = None

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

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

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

    def __hash__(self):
        if self._hash is None:
            self._hash = hash(frozenset(self._dict.items()))
        return self._hash

    def __eq__(self, other):
        return self._dict == other._dict

    def __repr__(self):
        return str(self._dict)

Answer 8

你可以使用枚举：

import enum

KeyDict1 = enum.Enum('KeyDict1', {'InnerDictKey1':'bla', 'InnerDictKey2 ':2})

d = { KeyDict1: 'whatever', KeyDict2: 1, ...}

您可以像访问字典一样访问枚举：

KeyDict1['InnerDictKey2'].value  # This is 2

您可以遍历名称并获取它们的值...它可以满足您的所有期望。