Resetowanie obiektu generatora w Pythonie

Generatory nie mogą być odwrócone. Masz następujące opcje:

1. Uruchom ponownie funkcję generatora, restartując generowanie:

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

2. Przechowuj wyniki generatora w strukturze danych na pamięci lub dysku, którą możesz powtórzyć:

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

Minusem opcji 1 jest to, że oblicza wartości ponownie. Jeśli to obciąża procesor, kończysz obliczanie dwa razy. Z drugiej strony minusem 2 jest magazyn. Cała lista wartości zostanie zapisana w pamięci. Jeśli jest zbyt wiele wartości, może to być niepraktyczne.

Więc masz klasyczną pamięć a procesor . Nie wyobrażam sobie sposobu przewijania generatora bez zapisywania wartości lub obliczania ich ponownie.

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

Prawdopodobnie najprostszym rozwiązaniem jest owinięcie kosztownej części w obiekt i przekazanie jej do generatora:

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

Jeśli możesz zachować wszystkie wyniki w pamięci RAM w tym samym czasie, użyj list(), aby zmaterializować wyniki generatora na zwykłej liście i pracować z tym.

Chcę zaproponować inne rozwiązanie starego problemu

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)

Korzyść z tego w porównaniu do czegoś podobnego list(iterator) jest taka, że jest to O(1) złożoność przestrzeni i list(iterator) jest O(n). Wadą jest to, że jeśli masz dostęp tylko do iteratora, ale nie do funkcji, która go wyprodukowała, nie możesz użyć tej metody. Na przykład, może się wydawać rozsądne, aby wykonać następujące czynności, ale to nie zadziała.

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

squares = IterableAdapter(lambda: g)

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

Jeśli odpowiedź Grzegorzoledzkiego nie wystarczy, prawdopodobnie możesz użyć send(), aby osiągnąć swój cel. Zobacz PEP-0342 aby uzyskać więcej szczegółów na temat ulepszonych generatorów i wyrażeń wydajności.

Aktualizacja: Zobacz też itertools.tee(). Wiąże się to z pewną ilością tej pamięci w porównaniu z obróbką wymienioną powyżej, ale to Może zaoszczędzić trochę pamięci, ponieważ samo przechowywanie generatora skutkuje list; zależy to od tego, jak używasz generatora.

Jeśli twój generator jest czysty w tym sensie, że jego wynik zależy tylko od podanych argumentów i numeru kroku, i chcesz, aby generator wynikowy był restartowalny, oto przykładowy fragment, który może być przydatny:

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

Wyjścia:

[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

Możesz zdefiniować funkcję, która zwraca twój generator

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

  return FunctionWithYield

Teraz możesz robić tyle razy, ile chcesz:

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

Z oficjalnej dokumentacji tee :

Ogólnie, jeśli jeden iterator wykorzystuje większość lub wszystkie dane przed uruchamia się kolejny iterator, szybsze jest użycie list () zamiast tee ().

Więc najlepiej użyć list(iterable) zamiast w Twoim przypadku.

Nie ma opcji resetowania iteratorów. Iterator Zwykle wyskakuje, gdy iteracja odbywa się za pomocą funkcji next(). Jedynym sposobem jest zrobienie kopii zapasowej przed iteracją na obiekcie iterator. Sprawdź poniżej.

Tworzenie obiektu iteratora z pozycjami od 0 do 9

i=iter(range(10))

Iteracja przez funkcję next (), która wyskoczy

print(next(i))

Konwersja obiektu iterator do list

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

Więc pozycja 0 już wyskoczyła. Również wszystkie elementy są popped jak my przekonwertował iterator do list.

next(L) 

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

Więc musisz przekonwertować iterator na listy do tworzenia kopii zapasowych przed rozpoczęciem iteracji. Lista może być przekonwertowana do iteratora za pomocą iter(<list-object>)

Możesz teraz użyć more_itertools.seekable (Narzędzie innej firmy), które umożliwia Resetowanie iteratorów.

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

Uwaga: zużycie pamięci rośnie wraz z rozwojem iteratora, więc uważaj na duże iteraby.

Nie jestem pewien, co miałeś na myśli przez drogie preparaty, ale myślę, że rzeczywiście masz

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)

Ok, mówisz, że chcesz zadzwonić do generatora wiele razy, ale inicjalizacja jest kosztowna... A co z czymś takim?

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

Alternatywnie, możesz po prostu stworzyć własną klasę, która podąża za protokołem iteratora i definiuje jakąś funkcję '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

Używanie funkcji wrapper do obsługi StopIteration

Możesz napisać prostą funkcję wrappera do generatora-generującą funkcję, która śledzi, gdy generator jest wyczerpany. Zrobi to za pomocą wyjątku StopIteration, który generator rzuca, gdy osiągnie koniec iteracji.

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

Jak widać powyżej, gdy nasza funkcja wrapper wychwytuje wyjątek StopIteration, po prostu ponownie inicjalizuje obiekt generatora(używając innej instancji wywołania funkcji).

I wtedy, zakładając, że zdefiniuj gdzieś swoją funkcję dostarczającą generator, jak poniżej, możesz użyć składni dekoratora funkcji Pythona, aby zawinąć ją niejawnie:

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

Można to zrobić za pomocą obiektu code. Oto przykład.

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