使用不可散列的 Python 对象作为字典中的键

Question

Python 不允许将不可散列的对象用作其他字典中的键。正如 Andrey Vlasovskikh 所指出的，对于使用非嵌套字典作为键的特殊情况，有一个很好的解决方法：

frozenset(a.items())#Can be put in the dictionary instead

有没有使用任意对象作为字典键的方法？

示例：

这将如何用作密钥？

{"a":1, "b":{"c":10}}

您实际上必须在代码中使用类似的东西是非常罕见的。如果您认为是这种情况，请考虑先更改您的数据模型。

具体用例

用例是缓存对任意关键字函数的调用。字典中的每个键都是一个字符串（参数的名称），对象可能非常复杂，由分层字典、列表、元组等组成。

相关问题

这个子问题已从the problem here 中分离出来。这里的解决方案处理字典没有分层的情况。

Answer 1

再次基于 Chris Lutz 的解决方案。

import collections

def hashable(obj):
    if isinstance(obj, collections.Hashable):
        items = obj
    elif isinstance(obj, collections.Mapping):
        items = frozenset((k, hashable(v)) for k, v in obj.iteritems())
    elif isinstance(obj, collections.Iterable):
        items = tuple(hashable(item) for item in obj)
    else:
        raise TypeError(type(obj))

    return items

Answer 2

不要。我同意 Andreys 对上一个问题的评论，即将字典作为键是没有意义的，尤其是嵌套字典。您的数据模型显然非常复杂，字典可能不是正确的答案。您应该尝试一些 OO。

Answer 3

基于 Chris Lutz 的解决方案。请注意，这不处理迭代更改的对象，例如流，也不处理循环。

import collections

def make_hashable(obj):
    """WARNING: This function only works on a limited subset of objects
    Make a range of objects hashable. 
    Accepts embedded dictionaries, lists or tuples (including namedtuples)"""
    if isinstance(obj, collections.Hashable):
        #Fine to be hashed without any changes
        return obj
    elif isinstance(obj, collections.Mapping):
        #Convert into a frozenset instead
        items=list(obj.items())
        for i, item in enumerate(items):
                items[i]=make_hashable(item)
        return frozenset(items)
    elif isinstance(obj, collections.Iterable):
        #Convert into a tuple instead
        ret=[type(obj)]
        for i, item in enumerate(obj):
                ret.append(make_hashable(item))
        return tuple(ret)
    #Use the id of the object
    return id(obj)

Answer 4

如果你真的必须，让你的对象可散列。子类化您想要作为键放入的任何内容，并提供一个 __hash__ 函数，该函数返回该对象的唯一键。

举例说明：

>>> ("a",).__hash__()
986073539
>>> {'a': 'b'}.__hash__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'NoneType' object is not callable

如果您的哈希不够唯一，您将遇到冲突。也可能很慢。

Answer 5

我完全不同意 cmets 和回答说出于数据模型纯度的原因不应该这样做。

字典使用前一个对象作为键将一个对象与另一个对象相关联。字典不能用作键，因为它们不可散列。这不会降低将字典映射到其他对象的意义/实用性/必要性。

据我了解 Python 绑定系统，您可以将任何字典绑定到多个变量（或相反，取决于您的术语），这意味着这些变量都知道指向该字典的相同唯一“指针”。难道不能将该标识符用作散列键吗？ 如果您的数据模型确保/强制您不能将两个具有相同内容的字典用作键，那么这对我来说似乎是一种安全的技术。

我应该补充一点，我不知道如何/应该如何做到这一点。

我并不完全认为这应该是一个答案还是一个评论。如有需要请指正。

Answer 6

我同意 Lennart Regebro 的观点，你不同意。但是我经常发现缓存一些函数调用、可调用对象和/或享元对象很有用，因为它们可能使用关键字参数。

但如果你真的想要它，试试pickle.dumps（或者cPickle，如果是python 2.6）作为一个快速而肮脏的黑客。它比任何使用递归调用使项目不可变且字符串可散列的答案都快得多。

import pickle
hashable_str = pickle.dumps(unhashable_object)

Answer 7

recursion!

def make_hashable(h):
    items = h.items()
    for item in items:
        if type(items) == dict:
            item = make_hashable(item)
    return frozenset(items)

您可以为任何其他想要使其可散列的可变类型添加其他类型测试。应该不难。

Answer 8

我在使用基于调用签名缓存先前调用结果的装饰器时遇到了这个问题。我不同意这里的 cmets/answers 大意是“你不应该这样做”，但我认为重要的是要认识到走这条路时可能会出现令人惊讶和意外的行为。我的想法是，由于实例既是可变的又是可散列的，并且改变它似乎不切实际，因此创建非散列类型或对象的可散列等效项本质上没有错。当然，这只是我的看法。

对于需要兼容 Python 2.5 的任何人，以下内容可能会有用。我基于之前的答案。

from itertools import imap
tuplemap = lambda f, data: tuple(imap(f, data))
def make_hashable(obj):
  u"Returns a deep, non-destructive conversion of given object to an equivalent hashable object"
  if isinstance(obj, list):
    return tuplemap(make_hashable, iter(obj))
  elif isinstance(obj, dict):
    return frozenset(tuplemap(make_hashable, obj.iteritems()))
  elif hasattr(obj, '__hash__') and callable(obj.__hash__):
    try:
      obj.__hash__()
    except:
      if hasattr(obj, '__iter__') and callable(obj.__iter__):
        return tuplemap(make_hashable, iter(obj))
      else:
        raise NotImplementedError, 'object of type %s cannot be made hashable' % (type(obj),)
    else:
      return obj
  elif hasattr(obj, '__iter__') and callable(obj.__iter__):
    return tuplemap(make_hashable, iter(obj))
  else:
    raise NotImplementedError, 'object of type %s cannot be made hashable' % (type, obj)