İşlev dönüş değerlerini önbelleğe almak için bir dekoratör var mı?

Aşağıdakileri göz önünde bulundur:

@property
def name(self):

    if not hasattr(self, '_name'):

        # expensive calculation
        self._name = 1 + 1

    return self._name

Ben yeniyim ama bence önbellek bir dekoratöre dönüştürülebilir. Sadece böyle bir tane bulamadım;)

PS, gerçek hesaplama değiştirilebilir değerlere bağlı değildir

Python 3.2'den itibaren yerleşik bir dekoratör var:

@functools.lru_cache(maxsize=100, typed=False)

Dekoratör, en son yapılan aramaların maksimum boyutuna kadar kaydedilebilen bir memoizing callable ile bir fonksiyon sarmak için. Pahalı veya G / Ç bağlantılı bir işlev aynı argümanlarla periyodik olarak çağrıldığında zaman kazanabilir.

Fibonacci sayılarını hesaplamak için LRU önbellek örneği :

@lru_cache(maxsize=None)
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

>>> print([fib(n) for n in range(16)])
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]

>>> print(fib.cache_info())
CacheInfo(hits=28, misses=16, maxsize=None, currsize=16)

Python 2.x ile sıkışıp kalıyorsanız, diğer uyumlu not kütüphanelerinin listesi:

• functools32| PyPI | Kaynak kodu
• repoze.lru| PyPI | Kaynak kodu
• pylru| PyPI | Kaynak kodu
• backports.functools_lru_cache| PyPI | Kaynak kodu

Eğer gibi geliyor değil (farklı argüman değerleri için önbellek dönüş değerlerine istediğiniz yere yani sen genel durumda ilgilenen değiliz) genel amaçlı memoization taslağıydı. Yani, buna sahip olmak istersiniz:

x = obj.name  # expensive
y = obj.name  # cheap

genel amaçlı bir not dekoratörü size şunları verir:

x = obj.name()  # expensive
y = obj.name()  # cheap

Metod çağrısı sözdiziminin daha iyi bir stil olduğunu, çünkü özellik sözdiziminin hızlı bir arama önerdiğini pahalı hesaplama olasılığını önerdiğini belirtiyorum.

[Güncelleme: Daha önce bağladığım ve burada alıntıladığım sınıf tabanlı not çözücü, yöntemler için çalışmıyor. Bunu bir dekoratör işleviyle değiştirdim.] Genel amaçlı bir not dekoratör kullanmak istiyorsanız, işte basit bir işlem:

def memoize(function):
  memo = {}
  def wrapper(*args):
    if args in memo:
      return memo[args]
    else:
      rv = function(*args)
      memo[args] = rv
      return rv
  return wrapper

Örnek kullanım:

@memoize
def fibonacci(n):
  if n < 2: return n
  return fibonacci(n - 1) + fibonacci(n - 2)

Önbellek boyutunu sınırlayan başka bir not dekoratörü burada bulunabilir .

class memorize(dict):
    def __init__(self, func):
        self.func = func

    def __call__(self, *args):
        return self[args]

    def __missing__(self, key):
        result = self[key] = self.func(*key)
        return result

Örnek kullanımlar:

>>> @memorize
... def foo(a, b):
...     return a * b
>>> foo(2, 4)
8
>>> foo
{(2, 4): 8}
>>> foo('hi', 3)
'hihihi'
>>> foo
{(2, 4): 8, ('hi', 3): 'hihihi'}

Python 3.8 functools.cached_propertydekoratör

https://docs.python.org/dev/library/functools.html#functools.cached_property

cached_propertyWerkzeug from https://stackoverflow.com/a/5295190/895245 adresinden bahsedildi, ancak sözde türetilmiş bir sürüm 3.8 ile birleştirilecek, bu harika.

Bu dekoratör önbellekleme @propertyveya @functools.lru_cacheherhangi bir argümanınız olmadığı zamanlar için bir temizleyici olarak görülebilir .

Dokümanlar şöyle diyor:

@functools.cached_property(func)

Sınıf yöntemini, değeri bir kez hesaplanan ve daha sonra örneğin yaşamı için normal bir öznitelik olarak önbelleğe alınan bir özelliğe dönüştürün. Önbellek ekleyerek property () öğesine benzer. Aksi takdirde etkili bir şekilde değiştirilemeyen örneklerin pahalı hesaplanmış özellikleri için kullanışlıdır.

Misal:

class DataSet:
    def __init__(self, sequence_of_numbers):
        self._data = sequence_of_numbers

    @cached_property
    def stdev(self):
        return statistics.stdev(self._data)

    @cached_property
    def variance(self):
        return statistics.variance(self._data)

3.8 sürümündeki yenilikler.

Not Bu dekoratör , her örnekte dict özniteliğinin değiştirilebilir bir eşleme olmasını gerektirir . Bu, metasınıflar (bazı türlerdeki dict öznitelikleri sınıf ad alanı için salt okunur proxy'ler olduğu için) ve tanımlanmış yuvalardan biri olarak dict içermeyen yuvaları belirten bazı türlerle (bu tür sınıflar gibi) çalışmayacağı anlamına gelir. bir dict niteliği vermeyin ).

Werkzeug'un cached_propertydekoratörü var ( dokümanlar , kaynak )

İşlev yanıtlarını önbelleğe almak için bu basit dekoratör sınıfını kodladım. Projelerim için ÇOK yararlı buluyorum:

from datetime import datetime, timedelta 

class cached(object):
    def __init__(self, *args, **kwargs):
        self.cached_function_responses = {}
        self.default_max_age = kwargs.get("default_cache_max_age", timedelta(seconds=0))

    def __call__(self, func):
        def inner(*args, **kwargs):
            max_age = kwargs.get('max_age', self.default_max_age)
            if not max_age or func not in self.cached_function_responses or (datetime.now() - self.cached_function_responses[func]['fetch_time'] > max_age):
                if 'max_age' in kwargs: del kwargs['max_age']
                res = func(*args, **kwargs)
                self.cached_function_responses[func] = {'data': res, 'fetch_time': datetime.now()}
            return self.cached_function_responses[func]['data']
        return inner

Kullanımı basittir:

import time

@cached
def myfunc(a):
    print "in func"
    return (a, datetime.now())

@cached(default_max_age = timedelta(seconds=6))
def cacheable_test(a):
    print "in cacheable test: "
    return (a, datetime.now())


print cacheable_test(1,max_age=timedelta(seconds=5))
print cacheable_test(2,max_age=timedelta(seconds=5))
time.sleep(7)
print cacheable_test(3,max_age=timedelta(seconds=5))

YASAL UYARI: Ben kids.cache yazarım .

Kontrol etmelisiniz kids.cache, @cachepython 2 ve python 3 üzerinde çalışan bir dekoratör sağlar. Bağımlılık yok, ~ 100 kod satırı. Örneğin, kodunuzu göz önünde bulundurarak kullanmak çok basittir, bunu şu şekilde kullanabilirsiniz:

pip install kids.cache

Sonra

from kids.cache import cache
...
class MyClass(object):
    ...
    @cache            # <-- That's all you need to do
    @property
    def name(self):
        return 1 + 1  # supposedly expensive calculation

Veya @cachedekoratörü @property(aynı sonuçtan) sonra koyabilirsiniz .

Bir özellikte önbellek kullanımına tembel değerlendirme denir , kids.cacheçok daha fazlasını yapabilir (herhangi bir argüman, özellik, herhangi bir yöntem türü ve hatta sınıflarla işlev üzerinde çalışır ...). Gelişmiş kullanıcılar için, python 2 ve python 3'e (LRU, LFU, TTL, RR önbellek) süslü önbellek depoları sağlayan kids.cachedestekler cachetools.

ÖNEMLİ NOT : varsayılan önbellek deposu, kids.cachesürekli büyüyen bir önbellek deposuna yol açacağı için her zaman farklı sorguları olan uzun süren program için tavsiye edilmeyen standart bir diksiyondur. Bu kullanım için örneğin kullanarak diğer önbellek depolarını ekleyebilirsiniz ( @cache(use=cachetools.LRUCache(maxsize=2))işlevinizi / mülkünüzü / sınıfınızı / yönteminizi süslemek için ...)

Ah, sadece bunun için doğru ismi bulmalıydım: " Tembel mülk değerlendirmesi ".

Bunu ben de çok yapıyorum; belki bu tarifi bir zaman kodumda kullanacağım.

Orada fastcache olan "Python 3 functools.lru_cache C uygulaması standart kütüphanesinde üzerinde 10-30x sağlanan hızlanmayı sağlar."

Seçilen cevapla aynı , sadece farklı içe aktarma:

from fastcache import lru_cache
@lru_cache(maxsize=128, typed=False)
def f(a, b):
    pass

Ayrıca, yüklenmesi gereken functools'un aksine Anaconda'da yüklü olarak gelir .

Python Wiki'de bir not dekoratörünün başka bir örneği daha var :

http://wiki.python.org/moin/PythonDecoratorLibrary#Memoize

Bu örnek biraz akıllıdır, çünkü parametreler değiştirilebilirse sonuçları önbelleğe almaz. (Bu kodu kontrol edin, çok basit ve ilginç!)

Django Framework kullanıyorsanız, API'lerin kullanımının bir görünümünü veya yanıtını önbelleğe almak için böyle bir özelliğe sahiptir @cache_page(time)ve başka seçenekler de olabilir.

Misal:

@cache_page(60 * 15, cache="special_cache")
def my_view(request):
    ...

Daha fazla ayrıntıyı burada bulabilirsiniz .

Memoize Örneği ile birlikte aşağıdaki python paketlerini buldum:

• önbellek ; Önbelleğe alınmış işlevler için ttl ve \ ya da çağrı sayısını ayarlamayı sağlar; Ayrıca, bir şifreli dosya tabanlı önbellek kullanabilirsiniz ...
• percache

Böyle bir şey uyguladım, kalıcılık için turşu kullanarak ve neredeyse kesinlikle benzersiz kısa kimlikler için sha1'i kullandım. Temel olarak önbellek, bir sha1 elde etmek için işlevin kodunu ve bağımsız değişkenlerin yığınını karma hale getirerek adında o sha1 ile bir dosya aradı. Varsa, açtı ve sonucu döndürdü; değilse, işlevi çağırır ve sonucu kaydeder (isteğe bağlı olarak yalnızca işlenmesi belirli bir zaman alırsa tasarruf sağlar).

Dedi ki, yemin ederim ki bunu yapan mevcut bir modül buldum ve kendimi burada bu modülü bulmaya çalışırken buluyorum ... Bulabildiğim en yakın şey, şu doğru görünüyor: http: //chase-seibert.github. / 2011/11/23 / pythondjango-disk tabanlı önbelleğe alma-decorator.html io / blog

Bununla birlikte gördüğüm tek sorun, büyük diziler için iyi çalışmaz, çünkü dev diziler için benzersiz olmayan str (arg) hashes.

Bir sınıfın içeriğinin güvenli bir karma değerini döndüren bir unique_hash () protokolü olsaydı iyi olurdu . Temelde elle ilgilendiğim türler için bunu uyguladım.

Joblib http://pythonhosted.org/joblib/memory.html adresini deneyin

from joblib import Memory
memory = Memory(cachedir=cachedir, verbose=0)
@memory.cache
    def f(x):
        print('Running f(%s)' % x)
        return x

Django kullanıyorsanız ve görünümleri önbelleğe almak istiyorsanız Nikhil Kumar'ın cevabına bakın .

Ancak HERHANGİ bir işlev sonucunu önbelleğe almak istiyorsanız, django-cache-utils kullanabilirsiniz .

Django önbelleklerini yeniden kullanır ve kullanımı kolay cacheddekoratör sağlar:

from cache_utils.decorators import cached

@cached(60)
def foo(x, y=0):
    print 'foo is called'
    return x+y

@lru_cache varsayılan işlev değerleri ile mükemmel değil

Benim memdekoratör:

import inspect


def get_default_args(f):
    signature = inspect.signature(f)
    return {
        k: v.default
        for k, v in signature.parameters.items()
        if v.default is not inspect.Parameter.empty
    }


def full_kwargs(f, kwargs):
    res = dict(get_default_args(f))
    res.update(kwargs)
    return res


def mem(func):
    cache = dict()

    def wrapper(*args, **kwargs):
        kwargs = full_kwargs(func, kwargs)
        key = list(args)
        key.extend(kwargs.values())
        key = hash(tuple(key))
        if key in cache:
            return cache[key]
        else:
            res = func(*args, **kwargs)
            cache[key] = res
            return res
    return wrapper

ve test kodu:

from time import sleep


@mem
def count(a, *x, z=10):
    sleep(2)
    x = list(x)
    x.append(z)
    x.append(a)
    return sum(x)


def main():
    print(count(1,2,3,4,5))
    print(count(1,2,3,4,5))
    print(count(1,2,3,4,5, z=6))
    print(count(1,2,3,4,5, z=6))
    print(count(1))
    print(count(1, z=10))


if __name__ == '__main__':
    main()

sonuç - uyku ile sadece 3 kez

ama @lru_cacheonunla 4 kez olacak, çünkü bu:

print(count(1))
print(count(1, z=10))

iki kez hesaplanacaktır (varsayılanlarla kötü çalışma)