Existe um decorador para simplesmente armazenar em cache os valores de retorno da função?

Considere o seguinte:

@property
def name(self):

    if not hasattr(self, '_name'):

        # expensive calculation
        self._name = 1 + 1

    return self._name

Sou novo, mas acho que o armazenamento em cache pode ser fatorado em um decorador. Só que eu não encontrei um igual;)

PS o cálculo real não depende de valores mutáveis

A partir do Python 3.2, existe um decorador embutido:

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

Decorador para agrupar uma função com uma chamada de memorização que economize até as chamadas mais recentes de tamanho máximo. Isso pode economizar tempo quando uma função cara ou ligada à E / S é chamada periodicamente com os mesmos argumentos.

Exemplo de um cache LRU para calcular números de Fibonacci :

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

Se você está preso ao Python 2.x, aqui está uma lista de outras bibliotecas de memoização compatíveis:

• functools32| PyPI | Código fonte
• repoze.lru| PyPI | Código fonte
• pylru| PyPI | Código fonte
• backports.functools_lru_cache| PyPI | Código fonte

Parece que você não está solicitando um decorador de memorização de uso geral (ou seja, não está interessado no caso geral em que deseja armazenar em cache valores de retorno para diferentes valores de argumento). Ou seja, você gostaria de ter o seguinte:

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

enquanto um decorador de memorização de uso geral daria a você o seguinte:

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

Eu afirmo que a sintaxe da chamada de método tem um estilo melhor, porque sugere a possibilidade de computação cara, enquanto a sintaxe da propriedade sugere uma pesquisa rápida.

[Atualização: o decorador de memorização baseado em classe ao qual vinculei e citei aqui anteriormente não funciona para métodos. Substituí-lo por uma função decoradora.] Se você deseja usar um decorador de memorização de uso geral, aqui está uma simples:

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

Exemplo de uso:

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

Outro decorador de memorização com um limite no tamanho do cache pode ser encontrado aqui .

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

Usos da amostra:

>>> @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'}

functools.cached_propertyDecorador Python 3.8

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

cached_propertydo Werkzeug foi mencionado em: https://stackoverflow.com/a/5295190/895245, mas uma versão supostamente derivada será mesclada no 3.8, o que é incrível.

Esse decorador pode ser visto como armazenamento em cache @propertyou como um limpador @functools.lru_cachepara quando você não tiver argumentos.

Os documentos dizem:

@functools.cached_property(func)

Transforme um método de uma classe em uma propriedade cujo valor é calculado uma vez e, em seguida, armazenado em cache como um atributo normal durante a vida da instância. Semelhante à propriedade (), com a adição de armazenamento em cache. Útil para propriedades computadas caras de instâncias que são efetivamente imutáveis.

Exemplo:

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)

Novo na versão 3.8.

Nota Este decorador requer que o atributo dict em cada instância seja um mapeamento mutável. Isso significa que ele não funcionará com alguns tipos, como metaclasses (já que os atributos dict nas instâncias de tipo são proxies somente leitura para o espaço de nomes da classe) e aqueles que especificam slots sem incluir o dict como um dos slots definidos (como essas classes não forneça um atributo dict ).

Werkzeug tem um cached_propertydecorador ( documentos , fonte )

Eu codifiquei essa classe simples de decorador para armazenar em cache as respostas das funções. Acho MUITO útil para meus projetos:

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

O uso é direto:

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

AVISO LEGAL: Eu sou o autor de kids.cache .

Você deve verificar kids.cache, ele fornece um @cachedecorador que funciona no python 2 e python 3. Sem dependências, ~ 100 linhas de código. É muito simples de usar, por exemplo, com seu código em mente, você pode usá-lo assim:

pip install kids.cache

Então

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

Ou você pode colocar o @cachedecorador após o @property(mesmo resultado).

O uso de cache em uma propriedade é chamado de avaliação lenta , kids.cachepode fazer muito mais (funciona na função com argumentos, propriedades, qualquer tipo de método e até classe ...). Para usuários avançados, kids.cachesuporte cachetoolsque fornece armazenamentos de cache sofisticados para python 2 e python 3 (cache LRU, LFU, TTL, RR).

NOTA IMPORTANTE : o armazenamento em cache padrão de kids.cacheé um ditado padrão, que não é recomendado para programas de longa duração com consultas sempre diferentes, pois isso levaria a um armazenamento em cache cada vez maior. Para esse uso, você pode conectar outros repositórios de cache usando, por exemplo ( @cache(use=cachetools.LRUCache(maxsize=2))para decorar sua função / propriedade / classe / método ...)

Ah, só precisava encontrar o nome certo para isso: " Avaliação preguiçosa da propriedade ".

Eu também faço muito isso; talvez eu use essa receita no meu código em algum momento.

Existe o fastcache , que é "A implementação em C do Python 3 functools.lru_cache. Fornece uma aceleração de 10 a 30x na biblioteca padrão".

O mesmo que a resposta escolhida , apenas importação diferente:

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

Além disso, ele é instalado no Anaconda , ao contrário das funções que precisam ser instaladas .

Há ainda outro exemplo de decorador de memoize no Python Wiki:

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

Esse exemplo é um pouco inteligente, porque não armazenará em cache os resultados se os parâmetros forem mutáveis. (verifique esse código, é muito simples e interessante!)

Se você estiver usando o Django Framework, ele possui essa propriedade para armazenar em cache uma visualização ou resposta do uso da API @cache_page(time)e também pode haver outras opções.

Exemplo:

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

Mais detalhes podem ser encontrados aqui .

Junto com o exemplo Memoize , encontrei os seguintes pacotes python:

• cachepy ; Permite configurar ttl e \ ou o número de chamadas para funções em cache; Além disso, pode-se usar cache baseado em arquivo criptografado ...
• percache

Eu implementei algo assim, usando pickle para persistência e sha1 para identificações curtas, quase certamente únicas. Basicamente, o cache hash o código da função e o histórico dos argumentos para obter um sha1 e, em seguida, procurou um arquivo com esse sha1 no nome. Se existia, abriu e retornou o resultado; caso contrário, ele chama a função e salva o resultado (opcionalmente, salvando apenas se levar um certo tempo para processar).

Dito isso, eu juro que encontrei um módulo existente que fez isso e me encontro aqui tentando encontrá-lo ... O mais próximo que posso encontrar é esse, que parece certo: http: //chase-seibert.github. io / blog / 2011/11/23 / pythondjango-disk-based-caching-decorator.html

O único problema que vejo com isso é que não funcionaria bem para entradas grandes, pois hashes str (arg), que não é exclusivo para matrizes gigantes.

Seria bom se houvesse um protocolo unique_hash () que tivesse uma classe retornando um hash seguro de seu conteúdo. Basicamente, implementei isso manualmente para os tipos que me interessavam.

Tente joblib http://pythonhosted.org/joblib/memory.html

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

Se você estiver usando o Django e quiser armazenar em cache as visualizações, consulte a resposta de Nikhil Kumar .

Mas se você deseja armazenar em cache QUALQUER resultado de função, você pode usar django-cache-utils .

Ele reutiliza os caches do Django e fornece um cacheddecorador fácil de usar :

from cache_utils.decorators import cached

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

@lru_cache não é perfeito com valores de função padrão

meu memdecorador:

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

e código para teste:

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

resultado - apenas 3 vezes com sono

mas com @lru_cacheisso será 4 vezes, porque isso:

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

será calculado duas vezes (mau trabalho com padrões)