Posso memoizzare un generatore Python?

Question

Ho una funzione chiamata runquery che effettua chiamate a un database e quindi restituisce le righe, una alla volta. Ho scritto un decoratore memoize (o più esattamente, ne ho appena rubato uno da this stackoverflow question) ma nelle chiamate successive si ottiene solo una sequenza vuota, presumibilmente perché i valori di un generatore possono essere restituiti solo una volta.

Come è possibile modificare il decoratore di memoizzazione che funziona con i generatori Python? Mi rendo conto che a un certo punto dovrò memorizzarlo in memoria, ma mi piacerebbe gestirlo nel decoratore e non modificare la funzione originale.

Il codice attuale della funzione Memoizzazione è:

def memoized(f): 
    # Warning: Doesn't work if f yields values 
    cache={} 
    def ret(*args): 
     if args in cache: 
      return cache[args] 
     else: 
      answer=f(*args) 
      cache[args]=answer 
      return answer 
    return ret 

Answer 1

Mi rendo conto che è un po 'di una vecchia questione, ma per coloro che desiderano una soluzione completa: ecco uno, basato su suggerimento di jsbueno:

from itertools import tee 
from types import GeneratorType 

Tee = tee([], 1)[0].__class__ 

def memoized(f): 
    cache={} 
    def ret(*args): 
     if args not in cache: 
      cache[args]=f(*args) 
     if isinstance(cache[args], (GeneratorType, Tee)): 
      # the original can't be used any more, 
      # so we need to change the cache as well 
      cache[args], r = tee(cache[args]) 
      return r 
     return cache[args] 
    return ret 

Answer 2

Sì. C'è un decoratore pubblicato here. Prendi nota che, come dice il manifesto, perdi parte del beneficio della valutazione pigra.

def memoize(func): 
    def inner(arg): 
     if isinstance(arg, list): 
      # Make arg immutable 
      arg = tuple(arg) 
     if arg in inner.cache: 
      print "Using cache for %s" % repr(arg) 
      for i in inner.cache[arg]: 
       yield i 
     else: 
      print "Building new for %s" % repr(arg) 
      temp = [] 
      for i in func(arg): 
       temp.append(i) 
       yield i 
      inner.cache[arg] = temp 
    inner.cache = {} 
    return inner 


@memoize 
def gen(x): 
    if not x: 
     yield 0 
     return 

    for i in xrange(len(x)): 
     for a in gen(x[i + 1:]): 
      yield a + x[0] 


print "Round 1" 
for a in gen([2, 3, 4, 5]): 
    print a 

print 
print "Round 2" 
for a in gen([2, 3, 4, 5]): 
    print a 

Answer 3

from itertools import tee 

sequence, memoized_sequence = tee (sequence, 2) 

Fatto.

È più facile per i generatori perché la lib standard ha questo metodo "tee"!