如何写一个简单的回调函数？

Question

Python 2.7.10

我写了下面的代码来测试一个简单的回调函数。

def callback(a, b):
    print('Sum = {0}'.format(a+b))

def main(callback=None):
    print('Add any two digits.')
    if callback != None:
        callback

main(callback(1, 2))

我在执行时收到：

Sum = 3
Add any two digits.

为什么 Add any two digits 在 Sum = 3 之后？我猜是因为回调函数先执行了。 main()中的所有其他代码执行完后如何执行回调函数？

Answer 1

如评论中所述，只要您的回调以打开和关闭的括号为后缀，就会调用它；因此当你通过它时它会被调用。

您可能想要使用 lambda 并传入值。

#!/usr/bin/env python3

def main(callback=None, x=None, y=None):
    print('Add any two digits.')
    if callback != None and x != None and y != None:
        print("Result of callback is {0}".format(callback(x,y)))
    else:
        print("Missing values...")

if __name__ == "__main__":
    main(lambda x, y: x+y, 1, 2)

Answer 2

问题是您在将回调作为可调用对象传递之前评估回调。解决问题的一种灵活方法是：

def callback1(a, b):
    print('Sum = {0}'.format(a+b))

def callback2(a):
    print('Square = {0}'.format(a**2))

def callback3():
    print('Hello, world!')

def main(callback=None, cargs=()):
    print('Calling callback.')
    if callback != None:
        callback(*cargs)

main(callback1, cargs=(1, 2))
main(callback2, cargs=(2,))
main(callback3)

您可能希望包含一种支持关键字参数的方法。

Answer 3

这是您想要做的事情：

def callback(a, b):
    print('Sum = {0}'.format(a+b))

def main(a,b,f=None):
    print('Add any two digits.')
    if f is not None:
        f(a,b)

main(1, 2, callback)

Answer 4

你的代码执行如下：

main(callback(1, 2))

callback 函数用 (1, 2) 调用，它 returns None （没有 return 语句，你的函数打印 Sum = 3 和returns None)

main 函数以 None 作为参数调用（因此 callback != None 将始终为 False）

Answer 5

在此代码中

if callback != None:
    callback

callback 本身什么都不做；它接受参数 - def callback(a, b):

您首先执行 callback(1, 2) 的事实将调用该函数，从而打印 Sum = 3，然后使用 callback 函数的结果调用 main()，这是打印第二行

由于 callback returns 没有明确的值，它返回为 None。

因此，您的代码等同于

callback(1, 2)
main()

解决方案

您可以尝试先不调用该函数，只传递它的句柄。

def callback(n):
    print("Sum = {}".format(n))

def main(a, b, _callback = None):
    print("adding {} + {}".format(a, b))
    if _callback:
        _callback(a+b)

main(1, 2, callback)

Answer 6

这是一个旧的 post，但也许以下内容可能是关于编写和使用回调函数的额外说明，特别是如果您想知道它从哪里获取参数以及您是否可以访问它的 return 值（如果没有办法从接受回调函数的函数中获取）。

下面的代码定义了一个 class CallBack，它有两个回调方法（函数）my_callback_sum 和 my_callback_multiply。回调方法被送入方法 foo.

# understanding callback

class CallBack:

    @classmethod
    def my_callback_sum(cls, c_value1, c_value2):
        value = c_value1 + c_value2
        print(f'in my_callback_sum --> {c_value1} + {c_value2} = {value}')
        cls.operator = '+'
        return cls.operator, value

    @classmethod
    def my_callback_multiply(cls, c_value1, c_value2):
        value = c_value1 * c_value2
        print(f'in my_callback_multiply --> {c_value1} * {c_value2} = {value}')
        cls.operator = '*'
        return cls.operator, value

    @staticmethod
    def foo(foo_value, callback):
        _, value = callback(10, foo_value)
        # note foo only returns the value not the operator from callback!
        return value


if __name__ == '__main__':
    cb = CallBack()

    value = cb.foo(20, cb.my_callback_sum)
    print(f'in main --> {value} and the operator is {cb.operator}')

    value = cb.foo(20, cb.my_callback_multiply)
    print(f'in main --> {value} and the operator is {cb.operator}')

结果：

in my_callback_sum --> 10 + 20 = 30
in main --> 30 and the operator is +
in my_callback_multiply --> 10 * 20 = 200 
in main --> 200 and the operator is *

如您所见，回调函数 c_value2 的一个值来自 foo 中的参数 foo_value，并在 main 中给出值 20，而 c_value1 在这种情况下，它在内部从 foo 获取值 10（如果 foo 是第三方导入模块的某种方法，如 pyaudio，则可能不清晰可见）。

回调函数函数的return值可以通过将其添加到classCallBack的命名空间来检索，在本例中为cls.operator

Answer 7

您可以使用匿名函数

def callback(a, b):
    print('Sum = {0}'.format(a+b))

def main(callback=None):
    print('Add any two digits.')
    if callback != None:
        callback()

tmp_func = lambda: main(lambda: callback(2,3))
tmp_func()

#OR

tmp_func = lambda x,y: main(lambda: callback(x,y))
tmp_func(2,4)

如何写一个简单的回调函数？

How to write a simple callback function?

python

callback

python-2.x

python-2.7

解决方案