Python(6)——装饰器

装饰器就是对函数或者方法或者类进行修饰

#第一步：基本函数

def zuofan():
    print('做饭真好')

#调用函数
zuofan()
zuofan()


#第二步：扩展功能（不能直接修改原来函数#）

#定义用于扩展函数的函数
def decorate(func):
    #1.扩展功能1
    print('做饭之前，沐浴更衣')
    #2.原有函数功能
    func()#相当于调用zuofan
    #3.扩展功能2
    print('做饭之后，焚香祭祖')

def zuofan():
    print('做饭真好')

#装饰步骤(调用）
zuofan = decorate(zuofan)
#因为装饰函数没有返回值，做饭接收的是None
zuofan()
zuofan()


#第三步：装饰器功能

#定义用于扩展函数的函数
def decorate(func):#func接收做饭的函数
    #inner 就是扩展之后的做饭函数
    def inner():
        # 1.扩展功能1
        print('做饭之前，沐浴更衣')
        # 2.原有函数功能
        func()  # 相当于调用zuofan
        # 3.扩展功能2
        print('做饭之后，焚香祭祖')
    #返回值必须是函数，因为zuofan原来是函数
    return inner

def zuofan():
    print('做饭真好')

#装饰步骤(调用）
zuofan = decorate(zuofan)
#调用做饭函数
zuofan()
zuofan()

#第四步：语法糖方式事项装饰器

#定义用于扩展函数的函数
def decorate(func):#func接收做饭的函数
    #inner 就是扩展之后的做饭函数
    def inner():
        # 1.扩展功能1
        print('做饭之前，沐浴更衣')
        # 2.原有函数功能
        func()  # 相当于调用zuofan
        # 3.扩展功能2
        print('做饭之后，焚香祭祖')
    #返回值必须是函数，因为zuofan原来是函数
    return inner

@decorate #装饰步骤(调用） 相当于zuofan = decorate(zuofan)
def zuofan():
    print('做饭真好')
#调用做饭函数
zuofan()
zuofan()


#第五步：带有参数函数的装饰器

#定义用于扩展函数的函数
def decorate(func):#func接收做饭的函数
    #inner 就是扩展之后的做饭函数
    def inner(who,where):
        # 1.扩展功能1
        print('做饭之前，沐浴更衣')
        # 2.原有函数功能
        func(who,where)  # 相当于调用zuofan
        # 3.扩展功能2
        print('做饭之后，焚香祭祖')
    #返回值必须是函数，因为zuofan原来是函数
    return inner

@decorate #装饰步骤(调用） 相当于zuofan = decorate(zuofan)
def zuofan(who,where):
    print(who + '在'+ where +'做饭真好')

#因为装饰函数没有返回值，做饭接收的是None
zuofan('寒冰','北极')
zuofan('寒冰','北极')


#带有返回值的函数
#定义用于扩展函数的函数
def decorate(func):#func接收做饭的函数
    #inner 就是扩展之后的做饭函数
    def inner():
        # 1.扩展功能1
        print('做饭之前，沐浴更衣')
        # 2.原有函数功能
        var = func()  # 相当于调用zuofan
        # 3.扩展功能2
        print('做饭之后，焚香祭祖')
        #添加返回值，相当于zuofan函数的返回值
        return var

    #返回值必须是函数，因为zuofan原来是函数
    return inner

@decorate #装饰步骤(调用） 相当于zuofan = decorate(zuofan)
def zuofan():
    print('做饭真好')
    return '一大碗白饭'

#因为装饰函数没有返回值，做饭接收的是None
result = zuofan()
print(result)


#第六步：带有收集参数的函数装饰器

def decorate(func):
    #定义内部函数
    def inner(*who,**where):
        # 1.扩展功能1
        print('做饭之前，沐浴更衣')
        # 2.原有函数功能
        func(*who,**where)  # 相当于调用zuofan
        # 3.扩展功能2
        print('做饭之后，焚香祭祖')

    # 返回内部函数
    return inner

@decorate
def zuofan(*who,**where):
    print('参加做饭的人：',who)
    print('做饭地点',where)


zuofan('寒冰','士兵','旭东',hb='南极',sb= '赤道',xd = '北极')


#第七步：带有参数的装饰器

#外部函数
def outer(arg):
    #装饰器函数
    def decorate(func):
        #扩展函数
        def inner():#未来的zuofan函数
            # 1.扩展功能1
            if arg == '做':
                print('做饭之前，沐浴更衣')
            elif arg == '吃':
                print('饭前洗洗手')
            # 2.原有函数功能
            func()  # 相当于调用zuofan
            # 3.扩展功能2
            if arg == '做':
                print('做饭之后，焚香祭祖')
            elif arg =='吃':
                print('饭后走一走')
        #返回未来的zuofan函数
        return inner

    #返回装饰器函数
    return decorate


@outer('做')#@outer()的结果 =》@装饰器函数
def zuofan():
    print('做饭真好')
#调用做饭函数
zuofan()
zuofan()

@outer('吃')
def chifan():
    print('吃饱了吧')
#调用吃饭函数
chifan()
chifan()


#第八步：使用类作为装饰器的参数

class Fan:
    #方法1 做饭之前
    def before():
        print('做饭之前，沐浴更衣')
    #方法2  做饭之后
    def after():
        print('做饭之后，焚香祭祖')


def outer(arg):
    #定义装饰器
    def decorate(func):
        # 定义未来的chifan函数
        def inner():
            # 1.扩展功能1
            arg.before()
            # 2.原有函数功能
            func()  # 相当于调用zuofan
            # 3.扩展功能2
            arg.after()
            # 添加返回值，相当于zuofan函数的返回值

        #返回值必须是函数，因为zuofan原来是函数
        return inner
    #返回装饰器函数
    return decorate


@outer(Fan)
def zuofan():
    print('做饭真好')

#调用函数
zuofan()
zuofan()


#第九步：使用类作为装饰器

#装饰器类
class Decor:

    #初始化对象

    def __init__(self,arg):
        print(self,arg)
        self.var =arg


    #添加__call__魔术方法
    def __call__(self,func):
        print(self,func)
        #将func参数存入对象使得其他方法可以调用
        self.func = func
        #返回未来的做饭函数
        return self.inner

    #声明内部函数
    def inner(self):#inner
        # 1.扩展功能1
        print('做饭之前，沐浴更衣')
        # 2.原有函数功能
        self.func() # 相当于调用zuofan
        # 3.扩展功能2
        print('做饭之后，焚香祭祖')

@Decor(1) #相当于@对象  ——》@装饰器
def zuofan():
    print('做饭真好')

#调用
zuofan()


#第十步：为类添加装饰器

def decorate(cls):
    #未来的人类的结果
    def inner():
        #扩展功能1
        print('做饭之前，沐浴更衣')
        # inner的结果也是对象
        var = cls()
        # 3.扩展功能2
        print('做饭之后，焚香祭祖')
        #返回被装饰内容的结果
        return var
    return inner


@decorate
class Human:
    pass

#实例化对象
result =Human()
print(result)

#第十一步：装饰器的嵌套
#装饰器1
def decorate1(func):
    #定义内部函数（未来的做饭函数）
    def inner():
        #扩展功能1
        print('做饭之前，沐浴更衣')
        #调用函数
        func()
        #扩展功能2
        print('做饭之后，焚香祭祖')
    #返回inner
    return inner

#装饰器2
def decorate2(func):
    #定义内部函数（未来的zuofan函数）
    def inner():
        #扩展功能1
        print('吃饭之前洗洗手！！！')
        #调用函数
        func()
        #扩展功能2
        print('吃饭之后走一走～～～')

    #返回inner
    return inner

@decorate1
@decorate2
def zuofan():
    print('做饭真好～～～')

#调用
zuofan()