是什么让用户定义的类不可散列？

Question

docs 表示只要定义了__hash__ 方法和__eq__ 方法的类是可散列的。然而：

class X(list):
  # read-only interface of `tuple` and `list` should be the same, so reuse tuple.__hash__
  __hash__ = tuple.__hash__

x1 = X()
s = {x1} # TypeError: unhashable type: 'X'

是什么让X 不可散列？

请注意，我必须有相同的列表（就常规相等而言）才能被散列到相同的值；否则，我将 violate this requirement 讨论哈希函数：

唯一需要的属性是比较相等的对象具有 相同的哈希值

文档确实警告说，在其生命周期内不应修改可散列对象，当然我不会在创建后修改 X 的实例。当然，解释器无论如何也不会检查。

Answer 1

仅将__hash__ 方法设置为tuple 类的方法是不够的。你实际上并没有告诉它如何以不同的方式散列。元组是可散列的，因为它们是不可变的。如果你真的想让你的具体示例工作，它可能是这样的：

class X2(list):
    def __hash__(self):
        return hash(tuple(self))

在这种情况下，您实际上是在定义如何散列您的自定义列表子类。您只需要准确定义它如何生成哈希即可。您可以随意散列，而不是使用元组的散列方法：

def __hash__(self):
    return hash("foobar"*len(self))

Answer 2

如果您在创建后不修改 X 的实例，为什么不子类化元组？

但我要指出，这实际上不会引发错误，至少在 Python 2.6 中是这样。

>>> class X(list):
...     __hash__ = tuple.__hash__
...     __eq__ = tuple.__eq__
... 
>>> x = X()
>>> s = set((x,))
>>> s
set([[]])

我不敢说“有效”，因为这并没有达到你认为的效果。

>>> a = X()
>>> b = X((5,))
>>> hash(a)
4299954584
>>> hash(b)
4299954672
>>> id(a)
4299954584
>>> id(b)
4299954672

它只是使用对象 id 作为哈希。当您实际调用__hash__ 时，您仍然会收到错误消息；同样适用于__eq__。

>>> a.__hash__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: descriptor '__hash__' for 'tuple' objects doesn't apply to 'X' object
>>> X().__eq__(X())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: descriptor '__eq__' for 'tuple' objects doesn't apply to 'X' object

我收集到 python 内部，出于某种原因，正在检测 X 有一个 __hash__ 和一个 __eq__ 方法，但没有调用它们。

这一切的寓意是：只需编写一个真正的哈希函数。由于这是一个序列对象，因此将其转换为元组和散列是最明显的方法。

def __hash__(self):
    return hash(tuple(self))

Answer 3

根据您的其他问题，您可以而且应该做的是： 不要子类化任何东西，只需封装一个元组。在 init 中这样做完全没问题。

class X(object):
    def __init__(self, *args):
        self.tpl = args
    def __hash__(self):
        return hash(self.tpl)
    def __eq__(self, other):
        return self.tpl == other
    def __repr__(self):
        return repr(self.tpl)

x1 = X()
s = {x1}

产生：

>>> s
set([()])
>>> x1
()

Answer 4

来自 Python3 文档：

如果一个类没有定义一个 __eq__() 方法，它就不应该定义一个 __hash__() 操作；如果它定义了 __eq__() 而不是 __hash__()，它的实例将不能用作可散列集合中的项目。如果一个类定义了可变对象并实现了一个 __eq__() 方法，它不应该实现 __hash__()，因为哈希集合的实现需要一个键的哈希 value 是不可变的（如果对象的哈希值发生变化，它将在 错误的哈希桶）。

参考：object.__hash__(self)

示例代码：

class Hashable:
    pass

class Unhashable:
    def __eq__(self, other):
        return (self == other)

class HashableAgain:
    def __eq__(self, other):
        return (self == other)

    def __hash__(self):
        return id(self)

def main():
    # OK
    print(hash(Hashable()))
    # Throws: TypeError("unhashable type: 'X'",)
    print(hash(Unhashable()))  
    # OK
    print(hash(HashableAgain()))

Answer 5

对上述答案的补充 - 对于 python3.7+ 中数据类的特定情况 - 要使数据类可散列，您可以使用

@dataclass(frozen=True)
class YourClass:
    pass

作为装饰而不是

@dataclass
class YourClass:
    pass