blocks|key|2176297|text|预先计算结果并迭代它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2176298|new_list+=+[x+for+x+in+map(f,+old_list)+if+x+!=0]|code-block|syntax|javascript|2176299|此外，由于map在访问元素时计算每个元素的结果，所以这只是一个循环。|2176300|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Compute the results beforehand and iterate over them

<pre><code>new_list = [x for x in map(f, old_list) if x !=0]
</code></pre>

Moreover, since map computes the result per element when the element is accessed this is just one loop.

blocks|key|2176384|text|您可以在列表理解中使用生成器表达式(以避免创建不必要的列表)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2176385|new_list+=+[fx+for+fx+in+(f(x)+for+x+in+old_list)+if+fx+!=+0]|code-block|syntax|javascript|2176386|从python3.8开始，您将能够执行这|offset|length|2176387|new_list+=+[fx+for+x+in+old_list+if+(fx+:=+f(x))+!=+0]|2176388|entityMap|0|LINK|mutability|MUTABLE|url|https://www.python.org/dev/peps/pep-0572/#simplifying-list-comprehensions^0|0|0|J|1|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@$I|X|J|Y|1|Z]]|A|$]]|$1|K|3|L|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

you could use a generator expression (in order to avoid creating an unnecessary list) inside your list comprehension:

<pre><code>new_list = [fx for fx in (f(x) for x in old_list) if fx != 0]
</code></pre>

<hr>

starting from python 3.8 you will be able to do <a href="https://www.python.org/dev/peps/pep-0572/#simplifying-list-comprehensions" rel="nofollow noreferrer">this</a>:

<pre><code>new_list = [fx for x in old_list if (fx := f(x)) != 0]
</code></pre>

blocks|key|731279|text|在Python3.8中，我们将拥有“海象操作员”并能够做到这一点！|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|731280|[y+for+x+in+old_list+if+(y+:=+f(x))+!=+0]|code-block|syntax|javascript|731281|entityMap|0|LINK|mutability|MUTABLE|url|https://www.python.org/dev/peps/pep-0572/#simplifying-list-comprehensions^0|H|7|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

in Python 3.8 we'll have the <a href="https://www.python.org/dev/peps/pep-0572/#simplifying-list-comprehensions" rel="nofollow noreferrer">"walrus operator"</a> and be able to do just that!

<pre class="lang-py prettyprint-override"><code>[y for x in old_list if (y := f(x)) != 0]
</code></pre>

blocks|key|2176343|text|可以使用filter删除结果：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2176344|def+f+(x):
++return+x+*+2

old_list+=+[0,+1,+2,+3]

new_list+=+filter(lambda+x:+x+!=+0,+[f(x)+for+x+in+old_list])

for+x+in+new_list:
++print(x)|code-block|syntax|javascript|2176345|看到它在工作这里。|2176346|或者，您可以回溯该函数，以避免不得不计算相同的结果两次：|2176347|def+f+(x):
++return+x+*+2

def+memoize(f):
++++memo+=+{}
++++def+helper(x):
++++++++if+x+not+in+memo:
++++++++++++print("Computing+result+for+%25s"+%25+x)++++++++
++++++++++++memo[x]+=+f(x)
++++++++return+memo[x]
++++return+helper

memF+=+memoize(f)

old_list+=+[0,+1,+2,+3]

new_list+=+[memF(x)+for+x+in+old_list+if+memF(x)+!=+0]

for+x+in+new_list:
++print(x)|2176348|哪个是可用的这里。？|2176349|entityMap|0|LINK|mutability|MUTABLE|url|https://repl.it/repls/WealthyCriminalNanotechnology|1|https://repl.it/repls/FrankLemonchiffonFibonacci^0|4|6|0|0|6|3|0|0|0|0|6|3|1|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|M|3|N|5|6|7|1A|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1C|8|@]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|S|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]]]

You could use a <code>filter</code> to remove results:

<pre class="lang-py prettyprint-override"><code>def f (x):
 return x * 2

old_list = [0, 1, 2, 3]

new_list = filter(lambda x: x != 0, [f(x) for x in old_list])

for x in new_list:
 print(x)
</code></pre>

See it working <a href="https://repl.it/repls/WealthyCriminalNanotechnology" rel="nofollow noreferrer">here.</a>

Alternatively you could memoize the function so as to prevent ever having to compute the same result twice:

<pre class="lang-py prettyprint-override"><code>def f (x):
 return x * 2

def memoize(f):
 memo = {}
 def helper(x):
 if x not in memo:
 print("Computing result for %s" % x) 
 memo[x] = f(x)
 return memo[x]
 return helper

memF = memoize(f)

old_list = [0, 1, 2, 3]

new_list = [memF(x) for x in old_list if memF(x) != 0]

for x in new_list:
 print(x)
</code></pre>

Which is available <a href="https://repl.it/repls/FrankLemonchiffonFibonacci" rel="nofollow noreferrer">here.</a>

I am using a function in a list comprehension and an if function: 

<pre><code>new_list = [f(x) for x in old_list if f(x) !=0]
</code></pre>

It annoys me that the expression <code>f(x)</code> is computed twice in each loop.

Is there a way to do it in a cleaner way? Something along the lines of storing the value or including the if statement at the beginning of the list comprehension.

Avoid computing the same expression twice in list comprehension

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我在列表理解中使用了一个函数，并使用了一个if函数：new_list = [f(x) for x in old_list if f(x) !=0]令我烦恼的是，表达式f(x)在每个循环中计算了两次。有更干净的方法吗？在列表理解的开头存储值或包含if语句的内容。

问避免在列表理解中计算相同的表达式两次
EN

回答 4

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问避免在列表理解中计算相同的表达式两次EN

回答 4

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问避免在列表理解中计算相同的表达式两次
EN