为什么我不能在Python中使用一个列表作为dict键？

这里有一个答案 http://wiki.python.org/moin/DictionaryKeys

如果你试图用列表作为键，用哈希作为，比如说，他们的内存位置，会出什么问题？

查找具有相同内容的不同列表会产生不同的结果，即使比较具有相同内容的列表会显示它们是等价的。

在字典查询中使用一个列表字面是什么情况？

因为列表是可变的， dict 键（和 set 成员）需要是可散列的，而散列可变对象是一个坏主意，因为散列值 should 是在实例属性的基础上计算出来的。

在这个答案中，我将给出一些具体的例子，希望能在现有答案的基础上增加价值。每一个见解也适用于 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]
{[1, 2, 3, 4]: 0}
>>> stupid in d
False
>>> stupid in d.keys()
False
>>> stupid in list(d.keys())
在突变了stupid之后，由于哈希值的改变，在dict中无法再找到它。只有对dict的键列表进行线性扫描才能找到stupid。
例2:......但为什么不只是一个恒定的哈希值？
>>> class stupidlist2(list):
...     def __hash__(self):
...         return id(self)
>>> stupidA = stupidlist2([1, 2, 3])
>>> stupidB = stupidlist2([1, 2, 3])
>>> stupidA == stupidB
>>> 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}
>>> stupidC in {stupidE: 0}
False
>>> d = {stupidC: 0}
>>> stupidC.append(5)
>>> stupidC in d
事情看起来像预期的那样，但想想正在发生的事情：当你的类的所有实例产生相同的哈希值时，只要有两个以上的实例作为dict中的键或存在于set中，你就会发生哈希碰撞。
找到my_dict[key]或key in my_dict（或item in my_set）的正确实例，需要执行与dict的键中存在的stupidlist3的实例一样多的平等检查（在最坏情况下）。在这一点上，字典的目的--O(1)查找--被完全击败了。这在下面的计时中得到了证明（用 IPython 完成）。
Some Timings for 例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的键，因为图元是不可变和可散列的。