5

我正在使用 lambda 函数与 tkinter 进行 GUI 编程。最近我在实现打开文件的按钮时卡住了：

self.file=""
button = Button(conf_f, text="Tools opt.",
        command=lambda: tktb.helpers.openfile(self.file))

如您所见，我想定义一个可以更新的文件路径，而这在创建 GUI 时是未知的。我遇到的问题是，早些时候我的代码是：

button = Button(conf_f, text="Tools opt.",
        command=lambda f=self.file: tktb.helpers.openfile(f))

lambda 函数有一个关键字参数来传递文件路径。在这种情况下，参数f未更新时self.file是。

我从代码片段中获得了关键字参数，并在任何地方使用它。显然我不应该...

这对我来说仍然不清楚......有人可以解释一下这两种 lambda 形式之间的区别以及何时使用彼此吗？

谢谢！

PS：以下评论使我找到了解决方案，但我想要更多解释： lambda workingly with tkinter

4

1 回答 1

10

我将尝试更深入地解释它。

如果你这样做

i = 0
f = lambda: i

您创建一个函数（lambda 本质上是一个函数），它访问其封闭范围的i变量。

在内部，它通过一个包含i. 粗略地说，它是一种指向实变量的指针，它可以在不同的时间点保存不同的值。

def a():
    # first, yield a function to access i
    yield lambda: i
    # now, set i to different values successively
    for i in range(100): yield

g = a() # create generator
f = next(g) # get the function
f() # -> error as i is not set yet
next(g)
f() # -> 0
next(g)
f() # -> 1
# and so on
f.func_closure # -> an object stemming from the local scope of a()
f.func_closure[0].cell_contents # -> the current value of this variable

在这里，所有的值i- 在他们的时间 - 都存储在该闭包中。如果函数f()需要它们。它从那里得到它们。

您可以在反汇编列表中看到这种差异：

这些说的功能a()和f()反汇编是这样的：

>>> dis.dis(a)
  2           0 LOAD_CLOSURE             0 (i)
              3 BUILD_TUPLE              1
              6 LOAD_CONST               1 (<code object <lambda> at 0xb72ea650, file "<stdin>", line 2>)
              9 MAKE_CLOSURE             0
             12 YIELD_VALUE
             13 POP_TOP

  3          14 SETUP_LOOP              25 (to 42)
             17 LOAD_GLOBAL              0 (range)
             20 LOAD_CONST               2 (100)
             23 CALL_FUNCTION            1
             26 GET_ITER
        >>   27 FOR_ITER                11 (to 41)
             30 STORE_DEREF              0 (i)
             33 LOAD_CONST               0 (None)
             36 YIELD_VALUE
             37 POP_TOP
             38 JUMP_ABSOLUTE           27
        >>   41 POP_BLOCK
        >>   42 LOAD_CONST               0 (None)
             45 RETURN_VALUE
>>> dis.dis(f)
  2           0 LOAD_DEREF               0 (i)
              3 RETURN_VALUE

b()将其与看起来像的函数进行比较

>>> def b():
...   for i in range(100): yield
>>> dis.dis(b)
  2           0 SETUP_LOOP              25 (to 28)
              3 LOAD_GLOBAL              0 (range)
              6 LOAD_CONST               1 (100)
              9 CALL_FUNCTION            1
             12 GET_ITER
        >>   13 FOR_ITER                11 (to 27)
             16 STORE_FAST               0 (i)
             19 LOAD_CONST               0 (None)
             22 YIELD_VALUE
             23 POP_TOP
             24 JUMP_ABSOLUTE           13
        >>   27 POP_BLOCK
        >>   28 LOAD_CONST               0 (None)
             31 RETURN_VALUE

循环的主要区别是

        >>   13 FOR_ITER                11 (to 27)
             16 STORE_FAST               0 (i)

在b()与

        >>   27 FOR_ITER                11 (to 41)
             30 STORE_DEREF              0 (i)

in a()：STORE_DEREF存储在cell对象（闭包）中，同时STORE_FAST使用“正常”变量，它（可能）工作得更快一点。

lambda 也有所不同：

>>> dis.dis(lambda: i)
  1           0 LOAD_GLOBAL              0 (i)
              3 RETURN_VALUE

在这里你有一个LOAD_GLOBAL，而上面的一个使用LOAD_DEREF. 后者也用于关闭。

我完全忘记了lambda i=i: i。

如果您将该值作为默认参数，它会通过完全不同的路径进入函数： 的当前值i通过默认参数传递给刚刚创建的函数：

>>> i = 42
>>> f = lambda i=i: i
>>> dis.dis(f)
  1           0 LOAD_FAST                0 (i)
              3 RETURN_VALUE

这样该函数就被称为f(). 它检测到缺少参数并用默认值填充相应的参数。这一切都发生在函数被调用之前；在函数中，您只会看到该值被获取并返回。

还有另一种方法可以完成您的任务：只需使用 lambda，就好像它需要一个值：lambda i: i。如果你调用它，它会抱怨缺少参数。

但是您可以使用以下方法来应对functools.partial：

ff = [functools.partial(lambda i: i, x) for x in range(100)]
ff[12]()
ff[54]()

这个包装器获取一个可调用的和许多要传递的参数。结果对象是一个可调用对象，它使用这些参数以及您提供给它的任何参数调用原始可调用对象。它可以在这里用来保持锁定到预期的值。

于 2013-07-16T08:21:24.027 回答