Python 函数为什么以及如何是可散列的？

Question

我最近在 Python 中尝试了以下命令：

>>> {lambda x: 1: 'a'}
{<function __main__.<lambda>>: 'a'}

>>> def p(x): return 1
>>> {p: 'a'}
{<function __main__.p>: 'a'}

dict 的成功创建表明 lambda 和常规函数都是可散列的。 （{[]: 'a'} 之类的失败，TypeError: unhashable type: 'list'）。

哈希显然不一定是函数的ID：

>>> m = lambda x: 1
>>> id(m)
140643045241584
>>> hash(m)
8790190327599
>>> m.__hash__()
8790190327599

最后一条命令显示__hash__ 方法是为lambdas 显式定义的，也就是说，这不是 Python 根据类型计算的自动魔法。

使函数可散列化的动机是什么？另外，函数的哈希值是多少？

Answer 1

没什么特别的。如您检查函数类型的未绑定__hash__ 方法所见：

>>> def f(): pass
...
>>> type(f).__hash__
<slot wrapper '__hash__' of 'object' objects>

of 'object' objects 部分意味着它只是从object 继承了默认的基于身份的__hash__。函数== 和hash 按身份工作。 id 和 hash 之间的差异对于任何继承 object.__hash__ 的类型都是正常的：

>>> x = object()
>>> id(x)
40145072L
>>> hash(x)
2509067

---

您可能认为__hash__ 只应该为不可变对象定义，您几乎是对的，但它缺少一个关键细节。 __hash__ 应该只为 == 比较中涉及的所有内容 不可变的对象定义。对于== 基于身份的对象，将hash 基于身份也是完全标准的，因为即使对象是可变的，它们也不可能以改变其身份的方式可变。具有基于身份的== 的文件、模块和其他可变对象都以这种方式运行。

Answer 2

它可能很有用，例如，创建函数对象集，或按函数索引 dict。不可变对象通常支持__hash__。在任何情况下，def 或 lambda 定义的函数之间没有内部差异 - 这纯粹是句法。

使用的算法取决于 Python 的版本。看起来您正在 64 位机器上使用最新版本的 Python。在这种情况下，函数对象的散列是其id() 的右旋转 4 位，结果被视为带符号的 64 位整数。完成右移是因为对象地址（id() 结果）通常是对齐的，因此它们的最后 3 或 4 位始终为 0，这对于散列函数来说是一个有点烦人的属性。

在您的具体示例中，

>>> i = 140643045241584 # your id() result
>>> (i >> 4) | ((i << 60) & 0xffffffffffffffff) # rotate right 4 bits
8790190327599  # == your hash() result

Answer 3

函数是可散列的，因为它是一个普通的、内置的、不可变的对象。

来自Python Manual：

如果一个对象的哈希值在其生命周期内永远不会改变（它需要__hash__() 方法），并且可以与其他对象进行比较（它需要__eq__() 或__cmp__() 方法），则它是可哈希的。比较相等的可散列对象必须具有相同的散列值。

哈希性使对象可用作字典键和集合成员，因为这些数据结构在内部使用哈希值。

Python 的所有不可变内置对象都是可散列的，而没有可变容器（例如列表或字典）是可散列的。默认情况下，作为用户定义类实例的对象是可散列的；它们都比较不相等（除了它们自己），它们的哈希值来自它们的id()。