（10）-- 装饰器大全

# 装饰器

#对函数或类进行装饰，以扩展函数和类的功能

'''
#第一步：基本函数

def makecake():
    print('The cake is delicious!')

#调用函数
makecake()


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

#定义用于扩展函数的函数
def decorate(func):#func用于接收makecake的函数
    #1.扩展功能1
    print('Add eggs first')
    #2.原有函数功能
    func()#相当于调用makecake函数
    #3.扩展功能2
    print('Add cream last')

def makecake():
    print('The cake is delicious!')

#装饰步骤(调用)
makecake = decorate(makecake)
print(type(makecake))

#因为装饰函数没有返回值，所以makecake接收的是None
makecake()



#第三部：实现基本装饰器功能

#定义用于扩展函数的函数
def decorate(func):#func用于接收makecake的函数
    #inner就是扩展之后的makecake函数
    def inner():
        # 1.扩展功能1
        print('Add eggs first')
        # 2.原有函数功能
        func()  # 相当于调用makecake
        # 3.扩展功能2
        print('Add cream last')

    #返回值必须是函数，因为makecake原本也是函数
    return inner

def makecake():
    print('The cake is delicious!')

#装饰步骤(调用)
makecake = decorate(makecake)

#因为装饰函数没有返回值，makecake接收的是None
makecake()




#第四步：语法糖方式实现装饰功能

#定义用于扩展函数的函数
def decorate(func):#func用于接收makecake的函数
    #inner就是扩展之后的makecake函数
    def inner():
        # 1.扩展功能1
        print('Add eggs first')
        # 2.原有函数功能
        func()  # 相当于调用makecake函数
        # 3.扩展功能2
        print('Add cream last')

    #返回值必须是函数，因为makecake原本也是函数
    return inner
@decorate
#装饰步骤(调用)  相当于makecake = decorate(makecake)
def makecake():
    print('The cake is delicious!')



#因为装饰函数没有返回值，所以makecake接收的是None
makecake()





#第五步：带有参数的函数装饰器
def decorate(func):
    #定义内部函数的扩展功能
    def inner(he,said):
        # 1.扩展功能1
        print('Add eggs first')
        # 2.原有函数功能
        func(he,said)  # 相当于调用makecake函数
        # 3.扩展功能2
        print('Add cream last')

    #返回内部函数（未来的makecake函数）
    return inner

@decorate
def makecake(who,speak):
    print(who+' mustbe '+ speak +':'+ ' The cake is delicious!')


#调用函数
makecake('Fred','say')



#带有返回值的函数
def decorate(func):
    #定义内部函数的扩展功能
    def inner():
        # 1.扩展功能1
        print('Add eggs first')
        # 2.原有函数功能
        result = func()  # 相当于调用makecake函数
        # 3.扩展功能2
        print('Add cream last')
        #添加返回值（相当于makecake的返回值）
        return result

    #返回内部函数（未来的makecake函数）
    return inner

@decorate
def makecake():
    print('The cake is delicious!')
    return 'Well done!'

#调用函数
result = makecake()
print(result)





#第六步：带有收集参数的函数装饰器
def decorate(func):
    #定义内部函数
    def inner(*whose,**there):
        # 1.扩展功能1
        print('Add eggs first')
        # 2.原有函数功能
        func(*whose, **there)  # 相当于调用makecake函数
        # 3.扩展功能2
        print('Add cream last')

    #返回内部函数
    return inner

@decorate
def makecake(*who,**where):
    print(who,'are making cakes!')
    print('They are at',where)

#调用函数
makecake('Fred','Tom','David','Sundy',F = 'home',T = 'school',D = 'hotel',S = 'restaurant')







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

#外层函数
def outer(arg):
    # 装饰器函数
    def decorate(func):
        #扩展函数
        def inner():#未来的makecake函数
            # 1.扩展功能1
            #判断装饰哪个函数
            if arg == 'make':
                print('Add eggs first')
                func() # 相当于调用makecake函数
                print('Add cream last')
            elif arg == 'cake':
                print('The cake is round')
            # 2.原有函数功能
                func()  # 相当于调用makecake
            # 3.扩展功能2
                print('The cake is colorful!')
            else:
                pass
        #返回未来的makecake函数
        return inner
    #返回装饰器函数
    return decorate

@outer('make')#@outer()的结果 ==>  @装饰器函数
def makecake():
    print('The cake is delicious!')

#调用makecake函数

makecake()

@outer('cake')
def shape():
    print('The cake is new!')
#调用shape函数
shape()







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

class Cake:
    #方法1
    def before():
        print('Add eggs first')

    #方法2
    def after():
        print('Add cream last')


def outer(self):
    #定义装饰器
    def decorate(func):
        #定义未来的makecake函数
        def inner():
            # 1.扩展功能1
            self.before()
            # 2.原有的函数功能
            func()  # 相当于调用makecake函数
            # 3.扩展功能2
            self.after()

        #返回未来的makecake函数
        return inner

    return decorate

@outer(Cake)
def makecake():
    print('The cake is delicious!')


makecake()





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

#装饰器（类）
class Decor:

    #初始化方法
    def __init__(self,arg):#Outer
        self.arg = arg




    #添加call魔术方法
    def __call__(self,func):#decorate
        #将func参数存入对象使其他方法可以调用


        self.func = func
        #返回未来的makecake函数
        return self.inner

    # 声明内部函数
    def inner(self):#inner

        # 扩展功能1
        print('Add eggs first')
        # makecake函数
        self.func()
        # 扩展功能2
        print('Add cream last')


@Decor('makecake')  #相当于 @对象 ==>  @装饰器
def makecake():
    print('The cake is delicious!')


makecake()






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

#装饰器
def decorate(cls):

    #未来Cake类的结果
    def inner():
        #扩展功能1
        print('Add eggs first')
        #inner函数内cls调用的结果也是对象

        var = cls.make()

        #扩展功能2
        print('Add cream last')
        #返回make的结果
        return var  #返回一个字符串

    #返回未来的函数  （inner)
    return inner

@decorate
class Cake:
    name = 'cake'
    def make():
        print('The cake is delicious!')
        return 'makecake'

#实例化对象
result = Cake()#类的调用结果为对象
print(result)



'''



# 第十一步：装饰器的嵌套


# 装饰器1

def decorate1(func):
    # 定义内部函数
    def inner():
        # 1.扩展功能1
        print('Add eggs first')
        # 2.原有函数功能
        func()  # 相当于调用makecake
        # 3.扩展功能2
        print('Add cream last')
    # 返回内部函数
    return inner


# 装饰器2
def decorate2(func):
    # 定义内部函数
    def inner():
        # 1.扩展功能1
        print('first')
        # 2.原有函数功能
        func()  # 相当于调用makecake
        # 3.扩展功能2
        print('last')

    # 返回inner
    return inner





@decorate1
@decorate2

def makecake():
    print('The cake is delicious!')


makecake()

兄弟连学python

Python学习交流、资源共享群：563626388 QQ