文章 96
评论 76
浏览 89991
Python之@函数装饰器

Python之@函数装饰器

@函数装饰器

装饰器的作用 —— 不想修改函数的调用方式 但是还想在原来的函数前后添加功能
原则: 开放封闭原则
开放 : 对扩展是开放的
封闭 : 对修改是封闭的

示例

当程序使用“@函数”(比如函数 A )装饰另一个函数(比如函数 B )时, 实际上完成如下两
步。

  1. 将被修饰的函数(函数 B )作为参数传给@符号引用的函数(函数 A )。
  2. 将函数 B 替换(装饰)成第 ① 步的返回值。
    从上面介绍不难看出,被“@函数”修饰的函数不再是原来的函数,而是被替换成一个新的东西。

看一下实例:

def funA(fn):
    print('A')
    fn()
    return 'asdf'
'''
下面的装饰效果相当于funA(funB)
funB 将会被替换(装饰)成该语句的返回值
由于funA 函数返回fkit ,因此funB 就是asdf
'''
@funA
def funB():
    print('B')
print(funB)

上面程序使用@funA 修饰 funB ,这意味着程序要完成两步操作。
① 将 funB 作为 funA()的参数,也就是上面的粗体字代码相当于执行 funA(funB)。
② 将 funB 替换成 ① 第步执行的结果, funA()执行完成后返回 asdf,因此 funB 就不再是函数,而是被替换成一个字符串。
查看运行结果:

A
B
asdf

实例 2:

def wapper(func):
    def inner(*args,**kargs):
        ret = func(*args,**kargs)
        return ret
    return inner
@wapper   #qqxing = wrapper(qqxing)
def qqxing():
    print(123,123)
qqxing()  #实际是行inner

这个函数装饰器导致被修饰的函数变成了字符串,那么函数装饰器有什么用?
别忘记了,被修饰的函数总是被替换成@符号所引用的函数的返回值,因此被修饰的函数会变成什么,完全由于@符号所引用的函数的返回值决定一一如果@符号所引用的函数的返回值是函数,那么被修饰的函数在替换之后还是函数。

下面师范更为复杂的函数装饰器:

def foo(fn):
    def bar(*args):
        print("1",args)
        n = args[0]
        print(2,n*(n-1))
        print(fn.__name__)
        fn(n*(n-1))
        print("*"*15)
        return fn(n*(n-1))
    return bar
'''
下面的装饰效果相当于foo(my_test)
my_test 将会被替换(装饰〉成该语句的返回值
由于foo()函数返回bar 函数,因此funB 就是bar
'''
@foo
def my_test(a):
    print("==3==",a)
print(my_test)
# my_test(10)
my_test(5,6)

上面程序定义了一个装饰器函数 foo ,该函数执行完成后并不是返回普通值,而是返回 bar 函数(这是关键〉,这意味着被该@foo 修饰的函数最终都会被替换成 bar 函数。

上面程序使用@foo 修饰 my_test()函数,因此程序同样会执行 foo(my_test),并将 my_test 替换成 foo()函数的返回值: bar 函数。所以,上面程序代码print(my_test)在打印 my_test 函数时,实际上输出的是 bar 函数,这说明 my_test 已经被替换成 bar 函数。接下来程序两次调用 my_test()函数,实际上就是调用 bar()函数。

运行结果:

<function foo.<locals>.bar at 0x000001E2ECA52708>
1 (5, 6)
2 20
my_test
==3== 20
***************
==3== 20

通过@符号来修饰函数是 Python 的一个非常实用的功能,它既可以在被修饰函数的前面添加一些额外的处理逻辑(比如权限检查),也可以在被修饰函数的后面添加-些额外的处理逻辑( 比如记录日志),还可以在目标方法抛出异常时进行一些修复操作……这种改变不需要修改被修饰函数的代码,只要增加一个修饰即可。

总结装饰器语法:

@deco
def target():
    print('running target()')

上述代码可写成:

def target():
    print('running target()')
target = deco(target)

两种写法的最终结果一样:上述两个代码片段执行完毕后得到的 target 不一定是原来那个 target 函数,而是 decorate(target) 返回的函数。

装饰器通常把函数替换成另一个函数

def deco(func):
    def inner():
        print('running inner()')
    return inner 
@deco
def target():
    print('running target()')
print(target())

❶ deco 返回 inner 函数对象。
❷ 使用 deco 装饰 target。
❸ 调用被装饰的 target 其实会运行 inner。
❹ 审查对象,发现 target 现在是 inner 的引用。

模拟场景:

def auth(fn):
    def auth_fn(*args):
    #用一条语句模拟执行权限检查
        print("---权限检查---")
    #回调修饰的目标函数
        fn(*args)
    return auth_fn

@auth
def test(a,b):
    print("执行test函数,参数a: %s,参数b: %s"%(a,b))
test(100,13)

上面程序使用@auth 修饰了 test()函数,这会使得 test()函数被替换成 auth()函数所返回的 auth_fn
函数,而 auth_fn 函数的执行流程是:
① 先执行权限检查;
② 回调被修饰的目标函数——简单来说, auth_fn 函数就为被修饰函数添加了一个权限检查的功能。

多个装饰器装饰一个函数

def wrapper1(func):
    def inner1():
        print('wrapper1 ,before func')
        ret = func()
        print('wrapper1 ,after func')
        return ret
    return inner1

def wrapper2(func):
    def inner2():
        print('wrapper2 ,before func')
        ret = func()
        print('wrapper2 ,after func')
        return ret
    return inner2

def wrapper3(func):
    def inner3():
        print('wrapper3 ,before func')
        ret = func()
        print('wrapper3 ,after func')
        return ret
    return inner3

@wrapper3
@wrapper2
@wrapper1
def f():
    print('in f')
    return '哈哈哈'
print(f())

返回值 L:

wrapper2 ,before func
wrapper1 ,before func
in f
wrapper1 ,after func
wrapper2 ,after func
哈哈哈

@装饰函数顺序决定执行函数顺序

可大概看下是行顺序:
image.png

  • 装饰器会先找离自己最近的函数,因为@wrapper2 没找到,则在@wrapper1 那里进行执行。

大致代码执行过程:
image.png

image.png

到头来 我们记住的 不是敌人的攻击 而是朋友的沉默 ---马丁·路德·金

                    

记录精彩的坎坷人生,经营属于自己的世界!