替换属性以获得性能增益

Question

情况

类似于这个问题，我想要更换财产。与这个问题不同，我不想在子类中覆盖它。为了提高效率，我想在 init 和属性本身中替换它，这样就不必调用每次调用属性时计算值的函数。

我有一个类，上面有一个属性。构造函数可以获取属性的值。如果传递的是值，我想用值替换属性（而不仅仅是设置属性）。这是因为属性本​​身计算值，这是一个昂贵的操作。同样，我想用属性计算后的值替换该属性，以便将来对该属性的调用不必重新计算：

class MyClass(object):
    def __init__(self, someVar=None):
        if someVar is not None: self.someVar = someVar

    @property
    def someVar(self):
        self.someVar = calc_some_var()
        return self.someVar

问题

上面的代码不起作用，因为执行 self.someVar = 确实如此不替换 someVar 函数。它尝试调用未定义的属性的 setter。

潜在的解决方案

我知道我可以通过稍微不同的方式实现相同的目标，如下所示：

class MyClass(object):
    def __init__(self, someVar=None):
        self._someVar = someVar

    @property
    def someVar(self):
        if self._someVar is None:
            self._someVar = calc_some_var()
        return self._someVar

这会稍微降低效率，因为每次调用该属性时都必须检查 None 。该应用程序对性能至关重要，因此这可能足够好，也可能不够好。

问题

有没有办法替换类实例上的属性？如果我能够做到这一点（即避免 None 检查和函数调用），效率会高多少？

Answer 1

您正在寻找的是Denis Otkidach的优秀CachedAttribute：

class CachedAttribute(object):    
    '''Computes attribute value and caches it in the instance.
    From the Python Cookbook (Denis Otkidach)
    This decorator allows you to create a property which can be computed once and
    accessed many times. Sort of like memoization.
    '''
    def __init__(self, method, name=None):
        # record the unbound-method and the name
        self.method = method
        self.name = name or method.__name__
        self.__doc__ = method.__doc__
    def __get__(self, inst, cls):
        # self: <__main__.cache object at 0xb781340c>
        # inst: <__main__.Foo object at 0xb781348c>
        # cls: <class '__main__.Foo'>       
        if inst is None:
            # instance attribute accessed on class, return self
            # You get here if you write `Foo.bar`
            return self
        # compute, cache and return the instance's attribute value
        result = self.method(inst)
        # setattr redefines the instance's attribute so this doesn't get called again
        setattr(inst, self.name, result)
        return result

它可以像这样使用：

def demo_cache():
    class Foo(object):
        @CachedAttribute
        def bar(self):
            print 'Calculating self.bar'  
            return 42
    foo=Foo()
    print(foo.bar)
    # Calculating self.bar
    # 42

注意访问< code>foo.bar 随后的时间不会调用getter函数。 （计算 self.bar 不会被打印。）

    print(foo.bar)    
    # 42
    foo.bar=1
    print(foo.bar)
    # 1

从 foo.__dict__ 中删除 foo.bar 会重新公开 Foo 中定义的属性。
因此，再次调用 foo.bar 会再次重新计算该值。

    del foo.bar
    print(foo.bar)
    # Calculating self.bar
    # 42

demo_cache()

该装饰器发布在 Python Cookbook 中，也可以在 活动状态。

这是高效的，因为虽然该属性存在于类的 __dict__ 中，但在计算之后，会在实例的 __dict__ 中创建同名的属性。 Python 的属性查找规则优先考虑实例的 __dict__ 中的属性，因此类中的属性会被有效地覆盖。

Answer 2

当然，您可以在类实例的私有字典中设置属性，该属性在调用属性函数 foo 之前优先（位于静态字典 A.__dict__ 中）

class A:
    def __init__(self):
        self._foo = 5
        self.__dict__['foo'] = 10

    @property
    def foo(self):
        return self._foo

assert A().foo == 10

如果您想再次重置以处理该属性，只需 del self.__dict__['foo']

Answer 3

class MaskingProperty():
    def __init__(self, fget=None, name=None, doc=None):
        self.fget = fget
        if fget is not None:
            self.name = fget.__name__
        self.__doc__ = doc or fget.__doc__
    def __call__(self, func):
        self.fget = func
        self.name = func.__name__
        if not self.__doc__:
            self.__doc__ = func.__doc__
        return self
    def __get__(self, instance, cls):
        if instance is None:
            return self         
        if self.fget is None:
            raise AttributeError("seriously confused attribute <%s.%s>" % (cls, self.name))
        result = self.fget(instance)
        setattr(instance, self.name, result)
        return result

这与 Denis Otkidach 的 CachedAttribute 基本相同，但稍微更健壮，因为它允许：

@MaskingProperty
def spam(self):
    ...

或

@MaskingProperty()     # notice the parens!  ;)
def spam(self):
    ...

Answer 4

您可以通过替换函数的 来更改函数的代码 >__code__ 对象与来自另一个函数的 __code__ 对象。

这是我创建的一个装饰器函数来为您完成此任务。请随意修改您认为合适的内容。但要记住的重要一点是，这两个函数需要具有相同数量的“自由变量”才能像这样交换。通过使用 nonlocal 来强制执行此操作可以轻松完成（如下所示）。

NULL = object()
def makeProperty(variable = None, default = NULL, defaultVariable = None):
    """Crates a property using the decorated function as the getter.
    The docstring of the decorated function becomes the docstring for the property.

    variable (str) - The name of the variable in 'self' to use for the property
        - If None: uses the name of 'function' prefixed by an underscore

    default (any) - What value to initialize 'variable' in 'self' as if it does not yet exist
        - If NULL: Checks for a kwarg in 'function' that matches 'defaultVariable'

    defaultVariable (str) - The name of a kwarg in 'function' to use for 'default'
        - If None: Uses "default"
        Note: this must be a kwarg, not an arg with a default; this means it must appear after *
    ___________________________________________________________

    Example Use:
        class Test():
            @makeProperty()
            def x(self, value, *, default = 0):
                '''Lorem ipsum'''
                return f"The value is {value}"

        test = Test()
        print(test.x) #The value is 0
        test.x = 1
        print(test.x) #The value is 1

    Equivalent Use:
        @makeProperty(defaultVariable = "someKwarg")
        def x(self, value, *, someKwarg = 0):

    Equivalent Use:
        @makeProperty(default = 0)
        def x(self, value):
    ___________________________________________________________
    """
    def decorator(function):
        _variable = variable or f"_{function.__name__}"

        if (default is not NULL):
            _default = default
        elif (function.__kwdefaults__ is not None):
            _default = function.__kwdefaults__.get(defaultVariable or "default")
        else:
            _default = None

        def fget(self):
            nonlocal fget_runOnce, fget, fset, _default #Both functions must have the same number of 'free variables' to replace __code__
            return getattr(self, _variable)

        def fget_runOnce(self):
            if (not hasattr(self, _variable)):
                fset(self, _default)

            fget_runOnce.__code__ = fget.__code__
            return getattr(self, _variable)

        def fset(self, value):
            setattr(self, _variable, function(self, value))

        def fdel(self):
            delattr(self, _variable)

        return property(fget_runOnce, fset, fdel, function.__doc__)
    return decorator