假设我有这个类:
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”方式来做到这一点?
最佳答案
有几种方法可以解决这个问题。当属性需要一定数量的计算时,一种选择是将其转换为 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']
关于python - 在 Python 中进行子类化时追加到成员列表,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/36170489/