2022年 11月 5日

Python——回调函数（callback）

摘要

主要是介绍python 的回调函数callback。

什么是回调函数

当程序运行是，一般情况下，应用程序会时常通过API调用库里所预先备好的函数。但是有些库函数却要求应用先传给它一个函数，好在合适的时候调用，以完成目标任务。这个被传入的、后又被调用的函数就称为回调函数（callback function）。

例如：

有一家旅馆提供叫醒服务，但是要求旅客自己决定叫醒的方法。可以是打客房电话，也可以是派服务员去敲门，睡得死怕耽误事的，还可以要求往自己头上浇盆水。这里，“叫醒”这个行为是旅馆提供的，相当于库函数，但是叫醒的方式是由旅客决定并告诉旅馆的，也就是回调函数。而旅客告诉旅馆怎么叫醒自己的动作，也就是把回调函数传入库函数的动作，称为登记回调函数（to register a callback function）

可以看到，回调函数通常和应用处于同一抽象层（因为传入什么样的回调函数是在应用级别决定的）。而回调就成了一个高层调用底层，底层再回过头来调用高层的过程。（我认为）这应该是回调最早的应用之处，也是其得名如此的原因。

回调机制的优势

回调机制提供了非常大的灵活性。我们把图中的库函数改称为中间函数了，这是因为回调并不仅仅用在应用和库之间。任何时候，只要想获得类似于上面情况的灵活性，都可以利用回调。有的同学可定想回调似乎只是函数间的调用，可以发现两者之间的一个关键的不同：

在回调中，我们利用某种方式，把回调函数像参数一样传入中间函数。可以这么理解，在传入一个回调函数之前，中间函数是不完整的。换句话说，程序可以在运行时，通过登记不同的回调函数，来决定、改变中间函数的行为。这就比简单的函数调用要灵活太多了。

  1. #回调函数1
  2. #生成一个2k形式的偶数
  3. def double(x):
  4.     return x * 2
  5.     
  6. #回调函数2
  7. #生成一个4k形式的偶数
  8. def quadruple(x):
  9.     return x * 4
  10.  
  11. callback_demo.py`
  12.  
  13. from even import *
  14.  
  15. #中间函数
  16. #接受一个生成偶数的函数作为参数
  17. #返回一个奇数
  18. def getOddNumber(k, getEvenNumber):
  19.     return 1 + getEvenNumber(k)
  20.     
  21. #起始函数，这里是程序的主函数
  22. def main():    
  23.     k = 1
  24.     #当需要生成一个2k+1形式的奇数时
  25.     i = getOddNumber(k, double)
  26.     print(i)
  27.     #当需要一个4k+1形式的奇数时
  28.     i = getOddNumber(k, quadruple)
  29.     print(i)
  30.     #当需要一个8k+1形式的奇数时
  31.     i = getOddNumber(k, lambda x: x * 8)
  32.     print(i)
  33.     
  34. if __name__ == "__main__":
  35.     main()

异步处理有关的回调函数

  1. def apply_ascyn(func, args, callback):
  2.     """ 
  3.     func 函数的是处理的函数
  4.     args 表示的参数
  5.     callback 表示的函数处理完成后的 该执行的动作
  6.     """
  7.     result = func(*args)
  8.     callback(result)
  9.  
  10. def add(x, y):
  11.     return x + y
  12.  
  13. def print_result(result):
  14.     print(result)
  15.  
  16. apply_ascyn(add, (2, 3), callback=print_result)

这里print_result只能接收一个result的参数，不能传入其他信息。当想让回调函数访问其他变量或者特定环境的变量值的时候会遇到问题。

使用一个绑定方法来代替这个简单函数。

  1. def appy_async(func, args, *, callback):
  2.     result = func(*args)
  3.     #异步执行的函数 同时将执行后返回到这个早从这个函数跳出去
  4.     callback(result)
  5.  
  6. def add(x ,y):
  7.     return x + y
  8.  
  9. class ResultHandler(object):
  10.     def __init__(self):
  11.         self.sequence = 0
  12.  
  13.     def handle(self, result):
  14.         self.sequence += 1
  15.         print("[{}] Got: {}".format(self.sequence, result))
  16.  
  17. resultHandler = ResultHandler()
  18. appy_async(add, (2,3), callback=resultHandler.handle)

 使用闭包代替上面的类来实现

  1. def apply_async(func, args, *, callback):
  2.     result = func(*args)
  3.     callback(result)
  4.  
  5. def add(x ,y):
  6.     return x + y
  7.  
  8. def make_handler():
  9.     sequence = 0
  10.     def handler(result):
  11.         nonlocal sequence
  12.         sequence += 1
  13.         print("[{}] Got:{}".format(sequence, result))
  14.     return handler
  15.  
  16. handler = make_handler()
  17. apply_async(add, (2,3), callback=handler)

使用协程来完成异步操作

  1. def apply_async(func, args, *, callback):
  2.     result = func(*args)
  3.     callback(result)
  4.  
  5. def add(x, y):
  6.     return x + y
  7.  
  8. def make_handler():
  9.     sequence = 0
  10.     while True:
  11.         result = yield
  12.         sequence += 1
  13.         print("[{}] Got:{}".format(sequence, result))
  14.  
  15. handle = make_handler()
  16. next(handle)
  17.  
  18. apply_async(add, (2,3), callback=handle.send)

博文参考:

python3回调函数(callback) – 知乎