Espressioni del generatore e comprensione dell'elenco

Quando dovresti usare le espressioni del generatore e quando dovresti usare la comprensione delle liste in Python?

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

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

La risposta di John è buona (le comprensioni dell'elenco sono migliori quando si desidera ripetere più volte qualcosa). Tuttavia, vale anche la pena notare che è necessario utilizzare un elenco se si desidera utilizzare uno dei metodi dell'elenco. Ad esempio, il seguente codice non funzionerà:

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

Fondamentalmente, usa un'espressione del generatore se tutto ciò che stai facendo è iterare una volta. Se desideri archiviare e utilizzare i risultati generati, probabilmente stai meglio con una comprensione dell'elenco.

Poiché la performance è il motivo più comune per sceglierne una rispetto all'altra, il mio consiglio è di non preoccuparsene e di sceglierne una; se scopri che il tuo programma è in esecuzione troppo lentamente, allora e solo allora dovresti tornare indietro e preoccuparti di ottimizzare il tuo codice.

Iterare sull'espressione del generatore o sulla comprensione dell'elenco farà la stessa cosa. Tuttavia, la comprensione dell'elenco creerà prima l'intero elenco in memoria mentre l' espressione del generatore creerà gli elementi al volo, quindi sarai in grado di usarlo per sequenze molto grandi (e anche infinite!).

Utilizzare la comprensione dell'elenco quando il risultato deve essere ripetuto più volte o quando la velocità è fondamentale. Usa le espressioni del generatore in cui l'intervallo è ampio o infinito.

Vedere Espressioni del generatore e comprensione dell'elenco per ulteriori informazioni.

Il punto importante è che la comprensione dell'elenco crea un nuovo elenco. Il generatore crea un oggetto iterabile che "filtra" al volo il materiale sorgente mentre si consumano i bit.

Immagina di avere un file di registro da 2 TB chiamato "hugefile.txt" e desideri il contenuto e la lunghezza di tutte le righe che iniziano con la parola "ENTRY".

Quindi prova a iniziare scrivendo una lista di comprensione:

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

Ciò assorbe l'intero file, elabora ogni riga e memorizza le linee corrispondenti nell'array. Questo array può quindi contenere fino a 2 TB di contenuto. È molta RAM e probabilmente non è pratica per i tuoi scopi.

Quindi invece possiamo usare un generatore per applicare un "filtro" ai nostri contenuti. Nessun dato viene effettivamente letto fino a quando non si inizia a ripetere il risultato.

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

Nemmeno una singola riga è stata ancora letta dal nostro file. In effetti, supponiamo di voler filtrare ulteriormente il nostro risultato:

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

Ancora nulla è stato letto, ma ora abbiamo specificato due generatori che agiranno sui nostri dati come desideriamo.

Consente di scrivere le nostre linee filtrate su un altro file:

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

Ora leggiamo il file di input. Mentre il nostro forloop continua a richiedere linee aggiuntive, il long_entriesgeneratore richiede linee dal entry_linesgeneratore, restituendo solo quelle la cui lunghezza è superiore a 80 caratteri. E a sua volta, il entry_linesgeneratore richiede righe (filtrate come indicato) logfiledall'iteratore, che a sua volta legge il file.

Quindi, invece di "spingere" i dati nella funzione di output sotto forma di un elenco completamente popolato, stai offrendo alla funzione di output un modo per "estrarre" i dati solo quando necessario. Nel nostro caso questo è molto più efficiente, ma non altrettanto flessibile. I generatori sono a senso unico, a passaggio; i dati del file di registro che abbiamo letto vengono immediatamente eliminati, quindi non possiamo tornare a una riga precedente. D'altra parte, non dobbiamo preoccuparci di conservare i dati una volta terminato.

Il vantaggio di un'espressione del generatore è che usa meno memoria poiché non crea l'intero elenco in una sola volta. Le espressioni del generatore vengono utilizzate al meglio quando l'elenco è un intermediario, ad esempio sommando i risultati o creando un dettato dai risultati.

Per esempio:

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

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

Il vantaggio è che l'elenco non è completamente generato e quindi viene utilizzata poca memoria (e dovrebbe anche essere più veloce)

Tuttavia, è necessario utilizzare la comprensione dell'elenco quando il prodotto finale desiderato è un elenco. Non hai intenzione di salvare alcun memeory usando le espressioni del generatore, poiché desideri l'elenco generato. Ottieni anche il vantaggio di poter utilizzare una qualsiasi delle funzioni dell'elenco come ordinate o invertite.

Per esempio:

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

Quando si crea un generatore da un oggetto mutabile (come un elenco), tenere presente che il generatore verrà valutato sullo stato dell'elenco al momento dell'utilizzo del generatore, non al momento della creazione del generatore:

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

Se c'è qualche possibilità che la tua lista venga modificata (o un oggetto mutabile all'interno di quella lista) ma hai bisogno dello stato al momento della creazione del generatore, devi invece usare una comprensione della lista.

A volte è possibile cavarsela con la funzione tee da itertools , restituisce più iteratori per lo stesso generatore che può essere utilizzato in modo indipendente.

Sto usando il modulo Hadoop Mincemeat . Penso che questo sia un ottimo esempio per prendere nota di:

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

Qui il generatore ottiene i numeri da un file di testo (fino a 15 GB) e applica la matematica semplice su quei numeri usando la riduzione della mappa di Hadoop. Se non avessi usato la funzione di rendimento, ma invece una comprensione dell'elenco, ci sarebbe voluto molto più tempo per calcolare le somme e la media (per non parlare della complessità dello spazio).

Hadoop è un ottimo esempio per l'utilizzo di tutti i vantaggi dei generatori.