Python hafızaya alma / ertelenmiş arama özelliği dekoratörü

Son zamanlarda, örnek niteliklerinin bir veritabanında depolanan değerleri yansıttığı birçok sınıf içeren mevcut bir kod tabanından geçtim. Veritabanı aramalarının ertelenmesi için bu özniteliklerin çoğunu yeniden düzenledim. yapıcıda başlatılmamalıdır, ancak yalnızca ilk okunduğunda. Bu öznitelikler, örneğin kullanım ömrü boyunca değişmez, ancak ilk kez hesaplamak için gerçek bir darboğazdır ve yalnızca özel durumlar için gerçekten erişilir. Bu nedenle, veritabanından alındıktan sonra da önbelleğe alınabilir (bu nedenle bu , girdinin basitçe "giriş yok" olduğu hafızaya alma tanımına uyar ).

Kendimi, çeşitli sınıflarda çeşitli öznitelikler için aşağıdaki kod parçacığını tekrar tekrar yazarken buluyorum:

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

Bunu zaten Python'da yapacak, farkında olmadığım bir dekoratör var mı? Ya da, bunu yapan bir dekoratörü tanımlamanın oldukça basit bir yolu var mı?

Python 2.5 altında çalışıyorum, ancak 2.6 cevapları önemli ölçüde farklıysa yine de ilginç olabilir.

Not

Bu soru, Python bunun için birçok hazır dekoratör eklemeden önce sorulmuştu. Sadece terminolojiyi düzeltmek için güncelledim.

Her tür harika hizmet için bolton kullanıyorum .

Bu kitaplığın bir parçası olarak önbelleğe alınmış özelliğe sahipsiniz :

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)

İşte tembel bir özellik dekoratörünün örnek bir uygulaması:

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)

Etkileşimli oturum:

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

Bunu kendim için yazdım ... Gerçek tek seferlik hesaplanan tembel mülkler için kullanılmak üzere . Bunu seviyorum çünkü nesnelere fazladan nitelikler yapıştırmaktan kaçınıyor ve bir kez etkinleştirildiğinde nitelik mevcudiyetini vb. Kontrol etmek için zaman kaybetmiyor:

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

Not: lazy_propertySınıf, veri olmayan bir tanımlayıcıdır , yani salt okunurdur. Bir __set__yöntem eklemek, onun doğru çalışmasını engelleyecektir.

Burada yer, isteğe bağlı bir zaman aşımı argüman alır bir çağrılabilir var __call__ayrıca üzerinde kopyalayabilirsiniz __name__, __doc__, __module__fonk en ad alanından:

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]

örn:

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

propertybir sınıftır. Kesin olması gereken bir tanımlayıcı . Basitçe ondan türetin ve istenen davranışı uygulayın.

class lazyproperty(property):
   ....

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

Ne gerçekten istiyorum olduğunu reify(! Kaynak bağlantılı) Piramit dekoratör:

Sınıf yöntemi dekoratörü olarak kullanın. Neredeyse tıpkı Python @propertydekoratörü gibi çalışır , ancak süslediği yöntemin sonucunu ilk çağrıdan sonra örnek dikteye koyar ve süslediği işlevi etkili bir şekilde bir örnek değişkeni ile değiştirir. Python dilinde veri olmayan bir tanımlayıcıdır. Aşağıda bir örnek ve kullanımı verilmiştir:

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

Şimdiye kadar hem söz konusu hem de yanıtlarda bir dizi terim ve / veya kavram karmaşası var.

Tembel değerlendirme, bir şeyin bir değere ihtiyaç duyulduğunda mümkün olan en son anda çalışma zamanında değerlendirildiği anlamına gelir. Standart @propertydekoratör tam da bunu yapar. (*) Süslü işlev yalnızca ve bu özelliğin değerine her ihtiyacınız olduğunda değerlendirilir. (tembel değerlendirme hakkındaki wikipedia makalesine bakın)

(*) Aslında gerçek bir tembel değerlendirme (haskell ile karşılaştırın) python'da elde etmek çok zordur (ve deyimsel olmaktan uzak bir kodla sonuçlanır).

Hatırlatma, soruyu soranın aradığı şey için doğru terimdir. Dönüş değeri değerlendirmesi için yan etkilere bağlı olmayan saf işlevler güvenli bir şekilde hafızaya alınabilir ve aslında işlev araçlarında bir dekoratör vardır, @functools.lru_cachebu nedenle özel bir davranışa ihtiyacınız olmadıkça kendi dekoratörlerinizi yazmaya gerek yoktur.

Python yerel özelliğinden bir sınıf oluşturarak bunu güzel ve kolay bir şekilde yapabilirsiniz:

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

Bu özellik sınıfını normal sınıf özelliği gibi kullanabiliriz (Aynı zamanda görebileceğiniz gibi öğe atamasını da destekler)

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)

Değer sadece ilk kez hesaplandı ve bundan sonra tasarruf ettiğimiz değeri kullandık

Çıktı:

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