4

在比较 Python 中的各种等效形式时filter(xs, lambda x: x != el)，我偶然发现了一些令我惊讶的东西。考虑以下形式：

def method1(xs, el):
    p = lambda x: x != el
    return [x for x in xs if p(x)]

def method2(xs, el):
    return [x for x in xs if (lambda y: y != el)(x)]

我希望 Python 只构建一次 lambda，然后将其存储在一个临时变量中，这样两种形式的性能都差不多。method1由于名称查找，甚至可能表现更差。

但是当我对它们进行基准测试时，结果发现它们的method2表现始终比method1. 为什么是这样？是否为每次迭代重建 lambda？

我的基准脚本（在一个单独的模块中，并期望methods包含method1and method2）如下：

import math, timeit

def bench(n,rho,z):
    pre = """\
import random
from methods import %(method)s

x = [(random.randint(0,%(domain)i)) for r in xrange(%(size)i)]
el = x[0]\
"""

    def testMethod(m):
        mod = pre % { 'method': m, 'domain': int(math.ceil(n / rho)), 'size': n }
        return timeit.timeit("%s(x, el)" % m, mod, number = z)/(z * n)

    print "Testing", n, rho, z
    return tuple(testMethod(m) for m in ("method1", "method2"))

n = 31

min_size, max_size = 10.0**1, 10.0**4
size_base = math.pow(max_size / min_size, 1.0/(n-1))
# size_default = 10**3

#min_sel, max_sel = 0.001, 1.0
#sel_base = math.pow(max_sel / min_sel, 1.0/(n-1))
sel_default = 0.001

tests = [bench(int(min_size*size_base**x), sel_default, 100) for x in xrange(n)]
#tests = [bench(size_default, min_sel*sel_base**x, 100) for x in xrange(n)]

def median(x):
    x = list(sorted(x))
    mi = int(len(x)/2)
    if n % 2 == 0:
        return x[mi]
    else:
        return (x[mi] + x[mi+1])/2

def madAndMedian(x):
    meh = median(x)
    return meh, median([abs(xx - meh) for xx in x])

for z in zip(*tests):
    print madAndMedian(z)
4

2 回答 2

4

是的，它在每个循环上重建 lambda；它需要重新评估整个表达式。

要看到这一点，请使用dis模块：

>>> dis.dis(method1)
  2           0 LOAD_CLOSURE             0 (el)
              3 BUILD_TUPLE              1
              6 LOAD_CONST               1 (<code object <lambda> at 0x102000230, file "<stdin>", line 2>)
              9 MAKE_CLOSURE             0
             12 STORE_FAST               2 (p)

  3          15 BUILD_LIST               0
             18 LOAD_FAST                0 (xs)
             21 GET_ITER            
        >>   22 FOR_ITER                24 (to 49)
             25 STORE_FAST               3 (x)
             28 LOAD_FAST                2 (p)
             31 LOAD_FAST                3 (x)
             34 CALL_FUNCTION            1
             37 POP_JUMP_IF_FALSE       22
             40 LOAD_FAST                3 (x)
             43 LIST_APPEND              2
             46 JUMP_ABSOLUTE           22
        >>   49 RETURN_VALUE        
>>> dis.dis(method2)
  2           0 BUILD_LIST               0
              3 LOAD_FAST                0 (xs)
              6 GET_ITER            
        >>    7 FOR_ITER                33 (to 43)
             10 STORE_FAST               2 (x)
             13 LOAD_CLOSURE             0 (el)
             16 BUILD_TUPLE              1
             19 LOAD_CONST               1 (<code object <lambda> at 0x101fd37b0, file "<stdin>", line 2>)
             22 MAKE_CLOSURE             0
             25 LOAD_FAST                2 (x)
             28 CALL_FUNCTION            1
             31 POP_JUMP_IF_FALSE        7
             34 LOAD_FAST                2 (x)
             37 LIST_APPEND              2
             40 JUMP_ABSOLUTE            7
        >>   43 RETURN_VALUE

操作码加载 lambda 主体的LOAD_CONST编译代码；MAKE_CLOSURE从中创建 lambda。For method1this 发生一次，而 for method2this 在循环的每次迭代中重复（从FOR_ITER操作码到JUMP_ABSOLUTE操作码）；请注意LOAD_FAST变量的操作码，p其中method1它指的是局部变量。

于 2013-01-09T12:52:35.737 回答
2

Python 只构建 lambda 的代码一次。但它会在循环的每一次传递中构建一个新的函数对象（指代代码和包含el变量的封闭环境）。这通常是一个特性，因为每个函数对象都可以通过__setitem__.

在这种情况下，函数对象不会存储在任何地方，也不会泄漏到范围之外，因此将其创建移到循环之外是安全的，但是 Python 的编译器还不够聪明，无法执行这样的优化。

于 2013-01-09T12:57:05.103 回答