Restablecer objeto generador en Python

Tengo un objeto generador devuelto por rendimiento múltiple. La preparación para llamar a este generador es una operación bastante lenta. Es por eso que quiero reutilizar el generador varias veces.

y = FunctionWithYield()
for x in y: print(x)
#here must be something to reset 'y'
for x in y: print(x)

Por supuesto, estoy teniendo en cuenta copiar el contenido en una lista simple. ¿Hay alguna manera de restablecer mi generador?

Otra opción es usar la itertools.tee()función para crear una segunda versión de su generador:

y = FunctionWithYield()
y, y_backup = tee(y)
for x in y:
    print(x)
for x in y_backup:
    print(x)

Esto podría ser beneficioso desde el punto de vista del uso de memoria si la iteración original no procesara todos los elementos.

Los generadores no se pueden rebobinar. Tienes las siguientes opciones:

1. Ejecute la función de generador nuevamente, reiniciando la generación:

   y = FunctionWithYield()
   for x in y: print(x)
   y = FunctionWithYield()
   for x in y: print(x)

2. Almacene los resultados del generador en una estructura de datos en la memoria o en el disco que puede repetir nuevamente:

   y = list(FunctionWithYield())
   for x in y: print(x)
   # can iterate again:
   for x in y: print(x)

La desventaja de la opción 1 es que vuelve a calcular los valores. Si eso requiere mucha CPU, terminas calculando dos veces. Por otro lado, la desventaja de 2 es el almacenamiento. La lista completa de valores se almacenará en la memoria. Si hay demasiados valores, eso puede ser poco práctico.

Entonces tienes el clásico memoria frente a la compensación de procesamiento . No puedo imaginar una forma de rebobinar el generador sin almacenar los valores o calcularlos nuevamente.

>>> def gen():
...     def init():
...         return 0
...     i = init()
...     while True:
...         val = (yield i)
...         if val=='restart':
...             i = init()
...         else:
...             i += 1

>>> g = gen()
>>> g.next()
0
>>> g.next()
1
>>> g.next()
2
>>> g.next()
3
>>> g.send('restart')
0
>>> g.next()
1
>>> g.next()
2

Probablemente la solución más simple es envolver la parte costosa en un objeto y pasarla al generador:

data = ExpensiveSetup()
for x in FunctionWithYield(data): pass
for x in FunctionWithYield(data): pass

De esta manera, puede almacenar en caché los costosos cálculos.

Si puede mantener todos los resultados en la RAM al mismo tiempo, utilice list()para materializar los resultados del generador en una lista simple y trabaje con eso.

Quiero ofrecer una solución diferente a un viejo problema.

class IterableAdapter:
    def __init__(self, iterator_factory):
        self.iterator_factory = iterator_factory

    def __iter__(self):
        return self.iterator_factory()

squares = IterableAdapter(lambda: (x * x for x in range(5)))

for x in squares: print(x)
for x in squares: print(x)

El beneficio de esto cuando se compara con algo así list(iterator)es que esto es O(1)complejidad espacial y lo list(iterator)es O(n). La desventaja es que, si solo tiene acceso al iterador, pero no a la función que produjo el iterador, entonces no puede usar este método. Por ejemplo, puede parecer razonable hacer lo siguiente, pero no funcionará.

g = (x * x for x in range(5))

squares = IterableAdapter(lambda: g)

for x in squares: print(x)
for x in squares: print(x)

Si la respuesta de GrzegorzOledzki no es suficiente, probablemente podría utilizar send()para lograr su objetivo. Consulte PEP-0342 para obtener más detalles sobre generadores mejorados y expresiones de rendimiento.

ACTUALIZACIÓN: Ver también itertools.tee(). Involucra parte de ese intercambio de memoria versus procesamiento mencionado anteriormente, pero puede ahorrar algo de memoria en lugar de almacenar los resultados del generador en a list; depende de cómo estés usando el generador.

Si su generador es puro en el sentido de que su salida solo depende de argumentos pasados ​​y el número de paso, y desea que el generador resultante sea reiniciable, aquí hay un fragmento de clasificación que podría ser útil:

import copy

def generator(i):
    yield from range(i)

g = generator(10)
print(list(g))
print(list(g))

class GeneratorRestartHandler(object):
    def __init__(self, gen_func, argv, kwargv):
        self.gen_func = gen_func
        self.argv = copy.copy(argv)
        self.kwargv = copy.copy(kwargv)
        self.local_copy = iter(self)

    def __iter__(self):
        return self.gen_func(*self.argv, **self.kwargv)

    def __next__(self):
        return next(self.local_copy)

def restartable(g_func: callable) -> callable:
    def tmp(*argv, **kwargv):
        return GeneratorRestartHandler(g_func, argv, kwargv)

    return tmp

@restartable
def generator2(i):
    yield from range(i)

g = generator2(10)
print(next(g))
print(list(g))
print(list(g))
print(next(g))

salidas:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[]
0
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1

De la documentación oficial de tee :

En general, si un iterador usa la mayoría o la totalidad de los datos antes de que comience otro iterador, es más rápido usar list () en lugar de tee ().

Por lo tanto, es mejor usarlo list(iterable)en su caso.

Usar una función de contenedor para manejar StopIteration

Podría escribir una función envoltura simple en su función generadora de generador que rastrea cuando el generador está agotado. Lo hará utilizando la StopIterationexcepción que arroja un generador cuando llega al final de la iteración.

import types

def generator_wrapper(function=None, **kwargs):
    assert function is not None, "Please supply a function"
    def inner_func(function=function, **kwargs):
        generator = function(**kwargs)
        assert isinstance(generator, types.GeneratorType), "Invalid function"
        try:
            yield next(generator)
        except StopIteration:
            generator = function(**kwargs)
            yield next(generator)
    return inner_func

Como puede ver arriba, cuando nuestra función de contenedor detecta una StopIterationexcepción, simplemente reinicia el objeto generador (utilizando otra instancia de la llamada a la función).

Y luego, suponiendo que defina su función de suministro de generador en algún lugar como se muestra a continuación, podría usar la sintaxis del decorador de funciones de Python para envolverla implícitamente:

@generator_wrapper
def generator_generating_function(**kwargs):
    for item in ["a value", "another value"]
        yield item

Puede definir una función que devuelva su generador

def f():
  def FunctionWithYield(generator_args):
    code here...

  return FunctionWithYield

Ahora puedes hacer tantas veces como quieras:

for x in f()(generator_args): print(x)
for x in f()(generator_args): print(x)

No estoy seguro de qué querías decir con preparación costosa, pero supongo que realmente tienes

data = ... # Expensive computation
y = FunctionWithYield(data)
for x in y: print(x)
#here must be something to reset 'y'
# this is expensive - data = ... # Expensive computation
# y = FunctionWithYield(data)
for x in y: print(x)

Si ese es el caso, ¿por qué no reutilizar data?

No hay opción para restablecer iteradores. El iterador generalmente aparece cuando itera a través de la next()función. La única forma es hacer una copia de seguridad antes de iterar en el objeto iterador. Verifique a continuación.

Crear objeto iterador con elementos del 0 al 9

i=iter(range(10))

Iterando a través de la función next () que aparecerá

print(next(i))

Convertir el objeto iterador a la lista

L=list(i)
print(L)
output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

entonces el elemento 0 ya está desplegado. Además, todos los elementos aparecen cuando convertimos el iterador a la lista.

next(L) 

Traceback (most recent call last):
  File "<pyshell#129>", line 1, in <module>
    next(L)
StopIteration

Por lo tanto, debe convertir el iterador en listas para la copia de seguridad antes de comenzar a iterar. La lista podría convertirse a iterador coniter(<list-object>)

Ahora puede usar more_itertools.seekable(una herramienta de terceros) que permite restablecer iteradores.

Instalar a través de > pip install more_itertools

import more_itertools as mit


y = mit.seekable(FunctionWithYield())
for x in y:
    print(x)

y.seek(0)                                              # reset iterator
for x in y:
    print(x)

Nota: el consumo de memoria crece mientras avanza el iterador, así que tenga cuidado con los iterables grandes.

Puede hacerlo utilizando itertools.cycle () , puede crear un iterador con este método y luego ejecutar un bucle for sobre el iterador que recorrerá sus valores.

Por ejemplo:

def generator():
for j in cycle([i for i in range(5)]):
    yield j

gen = generator()
for i in range(20):
    print(next(gen))

generará 20 números, de 0 a 4 repetidamente.

Una nota de los documentos:

Note, this member of the toolkit may require significant auxiliary storage (depending on the length of the iterable).

Ok, dices que quieres llamar a un generador varias veces, pero la inicialización es costosa ... ¿Qué tal algo como esto?

class InitializedFunctionWithYield(object):
    def __init__(self):
        # do expensive initialization
        self.start = 5

    def __call__(self, *args, **kwargs):
        # do cheap iteration
        for i in xrange(5):
            yield self.start + i

y = InitializedFunctionWithYield()

for x in y():
    print x

for x in y():
    print x

Alternativamente, puede crear su propia clase que siga el protocolo iterador y defina algún tipo de función de 'restablecimiento'.

class MyIterator(object):
    def __init__(self):
        self.reset()

    def reset(self):
        self.i = 5

    def __iter__(self):
        return self

    def next(self):
        i = self.i
        if i > 0:
            self.i -= 1
            return i
        else:
            raise StopIteration()

my_iterator = MyIterator()

for x in my_iterator:
    print x

print 'resetting...'
my_iterator.reset()

for x in my_iterator:
    print x

https://docs.python.org/2/library/stdtypes.html#iterator-types http://anandology.com/python-practice-book/iterators.html

Mi respuesta resuelve un problema ligeramente diferente: si el generador es costoso de inicializar y cada objeto generado es costoso de generar. Pero necesitamos consumir el generador varias veces en múltiples funciones. Para llamar al generador y a cada objeto generado exactamente una vez, podemos usar subprocesos y ejecutar cada uno de los métodos de consumo en diferentes subprocesos. Es posible que no logremos un verdadero paralelismo debido a GIL, pero lograremos nuestro objetivo.

Este enfoque hizo un buen trabajo en el siguiente caso: el modelo de aprendizaje profundo procesa muchas imágenes. El resultado es una gran cantidad de máscaras para muchos objetos en la imagen. Cada máscara consume memoria. Tenemos alrededor de 10 métodos que hacen diferentes estadísticas y métricas, pero toman todas las imágenes a la vez. Todas las imágenes no pueden caber en la memoria. Los métodos pueden reescribirse fácilmente para aceptar el iterador.

class GeneratorSplitter:
'''
Split a generator object into multiple generators which will be sincronised. Each call to each of the sub generators will cause only one call in the input generator. This way multiple methods on threads can iterate the input generator , and the generator will cycled only once.
'''

def __init__(self, gen):
    self.gen = gen
    self.consumers: List[GeneratorSplitter.InnerGen] = []
    self.thread: threading.Thread = None
    self.value = None
    self.finished = False
    self.exception = None

def GetConsumer(self):
    # Returns a generator object. 
    cons = self.InnerGen(self)
    self.consumers.append(cons)
    return cons

def _Work(self):
    try:
        for d in self.gen:
            for cons in self.consumers:
                cons.consumed.wait()
                cons.consumed.clear()

            self.value = d

            for cons in self.consumers:
                cons.readyToRead.set()

        for cons in self.consumers:
            cons.consumed.wait()

        self.finished = True

        for cons in self.consumers:
            cons.readyToRead.set()
    except Exception as ex:
        self.exception = ex
        for cons in self.consumers:
            cons.readyToRead.set()

def Start(self):
    self.thread = threading.Thread(target=self._Work)
    self.thread.start()

class InnerGen:
    def __init__(self, parent: "GeneratorSplitter"):
        self.parent: "GeneratorSplitter" = parent
        self.readyToRead: threading.Event = threading.Event()
        self.consumed: threading.Event = threading.Event()
        self.consumed.set()

    def __iter__(self):
        return self

    def __next__(self):
        self.readyToRead.wait()
        self.readyToRead.clear()
        if self.parent.finished:
            raise StopIteration()
        if self.parent.exception:
            raise self.parent.exception
        val = self.parent.value
        self.consumed.set()
        return val

Uso:

genSplitter = GeneratorSplitter(expensiveGenerator)

metrics={}
executor = ThreadPoolExecutor(max_workers=3)
f1 = executor.submit(mean,genSplitter.GetConsumer())
f2 = executor.submit(max,genSplitter.GetConsumer())
f3 = executor.submit(someFancyMetric,genSplitter.GetConsumer())
genSplitter.Start()

metrics.update(f1.result())
metrics.update(f2.result())
metrics.update(f3.result())

Se puede hacer por objeto de código. Aquí está el ejemplo.

code_str="y=(a for a in [1,2,3,4])"
code1=compile(code_str,'<string>','single')
exec(code1)
for i in y: print i

1 2 3 4

for i in y: print i


exec(code1)
for i in y: print i

1 2 3 4