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!
python
list
nested
list-comprehension
Boy Pasmo
la source
la source
Réponses:
Voici comment procéder avec une compréhension de liste imbriquée:
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]
.la source
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:
Pour votre cas, ce sera quelque chose comme ça.
la source
(f(x) for x in l)
place la deuxième ligne de l'équivalent pour la boucle à gauche.la source
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:
Le principe est le suivant: utilisez le même ordre que vous utiliseriez pour l'écrire comme imbriqué pour les boucles.
la source
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:
est en fait identique à:
Et maintenant compréhension des listes imbriquées:
est identique à;
production:
la source
Si vous n'aimez pas les compréhensions de listes imbriquées, vous pouvez également utiliser la fonction de carte ,
la source
>>> float_l = [map(float, nested_list) for nested_list in l]
[[<map at 0x47be9b0>], [<map at 0x47be2e8>], [<map at 0x47be4a8>], [<map at 0x47beeb8>], [<map at 0x484b048>], [<map at 0x484b0b8>]]
mais en ajoutant un appel supplémentaire à la liste, cela fonctionne comme prévu:>>> float_l = [list(map(float, nested_list)) for nested_list in l]
python3
pour renvoyer les générateurs hors de compréhension.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
map
compré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
Dans la prochaine série de tests, je voudrais augmenter le nombre d'éléments par listes à 100 .
Permet de faire un pas courageux et de modifier le nombre d'éléments dans les listes à 1000
À partir de ces tests, nous pouvons conclure que cela
map
a un avantage sur les performances par rapport à la compréhension des listes. Cela s'applique également si vous essayez de caster surint
oustr
. 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 utilisermap
au 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 quemap
.la source
Oui, vous pouvez le faire avec un tel code:
la source
[float(y) for y in x for x in l]
cela se traduirait par un tas de 100 avec une somme de 2400.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.
Et la liste de sortie serait la suivante:
la source
La meilleure façon de le faire à mon avis est d'utiliser le
itertools
paquet de python .la source
Oui, vous pouvez effectuer les opérations suivantes.
la source
Ceci peut être réalisé en utilisant la compréhension de la liste:
la source