Python memoising / deferred lookup property decorator

Oto przykładowa implementacja leniwego dekoratora Nieruchomości:

import functools

def lazyprop(fn):
    attr_name = '_lazy_' + fn.__name__

    @property
    @functools.wraps(fn)
    def _lazyprop(self):
        if not hasattr(self, attr_name):
            setattr(self, attr_name, fn(self))
        return getattr(self, attr_name)

    return _lazyprop


class Test(object):

    @lazyprop
    def a(self):
        print 'generating "a"'
        return range(5)

Sesja Interaktywna:

>>> t = Test()
>>> t.__dict__
{}
>>> t.a
generating "a"
[0, 1, 2, 3, 4]
>>> t.__dict__
{'_lazy_a': [0, 1, 2, 3, 4]}
>>> t.a
[0, 1, 2, 3, 4]

Napisałam to dla siebie... Do użycia dla true jednorazowo obliczonych właściwości leniwych. Podoba mi się, ponieważ unika przyklejania dodatkowych atrybutów na obiektach, a po aktywacji nie marnuje czasu na sprawdzanie obecności atrybutów itp.:

import functools

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

        # copy the getter function's docstring and other attributes
        functools.update_wrapper(self, fget)

    def __get__(self, obj, cls):
        if obj is None:
            return self

        value = self.fget(obj)
        setattr(obj, self.fget.__name__, value)
        return value


class Test(object):

    @lazy_property
    def results(self):
        calcs = 1  # Do a lot of calculation here
        return calcs

Uwaga: klasa lazy_property jest nie-deskryptorem danych, co oznacza, że jest tylko do odczytu. Dodanie metody __set__ uniemożliwiłoby jej poprawne działanie.

Oto wywołanie, które pobiera opcjonalny argument timeout, w __call__ można również skopiować __name__, __doc__, __module__ z przestrzeni nazw func:

import time

class Lazyproperty(object):

    def __init__(self, timeout=None):
        self.timeout = timeout
        self._cache = {}

    def __call__(self, func):
        self.func = func
        return self

    def __get__(self, obj, objcls):
        if obj not in self._cache or \
          (self.timeout and time.time() - self._cache[key][1] > self.timeout):
            self._cache[obj] = (self.func(obj), time.time())
        return self._cache[obj]

Ex:

class Foo(object):

    @Lazyproperty(10)
    def bar(self):
        print('calculating')
        return 'bar'

>>> x = Foo()
>>> print(x.bar)
calculating
bar
>>> print(x.bar)
bar
...(waiting 10 seconds)...
>>> print(x.bar)
calculating
bar

property to klasa. A deskryptor aby być dokładnym. Po prostu wyprowadzić z niego i wdrożyć pożądane zachowanie.

class lazyproperty(property):
   ....

class testA(object):
   ....
  a = lazyproperty('_a')
  b = lazyproperty('_b')

To, czego naprawdę chcesz, to reify (źródło: linked!) dekorator z piramidy:

Użyj jako dekorator metody klasowej. Działa prawie dokładnie tak, jak dekorator Pythona @property, ale po pierwszym wywołaniu umieszcza wynik metody, którą dekoruje w dict instancji, skutecznie zastępując dekorowaną funkcję zmienną instancji. Jest to, w języku Python, deskryptor Nie-danych. Poniżej znajduje się przykład i jego użycie:

>>> from pyramid.decorator import reify

>>> class Foo(object):
...     @reify
...     def jammy(self):
...         print('jammy called')
...         return 1

>>> f = Foo()
>>> v = f.jammy
jammy called
>>> print(v)
1
>>> f.jammy
1
>>> # jammy func not called the second time; it replaced itself with 1
>>> # Note: reassignment is possible
>>> f.jammy = 2
>>> f.jammy
2

Do tej pory istnieje pomieszanie pojęć i/lub pomieszanie pojęć zarówno w pytaniach, jak i w odpowiedziach.

Leniwa ocena oznacza tylko, że coś jest oceniane w czasie wykonywania w ostatnim możliwym momencie, gdy potrzebna jest wartość. dekorator standardowy @property właśnie to robi. (*) funkcja jest obliczana tylko i za każdym razem, gdy potrzebujesz wartości tej właściwości. (zobacz artykuł na Wikipedii o leniwej ocenie)

(*)faktycznie prawdziwa leniwa ocena (porównaj np. haskell) jest bardzo trudne do osiągnięcia w Pythonie (i skutkuje kodem, który jest daleki od idiomatycznego).

Memoizacja jest właściwym określeniem tego, czego asker wydaje się szukać. Czyste funkcje, które nie zależą od efektów ubocznych, mogą być bezpiecznie zapamiętane i w functools istnieje dekorator @functools.lru_cache więc nie ma potrzeby pisania własnych dekoratorów, chyba że potrzebujesz specjalistycznego zachowania.

Możesz to zrobić ładnie i łatwo, budując klasę z natywnej właściwości Pythona:

class cached_property(property):
    def __init__(self, func, name=None, doc=None):
        self.__name__ = name or func.__name__
        self.__module__ = func.__module__
        self.__doc__ = doc or func.__doc__
        self.func = func

    def __set__(self, obj, value):
        obj.__dict__[self.__name__] = value

    def __get__(self, obj, type=None):
        if obj is None:
            return self
        value = obj.__dict__.get(self.__name__, None)
        if value is None:
            value = self.func(obj)
            obj.__dict__[self.__name__] = value
        return value

Możemy używać tej właściwości jak zwykłej właściwości klasy (jest to również wsparcie przypisanie pozycji, jak widać)

class SampleClass():
    @cached_property
    def cached_property(self):
        print('I am calculating value')
        return 'My calculated value'


c = SampleClass()
print(c.cached_property)
print(c.cached_property)
c.cached_property = 2
print(c.cached_property)
print(c.cached_property)

Wartość obliczana tylko za pierwszym razem, a następnie użyliśmy naszej zapisanej wartości

Wyjście:

I am calculating value
My calculated value
My calculated value
2
2