python - 在 Python 中进行子类化时追加到成员列表

Question

假设我有这个类:

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

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

    # ...

我想为此类扩展 FooClass 创建一个 SpecialisedFooClass , 添加项目 "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 ' 父类(super class)发生变化时)我将不可避免地忘记更新此引用。事实上，我已经在我正在处理的代码库中犯了这个错误 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

使用属性的主要缺点是这个上下文是它不再真正像类属性一样工作，因为您必须实例化一个类才能获取值。

您还可以使用 metaclasses (great answer on metaclasses)。在某些情况下，这可以大大减少您的代码库，但如果您有一个非常深的继承链并且不清楚是否正在使用元类，它也可能会造成混淆。但从好的方面来说，它的工作方式与类属性完全一样，因为它实际上是一个类属性。

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']