在 Python 中，为什么元组可以散列而不是列表？

Question

下面当我尝试对列表进行哈希处理时，它给了我一个错误，但适用于一个元组。猜想它与不变性有关。有人可以详细解释一下吗？

列表

 x = [1,2,3]
 y = {x: 9}
  Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 TypeError: unhashable type: 'list'

元组

z = (5,6)
y = {z: 89}
print(y)
{(5, 6): 89}

Answer 1

字典和其他对象使用hashes 非常快速地存储和检索项目。这一切的机制都发生在“幕后”——作为程序员的你不需要做任何事情，Python 会在内部处理这一切。基本思想是，当您使用 {key: value} 创建字典时，Python 需要能够散列您用于 key 的任何内容，以便它可以快速存储和查找值。

不可变对象或无法更改的对象是可散列的。它们有一个永远不会改变的唯一值，因此 python 可以“散列”该值并使用它来有效地查找字典值。属于这一类的对象包括字符串、元组、整数等。你可能会想，“但我可以改变一个字符串！我只是去mystr = mystr + 'foo'”，但实际上它的作用是创建一个new 字符串实例并将它分配给mystr。它不会修改 现有 实例。不可变对象永远不会改变，因此您始终可以确定，当您为不可变对象生成哈希时，通过哈希查找对象将始终返回您开始时使用的相同对象，而不是修改后的版本。

您可以自己尝试一下：hash("mystring")、hash(('foo', 'bar'))、hash(1)

可变对象，或可以修改的对象，不是可散列的。可以就地修改列表：mylist.append('bar') 或 mylist.pop(0)。您不能安全地散列一个可变对象，因为您不能保证该对象自您上次看到它以来没有更改。您会发现list、set 和其他可变类型没有__hash__() 方法。因此，您不能将可变对象用作字典键：

>>> hash([1,2,3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Eric Duminil 的回答提供了一个很好的例子，说明使用可变对象作为字典键会导致意外行为

Answer 2

以下示例说明了为什么允许可变类型作为键可能不是一个好主意。这种行为在某些情况下可能很有用（例如，使用对象的状态而不是对象本身），但它也可能导致令人惊讶的结果或错误。

Python

可以通过在list 的子类上定义__hash__ 来使用数字列表作为键：

class MyList(list):
    def __hash__(self):
        return sum(self)

my_list = MyList([1, 2, 3])

my_dict = {my_list: 'a'}

print(my_dict.get(my_list))
# a

my_list[2] = 4  # __hash__() becomes 7
print(next(iter(my_dict)))
# [1, 2, 4]
print(my_dict.get(my_list))
# None
print(my_dict.get(MyList([1,2,3])))
# None

my_list[0] = 0  # __hash_() is 6 again, but for different elements
print(next(iter(my_dict)))
# [0, 2, 4]
print(my_dict.get(my_list))
# 'a'

红宝石

在 Ruby 中，允许使用列表作为键。 Ruby 列表称为Array，字典称为Hash，但语法与 Python 非常相似：

my_list = [1]
my_hash = { my_list => 'a'}
puts my_hash[my_list]
#=> 'a'

但是如果这个列表被修改了，dict就再也找不到对应的值了，即使key还在dict里面：

my_list << 2

puts my_list
#=> [1,2]

puts my_hash.keys.first
#=> [1,2]

puts my_hash[my_list]
#=> nil

可以强制dict再次计算key hash：

my_hash.rehash
puts my_hash[my_list]
#=> 'a'

Answer 3

hashset 计算对象的 hash 并基于该散列，将对象存储在结构中以便快速查找。因此，按照约定，一旦将对象添加到字典中，哈希就不允许更改。大多数好的散列函数将取决于元素的数量和元素本身。

元组是不可变的，所以在构造之后，值不能改变，因此哈希也不能改变（或者至少一个好的实现不应该让哈希改变）。

另一方面，列表是可变的：以后可以添加/删除/更改元素。因此，哈希可能会违反合同而改变。

因此，所有不能保证哈希函数在添加对象后保持稳定的对象都违反了合同，因此不是好的候选对象。因为对于lookup，字典会首先计算key的hash，并确定正确的bucket。如果键同时更改，这可能会导致误报：对象在字典中，但由于散列不同，因此无法再检索它，因此将搜索与最初添加对象的存储桶不同的存储桶.

Answer 4

我想添加以下方面，因为其他答案尚未涵盖。

使可变对象可散列并没有错，它只是不明确，这就是为什么它需要由程序员自己（而不是编程语言）一致地定义和实现。

请注意，您可以为任何自定义类实现 __hash__ 方法，该方法允许将其实例存储在需要可散列类型（例如字典键或集合）的上下文中。

哈希值通常用于确定两个对象是否代表同一事物。所以考虑下面的例子。您有一个包含两个项目的列表：l = [1, 2]。现在您将一个项目添加到列表中：l.append(3)。现在你必须回答以下问题：它还是一样的吗？两者 - 是和否 - 都是有效的答案。 “是”，还是同一个列表，“否”，不再是同一个内容了。

所以这个问题的答案取决于你作为程序员，所以你可以为你的可变类型手动实现哈希方法。

Answer 5

基于Python Glossary

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

所有 Python 的不可变内置对象都是可散列的；可变容器（例如列表或字典）不是。

Answer 6

因为列表是可变的，而元组不是。例如，当您将值的哈希存储在 dict 中时，如果对象发生更改，则存储的哈希值不会被发现，因此它将保持不变。下次您查找对象时，字典将尝试通过不再相关的旧哈希值查找它。

为了防止这种情况，python 不允许你有可变的项目。