python - python映射中的派生值

我不确定这个问题是否有可能，但无论如何，假设我有一本字典：

 my_dict = {'a':0, 'b':1}

我想让一些键'c'等于（在这个简单的例子中）值a+b，这样如果我要更新字典：

my_dict['a'] = 2

然后打电话：

my_dict['c']

将返回3（a=2+b=1）
我找不到任何简单的方法，也许是lambda函数，但这似乎不对。当我想要a&b的和时，这将非常有用，我不需要显式地把它们拉出来并添加它们。
编辑：感谢您的快速响应，如果我一直知道值C，我想执行一些函数，但是我想能够动态地定义函数，比如说，在我的字典中，我希望“C”是a+b，但是在其他的字典中，我希望键“b”是（key='a'*52）/3（或者其他一些基本的数学运算）。在下面的解决方案中，我必须继续重新编写类，我不希望这样。有什么想法吗？

最佳答案

通过实现一个简单类来解决的典型问题。

class MyClass(object):
    def __init__(self, a=None, b=None):
        self.a = a
        self.b = b

    @property
    def c(self):
        return self.a + self.b


o = MyClass()
o.a = 1
o.b = 2
assert o.c == 3
o.a = 2
assert o.c == 4

如果必须是dict，可以创建自定义类并重写__getitem__magic方法。

class MyDict(dict):
    def __getitem__(self, key):
        if key == 'c':
            return self['a'] + self['b']
        return super(MyDict, self).__getitem__(key)


my_dict = MyDict()
my_dict['a'] = 1
my_dict['b'] = 2
assert my_dict['c'] == 3
my_dict['b'] = 3
assert my_dict['c'] == 4
assert isinstance(my_dict, dict)

如果你想有通用的解决方案，我会这样做：

class DefaultDict(dict):
    defaults = {}

    def __getitem__(self, key):
        if key in self.defaults:
            return self.defaults[key](self)
        return super(DefaultDict, self).__getitem__(key)

    def __setitem__(self, key, value):
        if key in self.defaults:
            raise RuntimeError('Default key: %s' % key)
        super(DefaultDict, self).__setitem__(key, value)


# alt. 1
o1 = DefaultDict()
o1.defaults = {'c': lambda d: d['a'] + d['b']}
o1['a'] = 1
o1['b'] = 2
assert o1['c'] == 3


# alt. 2
class DefaultDict1(DefaultDict):
    defaults = {'c': lambda d: d['a'] + d['b']}


o2 = DefaultDict1()
o2['a'] = 1
o2['b'] = 2
assert o2['c'] == 3

关于python - python映射中的派生值，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/32614738/