Python: Generator-Ausdruck gegen Ausbeute

Gibt es nur geringe Unterschiede in den beiden. Sie können die dis Modul zu prüfen, diese Art der Sache für sich selbst.

Edit: Meine erste version dekompiliert der generator-Ausdruck erstellt am Modul-Bereich in der interaktiven Eingabeaufforderung. Das ist etwas anders von der OP-version mit einer Funktion. Ich geändert habe Sie diese zu entsprechen, im konkreten Fall in Frage.

Wie Sie unten sehen können, die "Ausbeute" - generator (Erster Fall) hat drei zusätzliche Anweisungen in der setup, aber ab den ersten FOR_ITER Sie unterscheiden sich nur in einer Hinsicht: die "Ausbeute" Ansatz verwendet eine LOAD_FAST an die Stelle einer LOAD_DEREF innerhalb der Schleife. Die LOAD_DEREF ist "eher langsamere" als LOAD_FAST ist, so macht es die "Ausbeute" - version etwas schneller als der generator-Ausdruck für eine größere Zahl von x (äußere Schleife), weil der Wert der y geladen ist etwas schneller bei jedem Durchlauf. Für kleinere Werte von x würde es etwas langsamer sein, weil der zusätzliche Aufwand für das setup-code.

Könnte es auch sein, darauf hinzuweisen, dass der generator-Ausdruck in der Regel verwendet werden inline im code, anstatt wickelte Sie mit der Funktion wie. Das wäre zu entfernen ein wenig von der setup-Aufwand und halten den generator-Ausdruck etwas schneller für kleinere loop-Werte, auch wenn LOAD_FAST gab die "Ausbeute" - version einen Vorteil, sonst.

In keinem Fall würde der performance-Unterschied rechtfertigt die Entscheidung zwischen der einen oder der anderen. Die Lesbarkeit zählt weit mehr, also je nachdem, was fühlt sich am meisten lesbar sind für die situation bei der hand.

>>> def Generator(x, y):
...     for i in xrange(x):
...         for j in xrange(y):
...             yield(i, j)
...
>>> dis.dis(Generator)
  2           0 SETUP_LOOP              54 (to 57)
              3 LOAD_GLOBAL              0 (xrange)
              6 LOAD_FAST                0 (x)
              9 CALL_FUNCTION            1
             12 GET_ITER
        >>   13 FOR_ITER                40 (to 56)
             16 STORE_FAST               2 (i)

  3          19 SETUP_LOOP              31 (to 53)
             22 LOAD_GLOBAL              0 (xrange)
             25 LOAD_FAST                1 (y)
             28 CALL_FUNCTION            1
             31 GET_ITER
        >>   32 FOR_ITER                17 (to 52)
             35 STORE_FAST               3 (j)

  4          38 LOAD_FAST                2 (i)
             41 LOAD_FAST                3 (j)
             44 BUILD_TUPLE              2
             47 YIELD_VALUE
             48 POP_TOP
             49 JUMP_ABSOLUTE           32
        >>   52 POP_BLOCK
        >>   53 JUMP_ABSOLUTE           13
        >>   56 POP_BLOCK
        >>   57 LOAD_CONST               0 (None)
             60 RETURN_VALUE
>>> def Generator_expr(x, y):
...    return ((i, j) for i in xrange(x) for j in xrange(y))
...
>>> dis.dis(Generator_expr.func_code.co_consts[1])
  2           0 SETUP_LOOP              47 (to 50)
              3 LOAD_FAST                0 (.0)
        >>    6 FOR_ITER                40 (to 49)
              9 STORE_FAST               1 (i)
             12 SETUP_LOOP              31 (to 46)
             15 LOAD_GLOBAL              0 (xrange)
             18 LOAD_DEREF               0 (y)
             21 CALL_FUNCTION            1
             24 GET_ITER
        >>   25 FOR_ITER                17 (to 45)
             28 STORE_FAST               2 (j)
             31 LOAD_FAST                1 (i)
             34 LOAD_FAST                2 (j)
             37 BUILD_TUPLE              2
             40 YIELD_VALUE
             41 POP_TOP
             42 JUMP_ABSOLUTE           25
        >>   45 POP_BLOCK
        >>   46 JUMP_ABSOLUTE            6
        >>   49 POP_BLOCK
        >>   50 LOAD_CONST               0 (None)
             53 RETURN_VALUE

InformationsquelleAutor der Antwort Peter Hansen

Es ist kein Unterschied für die Art von einfachen Schleifen, dass Sie können passen in eine generator expression. Aber die Ausbeute kann verwendet werden, um Generatoren, die viel mehr tun, komplexe Verarbeitung. Hier ist ein einfaches Beispiel für die Generierung der fibonacci-Folge:

>>> def fibgen():
...    a = b = 1
...    while 1:
...        yield a
...        a, b = b, a+b

>>> list(itertools.takewhile((lambda x: x<100), fibgen()))
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

InformationsquelleAutor der Antwort Dave Kirby

In Gebrauch, beachten Sie die Unterscheidung zwischen einem generator-Objekt vs eine generator-Funktion.

Einem generator-Objekt ist, verwenden Sie einmal-nur, im Gegensatz zu einer generator-Funktion, die wiederverwendet werden können jedes mal, wenn Sie nennen es wieder, denn es gibt eine frische-generator-Objekt.

Generator-Ausdrücke sind in der Praxis meist verwendete "raw", ohne wickelte Sie in eine Funktion, und Sie kehren ein generator-Objekt.

E. g.:

def range_10_gen_func():
    x = 0
    while x < 10:
        yield x
        x = x + 1

print(list(range_10_gen_func()))
print(list(range_10_gen_func()))
print(list(range_10_gen_func()))

welche Ausgänge:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Vergleichen mit eine etwas andere Verwendung:

range_10_gen = range_10_gen_func()
print(list(range_10_gen))
print(list(range_10_gen))
print(list(range_10_gen))

welche Ausgänge:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[]
[]

Vergleichen und mit einem generator-Ausdruck:

range_10_gen_expr = (x for x in range(10))
print(list(range_10_gen_expr))
print(list(range_10_gen_expr))
print(list(range_10_gen_expr))

die auch-Ausgänge:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[]
[]

InformationsquelleAutor der Antwort Craig McQueen

Ja, es ist ein Unterschied.

Für den generator-Ausdruck (x for var in expr)iter(expr) wird aufgerufen, wenn der Ausdruck erstellt.

Bei der Verwendung def und yield um einen generator erzeugen, in:

def my_generator():
    for var in expr:
        yield x

g = my_generator()

iter(expr) noch nicht genannt. Es wird nur aufgerufen werden, wenn die Iteration auf g (und vielleicht nicht genannt werden).

Einnahme dieser iterator als Beispiel:

from __future__ import print_function


class CountDown(object):
    def __init__(self, n):
        self.n = n

    def __iter__(self):
        print("ITER")
        return self

    def __next__(self):
        if self.n == 0:
            raise StopIteration()
        self.n -= 1
        return self.n

    next = __next__  # for python2

Diesem code:

g1 = (i ** 2 for i in CountDown(3))  # immediately prints "ITER"
print("Go!")
for x in g1:
    print(x)

während:

def my_generator():
    for i in CountDown(3):
        yield i ** 2


g2 = my_generator()
print("Go!")
for x in g2:  # "ITER" is only printed here
    print(x)

Da die meisten Iteratoren nicht tun eine Menge Sachen, die in __iter__ ist es leicht zu übersehen, dieses Verhalten. Ein reales Beispiel wäre Django ' s QuerySetdie abrufen von Daten im __iter__ und data = (f(x) for x in qs) könnte viel Zeit in Anspruch nehmen, während def g(): for x in qs: yield f(x) gefolgt von data=g() würde sofort zurückkehren.

Weitere Infos und die formale definition siehe PEP 289 -- Generator-Ausdrücke.

InformationsquelleAutor der Antwort Udi