python - 从其他实例属性派生的类实例属性

Question

如果标题含糊不清，我深表歉意，我想不出用一句话来描述我的问题的方法。我正在 python2.7 中构建一些代码，如下所述。

最小工作示例

我的代码有 Parameter实现诸如name之类的属性的类和value ，看起来像这样。

class Parameter(object):
    def __init__(self, name, value=None, error=None, dist=None, prior=None):
        self.name   = name
        self._value = value # given value for parameter, this is going to be changed very often in an MCMC sampler
        self.error  = error # initial estimate of error for the parameter, will only be set once
        self._dist  = dist # a distribution for the parameter, will only be set once
        self.prior  = prior

    @property
    def value(self):
        return self._value

    @property
    def dist(self):
        return self._dist

该类还有几个属性，可返回 Parameter.dist 的平均值、中位数等。如果给出了分布。

我还有另一门课，例如ParameterSample ，这会创建不同的群体 Parameter对象。其中一些Parameter对象具有使用 value 设置的属性(例如 error 、 Parameter.set_parameter() )功能，但还有其他一些Parameter对象没有显式设置，但它们的 value和dist属性取决于其他一些Parameter设置的对象:

class ParameterSample(object):
    def __init__(self):
        varied_parameters  = ('a', 'b') # parameter names whose `value` attribute is varied
        derived_parameters = ('c',) # parameter names whose `value` attribute is varied, but depends on `a.value` and `b.value`
        parameter_names    = varied_parameters + derived_parameters
        
        # create `Parameter` objects for each parameter name
        for name in parameter_names:
            setattr(self, name, Parameter(name))

    def set_parameter(self, name, **kwargs):
        for key, val in kwargs.items():
            if key == 'value':
                key = '_'.join(['', key]) # add underscore to set `Parameter._value`
            setattr(getattr(self, name), key, val) # basically does e.g. `self.a.value = 1`

我现在可以创建一个ParameterSample并像这样使用它们:

parobj = ParameterSample()
parobj.set_parameter('a', value=1, error=0.1)
parobj.set_parameter('b', value=2, error=0.5)

parobj.a.value
>>> 1
parobj.b.error
>>> 0.5

parobj.set_parameter('b', value=3)
parobj.b.value
>>> 3
parobj.b.error
>>> 0.5

我想要什么

我最终想要的是使用Parameter.c一样的方法。例如:

parobj.c.value
>>> 4 # returns parobj.a.value + parobj.b.value
parobj.c.dist
>>> None # returns a.dist + b.dist, but since they are not currently set it is None

c因此需要是 Parameter具有与 a 相同属性的对象和b ，但它在哪里 value和dist根据a的当前属性进行更新和b .

但是，我还应该提到，我希望能够为参数 c 设置允许的先前范围。 ，例如parobj.set_parameter('c', prior=(0,10))在对其值进行任何调用之前 - 所以 c需要是一个已经定义的Parameter创建 ParameterSample 时的对象对象。

我如何将其实现到我的 ParameterSample 中类？

我尝试过的

我尝试过制作自己的装饰器，但我不确定这是否是可行的方法，因为我不完全明白如何使用它们。

我还考虑过将 @property 添加到 c这会创建一个新的 Parameter每次调用时都会对象，但我觉得这不是正确的方法，因为它可能会减慢代码速度。

我还应该注意到 ParameterSample上面的类将在不同的类中继承，因此无论解决方案是什么，它都应该能够在此设置中使用:

class Companion(ParameterSample)
    def __init__(self, name):
        self.name = name
        super(Companion, self).__init__()

comp = Companion(name='Earth')
comp.set_parameter('a', value=1)
comp.set_parameter('b', value=3)
comp.c.value
>>> 4

Answer 1

我无法让它在 Python 2 中工作 - setattr 调用似乎从未将属性传播到子类(Companion 不会有 c 属性)。

不过，我使用 Python 3 更成功。由于您有两种参数类型(可变参数类型和派生参数类型)，因此在我看来，使用两个类来实现该行为是有意义的，而不是将它们全部视为一个。

我添加了一个 DerivedParameter 类，该类继承自 Parameter，它接受一个 dependents 参数(及其父类的 args/kwargs)，但重新定义 value 和 dist 以提供依赖行为:

class DerivedParameter(Parameter):
    def __init__(self, name, dependents, **kwargs):
        self._dependents = dependents
        super().__init__(name, **kwargs)

    @property
    def value(self):
        try:
            return sum(x._value for x in self._dependents if x is not None)
        except TypeError:
            return None

    @property
    def dist(self):
        try:
            return sum(x._dist for x in self._dependents if x is not None)
        except TypeError:
            return None

然后我调整了参数对象的添加方式:

class ParameterSample:
    def __init__(self):
        # Store as instance attributes to reference later
        self.varied_params  = ('a', 'b') # parameter names whose `value` attribute is varied
        self.derived_params = ('c',) # parameter names whose `value` attribute is varied, but depends on `a.value` and `b.value`
        # No more combined names

        # create `Parameter` objects for each varied parameter name
        for name in self.varied_params:
            setattr(self, name, Parameter(name))

        # Create `DerivedParameter` objects for each derived parameter
        # Derived parameters depend on all `Parameter` objects. It wasn't
        # clear if this was the desired behavior though.
        params = [v for _, v in self.__dict__.items() if isinstance(v, Parameter)]
        for name in self.derived_params:
            setattr(self, name, DerivedParameter(name, params))

    def set_parameter(self, name, **kwargs):
        for key, val in kwargs.items():
            if key == 'value':
                key = '_'.join(['', key]) # add underscore to set `Parameter._value`
            setattr(getattr(self, name), key, val) # basically does e.g. `self.a.value = 1`

由此，我可以复制您给定的示例所需的行为:

>>> comp = Companion(name='Earth')
>>> comp.set_parameter('a', value=1)
>>> comp.set_parameter('b', value=3)
>>> print(comp.c.value)
>>> print(comp.c.dist)
4
None
>>> comp.set_parameter('c', prior=(0,10))
>>> print(comp.c.prior)
(0, 10)

正如我在评论中指出的，上面的设计最终导致所有派生参数使用所有不同的参数作为它们的依赖项 - 有效地使c和一个潜在的d 相同。您应该能够通过一些参数/条件相当轻松地解决此问题。

总的来说，我不得不同意@Error - 句法悔恨。这是一种非常复杂的设计类的方法，并且最多只会使维护变得困惑。我强烈鼓励您重新考虑您的设计，并尝试找到一种不涉及动态创建此类属性的适应性强的通用解决方案。