列表推导式 vs. lambda + filter

问题描述：

我有一个列表，想根据项目的属性进行过滤。

以下哪项是首选（可读性、性能、其他原因）？

xs = [x for x in xs if x.attribute == value]

xs = filter(lambda x: x.attribute == value, xs)

解决方案 1：

奇怪的是，不同的人对美的理解竟然有如此大的差异。我发现列表推导比filter+更清晰lambda，但无论你觉得哪个更容易，都可以使用。

有两件事可能会减慢您的使用速度filter。

首先是函数调用开销：只要你使用 Python 函数（无论是由def还是创建lambda），filter 就可能比列表推导慢。这几乎肯定不足以造成影响，你不应该过多考虑性能问题，除非你对代码进行了计时并发现它是一个瓶颈，但差异是存在的。

可能产生的另一个开销是 lambda 被强制访问作用域变量 ( value)。这比访问局部变量要慢，并且在 Python 2.x 中，列表推导式仅访问局部变量。如果您使用的是 Python 3.x，列表推导式将在单独的函数中运行，因此它也将value通过闭包进行访问，并且此差异不适用。

要考虑的另一种选择是使用生成器而不是列表推导：

def filterbyvalue(seq, value):
   for el in seq:
       if el.attribute==value: yield el

然后在您的主代码中（可读性非常重要），您用一个有意义的函数名称替换列表理解和过滤器。

解决方案 2：

这在 Python 中是一个有点宗教性的问题。尽管**Guido 考虑过从 Python 3 中删除和，map但filter`reduce**由于反对声太大，最终只将reduce`其从内置函数移到了functools.reduce。

我个人觉得列表推导式更容易阅读。表达式中发生的事情更加清晰，[i for i in list if i.attribute == value]因为所有行为都浮于表面，而不是在过滤函数内部。

我不会太担心这两种方法之间的性能差异，因为这种差异很小。如果事实证明这是应用程序的瓶颈，我才会对其进行优化，但这种情况不太可能发生。

此外，由于BDFL想要filter从语言中消失，那么列表推导肯定会更加符合 Python 风格 ;-)

解决方案 3：

由于任何速度差异都必然是微不足道的，因此使用过滤器还是列表理解取决于个人喜好。一般来说，我倾向于使用理解（这似乎与这里的大多数其他答案一致），但有一种情况我更喜欢filter。

一个非常常见的用例是提取某个可迭代 X 的值以满足谓词 P(x) 的要求：

[x for x in X if P(x)]

但有时您想先对值应用一些函数：

[f(x) for x in X if P(f(x))]

作为一个具体的例子，考虑

primes_cubed = [x*x*x for x in range(1000) if prime(x)]

我认为这看起来比使用略好filter。但现在考虑

prime_cubes = [x*x*x for x in range(1000) if prime(x*x*x)]

在这种情况下，我们希望filter反对后计算值。除了计算两次立方体的问题（想象一下更昂贵的计算）之外，还有编写两次表达式的问题，违反了DRY美学。在这种情况下，我倾向于使用

prime_cubes = filter(prime, [x*x*x for x in range(1000)])

解决方案 4：

虽然filter可能是“更快的方式”，但“Pythonic 的方式”是不关心这些事情，除非性能绝对关键（在这种情况下您不会使用 Python！）。

解决方案 5：

我想补充一点，在 Python 3 中，filter() 实际上是一个迭代器对象，因此您必须将过滤器方法调用传递给 list() 才能构建过滤列表。因此在 Python 2 中：

lst_a = range(25) #arbitrary list
lst_b = [num for num in lst_a if num % 2 == 0]
lst_c = filter(lambda num: num % 2 == 0, lst_a)

列表 b 和 c 具有相同的值，并且与 filter() 等效 [x for x in y if z] 的时间大致相同。然而，在 3 中，同样的代码会让列表 c 包含一个过滤器对象，而不是一个经过过滤的列表。要在 3 中生成相同的值：

lst_a = range(25) #arbitrary list
lst_b = [num for num in lst_a if num % 2 == 0]
lst_c = list(filter(lambda num: num %2 == 0, lst_a))

问题在于 list() 接受一个可迭代对象作为参数，并根据该参数创建一个新列表。结果是，在 Python 3 中以这种方式使用 filter 所花的时间是 [x for x in y if z] 方法的两倍，因为您必须迭代 filter() 的输出以及原始列表。

解决方案 6：

一个重要的区别是，列表推导将返回一个，list而过滤器将返回一个filter，你不能像 那样操作它list（即：调用len它，它不适用于 的返回filter）。

我自己的自学使我发现了一些类似的问题。

话虽如此，如果有一种方法可以从中获得结果list，filter有点像你在 .NET 中所做的那样lst.Where(i => i.something()).ToList()，我很好奇。

编辑：这是 Python 3 的情况，而不是 2（请参阅评论中的讨论）。

解决方案 7：

我发现第二种方法更易读。它准确地告诉你意图是什么：过滤列表。PS

：不要使用“list”作为变量名

解决方案 8：

filter如果使用内置函数的话通常会稍微快一些。

我希望你的情况列表理解会稍微快一点

解决方案 9：

过滤器就是这样。它过滤掉列表中的元素。你可以看到定义提到了同样的事情（在我之前提到的官方文档链接中）。而列表推导式是在对前一个列表上的某些内容进行操作后生成一个新列表。（过滤器和列表推导式都会创建新列表，而不是代替旧列表执行操作。这里的新列表类似于具有全新数据类型的列表。例如将整数转换为字符串等）

在您的示例中，根据定义，最好使用过滤器而不是列表推导式。但是，如果您希望从列表元素中检索 other_attribute（在您的示例中）作为新列表检索，那么您可以使用列表推导式。

return [item.other_attribute for item in my_list if item.attribute==value]

这就是我对过滤器和列表推导的记忆。使用过滤器删除列表中的某些内容并保持其他元素不变。使用列表推导在元素上使用自己的一些逻辑并创建适合某些目的的简化列表。

解决方案 10：

这是我在列表推导之后需要过滤某些内容时使用的简短代码。只是过滤器、lambda 和列表的组合（也称为猫的忠诚和狗的清洁）。

在这种情况下，我正在读取一个文件，删除空白行、注释掉的行以及行注释之后的任何内容：

# Throw out blank lines and comments
with open('file.txt', 'r') as lines:        
    # From the inside out:
    #    [s.partition('#')[0].strip() for s in lines]... Throws out comments
    #   filter(lambda x: x!= '', [s.part... Filters out blank lines
    #  y for y in filter... Converts filter object to list
    file_contents = [y for y in filter(lambda x: x != '', [s.partition('#')[0].strip() for s in lines])]

解决方案 11：

我花了一些时间才熟悉higher order functions filterand map。所以我习惯了它们，而且我实际上很喜欢它filter，因为它明确地通过保留任何真实内容来进行过滤，而且我感觉很酷，因为我知道一些functional programming术语。

然后我读了这一段（Fluent Python Book）：

map 和 filter 函数在 Python 3 中仍然是内置函数，但自从引入列表推导和生成器表达式后，它们就不再那么重要了。列表推导或生成器表达式可以完成 map 和 filter 的综合工作，但可读性更强。

现在我想，如果可以用已经广泛使用的惯用语（如列表推导）来实现，那么为什么还要费心去考虑filter/的概念呢 ？此外和是一种函数。在这种情况下，我更喜欢使用lambda。map`mapsfiltersAnonymous functions`

最后，仅仅为了进行测试，我对两种方法（map和listComp）进行了计时，并没有发现任何相关的速度差异，从而无法进行争论。

from timeit import Timer

timeMap = Timer(lambda: list(map(lambda x: x*x, range(10**7))))
print(timeMap.timeit(number=100))

timeListComp = Timer(lambda:[(lambda x: x*x) for x in range(10**7)])
print(timeListComp.timeit(number=100))

#Map:                 166.95695265199174
#List Comprehension   177.97208347299602

解决方案 12：

我得出的结论是：使用列表推导式而不是过滤器，因为它

• 更具可读性

• 更加 Python 化

• 更快（对于 Python 3.11，请参阅附件的基准测试，另请参阅）

请记住，过滤器返回的是迭代器，而不是列表。

python3 -m timeit '[x for x in range(10000000) if x % 2 == 0]'            

1 循环，5 次最佳：每次循环 270 毫秒

python3 -m timeit 'list(filter(lambda x: x % 2 == 0, range(10000000)))'

1 循环，5 次最佳：每次循环 432 毫秒

解决方案 13：

除了可接受的答案之外，还有一种特殊情况，此时您应该使用过滤器而不是列表推导。如果列表不可散列，则不能直接使用列表推导来处理它。一个真实的例子是，如果您使用pyodbc从数据库读取结果。fetchAll()结果cursor是一个不可散列的列表。在这种情况下，要直接操作返回的结果，应该使用过滤器：

cursor.execute("SELECT * FROM TABLE1;")
data_from_db = cursor.fetchall()
processed_data = filter(lambda s: 'abc' in s.field1 or s.StartTime >= start_date_time, data_from_db) 

如果您在这里使用列表推导，您将收到错误：

类型错误：不可散列的类型：“列表”

解决方案 14：

就性能而言，这视情况而定。

filter不返回列表而是返回迭代器，如果您需要“立即”过滤和转换列表，对于非常大的列表（>1M），它比列表理解慢约 40%。元素数量不超过 100K，几乎没有区别，从 600K 开始，开始出现差异。

如果不转换为列表，filter实际上是即时的。

更多信息请访问：https: //blog.finxter.com/python-lists-filter-vs-list-comprehension-which-is-faster/

解决方案 15：

奇怪的是，在 Python 3 上，我发现过滤器的执行速度比列表推导更快。

我一直认为列表推导会更高效。类似这样的代码：[name for name in brand_names_db if name is not None] 生成的字节码会好一点。

>>> def f1(seq):
...     return list(filter(None, seq))
>>> def f2(seq):
...     return [i for i in seq if i is not None]
>>> disassemble(f1.__code__)
2         0 LOAD_GLOBAL              0 (list)
          2 LOAD_GLOBAL              1 (filter)
          4 LOAD_CONST               0 (None)
          6 LOAD_FAST                0 (seq)
          8 CALL_FUNCTION            2
         10 CALL_FUNCTION            1
         12 RETURN_VALUE
>>> disassemble(f2.__code__)
2           0 LOAD_CONST               1 (<code object <listcomp> at 0x10cfcaa50, file "<stdin>", line 2>)
          2 LOAD_CONST               2 ('f2.<locals>.<listcomp>')
          4 MAKE_FUNCTION            0
          6 LOAD_FAST                0 (seq)
          8 GET_ITER
         10 CALL_FUNCTION            1
         12 RETURN_VALUE

但实际上它们更慢：

   >>> timeit(stmt="f1(range(1000))", setup="from __main__ import f1,f2")
   21.177661532000116
   >>> timeit(stmt="f2(range(1000))", setup="from __main__ import f1,f2")
   42.233950221000214

解决方案 16：

正如在接受的答案中提到的，filter()可能会产生不必要的函数调用过载，但您可以使用括号进行生成器理解：

xs = (x for x in xs if x.attribute == value)

这样，您就可以两全其美：获得良好的语法和惰性求值。如果您不需要后者，只需将其替换()为[]。

解决方案 17：

总结其他答案

纵观这些答案，我们看到了很多争论，关于列表推导或过滤器是否可能更快，或者关心这样的问题是否重要或符合 Python 规范。最后，答案和大多数时候一样：视情况而定。

我在优化代码时偶然发现了这个问题，这个确切的问题（尽管与in表达式结合，但不是==）非常相关 - filter+lambda表达式占用了我计算时间的三分之一（几分钟）。

我的情况

在我的例子中，列表推导要快得多（速度快了一倍）。但我怀疑这会因过滤器表达式以及所使用的 Python 解释器而有很大差异。

亲自测试

这是一个简单的代码片段，应该很容易适应。如果你对其进行分析（大多数 IDE 都可以轻松做到这一点），你将能够根据你的具体情况轻松决定哪个是更好的选择：

whitelist = set(range(0, 100000000, 27))

input_list = list(range(0, 100000000))

proximal_list = list(filter(
        lambda x: x in whitelist,
        input_list
    ))

proximal_list2 = [x for x in input_list if x in whitelist]

print(len(proximal_list))
print(len(proximal_list2))

如果您没有可以轻松进行分析的 IDE，请尝试这个（从我的代码库中提取，因此有点复杂）。此代码片段将为您创建一个配置文件，您可以使用例如snakeviz轻松将其可视化：

import cProfile
from time import time


class BlockProfile:
    def __init__(self, profile_path):
        self.profile_path = profile_path
        self.profiler = None
        self.start_time = None

    def __enter__(self):
        self.profiler = cProfile.Profile()
        self.start_time = time()
        self.profiler.enable()

    def __exit__(self, *args):
        self.profiler.disable()
        exec_time = int((time() - self.start_time) * 1000)
        self.profiler.dump_stats(self.profile_path)


whitelist = set(range(0, 100000000, 27))
input_list = list(range(0, 100000000))

with BlockProfile("/path/to/create/profile/in/profile.pstat"):
    proximal_list = list(filter(
            lambda x: x in whitelist,
            input_list
        ))

    proximal_list2 = [x for x in input_list if x in whitelist]

print(len(proximal_list))
print(len(proximal_list2))

解决方案 18：

你的问题很简单，但很有趣。它只是展示了 Python 作为一种编程语言是多么灵活。人们可以使用任何逻辑并根据自己的天赋和理解编写程序。只要我们得到答案就没问题。

就您而言，这只是一种简单的过滤方法，两种方法都可以实现，但我更喜欢第一种方法，my_list = [x for x in my_list if x.attribute == value]因为它看起来很简单，不需要任何特殊语法。任何人都可以理解这个命令，并在需要时进行更改。（虽然第二种方法也很简单，但对于初级程序员来说，它仍然比第一种方法更复杂）

解决方案 19：

为了便于阅读，我有时使用这种方式：

by_attribute = lambda x: x.attribute == value
xs = filter(by_attribute , xs)

是的，这是两行代码而不是一行，但是你可以从繁琐的 lambda 中清除过滤表达式，并且通过很好地命名 lambda，它实际上可以被读作“按属性过滤”:)

解决方案 20：

我迟到了但我认为我还没看到这场战斗：

如果你想实现filter_map模式列表理解会更好。你map必须filter做

step1 = list(map(lambda x: test_and_value(x), step0))
step2 = list(filter(lambda x: x[1], step1))
step3 = list(map(lambda x: x[0], step2))

我分三步进行，因为test_and_value返回一个带有映射值和布尔结果的元组，以避免丢失部分工作：

成像test_and_value：

def test_and_value(x):
  inter = 3 * x # Very high computation compared to looping + allocating new list
  return inter, inter % 2 == 1

我们可以分两步进行，但然后重新计算inter。

通过列表理解，你可以做类似最佳代码的事情（使用常规 for 循环和 list.append）

此外，列表推导式也可以实现“flat_mapping”，因此对于像问题这样的基本代码，我不知道该选择什么。对于复杂的事情，我肯定会选择列表推导式。所以我将它们用作默认设置，以避免不得不以另一种风格重写。