我有一个列表推导式，大致如下：
[f(x) for x in l if f(x)]
假设l是一个列表，f(x)是一个昂贵的函数，它返回一个列表。
我希望避免在每个非空出现 f(x) 的情况下对其进行两次评估。有没有办法在列表推导中保存它的输出？
我可以删除最后的条件，生成整个列表然后修剪它，但那似乎很浪费。
编辑：
已经提出了两种基本方法：
一种是内部生成器推导式：
[y for y in (f(x) for x in l) if y]
或记忆化。
我认为内部生成器推导式对于所述问题非常优雅。实际上，我简化了问题以使其更清晰明了，我真正想要的是：
[g(x, f(x)) for x in l if f(x)]
对于这种更为复杂的情况，我认为记忆化可以产生更清晰的结果。
[y for y in (f(x) for x in l) if y]
好的。
从Python 3.8开始，并引入了赋值表达式（PEP 572）（:=运算符），可以在列表推导式中使用局部变量，以避免两次调用相同的函数：
在我们的情况下，我们可以将f(x)的计算命名为变量y，同时使用表达式的结果来过滤列表，也作为映射值：
[y for x in l if (y := f(x))]
如果您有重复的 x 值，则 记忆化 函数 f 是一个最佳解决方案，即创建一个包装函数保存调用该函数的参数，然后如果请求相同的值，则返回已保存的结果。
以下是一个非常简单的实现:
storage = {}
def memoized(value):
if value not in storage:
storage[value] = f(value)
return storage[value]
[memoized(x) for x in l if memoized(x)]
然后在列表推导式中使用这个函数。这种方法在两个条件下是有效的，一个是理论上的，一个是实际上的。第一个条件是函数f必须是确定性的，即给定相同的输入返回相同的结果，而另一个条件是对象x可以用作字典键。如果第一个条件无效，则必须根据定义每次重新计算f，而如果第二个条件失败，则可以使用一些稍微更强大的方法。
您可以在网络上找到许多备忘录化的实现，我认为新版本的Python也包括了一些内容。
顺便提一句，永远不要使用小写字母L作为变量名，因为它可能会在某些终端上与i或1混淆，这是一种不好的习惯。
编辑：
正如评论所述，使用生成器推导式（以避免创建无用的重复临时变量）的可能解决方案是此表达式：
[g(x, fx) for x, fx in ((x,f(x)) for x in l) if fx]
考虑到函数f的计算成本、原始列表中重复元素的数量以及您拥有的内存，您需要权衡选择。记忆化（Memoization）进行了一种空间-速度权衡，这意味着它会跟踪每个结果并将其保存下来，因此如果您有巨大的列表，则可能会在内存占用方面变得昂贵。
你应该使用一个记忆化装饰器。这里有一个有趣的链接。
使用链接中的记忆化以及你的'代码':
def memoize(f):
""" Memoization decorator for functions taking one or more arguments. """
class memodict(dict):
def __init__(self, f):
self.f = f
def __call__(self, *args):
return self[args]
def __missing__(self, key):
ret = self[key] = self.f(*key)
return ret
return memodict(f)
@memoize
def f(x):
# your code
[f(x) for x in l if f(x)]
f.f（...） 访问该函数，它基于每个函数保持状态（而不是全局基础），它使用了 dict.__missing__，这非常有用。您有我的支持。 - mgilson[y for y in [f(x) for x in l] if y]
针对您更新后的问题，以下内容可能会有所帮助：
[g(x,y) for x in l for y in [f(x)] if y]
没有（简洁的）方法可以做到这一点。使用传统的循环方法并没有什么问题：
output = []
for x in l:
result = f(x)
if result:
output.append(result)
[g(x, f(x)) for x in series if f(x)]
要计算最终值，您需要同时拥有 x 和 f(x)。没问题，可以像这样同时传递它们：
[g(x, y) for (x, y) in ( (x, f(x)) for x in series ) if y ]
再次提醒：应该使用生成器（圆括号）而不是列表推导式（方括号）。否则，在开始过滤结果之前，您将构建整个列表。以下为列表推导式版本：
[g(x, y) for (x, y) in [ (x, f(x)) for x in series ] if y ] # DO NOT USE THIS
[g(x, y) for x in series for y in [f(x)] if y] 在内存占用方面会有所不同吗？列表何时被清理取决于记忆化函数的定义位置。 - user110954关于记忆化的问题，已经有很多解答了。Python 3标准库现在有一个lru_cache，它是最近最少使用缓存。因此，您可以这样做：
from functools import lru_cache
@lru_cache()
def f(x):
# function body here
这样一来，你的函数只会被调用一次。此外，你还可以指定 lru_cache 的大小，默认值为 128。上述 memoize 装饰器的问题在于列表的大小可能会失控。
lru_cache 大小为1，因为我只想重复使用最近使用过的值？ - Stefanmap() !!comp = [x for x in map(f, l) if x]
f 是函数 f(X)，l 是列表
map() 会对列表中的每个 x 返回函数 f(x) 的结果。
def memoize(func):
def wrapper(*args):
if args in wrapper.d:
return wrapper.d[args]
ret_val = func(*args)
wrapper.d[args] = ret_val
return ret_val
wrapper.d = {}
return wrapper
@memoize
def f(x):
...
现在f是其自身的记忆化版本。
使用这种实现方式，您可以使用@memoize装饰器来记忆化任何函数。
[g(x, fx) for x, fx in ((x,f(x)) for x in l) if fx]。主要问题是x是否有任何重复。 - EnricoGiampieri