Wann ist kein guter Zeitpunkt, um Python-Generatoren zu verwenden?

Dies ist eher die Umkehrung von Wofür können Sie Python-Generatorfunktionen verwenden? : Python-Generatoren, Generatorausdrücke und das itertoolsModul sind einige meiner Lieblingsfunktionen von Python in diesen Tagen. Sie sind besonders nützlich, wenn Sie Betriebsketten einrichten, die für einen großen Datenstapel ausgeführt werden sollen. Ich verwende sie häufig bei der Verarbeitung von DSV-Dateien.

Wann ist es also kein guter Zeitpunkt, einen Generator, einen Generatorausdruck oder eine itertoolsFunktion zu verwenden?

• Wann sollte ich lieber zip()als itertools.izip()oder
• range()vorbei xrange()oder
• [x for x in foo]vorbei (x for x in foo)?

Offensichtlich müssen wir irgendwann einen Generator in tatsächliche Daten "auflösen", normalerweise indem wir eine Liste erstellen oder mit einer Nicht-Generator-Schleife darüber iterieren. Manchmal müssen wir nur die Länge kennen. Das frage ich nicht.

Wir verwenden Generatoren, damit wir keine neuen Listen für Zwischendaten im Speicher zuweisen. Dies ist insbesondere bei großen Datenmengen sinnvoll. Ist es auch für kleine Datensätze sinnvoll? Gibt es einen spürbaren Kompromiss zwischen Speicher und CPU?

Ich bin besonders interessiert, wenn jemand ein Profil erstellt hat, angesichts der aufschlussreichen Diskussion über die Leistung des Listenverständnisses im Vergleich zu map () und filter () . ( Alt Link )

Verwenden Sie eine Liste anstelle eines Generators, wenn:

1) Sie müssen die Daten für den Zugriff auf mehrere Male (dh Cache die Ergebnisse statt recomputing sie):

for i in outer:           # used once, okay to be a generator or return a list
    for j in inner:       # used multiple times, reusing a list is better
         ...

2) Sie benötigen einen Direktzugriff (oder einen anderen Zugriff als die sequentielle Vorwärtsreihenfolge):

for i in reversed(data): ...     # generators aren't reversible

s[i], s[j] = s[j], s[i]          # generators aren't indexable

3) Sie müssen sich verbinden Strings (die zwei Durchgänge über die Daten benötigt):

s = ''.join(data)                # lists are faster than generators in this use case

4) Sie verwenden PyPy, das den Generatorcode manchmal nicht so stark optimieren kann wie bei normalen Funktionsaufrufen und Listenmanipulationen.

Verwenden Sie im Allgemeinen keinen Generator, wenn Sie Listenoperationen wie len (), reverse () usw. benötigen.

Es kann auch vorkommen, dass Sie keine verzögerte Auswertung wünschen (z. B. die gesamte Berechnung im Voraus durchführen, damit Sie eine Ressource freigeben können). In diesem Fall ist ein Listenausdruck möglicherweise besser.

Profil, Profil, Profil.

Das Profilieren Ihres Codes ist der einzige Weg, um festzustellen, ob das, was Sie tun, überhaupt Auswirkungen hat.

Die meisten Verwendungen von xrange, Generatoren usw. haben eine statische Größe und kleine Datensätze. Nur wenn Sie zu großen Datenmengen gelangen, macht dies wirklich einen Unterschied. Bei range () vs. xrange () geht es meistens nur darum, den Code ein bisschen hässlicher aussehen zu lassen, nichts zu verlieren und vielleicht etwas zu gewinnen.

Profil, Profil, Profil.

Sie sollten sich nicht begünstigen zipüber izip, rangeüber xrangeoder Listenkomprehensionen über Generator Comprehensions. In Python 3.0 rangehat xrange-ähnliche Semantik und ziphat izip-ähnliche Semantik.

Das Listenverständnis ist tatsächlich klarer, als list(frob(x) for x in foo)wenn Sie eine tatsächliche Liste benötigen.

Wie Sie bereits erwähnt haben: "Dies ist besonders bei großen Datenmengen sinnvoll", beantwortet dies Ihrer Meinung nach Ihre Frage.

Wenn Sie in Bezug auf die Leistung keine Wände erreichen, können Sie sich dennoch an Listen und Standardfunktionen halten. Wenn Sie dann auf Leistungsprobleme stoßen, wechseln Sie.

Wie von @ u0b34a0f6ae in den Kommentaren erwähnt, kann die Verwendung von Generatoren zu Beginn die Skalierung auf größere Datensätze erleichtern.

In Bezug auf die Leistung: Wenn Sie Psyco verwenden, können Listen viel schneller sein als Generatoren. Im folgenden Beispiel sind Listen bei Verwendung von psyco.full () fast 50% schneller.

import psyco
import time
import cStringIO

def time_func(func):
    """The amount of time it requires func to run"""
    start = time.clock()
    func()
    return time.clock() - start

def fizzbuzz(num):
    """That algorithm we all know and love"""
    if not num % 3 and not num % 5:
        return "%d fizz buzz" % num
    elif not num % 3:
        return "%d fizz" % num
    elif not num % 5:
        return "%d buzz" % num
    return None

def with_list(num):
    """Try getting fizzbuzz with a list comprehension and range"""
    out = cStringIO.StringIO()
    for fibby in [fizzbuzz(x) for x in range(1, num) if fizzbuzz(x)]:
        print >> out, fibby
    return out.getvalue()

def with_genx(num):
    """Try getting fizzbuzz with generator expression and xrange"""
    out = cStringIO.StringIO()
    for fibby in (fizzbuzz(x) for x in xrange(1, num) if fizzbuzz(x)):
        print >> out, fibby
    return out.getvalue()

def main():
    """
    Test speed of generator expressions versus list comprehensions,
    with and without psyco.
    """

    #our variables
    nums = [10000, 100000]
    funcs = [with_list, with_genx]

    #  try without psyco 1st
    print "without psyco"
    for num in nums:
        print "  number:", num
        for func in funcs:
            print func.__name__, time_func(lambda : func(num)), "seconds"
        print

    #  now with psyco
    print "with psyco"
    psyco.full()
    for num in nums:
        print "  number:", num
        for func in funcs:
            print func.__name__, time_func(lambda : func(num)), "seconds"
        print

if __name__ == "__main__":
    main()

Ergebnisse:

without psyco
  number: 10000
with_list 0.0519102208309 seconds
with_genx 0.0535933367509 seconds

  number: 100000
with_list 0.542204280744 seconds
with_genx 0.557837353115 seconds

with psyco
  number: 10000
with_list 0.0286369007033 seconds
with_genx 0.0513424889137 seconds

  number: 100000
with_list 0.335414877839 seconds
with_genx 0.580363490491 seconds

Was die Leistung betrifft, kann ich mir keine Zeiten vorstellen, in denen Sie eine Liste über einen Generator verwenden möchten.

Ich habe noch nie eine Situation gefunden, in der Generatoren Ihre Versuche behindern würden. Es gibt jedoch viele Fälle, in denen die Verwendung von Generatoren Ihnen nicht mehr helfen würde, als sie nicht zu verwenden.

Beispielsweise:

sorted(xrange(5))

Bietet keine Verbesserung gegenüber:

sorted(range(5))

Sie sollten Listenverständnisse bevorzugen, wenn Sie die Werte später für etwas anderes behalten müssen und die Größe Ihres Sets nicht zu groß ist.

Beispiel: Sie erstellen eine Liste, die Sie später in Ihrem Programm mehrmals durchlaufen werden.

In gewissem Maße können Sie sich Generatoren als Ersatz für Iteration (Schleifen) und Listenverständnis als eine Art Datenstrukturinitialisierung vorstellen. Wenn Sie die Datenstruktur beibehalten möchten, verwenden Sie Listenverständnisse.