python 装饰器

Posted 2021-01-23 jackchengcc

　　装饰器本质上是一个 Python 函数或类，它可以让其他函数或类在不需要做任何代码修改的前提下增加额外功能，装饰器的返回值也是一个函数/类对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景，装饰器是解决这类问题的绝佳设计。有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码到装饰器中并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

　　python装饰器之前首先要了解：python中函数的定义、函数作为返回值、函数作为参数、函数的嵌套以及闭包的使用

　　1）函数的定义　

def foo(num):
    return num+1

　　

　　调用函数只需要给函数名加上括号并传递必要的参数（如果函数定义的时候有参数的话）

value = foo(3)
print(value) # 4

　　变量名 foo 现在指向 <function foo at 0x1030060c8> 函数对象，但它也可以指向另外一个函数。

def bar():
    print("bar")
foo = bar
foo() # bar

　　

　　2）函数作为返回值

　　　　在Python中，一切皆为对象，函数也不例外，它可以像整数一样作为其它函数的返回值，例如：

def foo():
    return 1

def bar():
    return foo

print(bar()) # <function foo at 0x10a2f4140>

print(bar()()) # 1 
# 等价于
print(foo()) # 1

　　调用函数 bar() 的返回值是一个函数对象（一个函数地址） ，因为返回值是函数，所以我们可以继续对返回值进行调用（记住：调用函数就是在函数名后面加()）调用bar()()相当于调用 foo()，因为 变量 foo 指向的对象与 bar() 的返回值是同一个对象。

　　

　　3）函数作为参数

　　　　函数还可以像整数一样作为函数的参数，例如：

def foo(num):
    return num + 1

def bar(fun):
    return fun(3)

value = bar(foo)
print(value)  # 4

　　函数 bar 接收一个参数，这个参数是一个可被调用的函数对象，把函数 foo 传递到 bar中去时，foo 和 fun 两个变量名指向的都是同一个函数对象，所以调用 fun(3) 相当于调用 foo(3)。

　　

　　4）函数嵌套

　　　　函数不仅可以作为参数和返回值，函数还可以定义在另一个函数中，作为嵌套函数存在，例如：　　

def outer():
    x = 1
    def inner():
        print(x)
    inner()

outer() # 1

　　inner做为嵌套函数，它可以访问外部函数的变量，调用 outer 函数时，发生了3件事：

　　　　给变量 x 赋值为1

　　　　定义嵌套函数 inner，此时并不会执行 inner 中的代码，因为该函数还没被调用，直到第3步

　　　　调用 inner 函数，执行 inner 中的代码逻辑。

　　5）闭包

def outer(x):
    def inner():
        print(x)

    return inner
closure = outer(1)
closure() # 1

　　同样是嵌套函数，只是稍改动一下，把局部变量 x 作为参数了传递进来，嵌套函数不再直接在函数里被调用，而是作为返回值返回，这里的 closure就是一个闭包，本质上它还是函数，闭包是引用了自由变量(x)的函数(inner)。

　　重头戏（装饰器）

　　1）无参装饰器

def outer(func):
    def inner():
        print("记录日志开始")
        func() # 业务函数
        print("记录日志结束")
    return inner

def foo():
    print("foo")

foo = outer(foo) 
foo()

 

　　我没有修改 foo 函数里面的任何逻辑，只是给 foo 变量重新赋值了，指向了一个新的函数对象。最后调用 foo()，不仅能打印日志，业务逻辑也执行完了。现在来分析一下它的执行流程。

　　这里的 outer 函数其实就是一个装饰器，装饰器是一个带有函数作为参数并返回一个新函数的闭包，本质上装饰器也是函数。outer 函数的返回值是 inner 函数，在 inner 函数中，除了执行日志操作，还有业务代码，该函数重新赋值给 foo 变量后，调用 foo() 就相当于调用 inner()

　　foo重新赋值前：

　　　　

　　重新赋值后，foo = outer(foo)

　　

　　装饰器中@语法糖中@outer相当于foo = outer(foo) 

　　2）带参数的装饰器

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

def use_logging(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if level == "warn":
                logging.warn("%s is running" % func.__name__)
            elif level == "info":
                logging.info("%s is running" % func.__name__)
            return func(*args)
        return wrapper

    return decorator

@use_logging(level="warn")
def foo(name=‘foo‘):
    print("i am %s" % name)

foo()

　　上面的 use_logging 是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我

们使用@use_logging(level="warn")调用的时候，Python 能够发现这一层的封装，并把参数传递到装饰器的环境中。

　　@use_logging(level="warn")等价于@decorator

　　3）类装饰器

　　装饰器不仅可以是函数，还可以是类，相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器主要依靠类的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

class Foo(object):
    def __init__(self, func):
        self._func = func

    def __call__(self):
        print (‘class decorator runing‘)
        self._func()
        print (‘class decorator ending‘)

@Foo
def bar():
    print (‘bar‘)

bar()