Comprendre la liste sur une liste imbriquée?

J'ai cette liste imbriquée:

l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]

Maintenant, ce que je veux faire, c'est convertir chaque élément d'une liste en float. Ma solution est la suivante:

newList = []
for x in l:
  for y in x:
    newList.append(float(y))

Mais cela peut-il être fait en utilisant la compréhension de liste imbriquée, non?

ce que j'ai fait c'est:

[float(y) for y in x for x in l]

Mais le résultat est un tas de 100 avec la somme de 2400.

toute solution, une explication serait très appréciée. Merci!

Voici comment procéder avec une compréhension de liste imbriquée:

[[float(y) for y in x] for x in l]

Cela vous donnerait une liste de listes, semblable à celle avec laquelle vous avez commencé, sauf avec des flottants au lieu de chaînes. Si vous voulez une seule liste plate, vous l'utiliserez [float(y) for x in l for y in x].

Voici comment convertir la compréhension de la boucle imbriquée en liste imbriquée:

Voici comment fonctionne la compréhension des listes imbriquées:

            l a b c d e f
            ↓ ↓ ↓ ↓ ↓ ↓ ↓
In [1]: l = [ [ [ [ [ [ 1 ] ] ] ] ] ]
In [2]: for a in l:
   ...:     for b in a:
   ...:         for c in b:
   ...:             for d in c:
   ...:                 for e in d:
   ...:                     for f in e:
   ...:                         print(float(f))
   ...:                         
1.0

In [3]: [float(f)
         for a in l
   ...:     for b in a
   ...:         for c in b
   ...:             for d in c
   ...:                 for e in d
   ...:                     for f in e]
Out[3]: [1.0]

Pour votre cas, ce sera quelque chose comme ça.

In [4]: new_list = [float(y) for x in l for y in x]

>>> l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]
>>> new_list = [float(x) for xs in l for x in xs]
>>> new_list
[40.0, 20.0, 10.0, 30.0, 20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0, 30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0]

Vous ne savez pas quelle est votre sortie souhaitée, mais si vous utilisez la compréhension de liste, l'ordre suit l'ordre des boucles imbriquées, que vous avez à l'envers. J'ai donc obtenu ce que je pense que vous voulez:

[float(y) for x in l for y in x]

Le principe est le suivant: utilisez le même ordre que vous utiliseriez pour l'écrire comme imbriqué pour les boucles.

Comme je suis un peu en retard ici, mais je voulais partager comment fonctionne réellement la compréhension de liste, en particulier la compréhension de liste imbriquée:

New_list= [[float(y) for x in l]

est en fait identique à:

New_list=[]
for x in l:
    New_list.append(x)

Et maintenant compréhension des listes imbriquées:

[[float(y) for y in x] for x in l]

est identique à;

new_list=[]
for x in l:
    sub_list=[]
    for y in x:
        sub_list.append(float(y))

    new_list.append(sub_list)

print(new_list)

production:

[[40.0, 20.0, 10.0, 30.0], [20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0], [30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0], [100.0, 100.0], [100.0, 100.0, 100.0, 100.0, 100.0], [100.0, 100.0, 100.0, 100.0]]

Si vous n'aimez pas les compréhensions de listes imbriquées, vous pouvez également utiliser la fonction de carte ,

>>> from pprint import pprint

>>> l = l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']] 

>>> pprint(l)
[['40', '20', '10', '30'],
['20', '20', '20', '20', '20', '30', '20'],
['30', '20', '30', '50', '10', '30', '20', '20', '20'],
['100', '100'],
['100', '100', '100', '100', '100'],
['100', '100', '100', '100']]

>>> float_l = [map(float, nested_list) for nested_list in l]

>>> pprint(float_l)
[[40.0, 20.0, 10.0, 30.0],
[20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0],
[30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0],
[100.0, 100.0],
[100.0, 100.0, 100.0, 100.0, 100.0],
[100.0, 100.0, 100.0, 100.0]]

J'avais un problème similaire à résoudre, alors je suis tombé sur cette question. J'ai fait une comparaison des performances de la réponse d'Andrew Clark et de narayan que je voudrais partager.

La principale différence entre deux réponses est la façon dont elles parcourent les listes internes. L'un d'eux utilise une carte intégrée , tandis que l'autre utilise la compréhension de liste. La fonction de carte présente un léger avantage en termes de performances par rapport à sa compréhension de liste équivalente si elle ne nécessite pas l'utilisation de lambdas . Donc, dans le contexte de cette question, la mapcompréhension de la liste devrait être légèrement meilleure.

Permet de faire un benchmark de performance pour voir si c'est vraiment vrai. J'ai utilisé python version 3.5.0 pour effectuer tous ces tests. Dans la première série de tests, je voudrais garder les éléments par liste à 10 et faire varier le nombre de listes de 10 à 100 000

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*10]"
>>> 100000 loops, best of 3: 15.2 usec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*10]"
>>> 10000 loops, best of 3: 19.6 usec per loop 

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*100]"
>>> 100000 loops, best of 3: 15.2 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*100]"
>>> 10000 loops, best of 3: 19.6 usec per loop 

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*1000]"
>>> 1000 loops, best of 3: 1.43 msec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*1000]"
>>> 100 loops, best of 3: 1.91 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*10000]"
>>> 100 loops, best of 3: 13.6 msec per loop   
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*10000]"
>>> 10 loops, best of 3: 19.1 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,10))]*100000]"
>>> 10 loops, best of 3: 164 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,10))]*100000]"
>>> 10 loops, best of 3: 216 msec per loop

Dans la prochaine série de tests, je voudrais augmenter le nombre d'éléments par listes à 100 .

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*10]"
>>> 10000 loops, best of 3: 110 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*10]"
>>> 10000 loops, best of 3: 151 usec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*100]"
>>> 1000 loops, best of 3: 1.11 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*100]"
>>> 1000 loops, best of 3: 1.5 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*1000]"
>>> 100 loops, best of 3: 11.2 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*1000]"
>>> 100 loops, best of 3: 16.7 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*10000]"
>>> 10 loops, best of 3: 134 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*10000]"
>>> 10 loops, best of 3: 171 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,100))]*100000]"
>>> 10 loops, best of 3: 1.32 sec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,100))]*100000]"
>>> 10 loops, best of 3: 1.7 sec per loop

Permet de faire un pas courageux et de modifier le nombre d'éléments dans les listes à 1000

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*10]"
>>> 1000 loops, best of 3: 800 usec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*10]"
>>> 1000 loops, best of 3: 1.16 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*100]"
>>> 100 loops, best of 3: 8.26 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*100]"
>>> 100 loops, best of 3: 11.7 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*1000]"
>>> 10 loops, best of 3: 83.8 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*1000]"
>>> 10 loops, best of 3: 118 msec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*10000]"
>>> 10 loops, best of 3: 868 msec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*10000]"
>>> 10 loops, best of 3: 1.23 sec per loop

>>> python -m timeit "[list(map(float,k)) for k in [list(range(0,1000))]*100000]"
>>> 10 loops, best of 3: 9.2 sec per loop
>>> python -m timeit "[[float(y) for y in x] for x in [list(range(0,1000))]*100000]"
>>> 10 loops, best of 3: 12.7 sec per loop

À partir de ces tests, nous pouvons conclure que cela mapa un avantage sur les performances par rapport à la compréhension des listes. Cela s'applique également si vous essayez de caster sur intou str. Pour un petit nombre de listes avec moins d'éléments par liste, la différence est négligeable. Pour des listes plus grandes avec plus d'éléments par liste, on pourrait utiliser mapau lieu de la compréhension de la liste, mais cela dépend totalement des besoins de l'application.

Cependant, je trouve personnellement que la compréhension de la liste est plus lisible et idiomatique que map. C'est un standard de facto en python. Habituellement, les gens sont plus compétents et plus à l'aise (spécialement les débutants) pour utiliser la compréhension de liste que map.

Oui, vous pouvez le faire avec un tel code:

l = [[float(y) for y in x] for x in l]

Ce problème peut être résolu sans utiliser de boucle. Un code de ligne unique sera suffisant pour cela. L'utilisation de la carte imbriquée avec la fonction lambda fonctionne également ici.

l = [['40', '20', '10', '30'], ['20', '20', '20', '20', '20', '30', '20'], ['30', '20', '30', '50', '10', '30', '20', '20', '20'], ['100', '100'], ['100', '100', '100', '100', '100'], ['100', '100', '100', '100']]

map(lambda x:map(lambda y:float(y),x),l)

Et la liste de sortie serait la suivante:

[[40.0, 20.0, 10.0, 30.0], [20.0, 20.0, 20.0, 20.0, 20.0, 30.0, 20.0], [30.0, 20.0, 30.0, 50.0, 10.0, 30.0, 20.0, 20.0, 20.0], [100.0, 100.0], [100.0, 100.0, 100.0, 100.0, 100.0], [100.0, 100.0, 100.0, 100.0]]

La meilleure façon de le faire à mon avis est d'utiliser le itertoolspaquet de python .

>>>import itertools
>>>l1 = [1,2,3]
>>>l2 = [10,20,30]
>>>[l*2 for l in itertools.chain(*[l1,l2])]
[2, 4, 6, 20, 40, 60]

Oui, vous pouvez effectuer les opérations suivantes.

[[float(y) for y in x] for x in l]

    deck = [] 
    for rank in ranks:
        for suit in suits:
            deck.append(('%s%s')%(rank, suit))

Ceci peut être réalisé en utilisant la compréhension de la liste:

[deck.append((rank,suit)) for suit in suits for rank in ranks ]