Behandeln einer Ausnahme in einem generator

Wenn ein generator eine Ausnahme auslöst, wird er beendet. Man kann nicht mehr verbrauchen die Elemente, die es erzeugt.

Beispiel:

>>> def f():
...     yield 1
...     raise Exception
...     yield 2
... 
>>> g = f()
>>> next(g)
1
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in f
Exception
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

Wenn Sie Steuern den generator-code, können Sie die Ausnahme behandeln im inneren des Generators; wenn nicht, sollten Sie versuchen zu vermeiden, eine Ausnahme Auftritt.

InformationsquelleAutor Sven Marnach

Habe ich gebraucht um dieses problem zu lösen, ein paar mal und kam auf diese Frage nach einer Suche nach dem, was andere Menschen getan haben.

Werfen statt Erhöhen

Eine option - das erfordert die Umgestaltung ein wenig - wäre throw Ausnahme in den generator (auf ein anderes error-handling-generator) eher als raise. Hier ist, was das Aussehen könnte:

def read(handler):
    # the handler argument fixes errors/problems separately
    while something():
        try:
            yield something_else()
        except Exception as e:
            handler.throw(e)
    handler.close()

def err_handler():
    # a generator for processing errors
    while True:
        try:
            yield
        except Exception1:
            handle_exc1()
        except Exception2:
            handle_exc2()
        except Exception3:
            handle_exc3()
        except Exception:
            raise

def process():
    handler = err_handler()
    handler.send(None)  # initialize error handler
    for item in read(handler):
        do stuff

Dies ist nicht immer die beste Lösung zu sein, aber es ist sicherlich eine option.

Verallgemeinerte Lösung

Könnten Sie machen alles nur ein bisschen schöner mit einem decorator:

class MyError(Exception):
    pass

def handled(handler):
    """
    A decorator that applies error handling to a generator.

    The handler argument received errors to be handled.

    Example usage:

    @handled(err_handler())
    def gen_function():
        yield the_things()
    """
    def handled_inner(gen_f):
        def wrapper(*args, **kwargs):
            g = gen_f(*args, **kwargs)
            while True:
                try:
                    g_next = next(g)
                except StopIteration:
                    break
                if isinstance(g_next, Exception):
                    handler.throw(g_next)
                else:
                    yield g_next
        return wrapper
    handler.send(None)  # initialize handler
    return handled_inner

def my_err_handler():
    while True:
        try:
            yield
        except MyError:
            print("error  handled")
        # all other errors will bubble up here

@handled(my_err_handler())
def read():
    i = 0
    while i<10:
        try:
            yield i
            i += 1
            if i == 3:
                raise MyError()
        except Exception as e:
            # prevent the generator from closing after an Exception
            yield e

def process():
    for item in read():
        print(item)


if __name__=="__main__":
    process()

Ausgabe:

0
1
2
error  handled
3
4
5
6
7
8
9

Aber der Nachteil ist Sie haben noch zu setzen haben Generika Exception Handhabung im inneren des Generators, erzeugt möglicherweise Fehler. Es ist nicht möglich, dies zu umgehen, da die Anhebung jede exception, die in einem generator zu schließen.

Kernel von einer Idee

Wäre es schön, irgendeine Art yield raise Aussage, die erlaubt, dass der generator weiter läuft, wenn es kann, nachdem der Fehler geworfen wurde. Dann könnten Sie code schreiben:

@handled(my_err_handler())
def read():
    i = 0
    while i<10:
        yield i
        i += 1
        if i == 3:
            yield raise MyError()

...und die handler() Dekorator könnte wie folgt Aussehen:

def handled(handler):
    def handled_inner(gen_f):
        def wrapper(*args, **kwargs):
            g = gen_f(*args, **kwargs)
            while True:
                try:
                    g_next = next(g)
                except StopIteration:
                    break
                except Exception as e:
                    handler.throw(e)
                else:
                    yield g_next
        return wrapper
    handler.send(None)  # initialize handler
    return handled_inner

InformationsquelleAutor Rick Teachey