Python中函数装饰器介绍以及使用 装饰器难点说明

函数的装饰器

装饰器本质上就是函数，功能就是装饰它的函数，为其它函数添加附加功能。我们假设你写的几百个函数已经在线上运行了，但后期老板需要你添加一些函数原本没有的功能，这你不可能说一个个去原函数中修改吧，所以这时候就可以使用装饰器，解释的够清楚了吧！˘ᴗ˘

注意:

• 1.装饰器不能修改被装饰的函数的源代码
• 2.装饰器不能修改被装饰函数的调用方式

• 1.函数即变量
• 2.知道高阶函数、嵌套函数
• 3.高阶函数+嵌套函数—->装饰器

def foo():
    print('i am foo() function')

现在有一个新的需求，希望可以记录下函数的执行日志，于是在代码中添加日志代码：

def foo():
    print('i am foo() function')
    logging.info("foo() function is running")

import logging
def use_logging(func):
    logging.warning("%s is running" % func.__name__) 
    #创建warn警告的日志，.__name__是返回函数的名字
    func()

def foo():
    print('i am foo() function')

use_logging(foo)  #这里foo函数当实参不要加()，在函数部分已经解释过原因
#分清函数之间的传递

这样做逻辑上是没问题的，功能是实现了，但是我们调用的时候不再是调用真正的业务逻辑 foo 函数，而是换成了 use_logging 函数，这就破坏了原有的代码结构， 现在我们不得不每次都要把原来的那个 foo 函数作为参数传递给 use_logging 函数，那么有没有更好的方式的呢？当然有，答案就是装饰器。

def use_logging(func):
    def wrapper():
        logging.warning("%s is running" % func.__name__)
        return func()   # 把 foo 当做实参传递进来时，执行func()就相当于执行foo()
    return wrapper
def foo():
    print('i am foo() function')
    #return 'i am foooooo' #返回值实际上是None
foo = use_logging(foo)  # 因为装饰器 use_logging(foo) 返回的时函数对象 wrapper，
                        #这条语句相当于  foo = wrapper
foo()                   # 执行foo()就相当于执行 wrapper()

这里我们需要注意执行foo()就相当于执行 wrapper()在原函数里面想要带有返回值，你就需要去修改装饰器wrapper函数，它有返回值的话，原函数就会有返回值的

use_logging 就是一个装饰器，它一个普通的函数，它把执行真正业务逻辑的函数 func 包裹在其中，看起来像 foo 被 use_logging 装饰了一样，use_logging 返回的也是一个函数，这个函数的名字叫 wrapper。在这个例子中，函数进入和退出时 ，被称为一个横切面，这种编程方式被称为面向切面的编程。

@ 语法糖

前面说了那么多废话就是为了把你们引到这里，装饰器就是用 @ 符号来把它装饰到函数上的，它放在函数开始定义的地方，这样就可以省略最后一步再次赋值的操作。

def use_logging(func):
    def wrapper():
        logging.warn("%s is running" % func.__name__)
        return func()
    return wrapper

@use_logging #相当于foo=use_logging(foo)
def foo():
    print("i am foo() function")

foo()

如上所示，有了 @ ，我们就可以省去foo = use_logging(foo)这一句了，直接调用 foo() 即可得到想要的结果。你们看到了没有，foo() 函数不需要做任何修改，只需在定义的地方加上装饰器，调用的时候还是和以前一样，如果我们有其他的类似函数，我们可以继续调用装饰器来修饰函数，而不用重复修改函数或者增加新的封装。这样，我们就提高了程序的可重复利用性，并增加了程序的可读性。那么你可以做一些练习题来检测一下自己是否真的理解了

*args、**kwargs

可能有人问，如果我的业务逻辑函数 foo 需要参数怎么办？

def wrapper(*args):
        logging.warn("%s is running" % func.__name__)
        return func(*args)
    return wrapper
#*args可以传多个参数

如此一来，甭管 foo 定义了多少个参数，我都可以完整地传递到 func 中去。这样就不影响 foo 的业务逻辑了。这时还有读者会问，如果 foo 函数还定义了一些关键字参数呢？比如：

def foo(name, age=None, height=None):
    print("I am %s, age %s, height %s" % (name, age, height))
#%s格式化字符串

这时，你就可以把 wrapper 函数指定关键字函数：

def wrapper(*args, **kwargs):
        # args是一个数组，kwargs一个字典
        logging.warn("%s is running" % func.__name__)
        return func(*args, **kwargs)
    return wrapper

带参数的装饰器

装饰器还有更大的灵活性，例如带参数的装饰器，在上面的装饰器调用中，该装饰器接收唯一的参数就是执行业务的函数 foo 。装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。比如，我们可以在装饰器中指定日志的等级，因为不同业务函数可能需要的日志级别是不一样的。

装饰器如果加了参数的话，就是在装饰器中再加一层函数，用来接受参数，里面的函数还是跟原来的一样

import logging
def use_logging(level): #用来接收装饰器的参数
    def decorator(func):  #传入函数foo1，
        def wrapper(*args, **kwargs):
            if level == "warn":
                logging.warning("%s is running" % func.__name__)
            elif level == "info":
#默认情况下debug信息和info信息都不会被显示出来,所以如果关键字是info的话，什么内容也没有添加
                logging.info("%s is running" % func.__name__)
            return func(*args)
        return wrapper
    return decorator
@use_logging(level="warn")  #可以理解为foo1()=wapper()
def foo1(name='foo1'):
    print("i am %s" % name)
foo1()

@use_logging(level="info")
def foo2(name='foo2'):
    print("i am %s" % name)
foo2()

上面的 use_logging 是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level=”warn”)调用的时候，Python 能够发现这一层的封装，并把参数传递到装饰器的环境中。@use_logging(level=”warn”) 等价于 @decorator，对于新手来说不断地嵌套会有点模糊的，何况我还用了没有说明的logging模块，你可以在练习题中获得更深刻的理解