Cartographie d'une liste imbriquée avec liste en Python Comprehension?

Question

Je le code suivant que j'utilise pour mapper une liste imbriquée en Python pour produire une liste avec la même structure.

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

Peut-on faire avec la compréhension de la seule liste (sans utiliser la fonction de la carte)?

Answer 1

Pour les listes imbriquées, vous pouvez utiliser compréhensions liste imbriqués:

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

Personnellement, je trouve map être plus propre dans cette situation, même si je préfère presque toujours compréhensions de la liste. Il est donc vraiment votre appel, car soit fonctionnera.

Answer 2

Rappelez-vous le Zen de Python:

  

Il est en général plus d'un - et probablement plusieurs - façons évidentes de le faire **

.

** Note:. Edité pour la précision

De toute façon, je préfère carte.

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

Answer 3

La carte est certainement une façon beaucoup plus propre de faire ce que vous voulez. Vous pouvez imbriquer la liste compréhensions cependant, peut-être c'est ce que vous êtes après?

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

Answer 4

est la solution ici pour la liste imbriquée qui a une profondeur arbitraire :

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

vous voulez majuscules tout ce que vous élément de la liste, tapez simplement

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

Et plus important encore, cette fonction récursive peut faire plus que cela!

Je suis nouveau à python, ne hésitez pas à discuter!

Answer 5

D'autres affiches ont donné la réponse, mais chaque fois que je vais avoir du mal à envelopper ma tête autour d'une construction fonctionnelle, je ravaler ma fierté et épeler longhand avec des méthodes explicitement non-optimales et / ou des objets. Vous avez dit que vous vouliez finir avec un générateur, donc:

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)

Parfois, il est plus propre à garder l'une des versions de longhand. Pour moi, carte et réduire parfois faire plus évident, mais idiomes Python pourrait être plus évident pour les autres.