Spiegazione di come funziona la comprensione degli elenchi?

Question

Non ho alcun problema per la comprensione di questo:

a = [1,2,3,4] 
b = [x for x in a] 

ho pensato che era tutto, ma poi ho trovato questo frammento:

a = [[1,2],[3,4],[5,6]] 
b = [x for xs in a for x in xs] 

Il che rende b = [1,2,3,4,5,6]. Il problema è che ho problemi a capire la sintassi in [x for xs in a for x in xs], Qualcuno potrebbe spiegare come funziona?

Answer 1

Ah, le incomprensibili comprensioni "annidati". I loop si svolgono nello stesso ordine della comprensione.

[leaf for branch in tree for leaf in branch] 

Aiuta a pensarla così.

for branch in tree: 
    for leaf in branch: 
     yield leaf 

Il PEP202 afferma questa sintassi con "l'ultimo indice variando più veloce" è "quello giusto", in particolare, senza una spiegazione del motivo per cui .

Answer 2

può essere scritto come questo

result = [] 
for xs in a: 
    for x in xs: 
     result.append(x) 

Potete leggere di più su di esso here

Answer 3

b = [x for xs in a for x in xs] è simile al seguente ciclo nidificato.

b = [] 
for xs in a: 
    for x in xs: 
     b.append(x) 

Answer 4

efficace:

...for xs in a...] 

è iterare sopra la vostra lista principale (esterno) e il ritorno ognuno dei vostri sottoelenchi a sua volta.

...for x in xs] 

sta quindi iterando su ciascuno di questi sottogruppi.

questo può essere riscritta come:

b = [] 
for xs in a: 
    for x in xs: 
     b.append(x) 

Answer 5

se a = [[1,2],[3,4],[5,6]], se poi ci srotoliamo quella lista comp, otteniamo:

 +----------------a------------------+ 
     | +--xs---+ , +--xs---+ , +--xs---+ | for xs in a 
     | | x , x | | x , x | | x , x | | for x in xs 
a = [ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ] 
b = [ x for xs in a for x in xs ] == [1,2,3,4,5,6] #a list of just the "x"s 

Answer 6

Questo è un esempio di una comprensione nidificato. Pensa a a = [[1,2],[3,4],[5,6]] come matrice 3 per 2 (matrice = [[1,2], [3,4], [5,6]]).

 ______ 
row 1 |1 | 2 | 
     ______ 
row 2 |3 | 4 | 
     ______ 
row 3 |5 | 6 | 
     ______ 

La comprensione della lista che vedi è un altro modo per ottenere tutti gli elementi da questa matrice in un elenco.

Cercherò di spiegarlo utilizzando variabili diverse che, si spera, avranno più senso.

b = [element for row in matrix for element in row] 

Il primo ciclo for itera sulle righe all'interno della matrice cioè [1,2],[3,4],[5,6]. Il secondo ciclo iterato su ciascun elemento nell'elenco di 2 elementi.

Ho scritto un piccolo articolo su List Comprehension sul mio sito web http://programmathics.com/programming/python/python-list-comprehension-tutorial/ che in realtà copriva uno scenario molto simile a questa domanda. Fornisco anche altri esempi e spiegazioni sulla comprensione degli elenchi python.

Disclaimer: Sono il creatore di quel sito.

Answer 7

b = [x per xs in un for x in xs] è uguale a:

b = [] 
for xs in a: 
    for x in xs: 
     b.append(x) 

Per una migliore comprensione basta andare da destra a sinistra e aggiungere per i loop, uno dopo l'altro e in quanto crea Lista x diventato elemento di lista.

Answer 8

Le comprensibilità di lista sono elenchi che si generano con un ciclo for interno. Sono una caratteristica molto comune in Python e sembrano qualcosa come:

[cosa per cosa in list_of_things]

OK, grande, ma perché dovrei utilizzare questo?

Le comprensioni delle liste sono ottime da utilizzare quando si desidera risparmiare spazio. Sono anche a portata di mano quando hai solo bisogno di elaborare rapidamente un elenco per fare un po 'di lavoro ripetitivo su quella lista. Sono anche molto utili se si apprende la programmazione funzionale, ma questo è un argomento per un corso successivo (suggerimento suggerimento).

Ma se tutto quello che si può fare è lavorare direttamente in una lista, la comprensione delle liste non sarebbe poi così utile. Per fortuna, possono essere usati con condizioni.