Fonction qui calcule une fois, met en cache le résultat et retourne à partir du cache à l'infini (Python)

Question

J'ai une fonction qui effectue une opération coûteuse et s'appelle souvent; mais, l'opération doit seulement être effectuée une fois - son résultat pourrait être mis en cache.

J'ai essayé de faire un générateur infini, mais je n'ai pas les résultats que j'attendais:

>>> def g(): 
...  result = "foo" 
...  while True: 
...   yield result 
... 
>>> g() 
<generator object g at 0x1093db230> # why didn't it give me "foo"? 

Pourquoi ne pas g un générateur?

>>> g 
<function g at 0x1093de488> 

Modifier: il est très bien si cette approche ne fonctionne pas, mais je besoin quelque chose qui effectue exactement comme une fonction régulière, comme suit:

>>> [g() for x in range(3)] 
["foo", "foo", "foo"] 

Answer 1

Voici un décorateur de cache simple. Il ne tient pas compte des variations de paramètres, il renvoie juste le même résultat après le premier appel. Il y a des colombophiles là-bas qui mettent en cache le résultat pour chaque combinaison d'entrées ("memoization").

import functools 

def callonce(func): 

    result = [] 

    @functools.wraps(func) 
    def wrapper(*args, **kwargs): 
     if not result: 
      result.append(func(*args, **kwargs)) 
     return result[0] 

    return wrapper 

Utilisation:

@callonce 
def long_running_function(x, y, z): 
    # do something expensive with x, y, and z, producing result 
    return result 

Si vous préférez écrire votre fonction en tant que générateur pour une raison quelconque (peut-être le résultat est légèrement différent sur chaque appel, mais il y a encore une configuration initiale du temps , ou bien vous voulez simplement des variables statiques de type C qui permettent à votre fonction de se rappeler un peu peu de l'état d'un appel à l'autre), vous pouvez utiliser ce décorateur:

import functools 

def gen2func(generator): 

    gen = [] 

    @functools.wraps(generator) 
    def wrapper(*args, **kwargs): 
     if not gen: 
      gen.append(generator(*args, **kwargs)) 
     return next(gen[0]) 

    return wrapper 

utilisation:

@gen2func 
def long_running_function_in_generator_form(x, y, z): 
    # do something expensive with x, y, and z, producing result 
    while True: 
     yield result 
     result += 1 # for example 

A Python 2.5 ou version ultérieure qui utilise .send() pour permettre les paramètres à transmettre à chaque itération du générateur est comme suit (notez que **kwargs ne sont pas pris en charge):

import functools 

def gen2func(generator): 

    gen = [] 

    @functools.wraps(generator) 
    def wrapper(*args): 
     if not gen: 
      gen.append(generator(*args)) 
      return next(gen[0]) 
     return gen[0].send(args) 

    return wrapper 

@gen2func 
def function_with_static_vars(a, b, c): 
    # time-consuming initial setup goes here 
    # also initialize any "static" vars here 
    while True: 
     # do something with a, b, c 
     a, b, c = yield  # get next a, b, c 

Answer 2

g() est un générateur fonction. L'appeler renvoie le générateur. Vous devez ensuite utiliser ce générateur pour obtenir vos valeurs. En boucle, par exemple, ou en appelant next() sur elle:

gen = g() 
value = next(gen) 

Notez que l'appel g() nouveau calcule à nouveau la même valeur et produire un nouveau générateur .

Vous pouvez simplement utiliser un global pour mettre en cache la valeur. Le stockage comme un attribut sur la fonction pourrait fonctionner:

def g(): 
    if not hasattr(g, '_cache'): 
     g._cache = 'foo' 
    return g._cache 

Answer 3

Une meilleure option serait d'utiliser memoization. Vous pouvez créer un décorateur memoize que vous pouvez utiliser pour envelopper n'importe quelle fonction pour laquelle vous souhaitez mettre en cache les résultats. Vous pouvez trouver quelques bonnes implémentations here.

Answer 4

Une meilleure façon: @functools.lru_cache(maxsize=None). Python 2.7 est à backported, ou vous pouvez écrire le vôtre.

Je suis parfois coupable de faire:

def foo(): 
    if hasattr(foo, 'cache'): 
     return foo.cache 

    # do work 
    foo.cache = result 
    return result 

Answer 5

Vous pouvez également tirer parti Beaker et son cache. Il a également une tonne de extensions.