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

悠悠 2022-01-16 13:39 219阅读 0赞

[上一篇:由浅入深,走进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 :       <function old at 0x00000000024DAA60>
    >>>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 :        <function old at 0x00000000024AAAE8>
    >>> 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 :         <function outer.<locals>.inner at 0x00000000024FAAE8>
    >>> 1 我是outer函数,接收外部传进来的old的参数 :   普通参数a=1,  默认参数b=22,  多余的普通参数:args1和args2
    >>> 1 我是outer函数,接收外部传进来的old的参数 :   命令关键字参数d:4,  多余的关键字参数:value1和value2
    >>> 1 我是outer函数,接收外部传进来的old :         <function old at 0x00000000024FAA60>
    >>> 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 : <function old at 0x0000000001E8ABF8>
    >>> 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 :        <function old at 0x00000000021CABF8>
    >>> 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 :       <function old at 0x00000000024DAA60>
    >>>1 我是outer函数,接收外部传进来的old的参数 : 音乐
    >>>2 我是old函数, 参数:音乐
    >>>3 我是outer函数,我在old函数后显示

转载于:https://blog.51cto.com/dldxzjr/2378431

[Python_-----]: https://blog.51cto.com/dldxzjr/2378412