python中如何实现装饰器

装饰器

装饰器要求

给予一个函数，在不修改源码的前提下，实现在函数执行前和执行后分别输入

装饰器技术要求

1. 闭包
2. 函数嵌套
3. 函数传参
4. @函数名

函数示例

给予一个函数

def func():
    print("我是func函数")
    value = (11,22,33,44)
    return value

函数fun结果为

我是func函数
（11,22,33,44）

要求，在函数执行前后分别输入“before”和“after”

直接加print输出

def func():
    print("before")
    
    print("我是func函数")
    value = (11,22,33,44)
    
    print("aftere")
    return value

此时执行结果为

before
我是func函数
after
(11,22,33,44)

哈，一个函数这样操作简单，但是多个函数肯定是不能每一个都这样添加的

思路

将原函数封装在闭包中，然后将函数赋值为一个新的函数（内层函数），执行函数时再在内层函数中执行闭包中的原函数。

先写一个这样的,可以认为是1.0版本

def outer ():
    def inner():
        pass
    return inner

func = outer()
result = func()

先分析代码

func =  outer()

1.  执行outer函数
2.  outer函数返回inner 
3. fun等于inner函数

result = func()
此时不执行上面func函数而是执行inner函数
               

继续修改,outer定义一个参数，把func传过去

def outer (origin):
    def inner():
        res = origin()
        return res
    
    return inner

func = outer(func)
result = func()
print(result)

继续分析代码

func = outer(func)
1，outer函数中origin指向示例的func函数
2，完成一个闭包
3，inner返回给func

result = func()
1,此时执行的是inner函数
2，给inner函数内部添加内容，res = origin()
3,执行origin（），即是执行示例中的func函数
这是因为outer(func),把func当做参数传给origin

res = origin()
        return res
1,示例中func函数有返回值，用res接受并返回

此时函数输出结果，与给予函数没有区别

def func():
    print("我是func函数")
    value = (11,22,33,44)
    return value

def outer (origin):
    def inner():
        print("before")
        res = origin()
        print("after")
        return res
    
    return inner

func = outer(func)
result = func()
print(result)

功能实现，但是代码超级复杂

python中特殊语法——@函数名

@函数名
def xxx():
    pass

在某个函数上方，使用@函数名，python会自动执行函数名，会把函数当做参数传递过去，即是 函数名（xxx），再将结果赋值为xxx，即是xxx = 函数名（xxx）。

优化代码

def outer (origin):
    def inner():
        print("before")
        res = origin()
        print("after")
        return res
    
    return inner

@outer     #func = outer(func)
def func():
     print("我是func函数")
    value = (11,22,33,44)
    return value

result = func()
print(result)

1,用@outer 取代func = outer(func)

2，python是逐行解释，使用了@outer ，outer函数必须在前

3，效果一样，功能实现

在单个函数中依旧超级麻烦

需求改为给予多个函数

现在有三个函数,都需要在函数执行前后分别输入“before”和“after”

def func1():
    print("我是func1函数")
    value = (11,22,33,44)
    return value

def func2():
    print("我是func2函数")
    value = (11,22,33,44)
    return value

def func3():
    print("我是func3函数")
    value = (11,22,33,44)
    return value

func1()
func2()
func3()

直接加@outer

def outer (origin):
    def inner():
        print("before")
        res = origin()
        print("after")
        return res
    
    return inner

@outer 
def func1():
    print("我是func1函数")
    value = (11,22,33,44)
    return value

@outer 
def func2():
    print("我是func2函数")
    value = (11,22,33,44)
    return value

@outer 
def func3():
    print("我是func3函数")
    value = (11,22,33,44)
    return value

func1()
func2()
func3()

不需要返回值了，结果为

before
我是func1函数
after
before
我是func2函数
after
before
我是func3函数
after

总结，批量在多个函数执行前后添加内容，使用装饰器方便

继续分析优化

在函数有参数了

def func1(a1):
    print("我是func1函数")
    value = (11,22,33,44)
    return value

def func2(a1,a2):
    print("我是func2函数")
    value = (11,22,33,44)
    return value

def func3(a1):
    print("我是func3函数")
    value = (11,22,33,44)
    return value

func1(1)
func2(11,a2=22)
func3(999)

此时func函数有参数,而装饰器中inner没有，

就需要万能的动态参数，

def outer(origin):
    def inner(*args, **kwargs):
        print("before 110")
        res = origin(*args, **kwargs)  # 调用原来的func函数
        print("after")
        return res

    return inner


@outer  # func1 = outer(func1)
def func1(a1):
    print("我是func1函数")
    value = (11, 22, 33, 44)
    return value


@outer  # func2 = outer(func2)
def func2(a1, a2):
    print("我是func2函数")
    value = (11, 22, 33, 44)
    return value


@outer  # func3 = outer(func3)
def func3(a1):
    print("我是func3函数")
    value = (11, 22, 33, 44)
    return value


func1(1)
func2(11, a2=22)
func3(999)

执行结果为

我是func1函数
after
before 110
我是func2函数
after
before 110
我是func3函数
after

最终结果

• 实现原理：基于@语法和函数闭包，将原函数封装在闭包中，然后将函数赋值为一个新的函数（内层函数），执行函数时再在内层函数中执行闭包中的原函数。
• 实现效果：可以在不改变原函数内部代码 和 调用方式的前提下，实现在函数执行和执行扩展功能。
• 适用场景：多个函数系统统一在 执行前后自定义一些功能。

def outer (origin):
    def inner(*args, **kwargs):
       #执行前
        res = origin（*args, **kwargs）#调用原来的函数
        #执行后
        return res    
    return inner

@outer
def func():
    pass

func()