Python 中的字典是通用的数据结构，可提供高效的键值映射。虽然它们的常见用途涉及简单的数据查找和存储，但有一些有趣且鲜为人知的方面和用例值得探索：

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

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


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

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

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

因此，现在如果尝试扩展列表类并在其中添加此方法，__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,
                5: funcB}
func_mapping.get(num, func)()  # func is default function

因此，使用字典，我们可以通过为其提供密钥来直接检索相应的函数。

3. 字典作为开关语句

可以使用字典模拟 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 开始，字典有一个特殊的方法 __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: <class 'float'>}

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

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

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

# o/p: 
# 140407572928816 4308871808 140407573652336
# <class 'int'> <class 'bool'> <class 'float'>

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

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

# o/p: 1 1 1

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

o/p: {'1': 'string', True: <class 'float'>}

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

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

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