2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

# 使用@语法放在函数的定义上面 相当于执行 f=outer(f)，此时f赋值成为了一个新的outer函数，

# 此时f函数就指向了outer函数的返回值inner，inner是一个函数名，定义在oute函数里面

# 原来的f是函数名可简单理解为一个变量，作为outer函数的参数传递进去了 此时参数func相当于f

def outer(func):                    # 定义一个outer函数作为装饰器

    def inner():　　　　　　　　　　　 # 如果执行inner()函数的话步骤如下：

        print(‘start‘)              # 1、首先打印了字符‘start’，

        r=func()                    # 2、执行func函数，func函数相当于def f(): print(‘中‘)

        print(‘end‘)                # 3、接着函数打印‘end’

        return r                    # 4、将func函数的结果返回

    return inner

@outer

def f():              # f=outer(f)=innner

    print(‘中‘)

f()                   # f()相当于inner(),执行inner函数的步骤看上面定义处的注释<br>#打印结果顺序为   start 中 end

2

3

4

5

6

7

8

9

10

11

12

13

14

15

#其实只要将上面一种不带参数的装饰器修改一下就可以了

#修改也很简单，只需将inner和func的参数改为 (*args,**kwargs)

#其他实现的过程和上面一种一样，就不再介绍了

def outer(func):

    def inner(*args,**kwargs):

        print(‘start‘)

        r=func(*args,**kwargs)    # 这里func(*args,**kwargs)相当于f(a,b)

        print(‘end‘)

        return r

    return inner

@outer

def f(a,b):

    print(a+b)

f(1,4)          　　　　　　　　　　# f(1,4)相当于inner(1,4) 这里打印的结果为 start 5 end

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

def outer2(func2):

    def inner2(*args,**kwargs):

        print(‘开始‘)

        r=func2(*args,**kwargs)

        print(‘结束‘)

        return r

    return inner2

def outer1(func1):

    def inner1(*args,**kwargs):

        print(‘start‘)

        r=func1(*args,**kwargs)

        print(‘end‘)

        return r

    return inner1

@outer2                                # 这里相当于执行了 f=outer1(f)  f=outer2(f)，步骤如下

@outer1                                #1、f=outer1(f) f被重新赋值为outer1(1)的返回值inner1，

def f():                               #    此时func1为 f():print(‘f 函数‘)

    print(‘f 函数‘)                     #2、f=outer2(f) 类似f=outer2(inner1) f被重新赋值为outer2的返回值inner2

                                       #    此时func2 为inner1函数 inner1里面func1函数为原来的 f():print(‘f 函数‘)

f()                                    # 相当于执行 outer2(inner1)()

>>开始                                  # 在outer函数里面执行，首先打印 ‘开始 ’

>>start                                # 执行func2 即执行inner1函数 打印 ‘start’

>>f 函数                               # 在inner1函数里面执行 func1 即f()函数，打印 ‘f 函数’

>>end                                  # f函数执行完，接着执行inner1函数里面的 print(‘end‘)

>>结束                                 # 最后执行inner2函数里面的 print(‘结束‘)

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

import functools

def log(k=‘‘):                                      　　#这里参数定义的是一个默认参数，如果没有传入参数，默认为空，可以换成其他类型的参数

    def decorator(func):

        @functools.wraps(func)                      　　#这一句的功能是使被装饰器装饰的函数的函数名不被改变，

        def wrapper(*args, **kwargs):

            print(‘start‘)

            print(‘{}:{}‘.format(k, func.__name__))    #这里使用了装饰器的参数k

            r = func(*args, **kwargs)

            print(‘end‘)

            return r

        return wrapper

    return decorator

@log()                        # fun1=log()(fun1) 装饰器没有使用参数

def fun1(a):

    print(a + 10)

fun1(10)

# print(fun1.__name__)        # 上面装饰器如果没有@functools.wraps(func)一句的话，这里打印出的函数名为wrapper

@log(‘excute‘)                # fun2=log(‘excute‘)(fun2) 装饰器使用给定参数

def fun2(a):

    print(a + 20)

fun2(10)