Python `__missing__`：处理字典键不存在的自定义行为

好的，各位观众，各位朋友，欢迎来到今天的“Python 冷门知识大讲堂”。今天我们要聊的是一个字典的小秘密，但是威力却很大的东西：__missing__ 方法。

开场白：字典的“寻物启事”

想象一下，你是一个图书管理员，每天的工作就是根据读者的需求，在书架上找到对应的书。大部分时候，读者要的书你都有，直接拿给他们就行。但总有那么一些时候，读者要的书你压根就没听说过，书架上根本没有！

这时候你怎么办？是直接耸耸肩说“没有”？还是发挥你的聪明才智，找到一些替代方案，比如推荐类似的书，或者告诉读者哪里可能有这本书？

Python 的字典也面临着类似的问题。当我们用 my_dict['key'] 这样的方式访问字典时，如果 key 存在，一切都好说。但如果 key 不存在呢？默认情况下，Python 会毫不留情地抛出一个 KeyError 异常，就像图书管理员直接说“没有！”一样。

但是，如果我们想让字典在找不到 key 的时候，做一些更聪明的事情，而不是直接报错呢？这就是 __missing__ 方法的用武之地了！

__missing__ 方法：字典的“智能客服”

__missing__ 方法是 Python 字典类的一个特殊方法（也称为魔术方法或 dunder 方法）。它定义了当字典找不到给定的键时应该执行的操作。

简单来说，当你尝试访问一个字典中不存在的键时，Python 会自动调用该字典的 __missing__ 方法（如果定义了的话）。你可以在这个方法里编写任何你想要的代码，比如：

返回一个默认值
创建一个新的键值对并添加到字典中
抛出一个自定义的异常
记录日志
甚至可以根据键的类型或值来执行不同的操作

代码示例：最简单的 __missing__

让我们从一个最简单的例子开始：

class MyDict(dict):
    def __missing__(self, key):
        return "Key not found!"

my_dict = MyDict({'a': 1, 'b': 2})

print(my_dict['a'])  # 输出：1
print(my_dict['c'])  # 输出：Key not found!

在这个例子中，我们创建了一个名为 MyDict 的类，它继承了 Python 内置的 dict 类。我们重写了 __missing__ 方法，让它在找不到键的时候返回字符串 "Key not found!"。

可以看到，当我们尝试访问 my_dict['c'] 时，由于键 ‘c’ 不存在，__missing__ 方法被调用，并返回了我们预定义的字符串。

__missing__ 方法的参数

__missing__ 方法接收一个参数：key，也就是我们试图访问但不存在的键。你可以根据这个 key 的值来决定如何处理。

代码示例：根据键的值返回不同的默认值

class SmartDict(dict):
    def __missing__(self, key):
        if isinstance(key, int):
            return 0  # 如果键是整数，返回 0
        elif isinstance(key, str):
            return ""  # 如果键是字符串，返回空字符串
        else:
            return None  # 其他情况返回 None

my_dict = SmartDict({'a': 1, 'b': 2})

print(my_dict[10])   # 输出：0
print(my_dict['hello'])  # 输出：""
print(my_dict[True])  # 输出：0
print(my_dict[[]])  # 报错：TypeError: unhashable type: 'list'

在这个例子中，我们根据键的类型返回不同的默认值。如果键是整数，返回 0；如果键是字符串，返回空字符串；否则返回 None。

__missing__ 方法与 setdefault 方法的区别

你可能会想到，字典的 setdefault 方法也可以用来处理键不存在的情况。那么，__missing__ 方法和 setdefault 方法有什么区别呢？

特性	`__missing__` 方法	`setdefault` 方法
用途	定义字典在找不到键时的默认行为，不会修改字典本身。	在字典中插入一个键值对，如果键不存在，则插入指定的默认值。会修改字典本身。
调用时机	只有在读取字典中不存在的键时才会调用。	必须显式地调用 `setdefault` 方法。
是否修改字典	不修改字典。	修改字典。
适用场景	当你只想在读取键时提供一个默认值，而不想修改字典本身时。	当你需要在字典中添加一个键值对，并且在键不存在时使用一个默认值时。
实现方式	需要继承 `dict` 类并重写 `__missing__` 方法。	直接调用字典的 `setdefault` 方法。

简单来说，__missing__ 方法是用来定义字典的默认行为，而 setdefault 方法是用来修改字典。

代码示例：__missing__ 方法与 setdefault 方法的对比

class MyDict(dict):
    def __missing__(self, key):
        print(f"Key '{key}' not found, returning default value.")
        return None

my_dict = MyDict({'a': 1, 'b': 2})

print(my_dict['c'])  # 输出：Key 'c' not found, returning default value.  None
print(my_dict)       # 输出：{'a': 1, 'b': 2}  字典没有被修改

my_dict.setdefault('d', 'default_value')
print(my_dict['d'])  # 输出：default_value
print(my_dict)       # 输出：{'a': 1, 'b': 2, 'd': 'default_value'}  字典被修改了

__missing__ 方法的应用场景

__missing__ 方法有很多实用的应用场景，比如：

缓存: 缓存是一种常见的优化技术，它可以将计算结果存储起来，以便下次需要时直接返回，而不需要重新计算。__missing__ 方法可以用来实现一个简单的缓存机制。

class MemoizeDict(dict):
    def __missing__(self, key):
        print(f"Calculating value for key '{key}'...")
        value = self.calculate_value(key)  # 假设这是一个耗时的计算
        self[key] = value  # 将计算结果缓存起来
        return value

    def calculate_value(self, key):
        # 这里可以是一些复杂的计算逻辑
        return key * 2  # 简单的例子

my_dict = MemoizeDict()

print(my_dict[5])  # 输出：Calculating value for key '5'...  10
print(my_dict[5])  # 输出：10  （直接从缓存中获取，不再计算）
print(my_dict[10]) # 输出：Calculating value for key '10'... 20

自动创建数据结构: 有时候，我们需要在一个嵌套的数据结构中，如果某个键不存在，就自动创建一个新的数据结构（比如列表或字典）。__missing__ 方法可以用来实现这个功能。

class NestedDict(dict):
    def __missing__(self, key):
        value = self[key] = NestedDict()  # 递归创建新的 NestedDict
        return value

my_dict = NestedDict()

my_dict['a']['b']['c'] = 10

print(my_dict)  # 输出：{'a': {'b': {'c': 10}}}

提供更友好的错误信息: 默认的 KeyError 异常可能不够友好，__missing__ 方法可以用来抛出一个自定义的异常，提供更详细的错误信息。

class MyDict(dict):
    def __missing__(self, key):
        raise ValueError(f"Key '{key}' is invalid.  Please check your input.")

my_dict = MyDict({'a': 1, 'b': 2})

try:
    print(my_dict['c'])
except ValueError as e:
    print(e)  # 输出：Key 'c' is invalid.  Please check your input.

数据验证: __missing__ 方法可以用来验证键是否符合某种规则，如果不符合，可以抛出一个异常。

class ValidatedDict(dict):
    def __missing__(self, key):
        if not isinstance(key, str) or not key.startswith('prefix_'):
            raise ValueError(f"Invalid key: '{key}'. Key must be a string starting with 'prefix_'.")
        return None

my_dict = ValidatedDict({'prefix_a': 1, 'prefix_b': 2})

try:
    print(my_dict['c'])  # 报错：ValueError: Invalid key: 'c'. Key must be a string starting with 'prefix_'.
except ValueError as e:
    print(e)

try:
    print(my_dict[123])  # 报错：ValueError: Invalid key: '123'. Key must be a string starting with 'prefix_'.
except ValueError as e:
    print(e)

print(my_dict['prefix_c']) #ValueError: Invalid key: 'prefix_c'. Key must be a string starting with 'prefix_'.

注意事项

__missing__ 方法只在通过 my_dict['key'] 这种方式访问字典时才会调用。如果你使用 my_dict.get('key') 方法，__missing__ 方法不会被调用。get方法在key不存在时，会返回None或者指定的默认值。
__missing__ 方法应该返回一个值，或者抛出一个异常。如果你什么都不返回（也就是返回 None），Python 会抛出一个 RuntimeError 异常。
避免在 __missing__ 方法中进行过于复杂的操作，因为它可能会影响字典的性能。

总结

__missing__ 方法是 Python 字典类的一个强大特性，它可以让你自定义字典在找不到键时的行为。通过重写 __missing__ 方法，你可以实现缓存、自动创建数据结构、提供更友好的错误信息等功能。

虽然 __missing__ 方法可能不是你每天都会用到的东西，但了解它的存在，可以让你在遇到特定问题时，多一种解决方案。

希望今天的讲解对你有所帮助！下次再见！

Python `missing`：处理字典键不存在的自定义行为

发表回复取消回复

发表回复 取消回复

发表回复取消回复