Python的装饰器

1.闭包的概念

（1）什么是闭包？

在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。

（2）闭包的强大之处

一般一个函数运行结束的时候，临时变量会被销毁。但是闭包是一个特别的情况：当外函数发现，自己的临时变量会在将来的内函数中用到，自己在结束的时候，返回内函数的同时，会把外函数的临时变量同内函数绑定在一起。这样即使外函数已经结束了，内函数仍然能够使用外函数的临时变量。这就是闭包的强大之处。

代码示例：

#闭包函数的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer( a ):
    b = 10
    # inner是内函数
    def inner():
        #在内函数中 用到了外函数的临时变量
        print(a+b)
    # 外函数的返回值是内函数的引用
    return inner

if __name__ == '__main__':
    # 在这里我们调用外函数传入参数5
    #此时外函数两个临时变量 a是5 b是10 ，并创建了内函数，然后把内函数的引用返回存给了demo
    # 外函数结束的时候发现内部函数将会用到自己的临时变量，这两个临时变量就不会释放，会绑定给这个内部函数
    demo = outer(5)
    # demo存了外函数的返回值，也就是inner函数的引用，这里相当于执行inner函数
    demo() # 15
    demo2 = outer(7)
    demo2()#17

15
17

(3) 闭包中内函数修改外函数局部变量

在基本的python语法当中，一个函数可以随意读取全局数据，但是要修改全局数据的时候有两种方法:

• 1 global 声明全局变量
• 2 全局变量是可变类型数据的时候可以修改

在闭包内函数也是类似的情况。在内函数中想修改闭包变量（外函数绑定给内函数的局部变量）的时候，有两种方法：

• 1.可以用nonlocal 关键字声明 一个变量， 表示这个变量不是局部变量空间的变量，需要向上一层变量空间找这个变量。
• 2.可以把闭包变量改成可变类型数据进行修改，比如列表。

代码示例：

#修改闭包变量的实例
# outer是外部函数 a和b都是外函数的临时变量
def outer( a ):
    b = 10  # a和b都是闭包变量
    c = [a] #这里对应修改闭包变量的方法2
    # inner是内函数
    def inner():
        #内函数中想修改闭包变量
        # 方法一  nonlocal关键字声明
        nonlocal  b
        b+=1
        # 方法二，把闭包变量修改成可变数据类型 比如列表
        c[0] += 1
        print(c[0])
        print(b)
    # 外函数的返回值是内函数的引用
    return inner

if __name__ == '__main__':

    demo = outer(5)
    demo() # 6  11

6
11

2.Python的装饰器

顾名思义，它是用来"装饰"Python的工具，使得代码更具有Python简洁的风格。换句话说，它是一种函数的函数，因为装饰器传入的参数就是一个函数，然后通过实现各种功能来对这个函数的功能进行增强。
装饰器的本质就是一个python的函数,它在不需要更改任何代码的前提下给函数增加额外的功能。

(1) 在哪里使用装饰器？

装饰器最大的优势是用于解决重复性的操作，其主要使用的场景有如下几个：

• 计算函数运行时间
• 给函数打日志
• 类型检查
• 插入日志、性能测试、事务处理、缓存、权限校验等场景，装饰器是解决这类问题的绝佳设计

当然，如果遇到其他重复操作的场景也可以类比使用装饰器。有了装饰器，我们就可以抽离出大量与函数功能本身无关的雷同代码到装饰器中并继续重用。

(2) 装饰器的使用

装饰器的使用有两种方法:

• 方法一：不用语法糖@符号
• 方法二：采用语法糖@符号

1.装饰器不带参数，被修饰函数也不带参数的情况

由下面的示例代码可以看到，use_logging 就是一个装饰器，它一个普通的函数，它把执行真正业务逻辑的函数 func 包裹在其中，然后加上了日志功能，看起来像 foo 被 use_logging 装饰了一样，use_logging 返回的也是一个函数，这个函数的名字叫 wrapper。

## 不用语法糖
import 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')

foo = use_logging(foo)  # 因为装饰器 use_logging(foo) 返回的是函数对象 wrapper，这条语句相当于
# foo = wrapper
foo()                   # 执行foo()就相当于执行 wrapper()

## 使用语法糖
def use_logging(func):

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

@use_logging
def foo():
    print("i am foo")

foo()

@语法糖的用法

@ 符号就是装饰器的语法糖，它放在函数开始定义的地方，这样就可以省去foo = use_logging(foo)这一句了，直接调用 foo() 即可得到想要的结果。

可以看到，foo() 函数不需要做任何修改，只需在定义的地方加上装饰器，调用的时候还是和以前一样，这样我们就提高了程序的可重复利用性，并增加了程序的可读性。

2.装饰器不带参数，被修饰的函数带参数的情况

如果被修饰的函数带参数， 则装饰器函数的内函数也要带上参数（可以用*args定义参数，用**kwargs定义关键字参数。）
代码示例：

def use_logging(func):

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

@use_logging
def foo(name, age=None, height=None):
    print("I am %s, age %s, height %s" % (name, age, height))

foo('小红',18,165)

/opt/conda/lib/python3.7/site-packages/ipykernel_launcher.py:5: DeprecationWarning: The 'warn' function is deprecated, use 'warning' instead
"""
WARNING:root:foo is running
I am 小红, age 18, height 165

3.装饰器带参数，被修饰的函数带参数的情况

装饰器还有更大的灵活性，例如带参数的装饰器。在上面的装饰器调用中，该装饰器接收唯一的参数就是执行业务的函数 foo。

装饰器的语法允许我们在调用时，提供其它参数，比如@decorator(a)。这样，就为装饰器的编写和使用提供了更大的灵活性。

比如，我们可以在装饰器中指定日志的等级，因为不同业务函数可能需要的日志级别是不一样的。

## 装饰器带参数,就是在原有装饰器基础上，再在外面包一层，传递一个外部函数的变量进去
def use_logging(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if level == "warn":
                logging.warning("%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 能够发现这一层的封装，并把参数传递到装饰器的环境中。

(3) 装饰器的顺序

一个函数还可以同时定义多个装饰器，比如：

@a
@b
@c
def f ():
    pass

它的执行顺序是从里到外，最先调用最里层的装饰器，最后调用最外层的装饰器，它等效于

f = a(b(c(f)))

代码示例 :

#装饰器的基本使用

#定义函数：完成包裹数据
def makeBold(fn):
    def wrapped():
        return "<b>" + fn() + "</b>"
    return wrapped

#定义函数：完成包裹数据
def makeItalic(fn):
    def wrapped():
        return "<i>" + fn() + "</i>"
    return wrapped

@makeBold
def test1():
    return "hello world-1"

@makeItalic
def test2():
    return "hello world-2"

@makeBold
@makeItalic
def test3():
    return "hello world-3"

print(test1())
print(test2())
print(test3())

hello world-1
hello world-2
hello world-3