Was ist die "Ausbeute" Stichwort?

Zu verstehen, was yield funktioniert, müssen Sie verstehen, was Generatoren sind. Und bevor Sie verstehen können, Generatoren, müssen Sie verstehen iterables.

Iterables

Wenn Sie eine Liste erstellen, können Sie Lesen Sie die Elemente nacheinander. Die Lektüre seiner Elemente nacheinander aufgerufen iteration:

>>> mylist = [1, 2, 3]
>>> for i in mylist:
...    print(i)
1
2
3

mylist ist ein iterierbar. Wenn Sie eine Liste verwenden, Verständnis, erstellen Sie eine Liste, und so durchsuchbar:

>>> mylist = [x*x for x in range(3)]
>>> for i in mylist:
...    print(i)
0
1
4

Alles, was Sie können "for... in...", ist eine der iterierbar; lists, strings Dateien...

Diese iterables sind praktisch, da Sie Sie Lesen kann, so viel wie Sie wollen, aber Sie speichern alle Werte im Speicher, und dies ist nicht immer, was Sie wollen, wenn Sie haben eine Menge von Werten.

Generatoren

Generatoren Iteratoren, eine Art durchsuchbar können Sie nur Durchlaufen, sobald. Generatoren nicht speichern aller Werte im Speicher, , die Sie generieren, werden die Werte on-the-fly:

>>> mygenerator = (x*x for x in range(3))
>>> for i in mygenerator:
...    print(i)
0
1
4

Ist es genau das gleiche, außer Sie verwendet () statt []. ABER Sie nicht durchführen for i in mygenerator ein zweites mal, da die Erzeuger können nur einmal verwendet werden: berechnen Sie 0 ist, dann vergessen Sie es und berechnen 1, - und end-Berechnung 4, eins nach dem anderen.

Ertrag

yield ist ein Schlüsselwort, das verwendet wird, wie return, außer die Funktion gibt einen generator.

>>> def createGenerator():
...    mylist = range(3)
...    for i in mylist:
...        yield i*i
...
>>> mygenerator = createGenerator() # create a generator
>>> print(mygenerator) # mygenerator is an object!
<generator object createGenerator at 0xb7555c34>
>>> for i in mygenerator:
...     print(i)
0
1
4

Hier ist es ein nutzloses Beispiel, aber es ist praktisch, wenn Sie wissen, dass Ihre Funktion gibt eine riesige Menge von Werten, Sie müssen nur einmal gelesen werden.

Master yield müssen Sie verstehen, dass wenn Sie die Funktion aufrufen, den code, den Sie geschrieben haben, im Hauptteil der Funktion nicht ausgeführt. Die Funktion gibt nur die generator-Objekt, das ist ein bisschen tricky 🙂

Dann, Ihr code wird weiterhin von wo es aufgehört hat jedes mal for verwendet der generator.

Jetzt der schwierige Teil:

Ersten mal die for ruft der generator-Objekt erstellt aus Ihrer Funktion führen Sie den code in Ihrer Funktion von den Anfängen bis es trifft yield, dann werde zurückkehren den ersten Wert aus der Schleife. Dann, jeder weitere Anruf wird ausgeführt, die Schleife, die Sie geschrieben haben in die Funktion ein weiteres mal, und kehren Sie den nächsten Wert, bis es kein Wert zurückgeben.

Der generator gilt als leer, sobald die Funktion läuft, aber nicht trifft yield mehr. Es kann sein, weil die Schleife hatte zu einem Ende kommen, oder weil Sie nicht erfüllen, eine "if/else" mehr.

---

Dein code erklärt

Generator:

# Here you create the method of the node object that will return the generator
def _get_child_candidates(self, distance, min_dist, max_dist):

    # Here is the code that will be called each time you use the generator object:

    # If there is still a child of the node object on its left
    # AND if distance is ok, return the next child
    if self._leftchild and distance - max_dist < self._median:
        yield self._leftchild

    # If there is still a child of the node object on its right
    # AND if distance is ok, return the next child
    if self._rightchild and distance + max_dist >= self._median:
        yield self._rightchild

    # If the function arrives here, the generator will be considered empty
    # there is no more than two values: the left and the right children

Anrufer:

# Create an empty list and a list with the current object reference
result, candidates = list(), [self]

# Loop on candidates (they contain only one element at the beginning)
while candidates:

    # Get the last candidate and remove it from the list
    node = candidates.pop()

    # Get the distance between obj and the candidate
    distance = node._get_dist(obj)

    # If distance is ok, then you can fill the result
    if distance <= max_dist and distance >= min_dist:
        result.extend(node._values)

    # Add the children of the candidate in the candidates list
    # so the loop will keep running until it will have looked
    # at all the children of the children of the children, etc. of the candidate
    candidates.extend(node._get_child_candidates(distance, min_dist, max_dist))

return result

Dieser code enthält einige smart parts:

• Die Schleife iteriert über eine Liste, aber die Liste erweitert, während die Schleife wird Durchlaufen 🙂 Es ist ein prägnant Weg zu gehen durch alle diese verschachtelten Daten, auch wenn es ein bisschen gefährlich, da können Sie am Ende mit einer unendlichen Schleife. In diesem Fall candidates.extend(node._get_child_candidates(distance, min_dist, max_dist)) erschöpft alle Werte des Generators, aber while hält die Schaffung neuer generator-Objekte zu erstellen, die unterschiedliche Werte von den vorherigen, da Sie nicht angewendet, die auf demselben Knoten.

• Den extend() Methode ist ein list-Objekt-Methode, die erwartet, dass ein durchsuchbar und fügt seine Werte in die Liste.

In der Regel passieren wir eine Liste:

>>> a = [1, 2]
>>> b = [3, 4]
>>> a.extend(b)
>>> print(a)
[1, 2, 3, 4]

Aber in deinem code wird es einen generator an, der ist gut, weil:

1. Sie nicht brauchen, um Lesen Sie die Werte ab zweimal.
2. Können Sie eine Menge von Kindern, und Sie nicht wollen, dass Sie alle im Speicher gespeichert.

Und es funktioniert, weil Python nicht darum, ob das argument der Methode ist eine Liste oder nicht. Python erwartet iterables so funktioniert es mit strings, Listen, Tupeln und Generatoren! Dies wird als duck typing und ist einer der Gründe, warum Python ist so cool. Aber das ist eine andere Geschichte, eine andere Frage...

Können Sie hier aufhören, oder Lesen Sie ein wenig, um zu sehen, eine erweiterte Verwendung von einem generator:

Controlling a generator Erschöpfung

>>> class Bank(): # Let's create a bank, building ATMs
...    crisis = False
...    def create_atm(self):
...        while not self.crisis:
...            yield "$100"
>>> hsbc = Bank() # When everything's ok the ATM gives you as much as you want
>>> corner_street_atm = hsbc.create_atm()
>>> print(corner_street_atm.next())
$100
>>> print(corner_street_atm.next())
$100
>>> print([corner_street_atm.next() for cash in range(5)])
['$100', '$100', '$100', '$100', '$100']
>>> hsbc.crisis = True # Crisis is coming, no more money!
>>> print(corner_street_atm.next())
<type 'exceptions.StopIteration'>
>>> wall_street_atm = hsbc.create_atm() # It's even true for new ATMs
>>> print(wall_street_atm.next())
<type 'exceptions.StopIteration'>
>>> hsbc.crisis = False # The trouble is, even post-crisis the ATM remains empty
>>> print(corner_street_atm.next())
<type 'exceptions.StopIteration'>
>>> brand_new_atm = hsbc.create_atm() # Build a new one to get back in business
>>> for cash in brand_new_atm:
...    print cash
$100
$100
$100
$100
$100
$100
$100
$100
$100
...

Hinweis: Für Python 3 verwenden Sieprint(corner_street_atm.__next__()) oder print(next(corner_street_atm))

Kann es sinnvoll sein, für verschiedene Dinge wie die Steuerung des Zugriffs auf eine Ressource.

Itertools, Ihre beste Freundin

Dem itertools-Modul enthält spezielle Funktionen zum Bearbeiten von iterables. Immer verdoppeln möchten, einen generator?
Kette zwei Generatoren? Gruppe von Werten in einer verschachtelten Liste mit einem one-liner? Map /Zip ohne die Schaffung einer anderen Liste?

Dann nur import itertools.

Beispiel? Lassen Sie uns sehen, die mögliche Ordnungen der Ankunft für eine vier-Pferderennen:

>>> horses = [1, 2, 3, 4]
>>> races = itertools.permutations(horses)
>>> print(races)
<itertools.permutations object at 0xb754f1dc>
>>> print(list(itertools.permutations(horses)))
[(1, 2, 3, 4),
 (1, 2, 4, 3),
 (1, 3, 2, 4),
 (1, 3, 4, 2),
 (1, 4, 2, 3),
 (1, 4, 3, 2),
 (2, 1, 3, 4),
 (2, 1, 4, 3),
 (2, 3, 1, 4),
 (2, 3, 4, 1),
 (2, 4, 1, 3),
 (2, 4, 3, 1),
 (3, 1, 2, 4),
 (3, 1, 4, 2),
 (3, 2, 1, 4),
 (3, 2, 4, 1),
 (3, 4, 1, 2),
 (3, 4, 2, 1),
 (4, 1, 2, 3),
 (4, 1, 3, 2),
 (4, 2, 1, 3),
 (4, 2, 3, 1),
 (4, 3, 1, 2),
 (4, 3, 2, 1)]

Verständnis der inneren Mechanismen der iteration

Iteration ist ein Prozess impliziert iterables (Umsetzung der __iter__() - Methode) und Iteratoren (Umsetzung der __next__() - Methode).
Iterables sind alle Objekte, die Sie bekommen können, einen iterator aus. Iteratoren sind Objekte, mit denen Sie umzusetzen, iterables.

Gibt es mehr darüber in diesem Artikel über wie for - Schleifen arbeiten.

InformationsquelleAutor e-satis

Denken Sie an es auf diese Weise:

Ein iterator ist ein schicker klingenden Begriff für ein Objekt, das eine next() Methode. So eine Ausbeute-ed-Funktion endet als so etwas wie dieses:

Original version:

def some_function():
    for i in xrange(4):
        yield i

for i in some_function():
    print i

Dies ist im Grunde das, was der Python-interpreter nicht mit dem obigen code:

class it:
    def __init__(self):
        # Start at -1 so that we get 0 when we add 1 below.
        self.count = -1

    # The __iter__ method will be called once by the 'for' loop.
    # The rest of the magic happens on the object returned by this method.
    # In this case it is the object itself.
    def __iter__(self):
        return self

    # The next method will be called repeatedly by the 'for' loop
    # until it raises StopIteration.
    def next(self):
        self.count += 1
        if self.count < 4:
            return self.count
        else:
            # A StopIteration exception is raised
            # to signal that the iterator is done.
            # This is caught implicitly by the 'for' loop.
            raise StopIteration

def some_func():
    return it()

for i in some_func():
    print i

Für mehr Einblick, was hinter den kulissen geschieht, die for - Schleife umgeschrieben werden kann zu:

iterator = some_func()
try:
    while 1:
        print iterator.next()
except StopIteration:
    pass

Macht das mehr Sinn machen, oder nur verwirren Sie mehr? 🙂

Sollte ich beachten Sie, dass diese ist eine starke Vereinfachung der Veranschaulichung. 🙂

InformationsquelleAutor Jason Baker

Was bedeutet die yield Schlüsselwort do in Python?

Beantworten Gliederung/Inhaltsangabe

• Eine Funktion mit Ertrag, wenn Sie aufgerufen werden, gibt eine Generator.
• Generatoren Iteratoren, weil Sie die Anwendung der iterator-Protokoll, so dass Sie können Durchlaufen.
• Ein generator auch gesendeten Informationen, so dass es konzeptionell ein coroutine.
• In Python 3 können Sie delegieren von einem generator zum anderen in beiden Richtungen mit yield from.
• (Anhang Kritiken ein paar Antworten, einschließlich des oberen ein, und behandelt die Verwendung von return in einem generator.)

Generatoren:

yield ist nur zulässig innerhalb einer Funktionsdefinition, und die Einbeziehung von yield in die definition einer Funktion macht es wieder einen generator an.

Die Idee für Generatoren kommt aus anderen Sprachen (siehe Fußnote 1) mit unterschiedlichen Implementierungen. In Python Generatoren, die die Ausführung des Codes ist eingefroren an der Stelle, von der Ausbeute. Wenn der generator aufgerufen wird (Methoden werden weiter unten erläutert), die Ausführung und dann friert bei der nächsten yield.

yield bietet eine
einfach Weg von die Implementierung der iterator-Protokoll, definiert durch die folgenden zwei Methoden:
__iter__ und next (Python 2) oder __next__ (Python 3). Diese beiden Methoden
ein Objekt einen iterator, könnten Sie Typ-check mit der Iterator Abstrakte Basisklasse
Klasse aus der collections Modul.

>>> def func():
...     yield 'I am'
...     yield 'a generator!'
... 
>>> type(func)                 # A function with yield is still a function
<type 'function'>
>>> gen = func()
>>> type(gen)                  # but it returns a generator
<type 'generator'>
>>> hasattr(gen, '__iter__')   # that's an iterable
True
>>> hasattr(gen, 'next')       # and with .next (.__next__ in Python 3)
True                           # implements the iterator protocol.

Den generator-Typ ist ein Subtyp des Datentyps iterator:

>>> import collections, types
>>> issubclass(types.GeneratorType, collections.Iterator)
True

Und, wenn nötig, können wir Typ-überprüfung wie diese:

>>> isinstance(gen, types.GeneratorType)
True
>>> isinstance(gen, collections.Iterator)
True

Eine Funktion eines Iterator ist, dass einmal erschöpft, können Sie nicht wiederverwenden, oder es zurücksetzen:

>>> list(gen)
['I am', 'a generator!']
>>> list(gen)
[]

Musst du anderes machen, wenn Sie wollen, zu verwenden, seine Funktionalität wieder (siehe Fußnote 2):

>>> list(func())
['I am', 'a generator!']

Kann man die Ertragsdaten programmgesteuert, beispielsweise:

def func(an_iterable):
    for item in an_iterable:
        yield item

Den oben genannten einfachen generator entspricht auch der unter - wie der Python 3.3 (und nicht in Python 2), die Sie verwenden können,Ertrag:

def func(an_iterable):
    yield from an_iterable

Jedoch yield from ermöglicht auch die delegation subgenerators,
das wird im folgenden Abschnitt erläutert auf kooperative delegation mit sub-Coroutinen.

Coroutinen:

yield Formen einen Ausdruck, der es erlaubt, Daten an den generator (siehe Fußnote 3)

Hier ist ein Beispiel, beachten Sie die received variable, die die Daten, die gesendet wird, um den generator:

def bank_account(deposited, interest_rate):
    while True:
        calculated_interest = interest_rate * deposited 
        received = yield calculated_interest
        if received:
            deposited += received


>>> my_account = bank_account(1000, .05)

Zuerst müssen wir Schlange der generator mit der builtin-Funktion, next. Es wird
rufen Sie die entsprechende next oder __next__ Methode, abhängig von der version der
Python:

>>> first_year_interest = next(my_account)
>>> first_year_interest
50.0

Und jetzt können wir das senden von Daten in den generator. (Senden None
das gleiche wie der Aufruf von next.) :

>>> next_year_interest = my_account.send(first_year_interest + 1000)
>>> next_year_interest
102.5

Genossenschaft Delegation, Sub-Koroutine mit yield from

Nun, daran erinnern, dass yield from ist in Python 3. Dies ermöglicht es uns zu delegieren
Coroutinen zu einem subcoroutine:

def money_manager(expected_rate):
    under_management = yield     # must receive deposited value
    while True:
        try:
            additional_investment = yield expected_rate * under_management 
            if additional_investment:
                under_management += additional_investment
        except GeneratorExit:
            '''TODO: write function to send unclaimed funds to state'''
        finally:
            '''TODO: write function to mail tax info to client'''


def investment_account(deposited, manager):
    '''very simple model of an investment account that delegates to a manager'''
    next(manager) # must queue up manager
    manager.send(deposited)
    while True:
        try:
            yield from manager
        except GeneratorExit:
            return manager.close()

Und jetzt können wir das delegieren von Funktionalität zu einem sub-generator, und es kann verwendet werden,
durch einen generator-nur wie oben:

>>> my_manager = money_manager(.06)
>>> my_account = investment_account(1000, my_manager)
>>> first_year_return = next(my_account)
>>> first_year_return
60.0
>>> next_year_return = my_account.send(first_year_return + 1000)
>>> next_year_return
123.6

Lesen Sie mehr über die präzise Semantik von yield from im PEP 380.

Anderen Methoden: schließen und werfen

Den close - Methode löst GeneratorExit an dem Punkt der Funktion
die Ausführung war gefroren. Diese wird auch aufgerufen werden, indem Sie __del__ so dass Sie
können alle cleanup-code, wo Sie behandeln die GeneratorExit:

>>> my_account.close()

Können Sie auch werfen eine exception, die behandelt werden können, in den generator
oder propagiert zurück an den Benutzer:

>>> import sys
>>> try:
...     raise ValueError
... except:
...     my_manager.throw(*sys.exc_info())
... 
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
  File "<stdin>", line 2, in <module>
ValueError

Abschluss

Ich glaube, ich habe alle Gesichtspunkte, die folgende Frage:

Was bedeutet die yield Schlüsselwort do in Python?

Es stellt sich heraus, dass yield nicht viel. Ich bin sicher, ich könnte noch mehr
Gründliche Beispiele. Wenn Sie mehr wollen oder haben einige Konstruktive Kritik, lasst es mich wissen durch Kommentare
unten.

---

Anhang:

Kritik von Oben/Akzeptierte Antwort**

• Es ist verwirrt, was macht ein iterierbar, nur mit einer Liste als Beispiel. Siehe meine Verweise oben, aber in der Zusammenfassung: ein iterierbar hat eine __iter__ Methode zurückgeben iterator. Ein iterator bietet eine .next (Python 2 oder .__next__ (Python 3) - Methode, die implizit genannt, indem for Schleifen, bis es wirft StopIteration, und sobald es tut, wird es auch weiterhin tun.
• Es verwendet dann einen generator-Ausdruck, um zu beschreiben, was für ein generator ist. Da ein generator ist einfach eine bequeme Möglichkeit zum erstellen einer iterator, es verwirrt nur die Sache und wir haben immer noch noch nicht gekommen, um die yield Teil.
• In Controlling a generator Erschöpfung er ruft die .next Methode, wenn er stattdessen sollten die builtin-Funktion next. Es wäre eine entsprechende Dereferenzierung, weil sein code nicht funktioniert in Python 3.
• Itertools? Dies war nicht relevant, was yield nicht an alle.
• Keine Diskussion über die Methoden, die yield bietet zusammen mit der neuen Funktionalität yield from in Python 3. Oben/akzeptierte Antwort ist eine sehr unvollständige Antwort.

Kritik an der Antwort, die darauf hindeutet yield in einen generator-Ausdruck oder Verständnis.

Die Grammatik erlaubt derzeit eines Ausdrucks in einer Liste erfassen.

expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) |
                     ('=' (yield_expr|testlist_star_expr))*)
...
yield_expr: 'yield' [yield_arg]
yield_arg: 'from' test | testlist

Seit Ausbeute ist ein Ausdruck, es wurde angepriesen von einigen als interessant für die Nutzung in Verstehens-oder generator-Ausdruck - trotz der Anführungen kein besonders guter Anwendungsfall.

Den CPython-core-Entwickler sind diskutieren abwertend seine Zulage.
Hier ist ein relevanter Beitrag aus der mailing-Liste:

Am 30. Januar 2017 um 19:05, Brett Cannon schrieb:

On Sun, 29 Jan 2017 um 16:39 Craig Rodrigues schrieb:

Ich bin OK mit dem einen Ansatz. Wenn wir die Dinge so wie Sie sind in Python 3
ist keine gute, IMHO.

Meine Stimme ist es ein SyntaxError, da Sie nicht das bekommen, was Sie von uns erwarten
der syntax.

Ich würde Zustimmen, dass das ein vernünftiger Ort für uns, um am Ende, als jeder code
unter Berufung auf das aktuelle Verhalten ist wirklich zu klug zu sein
wartbar.

In Bezug auf die Anreise, wir werden wahrscheinlich möchten:

• SyntaxWarning oder DeprecationWarning in 3,7
• Py3k Warnung in 2.7.x
• SyntaxError in 3,8

Prost, Nick.

-- Nick Coghlan | ncoghlan an gmail.com | Brisbane, Australien

Weiter, es ist ein offene Frage (10544), die scheint zu sein, zeigt in die Richtung dieser nie eine gute Idee (PyPy, Python-Implementierung in Python geschrieben, ist bereits die Anhebung syntax Warnungen.)

Unteren Zeile, bis die Entwickler von CPython uns etwas anderes sagen: nicht setzen yield in einen generator-Ausdruck oder Verständnis.

Die return - Anweisung in einem generator

In Python 2:

In einer generator-Funktion, die return - Anweisung ist nicht zulässig, eine expression_list. In diesem Zusammenhang, eine bloße return zeigt an, dass der generator ist fertig und wird Ursache StopIteration angehoben werden.

Einer expression_list ist im Grunde eine beliebige Anzahl von Ausdrücken, die durch Komma getrennt - im wesentlichen in Python 2, stoppen Sie den generator mit return, aber Sie können nicht einen Wert zurückgeben.

In Python 3:

In einer generator-Funktion, die return - Anweisung zeigt an, daß der generator ist fertig und wird Ursache StopIteration angehoben werden. Der Rückgabewert (falls vorhanden) ist nicht als argument zu konstruieren StopIteration und wird die StopIteration.value Attribut.

Fußnoten

1. _{Sprachen CLU, Sather, und das Symbol waren auf die in dem Vorschlag
   Einführung das Konzept der Generatoren zu Python. Die Allgemeine Idee ist
   dass eine Funktion aufrechterhalten kann, den internen Zustand und den Ertrag intermediate
   Datenpunkte, die auf Nachfrage durch den Benutzer. Dieser versprach überlegen in der Leistung
   auf andere Ansätze, einschließlich Python threading, die nicht auch verfügbar auf einigen Systemen.}

2. _{Das bedeutet zum Beispiel, dass xrange Objekte (range in Python 3) nicht Iterators, obwohl Sie sind durchsuchbar, da Sie wiederverwendet werden können. Wie Listen, Ihre __iter__ Methoden zurück, iterator-Objekte.}

3. 
   _{yield wurde ursprünglich eingeführt, als eine Aussage, was bedeutet, dass es
   konnte nur am Anfang einer Zeile in einem code-block.
   Jetzt yield schafft eine Ausbeute Ausdruck.
   https://docs.python.org/2/reference/simple_stmts.html#grammar-token-yield_stmt
   Diese änderung wurde vorgeschlagen, um es einem Benutzer erlauben, Daten zu senden, in den generator nur als
   man könnte es erhalten haben. Um Daten zu senden, muss man in der Lage sein, ordnen Sie es mit etwas, und
   für eine Aussage will einfach nicht funktionieren.}

InformationsquelleAutor Aaron Hall

Gibt ' s eine zusätzliche Sache zu erwähnen: eine Funktion, die Erträge tatsächlich nicht zur Kündigung. Ich habe code geschrieben wie diese:

def fib():
    last, cur = 0, 1
    while True: 
        yield cur
        last, cur = cur, last + cur

Dann kann ich in anderen code wie folgt:

for f in fib():
    if some_condition: break
    coolfuncs(f);

Es hilft wirklich vereinfachen einige Probleme, und macht einige Dinge einfacher, mit zu arbeiten.

InformationsquelleAutor Claudiu

TL;DR

Statt:

def square_list(n):
    the_list = []                         # Replace
    for x in range(n):
        y = x * x
        the_list.append(y)                # these
    return the_list                       # lines

hierzu:

def square_yield(n):
    for x in range(n):
        y = x * x
        yield y                           # with this one.

Wann immer Sie sich finden, bauen Sie eine Liste von Grund auf neu yield jedes Stück statt.

Dies war mein erstes "aha" - moment mit der Ausbeute.

---

yield ist ein zuckerhaltige Art und Weise zu sagen

bauen eine Reihe von Sachen, die

Gleiche Verhalten:

>>> for square in square_list(4):
...     print(square)
...
0
1
4
9
>>> for square in square_yield(4):
...     print(square)
...
0
1
4
9

Anderes Verhalten:

Ausbeute ist single-pass -: Sie können nur einmal Durchlaufen. Wenn eine Funktion hat, eine Rendite in der it nennen wir es generator Funktion. Und ein iterator ist, was es gibt. Diese Begriffe sind aufschlussreich. Wir verlieren den Komfort eines Containers, aber die Kraft gewinnen, eine Serie, die ist so berechnet, als nötig, und das beliebig lange.

Ausbeute ist faul, es bringt aus Berechnung. Eine Funktion mit einem Ertrag in es nicht tatsächlich ausgeführt, wenn Sie aufgerufen werden. Es gibt ein iterator-Objekt , merkt sich wo er aufgehört hat. Jedes mal, wenn Sie anrufen next() auf den iterator (dies geschieht in einer for-Schleife) Ausführung Zentimeter vorwärts zum nächsten yield. return wirft StopIteration und endet die Serie (das ist das Natürliche Ende einer for-Schleife).

Ausbeute ist vielseitig. Daten, die nicht gespeichert werden müssen, alle zusammen, kann verfügbar gemacht werden, ein zu einer Zeit. Es kann unendlich sein.

>>> def squares_all_of_them():
...     x = 0
...     while True:
...         yield x * x
...         x += 1
...
>>> squares = squares_all_of_them()
>>> for _ in range(4):
...     print(next(squares))
...
0
1
4
9

---

Wenn Sie brauchen, mehrere Pässe und die Serie ist auch nicht zu lang, einfach anrufen list():

>>> list(square_yield(4))
[0, 1, 4, 9]

---

Brillante Wahl des Wortes yield weil beide Bedeutungen gelten:

Ertrag — produzieren oder zu liefern (wie in der Landwirtschaft)

...bieten die nächsten Daten der Serie.

Ertrag — nachgeben oder verzichten (wie in der politischen macht)

...verzichten CPU-Ausführung, bis der iterator Fortschritte.

InformationsquelleAutor Bob Stein

Es ist die Rückkehr eines Generators. Ich bin nicht besonders vertraut mit Python, aber ich glaube, es ist die gleiche Art der Sache als C#'s iterator-Blöcke wenn Sie vertraut mit diesen.

Die zentrale Idee ist, dass der compiler/interpreter/whatever, macht ein paar Tricks, so dass, wie weit da der Anrufer ist besorgt, Sie können halten Aufruf next() und es wird immer wieder Werte - , als ob der generator-Methode angehalten wurde. Nun man kann natürlich nicht wirklich "pause" eine Methode, damit der compiler baut eine state machine für Sie zu erinnern, wo Sie gerade sind und was die lokalen Variablen etc Aussehen. Dies ist viel einfacher als das schreiben einer iterator selbst.

InformationsquelleAutor Jon Skeet

Hier ist ein Beispiel im Klartext. Ich werde eine Korrespondenz zwischen high-level-menschlichen Konzepten zu low-level-Python-Konzepte.

Möchte ich den Betrieb auf einer Reihe von zahlen, aber ich will nicht stören, mein selbst mit der Erstellung dieser Sequenz, ich will nur den Fokus auf den Betrieb, die ich tun will. Also, ich Tue das folgende:

• Ich Sie anrufen und sagen, ich möchte eine Sequenz von zahlen, die produziert wird, in einer bestimmten Weise, und ich lasse Sie wissen, was der Algorithmus ist.
  
  Dieser Schritt entspricht defining der generator-Funktion, d.h. die Funktion mit einem yield.
• Irgendwann später, ich Sag dir, "OK, machen Sie sich bereit, mir zu sagen, die Reihenfolge der zahlen".
  
  Dieser Schritt entspricht dem Aufruf der generator-Funktion, die gibt ein generator-Objekt. Beachten Sie, dass Sie Sag mir nicht, die zahlen doch noch, greifen Sie einfach Ihr Papier und Bleistift.
• Ich bitte Sie, "sagen Sie mir die nächste Zahl", und Sie sagen mir, die erste Reihe; nach, dass Sie warten, für mich um Sie bitten, für die nächste Nummer. Es ist Ihre Aufgabe zu erinnern, wo Sie waren, welche zahlen Sie haben bereits gesagt, und was ist die nächste Nummer. Ich kümmern sich nicht um die details.
  
  Dieser Schritt entspricht dem aufrufen .next() auf die generator-Objekt.
• ... wiederholen Sie den vorherigen Schritt, bis...
• schließlich, Sie könnte zu einem Ende kommen. Sie brauchen mir nicht zu sagen, eine Zahl, Sie nur Schreien, "halten Sie Ihre Pferde! Ich bin fertig! Nicht mehr zahlen!"
  
  Dieser Schritt entspricht dem generator-Objekt und beendet Ihre Arbeit, und heben Sie ein StopIteration Ausnahme Der generator-Funktion nicht benötigen, heben Sie die Ausnahme. Es wird automatisch angehoben, wenn die Funktion endet, oder die Probleme, die eine return.

Dies ist, was ein generator ist (eine Funktion, die enthält eine yield); es beginnt mit der Ausführung, Pausen, Wann immer es tut yield, und wenn Sie aufgefordert werden, eine .next() Wert es geht an der Stelle weiter, es war die Letzte. Es passt perfekt von design mit dem iterator-Protokoll von Python, die beschreibt, wie nacheinander Anfrage Werte.

Den bekanntesten Benutzer des iterator-Protokolls ist die for Befehl in Python. Also, wenn Sie tun, ein:

for item in sequence:

ist es egal, ob sequence ist eine Liste, ein string, ein Wörterbuch oder einen generator, der Objekt wie oben beschrieben; das Ergebnis ist das gleiche: Sie Lesen Artikel aus einer Abfolge eins nach dem anderen.

Beachten Sie, dass defining eine Funktion, die enthält eine yield Schlüsselwort ist nicht der einzige Weg, um einen generator erzeugen; es ist nur der einfachste Weg, um eine zu erstellen.

Für genauere Informationen Lesen über iterator-Typen, die yield-Anweisung und Generatoren in der Python-Dokumentation.

InformationsquelleAutor tzot

Es ist ein weiterer yield Verwendung und Bedeutung (seit Python 3.3):

yield from <expr>

Vom PEP 380 -- Syntax für die übertragung an einen Subgenerator:

Einen syntax wird vorgeschlagen, für einen generator, der delegieren einen Teil Ihrer Operationen zu einem anderen generator. Dies ermöglicht eine code-Abschnitt, der mit 'Ertrag' zu werden ausgeklammert und in einen anderen generator. Darüber hinaus werden die subgenerator zulässig ist zurück, mit einem Wert, und den Wert zur Verfügung gestellt wird, um die delegierende generator.

Die neue syntax auch eröffnet einige Möglichkeiten zur Optimierung, wenn ein generator re-Erträge Werte produziert, die von einem anderen.

Außerdem diese einführen wird (seit Python 3.5):

async def new_coroutine(data):
   ...
   await blocking_action()

zu vermeiden, Coroutinen eine Verwechslung mit einem normalen generator (heute yield wird in beide).

InformationsquelleAutor Sławomir Lenart

Hier sind einige Python-Beispiele, wie Sie auch tatsächlich umzusetzen, Generatoren, als ob Python nicht syntaktischer Zucker für Sie:

Als Python-generator:

from itertools import islice

def fib_gen():
    a, b = 1, 1
    while True:
        yield a
        a, b = b, a + b

assert [1, 1, 2, 3, 5] == list(islice(fib_gen(), 5))

Über lexikalische Verschlüsse anstelle von Generatoren

def ftake(fnext, last):
    return [fnext() for _ in xrange(last)]

def fib_gen2():
    #funky scope due to python2.x workaround
    #for python 3.x use nonlocal
    def _():
        _.a, _.b = _.b, _.a + _.b
        return _.a
    _.a, _.b = 0, 1
    return _

assert [1,1,2,3,5] == ftake(fib_gen2(), 5)

Mit dem Objekt-Verschlüsse anstelle von Generatoren (weil ClosuresAndObjectsAreEquivalent)

class fib_gen3:
    def __init__(self):
        self.a, self.b = 1, 1

    def __call__(self):
        r = self.a
        self.a, self.b = self.b, self.a + self.b
        return r

assert [1,1,2,3,5] == ftake(fib_gen3(), 5)

InformationsquelleAutor Dustin Getz

Aus Programmier-Sicht, die Iteratoren implementiert werden als thunks.

Zur Implementierung Iteratoren, Generatoren und thread-pools für die gleichzeitige Ausführung etc. als thunks (auch als anonyme Funktionen), verwendet man E-Mails an eine closure-Objekt, das ein dispatcher, dispatcher Antworten auf "Nachrichten".

http://en.wikipedia.org/wiki/Message_passing

"nächsten" wird eine Nachricht gesendet, um eine Schließung, erstellt von der "iter" nennen.

Gibt es viele Möglichkeiten, zu implementieren Sie diese Berechnung. Ich benutzte mutation, aber es ist einfach zu tun, ohne mutation, durch Rücksendung der aktuelle Wert und der nächste Ertrag.

Hier ist eine demonstration, die wird die Struktur der R6RS, aber die Semantik ist absolut identisch mit Python. Es ist das gleiche Modell der Berechnung, und nur eine änderung in der syntax ist erforderlich, um zu umschreiben, dass es in Python.

Welcome to Racket v6.5.0.3.

-> (define gen
     (lambda (l)
       (define yield
         (lambda ()
           (if (null? l)
               'END
               (let ((v (car l)))
                 (set! l (cdr l))
                 v))))
       (lambda(m)
         (case m
           ('yield (yield))
           ('init  (lambda (data)
                     (set! l data)
                     'OK))))))
-> (define stream (gen '(1 2 3)))
-> (stream 'yield)
1
-> (stream 'yield)
2
-> (stream 'yield)
3
-> (stream 'yield)
'END
-> ((stream 'init) '(a b))
'OK
-> (stream 'yield)
'a
-> (stream 'yield)
'b
-> (stream 'yield)
'END
-> (stream 'yield)
'END
->

InformationsquelleAutor alinsoar

Hier ist ein mentales Bild von dem, was yield tut.

Ich mag zu denken, der einen thread als Stapel (auch wenn es nicht umgesetzt).

Wenn eine normale Funktion aufgerufen wird, legt es seine lokalen Variablen auf den stack, führt eine Berechnung aus, dann löscht den stack und zurück. Die Werte der lokalen Variablen werden nie wieder gesehen.

Mit einem yield - Funktion, wenn Ihr code beginnt zu laufen (also nach der Funktion aufgerufen, die ein generator-Objekt, dessen next() Methode wird dann aufgerufen), ist es ähnlich stellt seine lokalen Variablen in den stack und berechnet für eine Weile. Aber dann, wenn es trifft die yield Anweisung, vor der Lichtung seinen Teil des Stacks und Rückkehr, es dauert eine Momentaufnahme der lokalen Variablen und speichert Sie in der generator-Objekt. Er schreibt auch unten den Ort, wo es derzeit bis zu dem code (D. H. der speziellen yield - Anweisung).

Es ist also eine Art gefrorene Funktion, die den generator hängen auf.

Wenn next() aufgerufen wird anschließend ruft die Funktion die Sachen auf den stack und re-animiert. Die Funktion wird fortgesetzt, um zu berechnen, von wo es aufgehört hat, blind gegenüber der Tatsache, dass es war nur verbrachte eine Ewigkeit in der kalten Lagerung.

Vergleichen Sie die folgenden Beispiele:

def normalFunction():
    return
    if False:
        pass

def yielderFunction():
    return
    if False:
        yield 12

Beim aufrufen der zweiten Funktion, es verhält sich ganz anders als die erste. Die yield - Anweisung könnte nicht erreichbar sein, aber wenn es vorhanden ist, überall, es ändert sich die Art von dem, was wir zu tun haben.

>>> yielderFunction()
<generator object yielderFunction at 0x07742D28>

Aufrufen yielderFunction() nicht seinen code, macht aber einen generator, der aus dem code. (Vielleicht ist es eine gute Idee, die Namen solcher Dinge, die mit der yielder Präfix zur besseren Lesbarkeit.)

>>> gen = yielderFunction()
>>> dir(gen)
['__class__',
 ...
 '__iter__',    #Returns gen itself, to make it work uniformly with containers
 ...            #when given to a for loop. (Containers return an iterator instead.)
 'close',
 'gi_code',
 'gi_frame',
 'gi_running',
 'next',        #The method that runs the function's body.
 'send',
 'throw']

Den gi_code und gi_frame Felder sind, wo gefrorenem Zustand gelagert wird. Erkunden Sie mit dir(..) können wir bestätigen, dass unsere mentalen Modell oben, ist glaubwürdig.

InformationsquelleAutor Evgeni Sergeev

Ausbeute ist ein Objekt

Einen return in eine Funktion einen einzelnen Wert zurückgeben.

Wenn Sie möchten, eine Funktion zur Rückgabe einer riesigen Menge von Werten, verwenden Sie yield.

Wichtiger yield ist ein Barriere.

wie die Barriere in die CUDA-Sprache, es wird nicht übertragen, die Kontrolle, bis es kommt
abgeschlossen.

Ist, es wird führen Sie den code in Ihrer Funktion von den Anfängen bis es trifft yield. Dann, es werde der erste Wert der Schleife.

Dann, jeder weitere Anruf wird ausgeführt, die Schleife, die Sie geschrieben haben in die Funktion ein weiteres mal, wieder am nächsten Wert, bis es gibt keinen Wert zurück.

InformationsquelleAutor Kaleem Ullah

In der Zusammenfassung, die yield - Anweisung wandelt Sie Ihre Funktion in einer Fabrik, die produziert ein spezielles Objekt genannt generator welche den Körper umhüllt, die Ihre ursprüngliche Funktion. Wenn die generator iteriert wird, führt Sie Ihre Funktion bis zum erreichen der nächsten yield dann unterbricht die Ausführung und wertet die übergebene Wert zu yield. Es wiederholt diesen Vorgang für jede iteration, bis der Pfad der Ausführung beendet die Funktion. Zum Beispiel,

def simple_generator():
    yield 'one'
    yield 'two'
    yield 'three'

for i in simple_generator():
    print i

einfach Ausgänge

one
two
three

Kommt der Strom aus der Verwendung der generator mit einer Schleife berechnet eine Sequenz, die der generator führt die Schleife stoppen jedes mal auf 'Ertrag' das nächste Ergebnis der Berechnung, die in dieser Weise berechnet er eine Liste auf der fliege, den nutzen, den Speicher gespeichert, die speziell für große Berechnungen

Sagen, Sie wollten einen eigenen range Funktion, erzeugt einen wiederholenden Bereich von zahlen, könnten Sie es ja gerne machen,

def myRangeNaive(i):
    n = 0
    range = []
    while n < i:
        range.append(n)
        n = n + 1
    return range

und es so zu benutzen;

for i in myRangeNaive(10):
    print i

Aber das ist ineffizient, weil

• Sie ein array erstellen, die Sie nur einmal verwenden (dies verschwendet Speicher)
• Dieser code tatsächlich durchläuft das array zweimal! 🙁

Glücklicherweise Guido und sein team waren großzügig genug, um zu entwickeln, Generatoren, so konnten wir gerade tun;

def myRangeSmart(i):
    n = 0
    while n < i:
       yield n
       n = n + 1
    return

for i in myRangeSmart(10):
    print i

Nun bei jeder iteration eine Funktion, die generator genannt next() führt die Funktion, bis es entweder erreicht ein 'yield' statement, in dem er Stoppt und 'Erträge' der Wert erreicht oder das Ende der Funktion. In diesem Fall auf den ersten Anruf next() führt bis zu der Anweisung yield und Ausbeute 'n', auf den nächsten Anruf wird ausgeführt, die Inkrement-Anweisung, springen Sie zurück zu der 'while', bewerten, und wenn das stimmt, wird es anhalten und Ertrag 'n' wieder, es wird auch weiterhin so, bis die while-Bedingung gibt false zurück, und der generator springt an das Ende der Funktion.

InformationsquelleAutor redbandit

yield ist wie ein return-element für eine Funktion. Der Unterschied ist, dass die yield element dreht, eine Funktion in einen generator. Ein generator verhält sich wie eine Funktion, bis etwas ist 'ergab'. Der generator anhält, bis es wird weiter genannt, und setzt sich aus genau den gleichen Punkt, wie es begann. Sie können eine Folge von all der 'ergab' - Werte in einem durch den Aufruf list(generator()).

InformationsquelleAutor Theoremiser

Hier ist eine einfache yield basierten Ansatz zur Berechnung der fibonacci-Reihe, erklärt:

def fib(limit=50):
    a, b = 0, 1
    for i in range(limit):
       yield b
       a, b = b, a+b

Wenn Sie geben Sie diese in Ihren REPL und dann versuchen, und nennen Sie es, erhalten Sie eine verwirrende Ergebnis:

>>> fib()
<generator object fib at 0x7fa38394e3b8>

Dies ist, weil die Anwesenheit von yield signalisiert Python, die Sie erstellen möchten ein generator, das heißt, ein Objekt, das Werte generiert auf Nachfrage.

So, wie generieren Sie diese Werte? Diese kann entweder direkt über die integrierte Funktion next oder indirekt durch Verfütterung an ein Konstrukt, das verbraucht Werte.

Mithilfe der integrierten next() Funktion, die Sie direkt aufrufen .next/__next__, zwingt den generator zum erzeugen eines Wertes:

>>> g = fib()
>>> next(g)
1
>>> next(g)
1
>>> next(g)
2
>>> next(g)
3
>>> next(g)
5

Indirekt, wenn Sie fib zu einem for Schleife, ein list Initialisierer, ein tuple Initialisierer, oder irgendetwas anderes, die erwartet, dass ein Objekt erzeugt/produziert Werte, Sie "verbrauchen" des Generators, bis keine Werte mehr produziert werden kann, indem es (und gibt es):

results = []
for i in fib(30):       # consumes fib
    results.append(i) 
# can also be accomplished with
results = list(fib(30)) # consumes fib

Ebenso mit einem tuple Initialisierer:

>>> tuple(fib(5))       # consumes fib
(1, 1, 2, 3, 5)

Einen generator unterscheidet sich von einer Funktion in dem Sinne, dass es faul ist. Dies wird erreicht durch die Aufrechterhaltung es ist die lokale Staat, und damit Sie fortsetzen, Wann immer Sie Sie benötigen.

Beim ersten aufrufen fib durch aufrufen:

f = fib()

Python kompiliert die Funktion, trifft auf die yield Schlüsselwort und einfach gibt ein generator-Objekt zurück. Nicht sehr hilfreich, es scheint.

Wenn Sie dann fordern, die es erzeugt den ersten Wert, direkt oder indirekt, führt er alle Aussagen, die er findet, bis es auf eine yield es ergibt dann wieder den Wert, den Sie geliefert yield und Pausen. Für ein Beispiel, dass besser zeigt, lassen einige print Anrufe (ersetzen mit print "text" wenn auf Python 2):

def yielder(value):
    """ This is an infinite generator. Only use next on it """ 
    while 1:
        print("I'm going to generate the value for you")
        print("Then I'll pause for a while")
        yield value
        print("Let's go through it again.")

Geben Sie nun in der REPL:

>>> gen = yielder("Hello, yield!")

haben Sie ein generator-Objekt wartet nun auf einen Befehl für Sie, um einen Wert generieren. Verwenden next und sehen, was erhalten ist, gedruckt:

>>> next(gen) # runs until it finds a yield
I'm going to generate the value for you
Then I'll pause for a while
'Hello, yield!'

Den nicht börsennotierten Ergebnisse sind, was gedruckt wird. Das zitierte Ergebnis ist das, was zurückgegeben wird yield. Rufen Sie next jetzt wieder:

>>> next(gen) # continues from yield and runs again
Let's go through it again.
I'm going to generate the value for you
Then I'll pause for a while
'Hello, yield!'

Der generator merkt sich am angehalten wurde yield value auf und kehrt von dort. Die nächste Nachricht wird ausgedruckt, und die Suche nach der yield Anweisung zum anhalten auf, führte es dann wieder (aufgrund der while loop).

InformationsquelleAutor Jim Fasarakis Hilliard