Concept użyj kolejki blokującej z maxsize=1 i modelem producent / konsument.

Wywołanie zwrotne produkuje, następnie następne połączenie do wywołania zwrotnego zablokuje się w pełnej kolejce.

Konsument następnie zwraca wartość z kolejki, próbuje uzyskać inną wartość i blokuje odczyt.

Użycie:

def dummy(func, arg, callback=None):
  for i in range(100):
    callback(func(arg+i))

# Dummy example:
for i in Iteratorize(dummy, lambda x: x+1, 0):
  print(i)

# example with scipy:
for i in Iteratorize(scipy.optimize.fmin, func, x0):
   print(i)

Może być stosowany zgodnie z oczekiwaniami dla iterator:

for i in take(5, Iteratorize(dummy, lambda x: x+1, 0)):
  print(i)

Klasa iteracyjna:

from thread import start_new_thread
from Queue import Queue

class Iteratorize:
  """ 
  Transforms a function that takes a callback 
  into a lazy iterator (generator).
  """
  def __init__(self, func, ifunc, arg, callback=None):
    self.mfunc=func
    self.ifunc=ifunc
    self.c_callback=callback
    self.q = Queue(maxsize=1)
    self.stored_arg=arg
    self.sentinel = object()

    def _callback(val):
      self.q.put(val)

    def gentask():
      ret = self.mfunc(self.ifunc, self.stored_arg, callback=_callback)
      self.q.put(self.sentinel)
      if self.c_callback:
        self.c_callback(ret)

    start_new_thread(gentask, ())

  def __iter__(self):
    return self

  def next(self):
    obj = self.q.get(True,None)
    if obj is self.sentinel:
     raise StopIteration 
    else:
      return obj

Może prawdopodobnie zrobić z pewnym czyszczeniem, aby zaakceptować *args i **kwargs dla funkcji zawijanej i / lub wywołania zwrotnego wyniku końcowego.

Generator jako koroutine (bez gwintowania)

Niech FakeFtp z retrbinary funkcją wywołującą wywołanie zwrotne przy każdym pomyślnym odczycie fragmentu danych:

class FakeFtp(object):
    def __init__(self):
        self.data = iter(["aaa", "bbb", "ccc", "ddd"])

    def login(self, user, password):
        self.user = user
        self.password = password

    def retrbinary(self, cmd, cb):
        for chunk in self.data:
            cb(chunk)

Używanie prostej funkcji callback ma wadę, że jest wywoływana wielokrotnie, a callback funkcja nie może łatwo zachować kontekstu między wywołaniami.

Poniższy kod definiuje generator process_chunks, który będzie mógł odbierać fragmenty danych jeden przez jednego i przetwarzając je. W przeciwieństwie do prostego wywołania zwrotnego, tutaj jesteśmy w stanie zachować wszystkie przetwarzanie w ramach jednej funkcji bez utraty kontekstu.

from contextlib import closing
from itertools import count


def main():
    processed = []

    def process_chunks():
        for i in count():
            try:
                # (repeatedly) get the chunk to process
                chunk = yield
            except GeneratorExit:
                # finish_up
                print("Finishing up.")
                return
            else:
                # Here process the chunk as you like
                print("inside coroutine, processing chunk:", i, chunk)
                product = "processed({i}): {chunk}".format(i=i, chunk=chunk)
                processed.append(product)

    with closing(process_chunks()) as coroutine:
        # Get the coroutine to the first yield
        coroutine.next()
        ftp = FakeFtp()
        # next line repeatedly calls `coroutine.send(data)`
        ftp.retrbinary("RETR binary", cb=coroutine.send)
        # each callback "jumps" to `yield` line in `process_chunks`

    print("processed result", processed)
    print("DONE")

Aby zobaczyć kod w akcji, umieść klasę FakeFtp, kod pokazany powyżej i następujący wiersz:

main()

Do jednego pliku i nazwij go:

$ python headsandtails.py
('inside coroutine, processing chunk:', 0, 'aaa')
('inside coroutine, processing chunk:', 1, 'bbb')
('inside coroutine, processing chunk:', 2, 'ccc')
('inside coroutine, processing chunk:', 3, 'ddd')
Finishing up.
('processed result', ['processed(0): aaa', 'processed(1): bbb', 'processed(2): ccc', 'processed(3): ddd'])
DONE

Jak to działa

processed = [] jest tu tylko po to, aby pokazać, że generator process_chunks nie będzie miał problemów z współpraca z jego zewnętrznym kontekstem. Wszystko jest owinięte w def main():, aby udowodnić, że nie ma potrzeby użyj globalnego zmienne.

def process_chunks() jest podstawą rozwiązania. Może mieć parametry wejściowe jednego strzału (nie użyte tutaj), ale głównym punktem, w którym odbiera dane wejściowe jest każda linia yield zwracająca to, co ktoś wysyła poprzez {[14] } do instancji tego generatora. Można coroutine.send(chunk), ale w tym przykładzie odbywa się to poprzez wywołanie zwrotne odwołujące się do tej funkcji callback.send.

Zauważ, że w realnym rozwiązaniu nie ma problemu, aby w kodzie było wiele yields, są to przetwarzane jeden po drugim. Można to wykorzystać np. do odczytać (i zignorować) nagłówek pliku CSV, a następnie Kontynuuj przetwarzanie rekordów z danymi.

coroutine = process_chunks()
# Get the coroutine to the first yield
coroutine.next()

ftp = FakeFtp()
# next line repeatedly calls `coroutine.send(data)`
ftp.retrbinary("RETR binary", cb=coroutine.send)
# each callback "jumps" to `yield` line in `process_chunks`

# close the coroutine (will throw the `GeneratorExit` exception into the
# `process_chunks` coroutine).
coroutine.close()

Prawdziwy kod używa contextlib closing context manager, aby zapewnić, że coroutine.close() jest zawsze dzwoniłem.

Wnioski

To rozwiązanie nie zapewnia iteratora do zużywania danych w tradycyjnym stylu " z Na Zewnątrz". Z drugiej strony, jesteśmy w stanie:

• użyj generatora " z inside "
• zachowaj całe przetwarzanie iteracyjne w ramach jednej funkcji bez przerywania między wywołaniami zwrotnymi
• opcjonalnie użyj kontekstu zewnętrznego
• podaj użyteczne wyniki na zewnątrz
• wszystko to można zrobić bez użycia gwintowania

Credits : rozwiązanie jest mocno inspirowane przez SO answer Python FTP" chunk " iterator (bez ładowania całego pliku do pamięci) napisane przez user2357112

A może

data = []
scipy.optimize.fmin(func,x0,callback=data.append)
for line in data:
    print line

Jeśli nie, to co dokładnie chcesz zrobić z danymi generatora?