Dekorator właściwości zapamiętywania / odroczonego wyszukiwania w Pythonie

Ostatnio przejrzałem istniejącą bazę kodu zawierającą wiele klas, w których atrybuty instancji odzwierciedlają wartości przechowywane w bazie danych. Przefaktoryzowałem wiele z tych atrybutów, aby ich wyszukiwanie w bazie danych zostało odroczone, tj. nie być inicjalizowane w konstruktorze, ale tylko przy pierwszym czytaniu. Te atrybuty nie zmieniają się przez cały okres istnienia instancji, ale są prawdziwym wąskim gardłem w obliczaniu tego pierwszego razu i są dostępne tylko w specjalnych przypadkach. W związku z tym mogą być również buforowane po ich pobraniu z bazy danych (dlatego pasuje to do definicji memoizacji, w której dane wejściowe to po prostu „brak danych wejściowych”).

W kółko wpisuję następujący fragment kodu dla różnych atrybutów w różnych klasach:

class testA(object):

  def __init__(self):
    self._a = None
    self._b = None

  @property
  def a(self):
    if self._a is None:
      # Calculate the attribute now
      self._a = 7
    return self._a

  @property
  def b(self):
    #etc

Czy istnieje już dekorator, który może to zrobić w Pythonie, o którym po prostu nie wiem? A może istnieje dość prosty sposób na zdefiniowanie dekoratora, który to robi?

Pracuję pod Pythonem 2.5, ale odpowiedzi 2.6 mogą nadal być interesujące, jeśli są znacząco różne.

Uwaga

To pytanie zostało zadane, zanim Python zawierał wiele gotowych dekoratorów do tego. Zaktualizowałem go tylko pod kątem poprawnej terminologii.

Do wszelkiego rodzaju świetnych narzędzi używam boltons .

W ramach tej biblioteki masz cachedwłaściwość :

from boltons.cacheutils import cachedproperty

class Foo(object):
    def __init__(self):
        self.value = 4

    @cachedproperty
    def cached_prop(self):
        self.value += 1
        return self.value


f = Foo()
print(f.value)  # initial value
print(f.cached_prop)  # cached property is calculated
f.value = 1
print(f.cached_prop)  # same value for the cached property - it isn't calculated again
print(f.value)  # the backing value is different (it's essentially unrelated value)

Oto przykład implementacji 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łem to dla siebie ... Aby użyć go do prawdziwych, jednorazowo obliczonych leniwych właściwości. Podoba mi się, ponieważ unika przyklejania dodatkowych atrybutów do obiektów, 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: lazy_propertyKlasa nie jest deskryptorem danych , co oznacza, że ​​jest przeznaczona tylko do odczytu. Dodanie __set__metody uniemożliwiłoby jej prawidłowe działanie.

Oto wywoływalnym że pobiera opcjonalny argument limitu czasu, w __call__można również skopiować nad __name__, __doc__, __module__od nazw func za:

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]

dawny:

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

propertyjest klasą. Deskryptor być dokładne. Po prostu wyprowadzaj z niego i wdrażaj pożądane zachowanie.

class lazyproperty(property):
   ....

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

To, czego naprawdę chcesz, to dekorator reify(powiązany ze źródłem!) Z Pyramid:

Użyj jako dekoratora metody klas. Działa prawie dokładnie tak samo, jak @propertydekorator w Pythonie , ale po pierwszym wywołaniu umieszcza wynik metody, którą ozdabia, w dyktacie instancji, skutecznie zastępując dekorowaną funkcję zmienną instancji. W języku Pythona jest to deskryptor niebędący danymi. Poniżej znajduje się przykład i jego zastosowanie:

>>> 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

Jak dotąd dochodzi do pomieszania terminów i / lub pomieszania pojęć, zarówno w pytaniach, jak iw odpowiedziach.

Leniwa ocena oznacza po prostu, że coś jest oceniane w czasie wykonywania w ostatnim możliwym momencie, gdy potrzebna jest wartość. Właśnie to robi standardowy @propertydekorator. (*) Dekorowana 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)

(*) Właściwie prawdziwie leniwa ocena (porównaj np. Haskell) jest bardzo trudna do osiągnięcia w Pythonie (i skutkuje kodem, który jest daleki od idiomatyczności).

Zapamiętywanie jest poprawnym określeniem tego, czego szuka pytający. Czyste funkcje, które nie są uzależnione od efektów ubocznych dla oceny wartości powrotu może być bezpiecznie memoized i tam jest rzeczywiście dekorator w functools @functools.lru_cache więc bez konieczności pisania własnych dekoratorów, chyba że trzeba specjalizuje zachowanie.

Możesz to zrobić przyjemnie 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żyć tej klasy właściwości jak zwykłej właściwości klasy (obsługuje również przypisywanie elementów, 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ść obliczona tylko za pierwszym razem, a następnie wykorzystaliśmy zapisaną wartość

Wynik:

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