Mappare una lista annidata con Comprensione delle liste in Python?

Question

Ho il seguente codice che uso per mappare un elenco annidato in Python per produrre un elenco con la stessa struttura.

>>> nested_list = [['Hello', 'World'], ['Goodbye', 'World']] 
>>> [map(str.upper, x) for x in nested_list] 
[['HELLO', 'WORLD'], ['GOODBYE', 'WORLD']] 

questo può essere fatto con la lista solo di comprensione (senza utilizzare la funzione di mappa)?

Answer 1

Per le liste nidificate è possibile utilizzare list comprehension nidificate:

nested_list = [[s.upper() for s in xs] for xs in nested_list] 

Personalmente trovo map ad essere più pulita in questa situazione, anche se io preferisco quasi sempre list comprehension. Quindi è davvero la tua chiamata, dal momento che entrambi funzioneranno.

Answer 2

La mappa è sicuramente un modo molto più pulito di fare quello che vuoi. Puoi annidare le comprensioni delle liste, forse è quello che cerchi?

[[ix.upper() for ix in x] for x in nested_list] 

Answer 3

altri utenti hanno dato la risposta, ma ogni volta che sto avendo problemi confezionamento mia testa intorno a un costrutto funzionale, ho ingoiare il mio orgoglio e magia fuori longhand con metodi e/o gli oggetti in modo esplicito non ottimali. Hai detto che volevi finire con un generatore, in modo da:

for xs in n_l: 
    def doUpper(l): 
     for x in l: 
      yield x.upper() 
    yield doUpper(xs) 

for xs in n_l: 
    yield (x.upper() for x in xs) 

((x.upper() for x in xs) for xs in n_l) 

A volte è più pulita per mantenere una delle versioni esteso. Per me, mappare e ridurre a volte renderlo più ovvio, ma gli idiomi di Python potrebbero essere più ovvi per gli altri.

Answer 4

Ricordate la Zen di Python:.

V'è in generale più di uno - e probabilmente diversi - modi ovvi per farlo **

** Nota: A cura per precisione.

In ogni caso, preferisco la mappa.

from functools import partial 
nested_list = map(partial(map, str.upper), nested_list) 

Answer 5

Ecco soluzione per lista annidata che ha profondità arbitraria:

def map_nlist(nlist=nlist,fun=lambda x: x*2): 
    new_list=[] 
    for i in range(len(nlist)): 
     if isinstance(nlist[i],list): 
      new_list += [map_nlist(nlist[i],fun)] 
     else: 
      new_list += [fun(nlist[i])] 
    return new_list 

si desidera maiuscolo tutto quello che lista degli elementi, basta digitare

In [26]: nested_list = [['Hello', 'World'], ['Goodbye', [['World']]]] 
In [27]: map_nlist(nested_list,fun=str.upper) 
Out[27]: [['HELLO', 'WORLD'], ['GOODBYE', [['WORLD']]]] 

E più importante, questa funzione ricorsiva può fare più di questo!

Sono nuovo di Python, sentitevi liberi di discutere!