我想创建一个 python 字典，返回字典中缺少键的键值。
使用示例：
dic = smart_dict()
dic['a'] = 'one a'
print(dic['a'])
# >>> one a
print(dic['b'])
# >>> b
问问题
24633 次
6 回答
89
dicts__missing__对此有一个钩子：
class smart_dict(dict):
def __missing__(self, key):
return key
可以将其简化为（因为self从未使用过）：
class smart_dict(dict):
@staticmethod
def __missing__(key):
return key
于 2011-06-03T15:36:40.537 回答
34
你为什么不直接使用
dic.get('b', 'b')
当然，您可以dict像其他人指出的那样进行子类化，但我发现每隔一段时间提醒自己get可以有一个默认值很方便！
如果你想defaultdict尝试一下，试试这个：
dic = defaultdict()
dic.__missing__ = lambda key: key
dic['b'] # should set dic['b'] to 'b' and return 'b'
除了...好：AttributeError: ^collections.defaultdict^object attribute '__missing__' is read-only，所以你将不得不子类：
from collections import defaultdict
class KeyDict(defaultdict):
def __missing__(self, key):
return key
d = KeyDict()
print d['b'] #prints 'b'
print d.keys() #prints []
于 2011-06-03T15:26:34.780 回答
15
恭喜。你也发现了标准collections.defaultdict类型的无用。如果那一堆可恶的代码气味
像我一样冒犯了您的敏感感受，那么这就是您幸运的 StackOverflow 日。
由于内置的 3 参数变体的禁忌奇迹type()
，制作一个无用的默认字典类型既有趣又有利可图。
dict.__missing__() 有什么问题？
绝对没有，假设你喜欢多余的样板和令人震惊的愚蠢collections.defaultdict——它应该像预期的那样表现，但实际上并没有。公平地说，对于只需要一个默认字典的小规模用例来说， Jochen Ritzel公认的子类化dict和实现可选__missing__()
方法 的解决方案是一个极好的解决方法。
但是这种样板的扩展性很差。如果您发现自己实例化了多个默认字典，每个字典都有自己稍微不同的逻辑来生成缺失的键值对，那么需要一个工业强度的替代自动化样板。
或者至少不错。因为为什么不修复损坏的东西？
介绍 DefaultDict
在不到 10 行的纯 Python（不包括文档字符串、注释和空格）中，我们现在定义了一个DefaultDict类型，该类型使用用户定义的可调用对象进行初始化，为缺失的键生成默认值。传递给标准collections.defaultdict类型的可调用对象毫无用处地不接受任何
参数，而传递给我们的DefaultDict类型的可调用对象则有用地接受以下两个参数：
- 此词典的当前实例。
- 为其生成默认值的当前缺失键。
鉴于这种类型，解决sorin的问题可以简化为一行 Python：
>>> dic = DefaultDict(lambda self, missing_key: missing_key)
>>> dic['a'] = 'one a'
>>> print(dic['a'])
one a
>>> print(dic['b'])
b
理智。终于。
代码或它没有发生
def DefaultDict(keygen):
'''
Sane **default dictionary** (i.e., dictionary implicitly mapping a missing
key to the value returned by a caller-defined callable passed both this
dictionary and that key).
The standard :class:`collections.defaultdict` class is sadly insane,
requiring the caller-defined callable accept *no* arguments. This
non-standard alternative requires this callable accept two arguments:
#. The current instance of this dictionary.
#. The current missing key to generate a default value for.
Parameters
----------
keygen : CallableTypes
Callable (e.g., function, lambda, method) called to generate the default
value for a "missing" (i.e., undefined) key on the first attempt to
access that key, passed first this dictionary and then this key and
returning this value. This callable should have a signature resembling:
``def keygen(self: DefaultDict, missing_key: object) -> object``.
Equivalently, this callable should have the exact same signature as that
of the optional :meth:`dict.__missing__` method.
Returns
----------
MappingType
Empty default dictionary creating missing keys via this callable.
'''
# Global variable modified below.
global _DEFAULT_DICT_ID
# Unique classname suffixed by this identifier.
default_dict_class_name = 'DefaultDict' + str(_DEFAULT_DICT_ID)
# Increment this identifier to preserve uniqueness.
_DEFAULT_DICT_ID += 1
# Dynamically generated default dictionary class specific to this callable.
default_dict_class = type(
default_dict_class_name, (dict,), {'__missing__': keygen,})
# Instantiate and return the first and only instance of this class.
return default_dict_class()
_DEFAULT_DICT_ID = 0
'''
Unique arbitrary identifier with which to uniquify the classname of the next
:func:`DefaultDict`-derived type.
'''
钥匙……明白了，钥匙？对这个神秘魔法的调用是
对内置函数的3 参数变体type()的调用：
type(default_dict_class_name, (dict,), {'__missing__': keygen,})
这一行动态生成一个新的dict子类，将可选方法别名为__missing__调用者定义的可调用对象。请注意明显缺乏样板，将DefaultDict使用减少到一行 Python。
自动化取得惊人的胜利。
于 2017-05-23T06:07:07.387 回答
13
第一位受访者提到defaultdict，但您可以__missing__为 的任何子类定义dict：
>>> class Dict(dict):
def __missing__(self, key):
return key
>>> d = Dict(a=1, b=2)
>>> d['a']
1
>>> d['z']
'z'
另外，我喜欢第二位受访者的方法：
>>> d = dict(a=1, b=2)
>>> d.get('z', 'z')
'z'
于 2011-10-18T18:27:57.990 回答
3
我同意这应该很容易做到，也很容易设置不同的默认值或以某种方式转换缺失值的函数。
受Cecil Curry回答的启发，我问自己：为什么不将默认生成器（常量或可调用）作为类的成员，而不是一直生成不同的类？让我演示一下：
# default behaviour: return missing keys unchanged
dic = FlexDict()
dic['a'] = 'one a'
print(dic['a'])
# 'one a'
print(dic['b'])
# 'b'
# regardless of default: easy initialisation with existing dictionary
existing_dic = {'a' : 'one a'}
dic = FlexDict(existing_dic)
print(dic['a'])
# 'one a'
print(dic['b'])
# 'b'
# using constant as default for missing values
dic = FlexDict(existing_dic, default = 10)
print(dic['a'])
# 'one a'
print(dic['b'])
# 10
# use callable as default for missing values
dic = FlexDict(existing_dic, default = lambda missing_key: missing_key * 2)
print(dic['a'])
# 'one a'
print(dic['b'])
# 'bb'
print(dic[2])
# 4
它是如何工作的？没那么难：
class FlexDict(dict):
'''Subclass of dictionary which returns a default for missing keys.
This default can either be a constant, or a callable accepting the missing key.
If "default" is not given (or None), each missing key will be returned unchanged.'''
def __init__(self, content = None, default = None):
if content is None:
super().__init__()
else:
super().__init__(content)
if default is None:
default = lambda missing_key: missing_key
self.default = default # sets self._default
@property
def default(self):
return self._default
@default.setter
def default(self, val):
if callable(val):
self._default = val
else: # constant value
self._default = lambda missing_key: val
def __missing__(self, x):
return self.default(x)
当然，人们可以争论是否要允许在初始化后更改默认函数，但这只是意味着将@default.setter其逻辑删除并吸收到__init__.
启用对当前（常量）默认值的自省可以添加两行额外的行。
于 2017-12-13T10:24:49.510 回答
0
子类dict的__getitem__方法。例如，如何正确继承 dict 并覆盖 __getitem__ 和 __setitem__
于 2011-06-03T15:25:55.010 回答