python 字典 d[k]中key不存在的解决方案

有时候为了方便起见，就算某个键在映射里不存在，我们也希望在通过这个键读取值的时候能得到一个默认值。有两个途径能帮我们达到这个目的，一个是通过 defaultdict 这个类型而不是普通的 dict，另一个是给自己定义一个 dict 的子类，然后在子类中实现
__missing__ 方法。下面将介绍这两种方法。

defaultdict：处理找不到的键的一个选择

下面示例在 collections.defaultdict 的帮助下优雅地解决了d[k]里的问题。在用户创建 defaultdict 对象的时候，就需要给它配置一个为找不到的键创造默认值的方法。

# -*- coding: utf-8 -*-

from collections import defaultdict

index = defaultdict(list)  # 把 list 构造方法作为 default_factory 来创建一个 defaultdict
print(index)
# defaultdict(<class 'list'>, {})

word = 'name'
# 如果 index 并没有 word 的记录，那么 default_factory 会被调用，为查询不到的键创造一个值。
# 这个值在这里是一个空的列表，然后这个空列表被赋值给 index[word]，继而
# 被当作返回值返回，因此 .append(location) 操作总能成功。
index[word].append('mmmm')  
print(index)
# defaultdict(<class 'list'>, {'name': ['mmmm']})

具体而言，在实例化一个 defaultdict 的时候，需要给构造方法提供一个可调用对象，这个可调用对象会在 __getitem__ 碰到找不到的键的时候被调用，让 __getitem__ 返回某种默认值。

比如，我们新建了这样一个字典：dd = defaultdict(list)，如果键 new-key在 dd 中还不存在的话，表达式 dd['new-key'] 会按照以下的步骤来行事。

• 调用 list() 来建立一个新列表
• 把这个新列表作为值，‘new-key’ 作为它的键，放到 dd 中
• 返回这个列表的引用

而这个用来生成默认值的可调用对象存放在名为 default_factory 的实例属性里。

注意：
如果在创建 defaultdict 的时候没有指定 default_factory，查询不存在的键会触发KeyError。

defaultdict 里的 default_factory 只会在 __getitem__ 里被调用，在其他的方法里完全不会发挥作用。比如，dd 是个 defaultdict，k 是个找不到的键，dd[k] 这个表达式会调用 default_factory 创造某个默认值，而 dd.get(k) 则会返回 None。

所有这一切背后的功臣其实是特殊方法 __missing__。它会在 defaultdict 遇到找不到的键的时候调用 default_factory，而实际上这个特性是所有映射类型都可以选择去支持的。

特殊方法__missing__

所有的映射类型在处理找不到的键的时候，都会牵扯到 __missing__ 方法。这也是这个方法称作“missing”的原因。虽然基类 dict 并没有定义这个方法，但是 dict 是知道有这么个东西存在的。也就是说，如果有一个类继承了 dict，然后这个继承类提供了 __missing__ 方法，那么在 __getitem__ 碰到找不到的键的时候，Python 就会自动调用它，而不是抛出一个KeyError 异常。

注意：
__missing__ 方法只会被 __getitem__ 调用（比如在表达式 d[k] 中）。提供__missing__ 方法对 get 或者 __contains__（in 运算符会用到这个方法）这些方法的使用没有影响。这也是我在上面中提到，defaultdict 中的 default_factory 只对 __getitem__ 有作用的原因。

如果要自定义一个映射类型，更合适的策略其实是继承 collections.UserDict 类。这里我们从 dict 继承，只是为了演示__missing__ 是如何被 dict.__getitem__ 调用的。（直接继承dict是有一些问题的,以后再说）

# -*- coding: utf-8 -*-


class StrKeyDict0(dict):  # StrKeyDict0 继承了 dict。
    def __missing__(self, key):
        if isinstance(key, str):  # 如果找不到的键本身就是字符串，那就抛出 KeyError 异常。
            raise KeyError(key)
        return self[str(key)]  # 如果找不到的键不是字符串，那么把它转换成字符串再进行查找

    def get(self, key, default=None):
        try:
            # get 方法把查找工作用 self[key] 的形式委托给 __getitem__，这样在宣布查找失败之
            # 前，还能通过 __missing__ 再给某个键一个机会。
            return self[key]
        except KeyError:
            return default  # 如果抛出 KeyError，那么说明 __missing__ 也失败了，于是返回 default。

    def __contains__(self, key):
        # 先按照传入键的原本的值来查找（我们的映射类型中可能含有非字符串的键），如果没
        # 找到，再用 str() 方法把键转换成字符串再查找一次。
        return key in self.keys() or str(key) in self.keys()


if __name__ == '__main__':
    d = StrKeyDict0([('2', 'two'), ('4', 'four')])
    print(d['2'])  # two
    print(d[1])
    # Traceback (most recent call last):
    #   File "C:/myFiles/company_project/xbot/tests/miss_test.py", line 27, in <module>
    #     print(d[1])
    #   File "C:/myFiles/company_project/xbot/tests/miss_test.py", line 8, in __missing__
    #     return self[str(key)]  # 如果找不到的键不是字符串，那么把它转换成字符串再进行查找
    #   File "C:/myFiles/company_project/xbot/tests/miss_test.py", line 7, in __missing__
    #     raise KeyError(key)
    # KeyError: '1'
    print(2 in d)
    # True
    print(1 in d)
    # False

注意：
下面来看看为什么 isinstance(key, str) 测试在上面的 __missing__ 中是必需的。

如果没有这个测试，只要 str(k) 返回的是一个存在的键，那么 __missing__ 方法是没问题的，不管是字符串键还是非字符串键，它都能正常运行。但是如果 str(k) 不是一个存在的键，代码就会陷入无限递归。这是因为 __missing__ 的最后一行中的 self[str(key)] 会调用 __getitem__，而这个 str(key) 又不存在，于是 __missing__ 又会被调用。

为了保持一致性，__contains__ 方法在这里也是必需的。这是因为 k in d 这个操作会调用它，但是我们从 dict 继承到的__contains__ 方法不会在找不到键的时候调用 __missing__方法。__contains__ 里还有个细节，就是我们这里没有用更具 Python 风格的方式——k in my_dict——来检查键是否存在，因为那也会导致 __contains__ 被递归调用。为了避免这一情况，这里采取了更显式的方法，直接在这个 self.keys() 里查询。

像 k in my_dict.keys() 这种操作在 Python 3 中是很快的，而且即便映射类型对象很庞大也没关系。这是因为 dict.keys() 的返回值是一个“视图”。视图就像一个集合，而且跟字典类似的是，在视图里查找一个元素的速度很快。在“Dictionary view objects”（https://docs.python.org/3/library/stdtypes.html#dictionary-view-objects）里可以找到关于这个细节的文档。Python 2 的 dict.keys() 返回的是个列表，因此虽然上面的方法仍然是正确的，它在处理体积大的对象的时候效率不会太高，因为 k in my_list 操作需要扫描整个列表。