Mapeamento de uma lista aninhada com lista de compreensão em Python?

Question

Eu tenho o seguinte código que eu uso para mapear uma lista aninhada em Python para produzir uma lista com a mesma estrutura.

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

Isso pode ser feito com compreensão da lista sozinho (sem usar a função de mapa)?

Answer 1

Para listas aninhadas você pode usar lista aninhada compreensões:

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

Pessoalmente acho map ser limpo nesta situação, embora eu quase sempre preferem compreensões lista. Então, é realmente a sua chamada, uma vez que quer trabalhar vontade.

Answer 2

Lembre-se do Zen de Python:

Há geralmente mais de um - e, provavelmente, vários -. Maneiras óbvias de fazer isso **

** Nota:. Editado pela precisão

De qualquer forma, eu prefiro mapa.

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

Answer 3

Mapa é certamente uma forma mais limpa de fazer o que quiser. Você pode aninhar as compreensões lista embora, talvez isso é o que você procura?

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

Answer 4

Aqui está a solução para o lista aninhada que tem profundidade arbitrária :

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

Você quer maiúsculas tudo que você lista de elementos, basta digitar

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

E o mais importante, esta função recursiva pode fazer mais do que isso!

Eu sou novo para python, fique à vontade para discutir!

Answer 5

Outros cartazes têm dado a resposta, mas sempre que eu estou tendo problemas envolvendo minha cabeça em torno de uma construção funcional, eu engolir meu orgulho e soletrar longhand com métodos e / ou objetos explicitamente não-ideais. Você disse que queria acabar com um gerador, assim:

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)

Às vezes mais limpa que seja para manter uma das versões longhand. Para mim, mapa e reduzir, por vezes, torná-lo mais óbvio, mas expressões Python pode ser mais óbvio para os outros.