Question

我正在寻找一种干净，简单的方法来更新从基类继承的类级字典。例如：

class Foo(object):
    adict = {'a' : 1}

class Bar(Foo):
    adict.update({'b' : 2})  # this errors out since it can't find adict

这样：

Foo.adict == {'a' : 1}
Bar.adict == {'a' : 1, 'b' : 2}

我宁愿不在这里使用实例，如果可能也不使用类方法。

Answer 1

请注意，即使有效，您也可以更新相同的词典，而不是创建新词典（因此Foo.adict is Bar.adict，因此Foo.adict == Bar.adict）。

在任何情况下，最简单的方法是显式引用父类的dict（并复制它，见上文）：

class Bar(Foo):
    adict = dict(Foo.adict)
    adict.update({'b': 2})

Answer 2

我也遇到了这个问题。我通过使用元类来解决它，它也可以与多重继承一起使用：

import six


class CheckerMeta(type):

    def __new__(cls, name, bases, attrs):
        new_class = super(CheckerMeta, cls).__new__(cls, name, bases, attrs)

        base_configs = [bc.config for bc in bases if hasattr(bc, 'config')]
        configs = base_configs + [new_class.config]

        new_class.config = {}
        for config in configs:
            new_class.config.update(config)

        return new_class


class BaseChecker(six.with_metaclass(CheckerMeta)):
    config = {}


class CheckerA(BaseChecker):
    config = {'a': 1}


class CheckerB(BaseChecker):
    config = {'b': 2}


class CheckerC(CheckerA, CheckerB):
    config = {'c': 3}


assert CheckerA.config == {'a': 1}
assert CheckerB.config == {'b': 2}
assert CheckerC.config == {'a': 1, 'b': 2, 'c':3}

Answer 3

“我不想在这里使用实例，如果可能的话也不使用类方法。”

右。所以不要。

foo_adict =  {'a' : 1}

def B():
   foo_adict.update({'b': 2})

我不确定为什么使用类属性级别字典，它很少以有用或预期的方式运行。

Answer 4

在adict课程中初始化Foo，Bar初始化init super，然后update。

class Foo(object):
    def __init__(self):
        self.adict = {'a': 1}


class Bar(Foo):
    def __init__(self):
        super(Bar, self).__init__()
        self.adict.update({'b': 2})

示例：

In [14]: b = Bar()
In [15]: b.adict
Out[15]: {'a': 1, 'b': 2}

Python更新继承了类级别字典

4 个答案: