因为列表是可变的，dict 键（和 set 成员）需要是可散列的，而散列可变对象是个坏主意，因为散列值应该根据实例计算属性。
在这个答案中，我将给出一些具体的例子，希望在现有答案的基础上增加价值。每个见解也适用于 set 数据结构的元素。
示例 1：对可变对象进行哈希处理，其中哈希值基于对象的可变特征。
>>> class stupidlist(list):
... def __hash__(self):
... return len(self)
...
>>> stupid = stupidlist([1, 2, 3])
>>> d = {stupid: 0}
>>> stupid.append(4)
>>> stupid
[1, 2, 3, 4]
>>> d
{[1, 2, 3, 4]: 0}
>>> stupid in d
False
>>> stupid in d.keys()
False
>>> stupid in list(d.keys())
True
修改stupid 后，因为哈希值改变了，所以在字典中找不到了。只有对字典的键列表进行线性扫描才能找到stupid。
示例 2：...但为什么不只是一个常量哈希值？
>>> class stupidlist2(list):
... def __hash__(self):
... return id(self)
...
>>> stupidA = stupidlist2([1, 2, 3])
>>> stupidB = stupidlist2([1, 2, 3])
>>>
>>> stupidA == stupidB
True
>>> stupidA in {stupidB: 0}
False
这也不是一个好主意，因为相等的对象应该具有相同的哈希值，以便您可以在 dict 或 set 中找到它们。
示例 3：...好吧，所有实例的常量哈希值如何？！
>>> class stupidlist3(list):
... def __hash__(self):
... return 1
...
>>> stupidC = stupidlist3([1, 2, 3])
>>> stupidD = stupidlist3([1, 2, 3])
>>> stupidE = stupidlist3([1, 2, 3, 4])
>>>
>>> stupidC in {stupidD: 0}
True
>>> stupidC in {stupidE: 0}
False
>>> d = {stupidC: 0}
>>> stupidC.append(5)
>>> stupidC in d
True
事情似乎按预期工作，但想想发生了什么：当你的类的所有实例产生相同的哈希值时，只要有两个以上实例作为 dict 中的键或存在，你就会发生哈希冲突在set。
使用my_dict[key] 或key in my_dict（或item in my_set）找到正确的实例需要执行与字典键中stupidlist3 实例一样多的相等性检查（在最坏的情况下）。在这一点上，字典的目的——O(1) 查找——完全失败了。这在以下时序中得到了证明（使用 IPython 完成）。
示例 3 的一些时间安排
>>> lists_list = [[i] for i in range(1000)]
>>> stupidlists_set = {stupidlist3([i]) for i in range(1000)}
>>> tuples_set = {(i,) for i in range(1000)}
>>> l = [999]
>>> s = stupidlist3([999])
>>> t = (999,)
>>>
>>> %timeit l in lists_list
25.5 µs ± 442 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
>>> %timeit s in stupidlists_set
38.5 µs ± 61.2 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
>>> %timeit t in tuples_set
77.6 ns ± 1.5 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
如您所见，stupidlists_set 中的成员资格测试甚至比对整个 lists_list 的线性扫描还要慢，而在没有哈希负载的集合中，您具有预期的超快查找时间（因子 500）碰撞。
TL; DR：您可以将tuple(yourlist) 用作dict 键，因为元组是不可变且可散列的。