Est-il possible de renvoyer 2 (ou plus) éléments pour chaque élément d'une liste de compréhension?
Ce que je veux (exemple):
[f(x), g(x) for x in range(n)]
devrait retourner [f(0), g(0), f(1), g(1), ..., f(n-1), g(n-1)]
Donc, quelque chose pour remplacer ce bloc de code:
result = list()
for x in range(n):
result.add(f(x))
result.add(g(x))
>>> from itertools import chain
>>> f = lambda x: x + 2
>>> g = lambda x: x ** 2
>>> list(chain.from_iterable((f(x), g(x)) for x in range(3)))
[2, 0, 3, 1, 4, 4]
Calendrier:
from timeit import timeit
f = lambda x: x + 2
g = lambda x: x ** 2
def fg(x):
yield f(x)
yield g(x)
print timeit(stmt='list(chain.from_iterable((f(x), g(x)) for x in range(3)))',
setup='gc.enable(); from itertools import chain; f = lambda x: x + 2; g = lambda x: x ** 2')
print timeit(stmt='list(chain.from_iterable(fg(x) for x in range(3)))',
setup='gc.enable(); from itertools import chain; from __main__ import fg; f = lambda x: x + 2; g = lambda x: x ** 2')
print timeit(stmt='[func(x) for x in range(3) for func in (f, g)]',
setup='gc.enable(); f = lambda x: x + 2; g = lambda x: x ** 2')
print timeit(stmt='list(chain.from_iterable((f(x), g(x)) for x in xrange(10**6)))',
setup='gc.enable(); from itertools import chain; f = lambda x: x + 2; g = lambda x: x ** 2',
number=20)
print timeit(stmt='list(chain.from_iterable(fg(x) for x in xrange(10**6)))',
setup='gc.enable(); from itertools import chain; from __main__ import fg; f = lambda x: x + 2; g = lambda x: x ** 2',
number=20)
print timeit(stmt='[func(x) for x in xrange(10**6) for func in (f, g)]',
setup='gc.enable(); f = lambda x: x + 2; g = lambda x: x ** 2',
number=20)
2.69210777094
3.13900787874
1.62461071932
25.5944058287
29.2623711793
25,7211849286
Compréhension de la double liste:
[f(x) for x in range(5) for f in (f1,f2)]
Démo:
>>> f1 = lambda x: x
>>> f2 = lambda x: 10*x
>>> [f(x) for x in range(5) for f in (f1,f2)]
[0, 0, 1, 10, 2, 20, 3, 30, 4, 40]
sum( ([f(x),g(x)] for x in range(n)), [] )
Cela équivaut à [f(1),g(1)] + [f(2),g(2)] + [f(3),g(3)] + ...
Vous pouvez également le considérer comme:
def flatten(list):
...
flatten( [f(x),g(x)] for x in ... )
note: La bonne façon est d'utiliser itertools.chain.from_iterable
ou la compréhension de la double liste. (Il ne nécessite pas de recréer la liste sur tous les +, donc a des performances O(N) plutôt que des performances O (N ^ 2).) Je vais toujours utiliser sum(..., [])
lorsque je veux une ligne rapide rapide ou que je suis pressé, ou lorsque le nombre de termes combinés est limité (par exemple <= 10). C'est pourquoi je le mentionne toujours ici, avec cette mise en garde. Vous pouvez également utilisez des tuples: ((f(x),g(x)) for ...), ()
(ou selon le commentaire de khachik, ayant un générateur fg (x) qui produit un double-Tuple).
Cette fonction lambda zippe deux listes en une seule:
zipped = lambda L1, L2: [L[i]
for i in range(min(len(L1), len(L2)))
for L in (L1, L2)]
Exemple:
>>> f = [x for x in range(5)]
>>> g = [x*10 for x in range(5)]
>>> zipped(f, g)
[0, 0, 1, 10, 2, 20, 3, 30, 4, 40]