Generatorausdrücke vs. Listenverständnis

Wann sollten Sie Generatorausdrücke verwenden und wann sollten Sie Listenverständnisse in Python verwenden?

# Generator expression
(x*2 for x in range(256))

# List comprehension
[x*2 for x in range(256)]

Johns Antwort ist gut (das Listenverständnis ist besser, wenn Sie etwas mehrmals durchlaufen möchten). Es ist jedoch auch erwähnenswert, dass Sie eine Liste verwenden sollten, wenn Sie eine der Listenmethoden verwenden möchten. Der folgende Code funktioniert beispielsweise nicht:

def gen():
    return (something for something in get_some_stuff())

print gen()[:2]     # generators don't support indexing or slicing
print [5,6] + gen() # generators can't be added to lists

Verwenden Sie grundsätzlich einen Generatorausdruck, wenn Sie nur einmal iterieren. Wenn Sie die generierten Ergebnisse speichern und verwenden möchten, sind Sie mit einem Listenverständnis wahrscheinlich besser dran.

Da Leistung der häufigste Grund ist, eine über die andere zu wählen, ist mein Rat, sich keine Sorgen zu machen und nur eine auszuwählen. Wenn Sie feststellen, dass Ihr Programm zu langsam läuft, sollten Sie sich nur dann Gedanken über die Optimierung Ihres Codes machen.

Das Iterieren über den Generatorausdruck oder das Listenverständnis bewirkt dasselbe. Das Listenverständnis erstellt jedoch zuerst die gesamte Liste im Speicher, während der Generatorausdruck die Elemente im laufenden Betrieb erstellt, sodass Sie sie für sehr große (und auch unendliche!) Sequenzen verwenden können.

Verwenden Sie Listenverständnisse, wenn das Ergebnis mehrmals wiederholt werden muss oder wenn Geschwindigkeit an erster Stelle steht. Verwenden Sie Generatorausdrücke, bei denen der Bereich groß oder unendlich ist.

Weitere Informationen finden Sie unter Generatorausdrücke und Listenverständnisse .

Der wichtige Punkt ist, dass das Listenverständnis eine neue Liste erstellt. Der Generator erstellt ein iterierbares Objekt, das das Quellmaterial im laufenden Betrieb "filtert", während Sie die Bits verbrauchen.

Stellen Sie sich vor, Sie haben eine 2-TB-Protokolldatei mit dem Namen "vastfile.txt" und möchten den Inhalt und die Länge aller Zeilen, die mit dem Wort "ENTRY" beginnen.

Versuchen Sie also zunächst, ein Listenverständnis zu schreiben:

logfile = open("hugefile.txt","r")
entry_lines = [(line,len(line)) for line in logfile if line.startswith("ENTRY")]

Dadurch wird die gesamte Datei verschluckt, jede Zeile verarbeitet und die übereinstimmenden Zeilen in Ihrem Array gespeichert. Dieses Array kann daher bis zu 2 TB Inhalt enthalten. Das ist viel RAM und wahrscheinlich nicht praktisch für Ihre Zwecke.

Stattdessen können wir einen Generator verwenden, um einen "Filter" auf unseren Inhalt anzuwenden. Es werden tatsächlich keine Daten gelesen, bis wir beginnen, über das Ergebnis zu iterieren.

logfile = open("hugefile.txt","r")
entry_lines = ((line,len(line)) for line in logfile if line.startswith("ENTRY"))

Es wurde noch nicht einmal eine einzige Zeile aus unserer Datei gelesen. Nehmen wir an, wir möchten unser Ergebnis noch weiter filtern:

long_entries = ((line,length) for (line,length) in entry_lines if length > 80)

Es wurde noch nichts gelesen, aber wir haben jetzt zwei Generatoren angegeben, die auf unsere Daten reagieren, wie wir es wünschen.

Schreiben wir unsere gefilterten Zeilen in eine andere Datei:

outfile = open("filtered.txt","a")
for entry,length in long_entries:
    outfile.write(entry)

Jetzt lesen wir die Eingabedatei. Da unsere forSchleife weiterhin zusätzliche Zeilen anfordert, long_entriesfordert der Generator Zeilen vom entry_linesGenerator an und gibt nur diejenigen zurück, deren Länge größer als 80 Zeichen ist. Der entry_linesGenerator fordert wiederum Zeilen (gefiltert wie angegeben) vom logfileIterator an, der wiederum die Datei liest.

Anstatt Daten in Form einer vollständig ausgefüllten Liste an Ihre Ausgabefunktion zu "pushen", geben Sie der Ausgabefunktion die Möglichkeit, Daten nur dann zu "ziehen", wenn sie benötigt werden. Dies ist in unserem Fall viel effizienter, aber nicht ganz so flexibel. Generatoren sind eine Möglichkeit, ein Durchgang; Die Daten aus der von uns gelesenen Protokolldatei werden sofort verworfen, sodass wir nicht zu einer vorherigen Zeile zurückkehren können. Auf der anderen Seite müssen wir uns keine Sorgen mehr machen, dass die Daten erhalten bleiben, wenn wir damit fertig sind.

Der Vorteil eines Generatorausdrucks besteht darin, dass er weniger Speicher benötigt, da nicht die gesamte Liste auf einmal erstellt wird. Generatorausdrücke werden am besten verwendet, wenn die Liste ein Vermittler ist, z. B. das Summieren der Ergebnisse oder das Erstellen eines Diktats aus den Ergebnissen.

Zum Beispiel:

sum(x*2 for x in xrange(256))

dict( (k, some_func(k)) for k in some_list_of_keys )

Der Vorteil besteht darin, dass die Liste nicht vollständig generiert wird und daher wenig Speicher verwendet wird (und auch schneller sein sollte).

Sie sollten jedoch Listenverständnisse verwenden, wenn das gewünschte Endprodukt eine Liste ist. Sie werden keine Speicher mit Generatorausdrücken speichern, da Sie die generierte Liste möchten. Sie haben auch den Vorteil, dass Sie alle Listenfunktionen wie sortiert oder umgekehrt verwenden können.

Zum Beispiel:

reversed( [x*2 for x in xrange(256)] )

Beachten Sie beim Erstellen eines Generators aus einem veränderlichen Objekt (wie einer Liste), dass der Generator zum Zeitpunkt der Verwendung des Generators und nicht zum Zeitpunkt der Erstellung des Generators nach dem Status der Liste bewertet wird:

>>> mylist = ["a", "b", "c"]
>>> gen = (elem + "1" for elem in mylist)
>>> mylist.clear()
>>> for x in gen: print (x)
# nothing

Wenn die Möglichkeit besteht, dass Ihre Liste geändert wird (oder ein veränderbares Objekt in dieser Liste), Sie jedoch den Status bei der Erstellung des Generators benötigen, müssen Sie stattdessen ein Listenverständnis verwenden.

Manchmal kann man mit der Tee- Funktion von itertools davonkommen . Sie gibt mehrere Iteratoren für denselben Generator zurück, die unabhängig voneinander verwendet werden können.

Ich verwende das Hadoop Mincemeat-Modul . Ich denke, dies ist ein großartiges Beispiel, um Folgendes zur Kenntnis zu nehmen:

import mincemeat

def mapfn(k,v):
    for w in v:
        yield 'sum',w
        #yield 'count',1


def reducefn(k,v): 
    r1=sum(v)
    r2=len(v)
    print r2
    m=r1/r2
    std=0
    for i in range(r2):
       std+=pow(abs(v[i]-m),2)  
    res=pow((std/r2),0.5)
    return r1,r2,res

Hier holt der Generator Zahlen aus einer Textdatei (bis zu 15 GB) und wendet einfache Berechnungen mit Hadoops Kartenreduzierung auf diese Zahlen an. Wenn ich nicht die Ertragsfunktion verwendet hätte, sondern ein Listenverständnis, hätte die Berechnung der Summen und des Durchschnitts viel länger gedauert (ganz zu schweigen von der Raumkomplexität).

Hadoop ist ein gutes Beispiel für die Nutzung aller Vorteile von Generatoren.