装饰器应用场景

01. 装饰器语法糖

如果你接触 Python 有一段时间了的话，想必你对 @ 符号一定不陌生了，没错 @ 符号就是装饰器的语法糖。
它放在一个函数开始定义的地方，它就像一顶帽子一样戴在这个函数的头上。和这个函数绑定在一起。在我们调用这个函数的时候，第一件事并不是执行这个函数，而是将这个函数做为参数传入它头顶上这顶帽子，这顶帽子我们称之为装饰函数
或 装饰器。

你要问我装饰器可以实现什么功能？我只能说你的脑洞有多大，装饰器就有多强大。

装饰器的使用方法很固定：

    先定义一个装饰函数（帽子）（也可以用类、偏函数实现）
    再定义你的业务函数、或者类（人）
    最后把这顶帽子带在这个人头上

装饰器的简单的用法有很多，这里举两个常见的。

    日志打印器
    时间计时器

02. 入门用法：日志打印器

首先是日志打印器。

它要实现的功能是

• 在函数执行前，先打印一行日志告知一下主人，我要执行函数了。
• 在函数执行完，也不能拍拍屁股就走人了，咱可是有礼貌的代码，再打印一行日志告知下主人，我执行完啦。

    # 这是装饰函数
    def logger(func):
      def wrapper(*args, **kw):
        print('我准备开始计算：{} 函数了:'.format(func.__name__))
    
        # 真正执行的是这行。
        func(*args, **kw)
    
        print('啊哈，我计算完啦。给自己加个鸡腿！！')
      return wrapper
    
    

假如，我的业务函数是，计算两个数之和。写好后，直接给它带上帽子。

    @logger
    def add(x, y):
      print('{} + {} = {}'.format(x, y, x+y))
    

然后我们来计算一下。

    add(200, 50)
    

快来看看输出了什么，神奇不？

我准备开始计算：add 函数了:
200 + 50 = 250
啊哈，我计算完啦。给自己加个鸡腿！

03. 入门用法：时间计时器

再来看看 时间计时器

实现功能：顾名思义，就是计算一个函数的执行时长。

    # 这是装饰函数
    def timer(func):
      def wrapper(*args, **kw):
        t1=time.time()
        # 这是函数真正执行的地方
        func(*args, **kw)
        t2=time.time()
    
        # 计算下时长
        cost_time = t2-t1 
        print("花费时间：{}秒".format(cost_time))
      return wrapper    

假如，我们的函数是要睡眠10秒。这样也能更好的看出这个计算时长到底靠不靠谱。

    import time
    
    @timer
    def want_sleep(sleep_time):
      time.sleep(sleep_time)
    
    want_sleep(10) 

来看看，输出。真的是10秒。

花费时间：10.0073800086975098秒

04. 进阶用法：带参数的函数装饰器

通过上面简单的入门，你大概已经感受到了装饰的神奇魅力了。

不过，装饰器的用法远不止如此。我们今天就要把这个知识点学透。

上面的例子，装饰器是不能接收参数的。其用法，只能适用于一些简单的场景。不传参的装饰器，只能对被装饰函数，执行固定逻辑。

如果你有经验，你一定经常在项目中，看到有的装饰器是带有参数的。

装饰器本身是一个函数，既然做为一个函数都不能携带函数，那这个函数的功能就很受限。只能执行固定的逻辑。这无疑是非常不合理的。而如果我们要用到两个内容大体一致，只是某些地方不同的逻辑。不传参的话，我们就要写两个装饰器。小明觉得这不能忍。

那么装饰器如何实现传参呢，会比较复杂，需要两层嵌套。

同样，我们也来举个例子。

我们要在这两个函数的执行的时候，分别根据其国籍，来说出一段打招呼的话。

    def american():
      print("I am from America.")
    
    def chinese():
      print("我来自中国。")    

在给他们俩戴上装饰器的时候，就要跟装饰器说，这个人是哪国人，然后装饰器就会做出判断，打出对应的招呼。
戴上帽子后，是这样的。

    @say_hello("china")
    def chinese():
      print("我来自中国。")
    
    @say_hello("america")
    def american():
      print("I am from America.")   

万事俱备，只差帽子了。来定义一下，这里需要两层嵌套。

    def say_hello(contry):
      def wrapper(func):
        def deco(*args, **kwargs):
          if contry == "china":
            print("你好!")
          elif contry == "america":
            print('hello.')
          else:
            return
    
          # 真正执行函数的地方
          func(*args, **kwargs)
        return deco
      return wrapper    

执行一下

    american()
    print("------------")
    chinese()

看看输出结果。

hello.
I am from America.
------------
你好!
我来自中国。

05. 高阶用法：不带参数的类装饰器

以上都是基于函数实现的装饰器，在阅读别人代码时，还可以时常发现还有基于类实现的装饰器。

基于类装饰器的实现，必须实现 call 和 __init__两个内置函数。

• init ：接收被装饰函数
• call ：实现装饰逻辑。

    class logger(object):
      def __init__(self, func):
        self.func = func
    
      def __call__(self, *args, **kwargs):
        print("[INFO]: the function {func}() is running...".format(func=self.func.__name__))
        return self.func(*args, **kwargs)
    
    @logger
    def say(something):
      print("say {}!".format(something))
    
    say("hello")   

我们指定WARNING级别，运行一下，来看看输出。

[INFO]: the function say() is running...
say hello!