由浅入深,走进Python装饰器-----第二篇:进阶--函数装饰函数

上一篇:由浅入深,走进Python装饰器-----第一篇:基础

---

---

装饰器的使用种类:

# 第一种
@函数
   被装饰函数

# 第二种
@函数
    被装饰类

# 第三种
@类
    被装饰类

# 第四种
@函数
   被装饰函数

---

---

本篇介绍第一种

@函数
   被装饰函数

1.1 对带参数的原函数进行修饰

# 默认将old函数的参数传给outer里面的第一层函数
def outer(f):
    def inner(var):
        print("1 我是outer函数,接收外部传进来的old :",f)
        print("1 我是outer函数,接收外部传进来的old的参数 :",var)
        f(var)
        print("3 我是outer函数,我在old函数后显示")
    return inner
    def inner2(var):
        pass
@outer                                     #old = outer(old)
def old(var):
    print("2 我是old函数","参数: ",var)

var = '音乐'                                                
old(var)

>>>1 我是outer函数,接收外部传进来的old :       
>>>1 我是outer函数,接收外部传进来的old的参数 : 音乐
>>>2 我是old函数, 参数:音乐
>>>3 我是outer函数,我在old函数后显示

1.2 对多参数的原函数进行修饰

def outer(f):
    def inner(a, b,*args,d,**kwargs):
        tmp = d                                            #通过变量接收命名关键字参数传进来的参数,然后再传递给内部调用的函数                          
        print("1 我是outer函数,接收外部传进来的old :",f)
        print("1 我是outer函数,接收外部传进来的old的参数 :\
            普通参数a={}, 默认参数b={}, 多余的普通参数:{}和{}".format(a,b,args[0],args[1]))
        print("1 我是outer函数,接收外部传进来的old的参数 :\
            命令关键字参数d:{}, 多余的关键字参数:{}和{}".format(d,kwargs["key1"],kwargs["key2"]))
        f(a,b, *args,d = tmp,**kwargs)
        print("3 我是outer函数,我在old函数后显示")
    return inner

@outer                                     #old = outer(old)
def old(a, b=2, *args,d,**kwargs):         #五种参数
    print("2 我是old函数",
        "普通参数a={0}, 默认参数b={1}, 多余的普通参数:{2}和{3},\
        命令关键字参数d:{4}, 多余的关键字参数:{5}和{6}"\
        .format(a,b,args[0],args[1],d,kwargs["key1"],kwargs["key2"]))

dict1 = {"key1":"value1","key2":"value2"}
old(1,22,'args1','args2',d=4,**dict1)

>>> 1 我是outer函数,接收外部传进来的old :        
>>> 1 我是outer函数,接收外部传进来的old的参数 :  普通参数a=1, 默认参数b=22, 多余的普通参数:args1和args2
>>> 1 我是outer函数,接收外部传进来的old的参数 :  命名关键字参数d:4, 多余的关键字参数:value1和value2
>>> 2 我是old函数 普通参数a=1, 默认参数b=22, 多余的普通参数:args1和args2,命名关键字参数d:4, 多余的关键字参数:value1和value2
>>> 3 我是outer函数,我在old函数后显示

1.3 对多参数的原函数进行嵌套修饰

def outer(f):
    def inner(a, b,*args,d,**kwargs):
        tmp = d                                            #通过变量接收命名关键字参数传进来的参数,然后再传递给内部调用的函数                          
        print("1 我是outer函数,接收外部传进来的old :",f)
        print("1 我是outer函数,接收外部传进来的old的参数 :\
            普通参数a={}, 默认参数b={}, 多余的普通参数:{}和{}".format(a,b,args[0],args[1]))
        print("1 我是outer函数,接收外部传进来的old的参数 :\
            命令关键字参数d:{}, 多余的关键字参数:{}和{}".format(d,kwargs["key1"],kwargs["key2"]))
        f(a,b, *args,d = tmp,**kwargs)
        print("3 我是outer函数,我在old函数后显示")
    return inner

@outer                         #old = outer(outer(old))
@outer                         #old = outer(old)
def old(a, b=2, *args,d,**kwargs):         #五种参数
    print("2 我是old函数",
        "普通参数a={0}, 默认参数b={1}, 多余的普通参数:{2}和{3},\
        命令关键字参数d:{4}, 多余的关键字参数:{5}和{6}"\
        .format(a,b,args[0],args[1],d,kwargs["key1"],kwargs["key2"]))

dict1 = {"key1":"value1","key2":"value2"}
old(1,22,'args1','args2',d=4,**dict1)

>>> 1 我是outer函数,接收外部传进来的old :         .inner at 0x00000000024FAAE8>
>>> 1 我是outer函数,接收外部传进来的old的参数 :   普通参数a=1,  默认参数b=22,  多余的普通参数:args1和args2
>>> 1 我是outer函数,接收外部传进来的old的参数 :   命令关键字参数d:4,  多余的关键字参数:value1和value2
>>> 1 我是outer函数,接收外部传进来的old :         
>>> 1 我是outer函数,接收外部传进来的old的参数 :   普通参数a=1, 默认参数b=22, 多余的普通参数:args1和args2
>>> 1 我是outer函数,接收外部传进来的old的参数 :   命令关键字参数d:4, 多余的关键字参数:value1和value2
>>> 2 我是old函数 普通参数a=1, 默认参数b=22, 多余的普通参数:args1和args2,命令关键字参数d:4, 多余的关键字参数:value1和value2
>>> 3 我是outer函数,我在old函数后显示
>>> 3 我是outer函数,我在old函数后显示

1.4 用带参数的装饰器函数 对 无参数原函数 进行修饰

def kuozhan(can_shu):
    def outer(f):
        tmp = can_shu
        def inner1():
            print("1 我是outer函数里的inner1,接收外部传进来的old :",f)
            f()
            print("3 我是outer函数里的inner1,我在old函数后显示")

        def inner2():
            print("1 我是outer函数里的inner2,接收外部传进来的old :",f)
            f()
            print("3 我是outer函数里的inner2,我在old函数后显示")
        if tmp == 1:
            return inner1
        else:
            return inner2

@kuozhan(2)                          # old = kuozhan(2)(old)    ==>      old = outer(old)
def old():
    print("2 我是old函数")

old()

>>> 1 我是outer函数里的inner2,接收外部传进来的old : 
>>> 2 我是old函数
>>> 3 我是outer函数里的inner2,我在old函数后显示

1.5用带参数的装饰器函数 对 有参数原函数 进行修饰

def kuozhan(can_shu):
    def outer(f):
        tmp = can_shu
        def inner1(var):
            print("1 我是outer函数里的inner1,接收外部传进来的old :",f)
            print("1  我是outer函数里的inner1,接收外部传进来的old的参数 :",var)
            f(var)
            print("3 我是outer函数里的inner1,我在old函数后显示")

        def inner2(var):
            print("1 我是outer函数里的inner2,接收外部传进来的old :",f)
            print("1  我是outer函数里的inner2,接收外部传进来的old的参数 :",var)
            f(var)
            print("3 我是outer函数里的inner2,我在old函数后显示")
        if tmp == 1:
            return inner1
        else:
            return inner2
    return outer

@kuozhan(2)                         # old = kuozhan(2)(old)    ==>      old = outer(old)
def old(var):
    print("2 我是old函数,","我的参数是: ",var)
var = "音乐"                                              
old(var)

>>> 1 我是outer函数里的inner2,接收外部传进来的old :        
>>> 1 我是outer函数里的inner2,接收外部传进来的old的参数 :  音乐
>>> 2 我是old函数,      我的参数是:  音乐
>>> 3 我是outer函数里的inner2,我在old函数后显示

1.6 对类内部的方法进行修饰

# 默认将old函数的参数传给outer里面的第一层函数
def outer(f):
    def inner(var):
        print("1 我是outer函数,接收外部传进来的old :",f)
        print("1 我是outer函数,接收外部传进来的old的参数 :",var)
        f(var)
        print("3 我是outer函数,我在old函数后显示")
    return inner
    def inner2(var):
        pass
class MyClass():
    @outer                                     #old = outer(old)
    def old(var):
        print("2 我是old函数","参数: ",var)

var = '音乐'                                                
MyClass.old(var)

>>>1 我是outer函数,接收外部传进来的old :       
>>>1 我是outer函数,接收外部传进来的old的参数 : 音乐
>>>2 我是old函数, 参数:音乐
>>>3 我是outer函数,我在old函数后显示