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)#调用原来的函数
        #执行后
        print("after")
        return res    
    return inner

@outer
def func():
    pass

func()
上一篇:Java|内部类


下一篇:Java内部类及其实例化