在 Python 中子类化时附加到成员列表

Question

说我有这门课：

class FooClass(object):
    foos = ["foo", "bar"]

    def do_foos(self):
        for foo in self.foos:
            print("I have a " + foo)

    # ...

我想为这个扩展的类创建一个 SpecialisedFooClass FooClass，将一个项目添加"spec"到foos（即foos包含["foo", "bar", "spec"]）。

SpecialisedFooClass.foos应该取决于FooClass.foos：如果我更改FooClass'定义以便foos包含["foo", "bam", "bat"]，则SpecialisedFooClass.foos应该包含["foo", "bam", "bat", "spec"]。

---

这是迄今为止我想出的最好的方法：

class SpecialisedFooClass(FooClass):
    foos = FooClass.foos + ["spec"]

但我发现明确提到了FooClass有关。当我决定添加一个中间子类时（即当SpecialisedFooClass' 超类更改时），我将不可避免地忘记更新此引用。事实上，我已经在 IRL 使用我正在处理的代码库中犯了这个错误（实际上并没有处理 foos、bams 和 bats...）。

---

在我的情况下实际上没有特殊要求foos是类成员而不是实例成员，所以这也可以，但我觉得它很难看。此外，该super调用仍然有一个显式的类引用 - 在这里不用担心，因为它是它出现的类。

class FooClass(object):
    def __init__(self, *args, **kwargs):
        self.foos = ["foo", "bar"]

    def do_foos(self):
        for foo in self.foos:
            print("I have a " + foo)

class SpecialisedFooClass(FooClass):
    def __init__(self, *args, **kwargs):
        super(SpecialisedFooClass, self).__init__(*args, **kwargs)
        self.foos.append("spec")

---

存在哪些其他选择，是否有“Pythonic”方式来做到这一点？

Answer 1

有几种方法可以处理这个问题。当属性需要一定量的计算时，一种选择是将其转换为property

class FooClass(object):
    foos = ["foo", "bar"]


class SpecializedFooClass(FooClass)

    @property
    def foos(self):
        return super(SpecializedFooClass, self).foos + ['spec']

您可以进行一些优化，使其只计算一次，或者可以在运行时更改，而不是每次都返回相同的内容。

class SpecializedFooClass(FooClass)

    def __init__(self):
        super(SpecializedFoo, self).__init__()
        self._foos = None

    @property
    def foos(self):
        if self._foos is None:
            self._foos = super(SpecializedFooClass, self).foos + ['spec']
        return self._foos

使用属性的主要缺点是这个上下文是它不会真正表现得像一个类属性，因为你必须实例化一个类来获取值。

您还可以使用元类（元类的好答案）。在某些情况下，这可以大大减少您的代码库，但如果您有一个非常深的继承链并且不清楚正在使用元类，它也会令人困惑。但从好的方面来说，它会像类属性一样工作，因为它实际上是一个类属性。

class FooMeta(type):

    def __new__(cls, name, bases, attrs):
        foos = []
        for base in bases:
            if hasattr(base, 'foos'):
                foos.extend(base.foos)
        attrs['foos'] = foos + attrs.get('foos', [])
        return type.__new__(cls, name, bases, attrs)


class Foo(object):
    __metaclass__ = FooMeta
    foos = ['one', 'two']


class SpecialFoo(Foo):
    foos = ['three']

print Foo.foos
# ['one', 'two']

print SpecialFoo.foos
# ['one', 'two', 'three']

第三种选择是使用类装饰器。它比元类少一点魔法，但这也意味着您将不得不记住装饰每个子类。它的功能与类属性完全一样，因为它实际上是一个属性。

def set_foos(cls):
    foos = []
    for base in cls.__bases__:
        if hasattr(base, 'foos'):
            foos.extend(base.foos)
    cls.foos = foos + getattr(cls, 'foos', [])
    return cls


class FooClass(object):
    foos = ['foo', 'bar']


@set_foo
class SpecialFoo(FooClass):
    foos = ['spec']