blocks|key|217713|text|>>>+from+itertools+import+chain
>>>+f+=+lambda+x:+x+%2B+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]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|217714|计时：|unstyled|217715|from+timeit+import+timeit

f+=+lambda+x:+x+%2B+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+%2B+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+%2B+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+%2B+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+%2B+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+%2B+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+%2B+2;+g+=+lambda+x:+x+**+2',
+++++++++++++number=20)|217716|217717|+2.69210777094|blockquote|217718|217719|3.13900787874|217720|1.62461071932|217721|25.5944058287|217722|29.2623711793|217723|25.7211849286|217724|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|11|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$]]|$1|M|3|-4|5|F|7|14|8|@]|9|@]|A|$]]|$1|N|3|O|5|F|7|15|8|@]|9|@]|A|$]]|$1|P|3|Q|5|F|7|16|8|@]|9|@]|A|$]]|$1|R|3|S|5|F|7|17|8|@]|9|@]|A|$]]|$1|T|3|U|5|F|7|18|8|@]|9|@]|A|$]]|$1|V|3|W|5|F|7|19|8|@]|9|@]|A|$]]|$1|X|3|-4|5|F|7|1A|8|@]|9|@]|A|$]]]|Y|$]]

<pre><code>&gt;&gt;&gt; from itertools import chain
&gt;&gt;&gt; f = lambda x: x + 2
&gt;&gt;&gt; g = lambda x: x ** 2
&gt;&gt;&gt; list(chain.from_iterable((f(x), g(x)) for x in range(3)))
[2, 0, 3, 1, 4, 4]
</code></pre>

Timings:

<pre><code>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)
</code></pre>

<blockquote>
 2.69210777094
 
 3.13900787874
 
 1.62461071932
 
 25.5944058287
 
 29.2623711793
 
 25.7211849286
</blockquote>

blocks|key|214862|text|sum(+([f(x),g(x)]+for+x+in+range(n)),+[]+)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|214863|这相当于[f(1),g(1)]+%2B+[f(2),g(2)]+%2B+[f(3),g(3)]+%2B+...|unstyled|offset|length|style|CODE|214864|你也可以把它想象成：|214865|def+flatten(list):
++++...

flatten(+[f(x),g(x)]+for+x+in+...+)|214866|注意:正确的方法是使用itertools.chain.from_iterable或双重列表理解。(它不需要在每个%2B上重新创建列表，因此具有O(N)性能，而不是O(N%5E2)性能。)当我想要一个快速的一行，或者我很着急，或者当组合的词条数量有限时(例如<=+10)，我仍然会使用sum(...,+[])。这就是为什么我仍然在这里提到它，但有这个警告。你也可以使用元组：((f(x),g(x))+for+...),+()+(或者根据卡奇克的评论，有一个生成器fg(x)，它产生一个二元组)。|214867|entityMap^0|0|4|19|0|0|0|B|T|3T|C|52|P|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@$G|U|H|V|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$B|C]]|$1|O|3|P|5|F|7|Y|8|@$G|Z|H|10|I|J]|$G|11|H|12|I|J]|$G|13|H|14|I|J]]|9|@]|A|$]]|$1|Q|3|-4|5|F|7|15|8|@]|9|@]|A|$]]]|R|$]]

<pre><code>sum( ([f(x),g(x)] for x in range(n)), [] )
</code></pre>

This is equivalent to <code>[f(1),g(1)] + [f(2),g(2)] + [f(3),g(3)] + ...</code>

You can also think of it as:

<pre><code>def flatten(list):
 ...

flatten( [f(x),g(x)] for x in ... )
</code></pre>

note: The right way is to use <code>itertools.chain.from_iterable</code> or the double list comprehension. (It does not require recreating the list on every +, thus has O(N) performance rather than O(N^2) performance.) I'll still use <code>sum(..., [])</code> when I want a quick one-liner or I'm in a hurry, or when the number of terms being combined is bounded (e.g. &lt;= 10). That is why I still mention it here, with this caveat. You can also use tuples: <code>((f(x),g(x)) for ...), ()</code> (or per khachik's comment, having a generator fg(x) which yields a two-tuple).

blocks|key|2864989|text|双重列表理解：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2864990|[f(x)+for+x+in+range(5)+for+f+in+(f1,f2)]|code-block|syntax|javascript|2864991|演示：|2864992|>>>+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]|2864993|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Double list comprehension:

<pre><code>[f(x) for x in range(5) for f in (f1,f2)]
</code></pre>

Demo:

<pre><code>&gt;&gt;&gt; f1 = lambda x: x
&gt;&gt;&gt; f2 = lambda x: 10*x

&gt;&gt;&gt; [f(x) for x in range(5) for f in (f1,f2)]
[0, 0, 1, 10, 2, 20, 3, 30, 4, 40]
</code></pre>

blocks|key|220021|text|这个lambda函数将两个列表压缩成一个列表：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|220022|zipped+=+lambda+L1,+L2:+[L[i]+
+++++++++++++++++++++++++for+i+in+range(min(len(L1),+len(L2)))+
+++++++++++++++++++++++++for+L+in+(L1,+L2)]|code-block|syntax|javascript|220023|示例：|220024|>>>+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]|220025|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This lambda function zips two lists into a single one:

<pre><code>zipped = lambda L1, L2: [L[i] 
 for i in range(min(len(L1), len(L2))) 
 for L in (L1, L2)]
</code></pre>

Example:

<pre><code>&gt;&gt;&gt; f = [x for x in range(5)]
&gt;&gt;&gt; g = [x*10 for x in range(5)]
&gt;&gt;&gt; zipped(f, g)
[0, 0, 1, 10, 2, 20, 3, 30, 4, 40]
</code></pre>

blocks|key|218299|text|我知道OP正在寻找一种列表理解解决方案，但我想提供一种使用list.extend()的替代方案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|218300|f+=+lambda+x:+x
g+=+lambda+x:+10*x

result+=+[]
extend+=+result.extend
for+x+in+range(5):
++++extend((f(x),g(x)))|code-block|syntax|javascript|218301|这比使用双列表理解的速度要快一些。|218302|nums+=+range(100000)

def+double_comprehension():
++++return+[func(x)+for+x+in+nums+for+func+in+(f,g)]

def+list_extend():
++++result+=+[]
++++extend+=+result.extend
++++for+x+in+nums:
++++++++extend((f(x),g(x)))
++++return+result

%25timeit+-n100+double_comprehension()
23.4+ms+±+67+µs+per+loop+(mean+±+std.+dev.+of+7+runs,+100+loops+each)

%25timeit+-n100+list_extend()
20.5+ms+±+213+µs+per+loop+(mean+±+std.+dev.+of+7+runs,+100+loops+each)|218303|Python版本:+3.8.0|218304|entityMap^0|T|D|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

I know OP is looking for a list comprehension solution, but I'd like to offer an alternative using <code>list.extend()</code>.
<pre><code>f = lambda x: x
g = lambda x: 10*x

result = []
extend = result.extend
for x in range(5):
 extend((f(x),g(x)))
</code></pre>
which is marginally faster than using double list comprehension.
<pre class="lang-py prettyprint-override"><code>nums = range(100000)

def double_comprehension():
 return [func(x) for x in nums for func in (f,g)]

def list_extend():
 result = []
 extend = result.extend
 for x in nums:
 extend((f(x),g(x)))
 return result

%timeit -n100 double_comprehension()
23.4 ms ± 67 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit -n100 list_extend()
20.5 ms ± 213 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
</code></pre>
Python version: 3.8.0

blocks|key|3078429|text|天啊，悲哀！为什么有这么多拉姆达、扁平、拉链和和呢？这难道不是最简单和最具可读性的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3078430|>>>+[v
...++for+x+in+range(5)
...++++++for+v+in+(2+*+x,
...++++++++++++++++2+*+x+%2B+1)]
[0,+1,+2,+3,+4,+5,+6,+7,+8,+9]
>>>|code-block|syntax|javascript|3078431|(将最后两个表达式替换为f(x)和g(x)等。)|offset|length|style|CODE|3078432|entityMap^0|0|0|C|4|H|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Goodness, grief! Why all these lambdas, flattens, zips and sums? Isn't this the simplest and most readable:
<pre><code>&gt;&gt;&gt; [v
... for x in range(5)
... for v in (2 * x,
... 2 * x + 1)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
&gt;&gt;&gt;
</code></pre>
(Replace the last two expressions with <code>f(x)</code> and <code>g(x)</code>, or whatever.)

Is it possible to return 2 (or more) items for each item in a list comprehension?

What I want (example):

<pre><code>[f(x), g(x) for x in range(n)]
</code></pre>

should return <code>[f(0), g(0), f(1), g(1), ..., f(n-1), g(n-1)]</code>

So, something to replace this block of code:

<pre><code>result = list()
for x in range(n):
 result.add(f(x))
 result.add(g(x))
</code></pre>

List comprehension: Returning two (or more) items for each item

Python

是否可以为列表理解中的每个项目返回2个(或更多)项目？我想要的(示例)：[f(x), g(x) for x in range(n)]应返回[f(0), g(0), f(1), g(1), ..., f(n-1), g(n-1)]因此，替换这段代码的内容如下：result = list()for x in range(n...

问列表理解:为每个项目返回两个(或更多)项目
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问列表理解:为每个项目返回两个(或更多)项目EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问列表理解:为每个项目返回两个(或更多)项目
EN