python装饰器

2019年10月12日 / 22次阅读 / Last Modified 2019年10月14日
语法

python装饰器的本质,就是闭包

我们一般谈Python的闭包,都是指普通的入参,而谈装饰器的时候,入参一定有函数!闭包和装饰器,返回的都是函数。函数是代码的最小封装单位,装饰器作用于函数,它不影响函数自身的执行,只是在函数的执行前后增加一些“装饰性”的动作。装饰器被称为python的语法糖(syntax sugar),也被视为python支持AOP编程(面向切面编程)的工具。

简单装饰器

以下代码实现了一个最简单的额装饰器,功能是给带上装饰器的函数,在函数执行前,增加一行print打印,代码如下:

def calling_trace(func):
    def wrapper():
        print('calling', func.__name__)
        func()
    return wrapper

@calling_trace
def test1():
    print('test1 is runing...')

# test1 = calling_trace(test1)
test1()

test1函数加上了calling_trace装饰器,在第7行,这一行代码的作用,相同于第11行的注释。test1还是test1,这个名字没有变,只是换成了一个闭包函数的返回值,此闭包函数,就是装饰器,它接收一个函数作为参数。以上代码运行效果如下:

$ python3 deco.py
calling test1
test1 is runing...

我们还可以稍微复杂一点点,既然是装饰器,被装饰的函数执行前后都可以加点小动作。修改后的代码如下:

def calling_trace(func):
    def wrapper():
        print('calling', func.__name__)
        a = func()
        print('this is the reture:',a)
    return wrapper

@calling_trace
def test2():
    print('test2 is runing...')
    return 'www.pynote.net'

# test2 = calling_trace(test2)
test2()

新的装饰器没有改名字,只是获取了被装饰函数的返回值,并将返回值打印出来。运行效果如下:

$ python3 deco.py
calling test2
test2 is runing...
this is the reture: www.pynote.net

test2函数执行前后,都增加了一些动作,作为装饰!

这就是装饰器的概念:不修改已有函数的代码,也不修改已有函数的调用处代码,却达到了丰富函数功能的效果!本质上装饰器是对函数的一种封装,只是我们要理解@语法。

闭包和装饰器

装饰器的本质就是闭包,我们如果把上面这段代码重写一遍,采用闭包的语法形式,不使用@语法,效果是完全一样的:

def calling_trace(func):
    def wrapper():
        print('calling', func.__name__)
        a = func()
        print('this is the reture:',a)
    return wrapper

def test2():
    print('test2 is runing...')
    return 'www.pynote.net'

t = calling_trace(test2)
t()

以上代码,没有@语法的使用啦,用变量t来获取calling_trace返回的函数对象,然后调用,效果与使用装饰器完全一样:

$ python3 deco.py
calling test2
test2 is runing...
this is the reture: www.pynote.net

使用@语法,阅读代码就如吃糖!

装饰带参数的函数

如果被装饰的函数有参数,需要在装饰器内部原样复制函数的参数定义。请看示例:

def calling_trace(func):
    def wrapper(a,b,c=3):
        print('calling', func.__name__)
        a = func(a,b,c)
        print('reture value:',a)
    return wrapper

@calling_trace
def test3(a,b,c=3):
    print('test3 is runing...')
    return a+b+c

test3(1,2,5)
test3(1,2)

装饰器返回的函数的参数定义,要与被装饰函数的参数定义保持一致!以上代码运行结果如下:

$ python3 deco.py
calling test3
test3 is runing...
reture value: 8
calling test3
test3 is runing...
reture value: 6

就算装饰参数个数不定的函数,语法上也是一样的,请看下面代码,test4函数的参数个数不定:

def calling_trace(func):
    def wrapper(*args):
        print('calling', func.__name__)
        a = func(*args)
        print('reture value:',a)
    return wrapper

@calling_trace
def test4(*args):
    print('test4 is runing...')
    return sum(args)

test4(1,2,3,4,5,6,7,8)
test4(23,34,45,56)

*args表示一个tuple,在函数定义处出现,就是packing打包调用时的参数,在调用时出现,就是unpacking展开tuple。跟**kw(对应dict)用法一样。以上代码运行效果:

$ python3 deco.py
calling test4
test4 is runing...
reture value: 36
calling test4
test4 is runing...
reture value: 158

给带参数的函数加装饰器,还有一种更通用更常见的参数写法,这种写法在修改函数参数和调用处时,有可以反过来保持装饰器部分代码不变。示例如下:

def calling_trace(func):
    def wrapper(*args, **kw):
        print('calling', func.__name__)
        a = func(*args, **kw)
        print('reture value:',a)
    return wrapper

@calling_trace
def test5(a,b,c=3):
    print('test5 is runing...')
    return a+b+c

test5(1,2)
test5(1,2,c=8)

装饰器中使用*args和**kw来接收和传递参数!这个地方要好好体会,这是python的一个特别精妙的地方。以上代码运行结果如下:

$ python3 deco.py
calling test5
test5 is runing...
reture value: 6
calling test5
test5 is runing...
reture value: 11

带参数的装饰器

本文以上示例,都是不带参数的装饰器,在使用@语法的时候,没有参数。而装饰器本身也可以带参数,通过在装饰器外再使用闭包,给装饰器封装其执行环境,可以使装饰器的功能更强大更灵活,也可以更好的控制函数的执行(比如在某些情况下不执行)。而带参数的装饰器,在语法上,也就跟闭包区分开来。(应该就是这个原因,闭包和装饰器在python中是分成了两个概念)

def calling_trace(run):
    def deco(func):
        def wrapper(*args, **kw):
            print('calling', func.__name__)
            if run == 1:
                a = func(*args, **kw)
                print('reture value:',a)
            else:
                print('not allow to run')
        return wrapper
    return deco

# test5 = calling_trace(run=1)(test5)
@calling_trace(run=1)
def test5(a,b,c=3):
    print('test5 is runing...')
    return a+b+c

@calling_trace(run=0)
def test6(*args):
    print('test6 is runing...')
    return sum(args)

test5(1,2)
test5(1,2,c=8)
test6(23,34,45,56)

先看一下这段代码的运行结果:

$ python3 deco.py
calling test5
test5 is runing...
reture value: 6
calling test5
test5 is runing...
reture value: 11
calling test6
not allow to run

达到预期,test5可以执行,而test6不允许执行。

calling_trace实际上就是一个闭包,它有一个参数,run,调用calling_trace(run=1)后,就相当于返回了一个有run这个参数的装饰器。然后再用这个装饰器去“修饰”它自己的参数func。这个效果,就如注释掉的那行代码。如果不使用@语法,把那行代码注释打开(放在test5的定义后面),运行效果一模一样!

多重装饰器

函数可以有多个装饰器!多个装饰器的效果,就相当于对函数进行了多层的封装包裹,而不同的装饰器对函数执行的功能影响,完全独立。比如有个装饰器用来控制函数是否能够被执行,另一个装饰器控制函数的所有raise出来的异常。

@a
@b
@c
def tt(): pass
# tt = a(b(c(tt)))

tt函数上面带3个装饰器,想过正如注释掉的那行代码。

我真的觉得python装饰器的设计,实在是非常精妙!

-- EOF --

本文链接:https://www.pynote.net/archives/1300

留言区

《python装饰器》有1条留言

电子邮件地址不会被公开。 必填项已用*标注

  • 麦新杰

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


前一篇:
后一篇:

More

麦新杰的Python笔记

Ctrl+D 收藏本页


©Copyright 麦新杰 Since 2019 Python笔记

go to top