Python 设计 - 初始化、设置和获取类属性

Question

我有一个类，其中的方法首先需要验证属性是否存在，否则调用函数来计算它。然后，确保该属性不None ，它对其执行一些操作。我可以看到两个略有不同的设计选择：

class myclass():
    def __init__(self):
        self.attr = None
    def compute_attribute(self):
        self.attr = 1
    def print_attribute(self):
        if self.attr is None:
            self.compute_attribute()
        print self.attr

和

class myclass2():
    def __init__(self):
        pass
    def compute_attribute(self):
        self.attr = 1
        return self.attr
    def print_attribute(self):
        try:
            attr = self.attr
        except AttributeError:
            attr = self.compute_attribute()
        if attr is not None:
            print attr

在第一个设计中，我需要确保所有类属性都提前设置为None，这可能会变得冗长，但也澄清了对象的结构。

第二种选择似乎是使用更广泛的选择。然而，对于我的目的（与信息论相关的科学计算），在任何地方使用try except块可能有点矫枉过正，因为这个类并没有真正与其他类交互，它只是需要数据并计算一堆东西。

Answer 1

首先，您可以使用hasattr来检查对象是否有属性，它返回True属性是否存在。

hasattr(object, attribute) # will return True if the object has the attribute

其次，您可以在 Python 中自定义属性访问，您可以在此处阅读更多相关信息：https://docs.python.org/2/reference/datamodel.html#customizing-attribute-access

基本上，您重写__getattr__方法来实现此目的，因此如下所示：

类 Myclass2（）： def init（self）： 通过

def compute_attr(self):
    self.attr = 1
    return self.attr
def print_attribute(self):
    print self.attr
def __getattr__(self, name):
    if hasattr(self, name) and getattr(self, name)!=None:
        return getattr(self, name):
    else:
        compute_method="compute_"+name; 
        if hasattr(self, compute_method):
            return getattr(self, compute_method)()

确保只使用 getattr 访问 __getattr__ 中的属性，否则最终会得到无限递归

Answer 2

基于Jonrsharpe链接的答案，我提供了第三种设计选择。这里的想法是，MyClass的客户端或MyClass本身的代码根本不需要特殊的条件逻辑。相反，装饰器应用于执行（假设昂贵的）属性计算的函数，然后存储该结果。

这意味着昂贵的计算是延迟完成的（仅当客户端尝试访问属性时），并且只执行一次。

def lazyprop(fn):
    attr_name = '_lazy_' + fn.__name__
    @property
    def _lazyprop(self):
        if not hasattr(self, attr_name):
            setattr(self, attr_name, fn(self))
        return getattr(self, attr_name)
    return _lazyprop

class MyClass(object):
    @lazyprop
    def attr(self):
        print('Generating attr')
        return 1
    def __repr__(self):
        return str(self.attr)

if __name__ == '__main__':
    o = MyClass()
    print(o.__dict__, end='nn')
    print(o, end='nn')
    print(o.__dict__, end='nn')
    print(o)

输出

{}
Generating attr
1
{'_lazy_attr': 1}
1

编辑

旋风的答案在OP上下文中的应用：

class lazy_property(object):
    '''
    meant to be used for lazy evaluation of an object attribute.
    property should represent non-mutable data, as it replaces itself.
    '''
    def __init__(self, fget):
        self.fget = fget
        self.func_name = fget.__name__
    def __get__(self, obj, cls):
        if obj is None:
            return None
        value = self.fget(obj)
        setattr(obj, self.func_name, value)
        return value

class MyClass(object):
    @lazy_property
    def attr(self):
        print('Generating attr')
        return 1
    def __repr__(self):
        return str(self.attr)

if __name__ == '__main__':
    o = MyClass()
    print(o.__dict__, end='nn')
    print(o, end='nn')
    print(o.__dict__, end='nn')
    print(o)

输出与上述相同。