Question

我正在处理小部件和信号，我想将信号绑定到某个回调。因为我真的不需要在感兴趣的情况下创建一个命名回调函数，所以我将它定义为lambda函数。但是，它与其他类集成的方式最好用以下最小的工作示例来描述：

class Foo():
    def parse(self, what):
        self.bar = what

foo = lambda x = Foo(): (x.parse("All set"), x)[-1]

print(foo().bar)
'All set'

lambda函数需要实例化一个类，调用其成员之一来解析字符串并更改其内部状态，并返回实例化的类。目前我能想到的唯一方法就是如上例所示：将实例作为默认参数传递，创建一个列表，其中第一个元素是对方法的调用，第二个元素是实例本身，然后选择最后一个元素。

是否有更多的pythonic和优雅的方法来获得相同的结果？

编辑：一些警告：在实际代码中，类Foo在其他模块中定义，并且我将lambda作为参数传递给另一个函数，因此我不需要为回调命名。实际上，我实际拥有的东西看起来像是

widget.bind( 'some_signal', lambda t, x = Foo(): (x.parse(t), x)[-1] )

Answer 1

最pythonic解决方案是不使用lambda：

def foo():
    x = Foo()
    x.parse("All set")
    return x

print(foo().bar)

python中的Lambdas是一种语法上的方便，并且比命名函数的功能强大得多。

Answer 2

工厂函数实现了在连接回调的代码中避免单独命名函数的目标。我会考虑这个pythonic。使用lambda函数做你必须做的事情绝对不是pythonic。

def create_callback(data):
    def callback():
        x = Foo()
        x.parse(data)
        return x
    return callback

Answer 3

基于@Vaibhav Sagar回答，有点修改：

class Foo():
    def parse(self, what):
        self.bar = what


def foo_factory(what):
    instance = Foo()
    instance.parse(what)
    return instance


all_set = foo_factory('All set')
ok = foo_factory('Ok')
ready = foo_factory('ready')

print(all_set)
print(all_set.bar)
print(ok)
print(ok.bar)
print(ready)
print(ready.bar)

输出：

<__main__.Foo object at 0x7f56a176cc50>
All set
<__main__.Foo object at 0x7f56a176cc88>
Ok
<__main__.Foo object at 0x7f56a176ccf8>
ready

Answer 4

怎么样？

def callback():
    x = Foo()
    x.parse("All set")
    return x

widget.bind('some_signal', callback)

注意，只有在第一次解释代码时，您的lambda才会实现Foo()。

实际上，

foo = lambda d=dict(): d

d = foo()
d['hello'] = 'world'
print(foo()) # This will print {'hello': 'world'} instead of {}

什么是实例化类的pythonic方法，调用其中一个方法，并从lambda函数返回它？

4 个答案: