1. 添加列表作为字典的键

_dict = {}
_list = [1, 2, 3]
_dict[_list] = 'Added'


Output - 
      _dict[_list] = 'Added'
  TypeError: unhashable type: 'list'

事实是，如果添加一个列表作为字典的键，上面的代码会引发错误。原因是每当我们添加一个对象作为字典的键时，Python 都会调用该对象类的 __hash__ 函数。

与 int、str、tuple 等不同，list 类中没有 __hash__ 方法的实现。

所以，现在如果尝试扩展列表类并在其中添加此方法，就添加一个列表作为字典的键。

class ClassList(list):
    def __hash__(self):
        return 0

_dict = {}
_list = ClassList([1, 2, 3])
_dict[_list] = 'Added'
print(_dict)


Output -
  {[1, 2, 3]: 'Added'}

不过不建议使用上述解决方法，因为这会使列表可哈希，从而导致代码中出现意外行为。

2. 使用字典作为 if条件的替代方法

字典的用途就是维护键值对。但字典还有另一个特殊的用例——将它们用作 if条件。

例如，请看下面的代码。在这里，对应于输入值，调用一个特定的函数。

num = 1

if num == 1:
    funcA()
elif num == 5:
    funcB()
else:
    func()

使用字典 -

num = 1

func_mapping = {1: funcA,
                2: funcB}
func_mapping.get(num, func)()  # func is default function

所以有了字典，可以通过给它提供键来直接检索到对应的函数。

3. 字典作为 switch 语句

可以使用字典模拟 switch 语句，以获得更简洁、更易读的代码。

def switch_case(case):
    return {
        'case1': 'This is case 1',
        'case2': 'This is case 2',
        'default': 'This is the default case'
    }.get(case, 'Invalid case')

result = switch_case('case1')

输出层 —This is case 1

4. __missing__值

从 2.5 开始，dicts 有一个特殊的方法__missing__，用于调用缺失的值：

class MyDict(dict):
    def __missing__(self, key):
        self[key] = rv = []
        return rv

m = MyDict()
m["foo"].append(1)
m["foo"].append(2)

print(dict(m))  # {'foo': [1, 2]}
print(m["x"])   # []

集合中还有一个 dict 子类，它的作用几乎相同，但调用一个函数，而不为不存在的项目提供参数：Defaultdict

from collections import defaultdict

m = defaultdict(list)
m["foo"].append(1)
m["foo"].append(2)

print(dict(m))  # {'foo': [1, 2]}

当要提供缺省值或在找不到键时执行特定操作，而不是引发 .KeyError

5. 哈希等效密钥

这里有一个有趣的字典例子——

my_dict = {'1': 'string', True: 'bool', 1: 'int', 1.0: float}
print(my_dict)

# o/p: {'1': 'string', True: }

尽管向 Python 字典添加了 4 个不同的键，但能说出为什么它只保留其中的两个键吗，这是因为 — 在 Python 中，字典根据哈希的等价性（使用 hash()计算）而不是身份（使用id() 计算）来查找键。

在这种情况下，毫无疑问1，1.0、 和 True本身具有不同的数据类型，也是不同的对象。

print(id(1), id(True), id(1.0))
print(type(1), type(True), type(1.0))

# o/p: 
# 140407572928816 4308871808 140407573652336
#   

但是，事实是它们共享相同的哈希值，字典将它们视为相同的键。

print(hash(1), hash(True), hash(1.0))

# o/p: 1 1 1

而且有没有看到对应于 True 的值是 bool，但它打印的是浮点数。

o/p: {'1': 'string', True: }

这是因为，首先，它被添加为键True，其值为 'bool'。接下来，在添加键时，python 将其识别为哈希值的等价值1。

因此，对应的值被 True覆盖，而键 'int'保持原样。True

最后，在添加1.0 时，会遇到另一个哈希等价关系True，现有键为True 。同样，在上一步中更新到的对应于'int' 的值被 'float'覆盖。