Redefinindo o objeto gerador em Python

Eu tenho um objeto gerador retornado por vários rendimentos. A preparação para chamar esse gerador é uma operação bastante demorada. É por isso que quero reutilizar o gerador várias vezes.

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

Claro, estou pensando em copiar o conteúdo para uma lista simples. Existe uma maneira de redefinir meu gerador?

Outra opção é usar a itertools.tee()função para criar uma segunda versão do seu gerador:

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

Isso pode ser benéfico do ponto de vista do uso de memória, se a iteração original não puder processar todos os itens.

Geradores não podem ser rebobinados. Você tem as seguintes opções:

1. Execute a função do gerador novamente, reiniciando a geração:

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

2. Armazene os resultados do gerador em uma estrutura de dados na memória ou no disco que você pode iterar novamente:

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

A desvantagem da opção 1 é que ela calcula os valores novamente. Se isso exige muita CPU, você acaba calculando duas vezes. Por outro lado, a desvantagem de 2 é o armazenamento. A lista inteira de valores será armazenada na memória. Se houver muitos valores, isso pode ser impraticável.

Então você tem a troca clássica de memória versus processamento . Não consigo imaginar uma maneira de rebobinar o gerador sem armazenar os valores ou calculá-los novamente.

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

Provavelmente, a solução mais simples é envolver a peça cara em um objeto e passá-la ao gerador:

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

Dessa forma, você pode armazenar em cache os cálculos caros.

Se você puder manter todos os resultados na RAM ao mesmo tempo, use list()para materializar os resultados do gerador em uma lista simples e trabalhe com isso.

Quero oferecer uma solução diferente para um problema antigo

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)

O benefício disso, quando comparado a algo semelhante, list(iterator)é que isso é O(1)complexidade do espaço e list(iterator)é O(n). A desvantagem é que, se você tiver apenas acesso ao iterador, mas não a função que produziu o iterador, não poderá usar esse método. Por exemplo, pode parecer razoável fazer o seguinte, mas não 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)

Se a resposta de GrzegorzOledzki não for suficiente, você provavelmente poderia usar send()para atingir seu objetivo. Consulte PEP-0342 para obter mais detalhes sobre geradores aprimorados e expressões de rendimento.

UPDATE: Veja também itertools.tee(). Envolve parte dessa troca de memória versus processamento mencionada acima, mas pode economizar memória ao armazenar apenas os resultados do gerador em a list; depende de como você está usando o gerador.

Se o seu gerador é puro, no sentido de que sua saída depende apenas dos argumentos passados ​​e do número da etapa, e você deseja que o gerador resultante seja reiniciado, aqui está um trecho de classificação que pode 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))

saídas:

[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

Da documentação oficial do tee :

Em geral, se um iterador usa a maioria ou todos os dados antes de outro iterador iniciar, é mais rápido usar list () em vez de tee ().

Portanto, é melhor usar list(iterable)no seu caso.

Usando uma função de wrapper para manipular StopIteration

Você pode escrever uma função de wrapper simples na função de geração do gerador que rastreia quando o gerador está esgotado. Isso será feito usando a StopIterationexceção que um gerador lança quando atinge o final da iteração.

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 você pode ver acima, quando nossa função wrapper captura uma StopIterationexceção, ela simplesmente reinicializa o objeto gerador (usando outra instância da chamada de função).

E então, supondo que você defina sua função de fornecimento de gerador em algum lugar como abaixo, você pode usar a sintaxe do decorador da função Python para envolvê-la implicitamente:

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

Você pode definir uma função que retorne seu gerador

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

  return FunctionWithYield

Agora você pode fazer quantas vezes quiser:

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

Não sei ao certo o que você quis dizer com preparação cara, mas acho que você realmente

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)

Se for esse o caso, por que não reutilizar data?

Não há opção para redefinir iteradores. O iterador geralmente aparece quando itera através da next()função. A única maneira é fazer um backup antes de iterar no objeto iterador. Confira abaixo.

Criando objeto iterador com itens de 0 a 9

i=iter(range(10))

Iterando através da função next () que será exibida

print(next(i))

Convertendo o objeto iterador na lista

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

então o item 0 já foi exibido. Todos os itens também são exibidos quando convertemos o iterador em lista.

next(L) 

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

Portanto, você precisa converter o iterador em listas para backup antes de começar a iterar. A lista pode ser convertida em iterador comiter(<list-object>)

Agora você pode usar more_itertools.seekable(uma ferramenta de terceiros) que permite redefinir os iteradores.

Instalar via > 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: o consumo de memória aumenta ao avançar o iterador, portanto, tenha cuidado com iteráveis ​​grandes.

Você pode fazer isso usando itertools.cycle (). Você pode criar um iterador com esse método e, em seguida, executar um loop for sobre o iterador, que fará um loop sobre seus valores.

Por exemplo:

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

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

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

Uma observação dos documentos:

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

Ok, você diz que deseja ligar para um gerador várias vezes, mas a inicialização é cara ... E algo assim?

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

Como alternativa, você pode criar sua própria classe que segue o protocolo do iterador e define algum tipo de função 'reset'.

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

Minha resposta resolve um problema ligeiramente diferente: se o gerador é caro para inicializar e cada objeto gerado é caro para gerar. Mas precisamos consumir o gerador várias vezes em várias funções. Para chamar o gerador e cada objeto gerado exatamente uma vez, podemos usar threads e executar cada um dos métodos de consumo em threads diferentes. Podemos não alcançar um verdadeiro paralelismo devido ao GIL, mas alcançaremos nosso objetivo.

Essa abordagem fez um bom trabalho no seguinte caso: o modelo de aprendizado profundo processa muitas imagens. O resultado são muitas máscaras para muitos objetos na imagem. Cada máscara consome memória. Temos cerca de 10 métodos que produzem estatísticas e métricas diferentes, mas eles capturam todas as imagens de uma só vez. Todas as imagens não cabem na memória. Os métodos podem ser reescritos facilmente para aceitar o 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())

Isso pode ser feito por objeto de código. Aqui está o exemplo.

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