python list comprehensions; comprimere un elenco di elenchi?

Question

ragazzi. Sto cercando di trovare la soluzione più elegante per un problema e mi chiedevo se Python avesse qualcosa di integrato per quello che sto cercando di fare.

Quello che sto facendo è questo. Ho una lista, A, e ho una funzione f che accetta un elemento e restituisce una lista. Posso usare una lista di comprensione per convertire tutto in A in questo modo;

[f(a) for a in A] 

Ma questo restituisce un elenco di elenchi;

[a1,a2,a3] => [[b11,b12],[b21,b22],[b31,b32]] 

Quello che voglio veramente è ottenere la lista appiattita;

[b11,b12,b21,b22,b31,b32] 

Ora, altri linguaggi ce l'hanno; è tradizionalmente chiamato flatmap in linguaggi di programmazione funzionale e .Net lo chiama SelectMany. Python ha qualcosa di simile? C'è un modo pulito per mappare una funzione su un elenco e appiattire il risultato?

Il vero problema che sto cercando di risolvere è questo; iniziando con un elenco di directory, trova tutte le sottodirectory. così;

import os 
dirs = ["c:\\usr", "c:\\temp"] 
subs = [os.listdir(d) for d in dirs] 
print subs 

currentliy mi dà una lista-di-liste, ma voglio davvero una lista.

Answer 1

Si possono avere nidificato iterazioni in una lista unica di comprensione:

[filename for path in dirs for filename in os.listdir(path)] 

Answer 2

Si potrebbe provare itertools.chain(), in questo modo:

import itertools 
import os 
dirs = ["c:\\usr", "c:\\temp"] 
subs = list(itertools.chain(*[os.listdir(d) for d in dirs])) 
print subs 

itertools.chain() restituisce un iteratore, da qui il passaggio alla list().

Answer 3

subs = [] 
map(subs.extend, (os.listdir(d) for d in dirs)) 

(risposta, ma Ants è migliore; +1 per lui)

Answer 4

È possibile trovare una buona risposta in itertools' recipes:

def flatten(listOfLists): 
    return list(chain.from_iterable(listOfLists)) 

(Nota: richiede Python 2.6+)

Answer 5

Google mi ha portato soluzione successiva:

def flatten(l): 
    if isinstance(l,list): 
     return sum(map(flatten,l)) 
    else: 
     return l 

Answer 6

Si potrebbe solo fare il semplice:

subs = [] 
for d in dirs: 
    subs.extend(os.listdir(d)) 

Answer 7

È possibile concatenare elenchi utilizzando l'operatore di aggiunta normale:

>>> [1, 2] + [3, 4] 
[1, 2, 3, 4] 

La funzione built-in sum aggiungerà i numeri in sequenza e può opzionalmente partire da un valore specifico:

>>> sum(xrange(10), 100) 
145 

Unire il sopra per appiattire una lista di liste:

>>> sum([[1, 2], [3, 4]], []) 
[1, 2, 3, 4] 

È ora possibile definire il flatmap:

>>> def flatmap(f, seq): 
... return sum([f(s) for s in seq], []) 
... 
>>> flatmap(range, [1,2,3]) 
[0, 0, 1, 0, 1, 2] 

Modifica: Ho appena visto la critica nei commenti per another answer e credo sia corretto che Python costruirà inutilmente e raccogliere molti elenchi più piccoli con questa soluzione. Quindi la cosa migliore che si può dire a questo proposito è che è molto semplice e concisa, se siete abituati a programmazione funzionale :-)

Answer 8

>>> listOfLists = [[1, 2],[3, 4, 5], [6]] 
>>> reduce(list.__add__, listOfLists) 
[1, 2, 3, 4, 5, 6] 

Sto indovinando la soluzione itertools è più efficiente di questo, ma questo mi sembra molto pitone ed evita di dover importare una libreria solo per una singola operazione di lista.

Answer 9

import itertools 
x=[['b11','b12'],['b21','b22'],['b31']] 
y=list(itertools.chain(*x)) 
print y 

itertools lavoreranno da python2.3 e una maggiore

Answer 10

La domanda proposta flatmap. Alcune implementazioni sono proposte ma potrebbero non essere necessarie la creazione di elenchi intermedi. Ecco un'implementazione basata su iteratori.

def flatmap(func, *iterable): 
    return itertools.chain.from_iterable(map(func, *iterable)) 

In [148]: list(flatmap(os.listdir, ['c:/mfg','c:/Intel'])) 
Out[148]: ['SPEC.pdf', 'W7ADD64EN006.cdr', 'W7ADD64EN006.pdf', 'ExtremeGraphics', 'Logs'] 

In Python 2.x, utilizzare itertools.map al posto di map.

Answer 11

If listA=[list1,list2,list3] 
flattened_list=reduce(lambda x,y:x+y,listA) 

Questo farà.

Answer 12

def flat_list(arr): 
    send_back = [] 
    for i in arr: 
     if type(i) == list: 
      send_back += flat_list(i) 
     else: 
      send_back.append(i) 
    return send_back 

Answer 13

È possibile utilizzare pyxtension:

from pyxtension.streams import stream 
stream([ [1,2,3], [4,5], [], [6] ]).flatMap() == range(7)