C’è un decoratore semplicemente cache funzione dei valori di ritorno?

A partire da Python 3.2 vi è un built-in decoratore:

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

Decoratore per avvolgere una funzione con un memoizing callable che consente di risparmiare fino al maxsize chiamate più recenti. È possibile risparmiare tempo quando un costoso o I/O bound funzione chiamata periodicamente con gli stessi argomenti.

Esempio di LRU cache per il calcolo I numeri di 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 si sono bloccati con Python 2.x, ecco qui di seguito un elenco di altri compatibili memoization librerie:

• functools32 | PyPI | Il codice sorgente
• repoze.lru | PyPI | Il codice sorgente
• pylru | PyPI | Il codice sorgente
• backports.functools_lru_cache | PyPI | Il codice sorgente

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

Esempio si utilizza:

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

Ho codificato questo semplice decoratore classe a funzione di cache le risposte. Io la trovo MOLTO utile per i miei progetti:

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

L’utilizzo è molto semplice:

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

DISCLAIMER: io sono l’autore di ragazzi.cache.

Si dovrebbe verificare kids.cache, esso fornisce un @cache decoratore che funziona su python 2 e python 3. Dipendenze, ~100 righe di codice. E ‘ molto semplice da usare, per esempio, con il codice in mente, si potrebbe utilizzare come questa:

pip install kids.cache

Poi

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

O si potrebbe mettere il @cache decoratore dopo il @property (stesso risultato).

L’utilizzo della cache su una proprietà è chiamato lazy evaluation, kids.cache può fare molto di più (funziona su una funzione con argomenti, proprietà, qualsiasi tipo di metodi, e anche le classi…). Per gli utenti avanzati, kids.cache supporta cachetools che fornisce fantasia cache memorizza per python 2 e python 3 (LRU, LFU, TTL, RR cache).

NOTA IMPORTANTE: la cache predefinita negozio di kids.cache è uno standard dict, che non è raccomandato per il lungo programma in esecuzione, con sempre diverse query in quanto porterebbe ad una sempre crescente di memorizzazione nella cache store. Per questo tipo di utilizzo è possibile plugin altre cache memorizza usando, per esempio, (@cache(use=cachetools.LRUCache(maxsize=2)) per decorare la vostra funzione/struttura/classe/metodo…)

C’è ancora un altro esempio di un memoize decoratore a Python Wiki:

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

Che l’esempio è un po ‘ intelligente, perché non in cache i risultati, se i parametri sono modificabili. (controllare che il codice è molto semplice e interessante!)

Insieme con il Memoize Esempio ho trovato i seguenti pacchetti di python:

• cachepy; Permette di impostare ttl e\o il numero di chiamate per la cache di funzioni; Inoltre, si può utilizzare un file crittografato a base di cache…
• percache

Ho implementato qualcosa di simile a questo, con la salamoia per la costanza e l’utilizzo sha1 per brevi quasi certamente-Id univoci. Fondamentalmente la cache hash il codice della funzione e l’hist di argomenti per avere una sha1 poi ho cercato un file con un sha1 nel nome. Se esistesse, si è aperto ed è tornato il risultato; se non lo è, si chiama la funzione e salva il risultato (facoltativamente solo di salvare se ha preso una certa quantità di tempo per il processo).

Detto questo, mi piacerebbe giuro ho trovato un modulo esistente che ha fatto questo e mi trovo qui a cercare di trovare quel modulo… Il più vicino che posso trovare è questo, che sembra sul diritto: http://chase-seibert.github.io/blog/2011/11/23/pythondjango-disk-based-caching-decorator.html

L’unico problema che vedo è che non funziona bene per le grandi ingressi in quanto hash str(arg), che non è unico per il gigante di matrici.

Sarebbe bello se ci fosse un unique_hash() protocollo che aveva una classe in un secure hash del suo contenuto. In pratica ho implementato manualmente che per le tipologie di cui mi interessasse.

Provare 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