blocks|key|1285181|text|如果generator可能是无限的，那么您不希望使用列表理解。而且，并不是所有的东西都必须是一行。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1285182|def+filtered_gen(gen):
++++for+item+in+gen:
++++++++result+=+expensive_function(item)
++++++++if+result+<+5:
++++++++++++yield+result|code-block|syntax|javascript|1285183|entityMap^0|2|9|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

If <code>generator</code> may be infinite, you do not want to use a list comprehension. And not everything has to be a one-liner.

<pre><code>def filtered_gen(gen):
 for item in gen:
 result = expensive_function(item)
 if result &lt; 5:
 yield result
</code></pre>

blocks|key|1281899|text|你应该创建两个生成器表达式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1281900|ys_all+=+(expensive(x)+for+x+in+xs)
ys_filtered+=+(y+for+y+in+ys_all+if+y+<5)|code-block|syntax|javascript|1281901|或|1281902|from+itertools+import+imap,+ifilter
ys+=+ifilter(lambda+y+:+y+<+5,+imap(expensive,+xs))|1281903|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|$]]

you should make 2 generator expressions:

<pre><code>ys_all = (expensive(x) for x in xs)
ys_filtered = (y for y in ys_all if y &lt;5)
</code></pre>

or

<pre><code>from itertools import imap, ifilter
ys = ifilter(lambda y : y &lt; 5, imap(expensive, xs))
</code></pre>

blocks|key|4105741|text|Warning这有点复杂，但可以解决问题。我将用一个例子来解释它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|4105742|让我们说expensive_function+=+math.sin|CODE|4105743|infinite+generator+=+collections.count(0.1,0.1)|4105744|然后|4105745|[z+for+z+in+(y+if+y+<+5+else+next(iter([]))+
+++++for+y+in+(math.sin(x)+for+x+in+itertools.count(0.1,0.1)))]|code-block|syntax|javascript|4105746|是|4105747|[0.09983341664682815,
+0.19866933079506122,
+0.2955202066613396,
+0.3894183423086505,
+0.479425538604203]|4105748|所以你的问题可以归结为|4105749|[z+for+z+in+(y+if+y+<+0.5+else+next(iter([]))+\
+++++++++for+y+in+(expensive_function(x)+for+x+in+generator))]|4105750|诀窍是从生成器中强制生成StopIteration，没有什么比next(iter([]))更优雅的了|4105751|在这里，expensive_function在每次迭代中只调用一次。|4105752|使用有限生成器扩展无限生成器，并带有停止条件。由于生成器不允许raise+StopIteration，我们选择了一种复杂的方式，即next(iter([]))，现在您有了一个有限生成器，它可以用于列表理解|4105753|由于OP涉及上述方法对于非monotonic函数的应用，这里是一个虚构的非单调函数|4105754|昂贵的非单调函数f(x)+=+random.randint(1,100)*x|4105755|停止条件=+<+7|4105756|[z+for+z+in+(y+if+y+<+7+else+next(iter([]))+for+y+in+
++++++(random.randint(1,10)*x+for+x+in+itertools.count(0.1,0.1)))]

[0.9,
+0.6000000000000001,
+1.8000000000000003,
+4.0,
+0.5,
+6.0,
+4.8999999999999995,
+3.1999999999999997,
+3.5999999999999996,
+5.999999999999999]|4105757|顺便说一句:在整个范围(0,2pi)上，真正意义上的sin是非单调的|4105758|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Monotonic_function^0|0|7|0|4|T|0|0|1B|0|0|0|0|0|0|0|C|D|V|E|0|4|I|0|V|J|1T|E|0|D|9|0|0|8|U|0|6|3|0|0|B|7|Q|3|0^^$0|@$1|2|3|4|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1Q|8|@$9|1R|A|1S|B|H]]|D|@]|E|$]]|$1|I|3|J|5|6|7|1T|8|@$9|1U|A|1V|B|H]]|D|@]|E|$]]|$1|K|3|L|5|6|7|1W|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|1X|8|@]|D|@]|E|$P|Q]]|$1|R|3|S|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|T|3|U|5|O|7|1Z|8|@]|D|@]|E|$P|Q]]|$1|V|3|W|5|6|7|20|8|@]|D|@]|E|$]]|$1|X|3|Y|5|O|7|21|8|@]|D|@]|E|$P|Q]]|$1|Z|3|10|5|6|7|22|8|@$9|23|A|24|B|H]|$9|25|A|26|B|H]]|D|@]|E|$]]|$1|11|3|12|5|6|7|27|8|@$9|28|A|29|B|H]]|D|@]|E|$]]|$1|13|3|14|5|6|7|2A|8|@$9|2B|A|2C|B|H]|$9|2D|A|2E|B|H]]|D|@]|E|$]]|$1|15|3|16|5|6|7|2F|8|@]|D|@$9|2G|A|2H|1|2I]]|E|$]]|$1|17|3|18|5|6|7|2J|8|@$9|2K|A|2L|B|H]]|D|@]|E|$]]|$1|19|3|1A|5|6|7|2M|8|@$9|2N|A|2O|B|H]]|D|@]|E|$]]|$1|1B|3|1C|5|O|7|2P|8|@]|D|@]|E|$P|Q]]|$1|1D|3|1E|5|6|7|2Q|8|@$9|2R|A|2S|B|H]|$9|2T|A|2U|B|H]]|D|@]|E|$]]|$1|1F|3|-4|5|6|7|2V|8|@]|D|@]|E|$]]]|1G|$1H|$5|1I|1J|1K|E|$1L|1M]]]]

Warning This is a bit convoluted but does the job. I will use an example to explain it.

Let say <code>expensive_function = math.sin</code>

<code>infinite generator = collections.count(0.1,0.1)</code>

then 

<pre><code>[z for z in (y if y &lt; 5 else next(iter([])) 
 for y in (math.sin(x) for x in itertools.count(0.1,0.1)))]
</code></pre>

is

<pre><code>[0.09983341664682815,
 0.19866933079506122,
 0.2955202066613396,
 0.3894183423086505,
 0.479425538604203]
</code></pre>

So your problem boils down to

<pre><code>[z for z in (y if y &lt; 0.5 else next(iter([])) \
 for y in (expensive_function(x) for x in generator))]
</code></pre>

The trick is to force a <code>StopIteration</code> from a generator and nothing elegant than <code>next(iter([]))</code>

Here <code>expensive_function</code> is only called once per iteration.

Extend the Infinite Generator with a Finite Generator, with the Stop Condition. 
As the generator won't allow <code>raise StopIteration</code>, we opt for a convoluted way i.e. <code>next(iter([]))</code>
And now you have a Finite Generator, which can be used in a List Comprehension

As OP was concerned with the application of the above method for a non-<a href="http://en.wikipedia.org/wiki/Monotonic_function" rel="nofollow">monotonic</a> function here is a fictitious non-monotonic function

Expensive Non-Monotonic Function <code>f(x) = random.randint(1,100)*x</code>

Stop Condition = <code>&lt; 7</code>

<pre><code>[z for z in (y if y &lt; 7 else next(iter([])) for y in 
 (random.randint(1,10)*x for x in itertools.count(0.1,0.1)))]

[0.9,
 0.6000000000000001,
 1.8000000000000003,
 4.0,
 0.5,
 6.0,
 4.8999999999999995,
 3.1999999999999997,
 3.5999999999999996,
 5.999999999999999]
</code></pre>

Btw: <code>sin</code> in true sense is non-monotonic over the entire range <code>(0,2pi)</code>

blocks|key|4105785|text|我将回答问题中关于如何在条件中使用的列表理解中捕获中间结果的部分，并忽略从无限生成器构建的列表理解的问题(这显然是行不通的)，以防有人在这里寻找标题中问题的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4105786|所以，你有一个这样的列表理解：|4105787|[expensive_function(x)+for+x+in+xrange(5)+if+expensive_function(x)+%25+2+==+0]|code-block|syntax|javascript|4105788|当expensive_function通过您的过滤器时，您希望避免计算两次。具有更具表现力的理解语法的语言(Scala、Haskell等)允许您简单地为通过理解变量计算的表达式指定名称，这使您可以执行以下操作：|offset|length|style|CODE|4105789|#+NOT+REAL+PYTHON
[result+for+x+in+xrange(5)+for+result+=+expensive_function(x)+if+result+%25+2+==+0]|4105790|但是，通过将赋值result+=+expensive_function(x)转换为一个元素序列上的另一个for迭代，可以很容易地模拟这一点：|4105791|[result+for+x+in+xrange(5)+for+result+in+(expensive_function(x),)+if+result+%25+2+==+0]|4105792|证据是：|4105793|>>>+def+expensive_function(x):
++++++++print+'expensive_function({})'.format(x)
++++++++return+x+%2B+10
>>>+[expensive_function(x)+for+x+in+xrange(5)+if+expensive_function(x)+%25+2+==+0]
expensive_function(0)
expensive_function(0)
expensive_function(1)
expensive_function(2)
expensive_function(2)
expensive_function(3)
expensive_function(4)
expensive_function(4)
[10,+12,+14]
>>>+[result+for+x+in+xrange(5)+for+result+in+(expensive_function(x),)+if+result+%25+2+==+0]
expensive_function(0)
expensive_function(1)
expensive_function(2)
expensive_function(3)
expensive_function(4)
[10,+12,+14]|4105794|entityMap^0|0|0|0|1|I|0|0|8|U|1G|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@$K|14|L|15|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|17|8|@$K|18|L|19|M|N]|$K|1A|L|1B|M|N]]|9|@]|A|$]]|$1|S|3|T|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|1D|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1E|8|@]|9|@]|A|$G|H]]|$1|Y|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|Z|$]]

I'm going to answer the part of the question about how to capture intermediate results in a list comprehension for use in a condition, and ignore the question of a list comprehension built from an infinite generator (which obviously isn't going to work), just in case anyone looking for an answer to the question in the title comes here.

So, you have a list comprehension like this:

<pre><code>[expensive_function(x) for x in xrange(5) if expensive_function(x) % 2 == 0]
</code></pre>

And you want to avoid calculating <code>expensive_function</code> twice when it passes your filter. Languages with more expressive comprehension syntax (Scala, Haskell, etc) allow you to simply assign names to expressions calculated from comprehension variables, which lets you do things like the following:

<pre><code># NOT REAL PYTHON
[result for x in xrange(5) for result = expensive_function(x) if result % 2 == 0]
</code></pre>

But you can easily emulate this by turning the assignment <code>result = expensive_function(x)</code> into another <code>for</code> iteration over a sequence of one element:

<pre><code>[result for x in xrange(5) for result in (expensive_function(x),) if result % 2 == 0]
</code></pre>

And the proof:

<pre><code>&gt;&gt;&gt; def expensive_function(x):
 print 'expensive_function({})'.format(x)
 return x + 10
&gt;&gt;&gt; [expensive_function(x) for x in xrange(5) if expensive_function(x) % 2 == 0]
expensive_function(0)
expensive_function(0)
expensive_function(1)
expensive_function(2)
expensive_function(2)
expensive_function(3)
expensive_function(4)
expensive_function(4)
[10, 12, 14]
&gt;&gt;&gt; [result for x in xrange(5) for result in (expensive_function(x),) if result % 2 == 0]
expensive_function(0)
expensive_function(1)
expensive_function(2)
expensive_function(3)
expensive_function(4)
[10, 12, 14]
</code></pre>

I want to construct a value in a list comprehension, but also filter on that value. For example:

<pre><code>[expensive_function(x) for x in generator where expensive_function(x) &lt; 5]
</code></pre>

I want to avoid calling <code>expensive_function</code> twice per iteration.

The <code>generator</code> may return an infinite series, and list comprehensions aren't lazily evaluated. So this wouldn't work:

<pre><code>[y in [expensive_function(x) for x in generator where expensive_function(x)] where y &lt; 5]
</code></pre>

I could write this another way, but it feels right for a list comprehension and I'm sure this is a common usage pattern (possible or not!).

Possible to capture the returned value from a Python list comprehension for use a condition?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想在列表理解中构造一个值，但也要对该值进行过滤。例如：[expensive_function(x) for x in generator where expensive_function(x) < 5]我想避免每次迭代调用两次expensive_function。generator可能会返回一个无限系列，并且列表理解...

问是否可以从Python列表理解中捕获返回值以使用条件？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否可以从Python列表理解中捕获返回值以使用条件？EN