Декоратор властивостей запам'ятовування / відкладеного пошуку Python

Нещодавно я пройшов існуючу базу коду, що містить безліч класів, де атрибути екземплярів відображають значення, що зберігаються в базі даних. Я відновив багато цих атрибутів, щоб відкласти їх пошукові бази даних, тобто. не ініціалізується в конструкторі, а лише після першого читання. Ці атрибути не змінюються впродовж життя примірника, але вони є справжнім вузьким місцем для обчислення цього першого разу і лише дійсно доступним для особливих випадків. Отже, вони також можуть бути кешовані після їх отримання з бази даних (отже, це відповідає визначенню запам'ятовування, де вхід просто "не вводиться").

Я можу вводити наступний фрагмент коду знову і знову для різних атрибутів для різних класів:

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

Чи існує існуючий декоратор, який би це зробив уже в Python, про який я просто не знаю? Або є досить простий спосіб визначити декоратора, який це робить?

Я працюю під Python 2.5, але 2,6 відповіді все ж можуть бути цікавими, якщо вони суттєво відрізняються.

Примітка

Це питання було задано ще до того, як Python включив для цього чимало готових декораторів. Я оновив його лише для виправлення термінології.

Для всіх видів чудових утиліт я використовую болтони .

Як частина цієї бібліотеки ви маєте кешоване властивість :

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)

Ось приклад реалізації лінивого декоратора властивостей:

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)

Інтерактивна сесія:

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

Я написав це для себе ... Щоб використовуватись для справжніх одноразових обчислених лінивих властивостей. Мені це подобається, тому що він уникає наклеювання додаткових атрибутів на об'єкти, а після активації не витрачає час на перевірку наявності атрибутів тощо:

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

Примітка. lazy_propertyКлас - це дескриптор даних , що означає, що він доступний лише для читання. Додавання __set__методу не дозволить йому правильно працювати.

Ось відкликані , який приймає необов'язковий аргумент тайм - ауту, в __call__Ви можете скопіювати над __name__, __doc__, __module__з простору імен 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]

колишній:

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- клас. Дескриптор повинен бути точним. Просто вийдіть з цього і реалізуйте бажану поведінку.

class lazyproperty(property):
   ....

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

Те, що ви насправді хочете, - це reify(джерело, пов’язане з джерелом!) Декоратор від Pyramid:

Використовувати як декоратор методу класу. Він працює майже так само, як і @propertyдекоратор Python , але він вводить результат методу, який він декорує, в дік екземпляра після першого виклику, ефективно замінюючи функцію, яку він декорує, змінною екземпляра. Це, кажучи Python, дескриптор даних. Нижче наведено приклад та його використання:

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

Наразі існує змішання термінів та / або плутанини понять як у питанні, так і у відповідях.

Ледача оцінка просто означає, що щось оцінюється під час виконання в останній можливий момент, коли потрібне значення. Стандарт@property декоратор робить саме це. (*) Оформлена функція оцінюється лише і кожного разу, коли вам потрібно значення цього властивості. (див. статтю Вікіпедії про ледачу оцінку)

(*) Насправді справжньої лінивої оцінки (порівняйте, наприклад, haskell) дуже важко досягти в python (і приводить до коду, який далеко не ідіоматичний).

Пам'ять - це правильний термін того, що, як видається, шукає. Чисті функції, які не залежать від побічних ефектів для оцінки повернених значень, можна безпечно запам’ятати, і насправді у фунікулерах є декоратор, @functools.lru_cacheтому немає необхідності писати власні декоратори, якщо вам не потрібна спеціалізована поведінка.

Ви можете зробити це красиво і легко, побудувавши клас з рідної власності Python:

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

Ми можемо використовувати цей клас властивостей, як властивість звичайного класу (це також підтримка призначення елементів, як ви бачите)

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)

Значення розраховується лише перший раз, після чого ми використали збережене значення

Вихід:

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