列表理解与 lambda + 过滤器

Question

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

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

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

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

Answer 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

然后在您的主代码（可读性真正重要的地方）中，您已经用一个希望有意义的函数名称替换了列表理解和过滤器。

Answer 2

这是 Python 中的一个宗教问题。 尽管Guido 考虑从 Python 3 中删除map 、 filter和reduce ，但还是有足够的反对意见，最终只有reduce从内置函数移到了functools.reduce 。

就我个人而言，我发现列表推导更容易阅读。 从表达式[i for i in list if i.attribute == value]可以更清楚地看出发生了什么，因为所有行为都在表面上，而不是在过滤器函数内部。

我不会太担心这两种方法之间的性能差异，因为它是微不足道的。 如果它被证明是您的应用程序中不太可能出现的瓶颈，我真的只会优化它。

此外，由于BDFL希望filter从语言中消失，那么肯定会自动使列表理解更加 Pythonic ;-)

Answer 3

由于任何速度差异都必然是微乎其微的，因此是否使用过滤器或列表推导归结为一个品味问题。 一般来说，我倾向于使用理解（这似乎与这里的大多数其他答案一致），但有一种情况我更喜欢filter 。

一个非常常见的用例是根据谓词 P(x) 提取一些可迭代 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)])

Answer 4

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

Answer 5

我想我只是在 python 3 中添加，filter() 实际上是一个迭代器对象，所以你必须将你的 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() 的输出以及原始列表。

Answer 6

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

我自己的自学让我遇到了一些类似的问题。

话虽如此，如果有一种方法可以从filter中获得结果list ，就像您在 .NET 中执行lst.Where(i => i.something()).ToList()时所做的那样，我是很想知道。

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

Answer 7

我发现第二种方式更具可读性。 它准确地告诉您意图是什么：过滤列表。
PS：不要使用'list'作为变量名

Answer 8

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

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

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

这就是我真正记得过滤器和列表理解的方式。 删除列表中的一些东西并保持其他元素不变，使用过滤器。 在元素上自己使用一些逻辑并创建一个适合某种目的的淡化列表，使用列表理解。

Answer 9

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

我希望在您的情况下列表理解会稍微快一些

Answer 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])]

Answer 11

我花了一些时间来熟悉higher order functions filter和map 。 所以我习惯了它们，我真的很喜欢filter ，因为它很明确地通过保持真实的东西来过滤，而且我对我知道一些functional programming术语感到很酷。

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

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

现在我想，如果您可以使用已经广泛传播的习语（如列表推导式）来实现filter / map的概念，为什么还要打扰它。 此外， maps和filters是一种功能。 在这种情况下，我更喜欢使用Anonymous functions lambdas。

最后，只是为了对其进行测试，我已经对这两种方法（ 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

Answer 12

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

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) 

如果你在这里使用列表推导，你会得到错误：

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

Answer 13

奇怪的是，在 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

Answer 14

总结其他答案

浏览答案，我们已经看到了很多来回，列表理解或过滤器是否可能更快，或者是否关心这样的问题是否重要或 pythonic。 最后，答案与大多数时候一样：视情况而定。

我只是在优化代码时偶然发现了这个问题，其中这个确切的问题（尽管与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))

Answer 15

在性能方面，这取决于。

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

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

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

Answer 16

我会得出结论：使用列表理解而不是过滤器，因为它

• 更具可读性
• 更像蟒蛇
• 更快（对于 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 毫秒

Answer 17

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

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

Answer 18

这只是个人喜好差异。

Answer 19

我的看法

def filter_list(list, key, value, limit=None):
    return [i for i in list if i[key] == value][:limit]