zoukankan      html  css  js  c++  java
  • 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()
  • 相关阅读:
    Leetcode 50.Pow(x,n) By Python
    Leetcode 347.前K个高频元素 By Python
    Leetcode 414.Fizz Buzz By Python
    Leetcode 237.删除链表中的节点 By Python
    Leetcode 20.有效的括号 By Python
    Leetcode 70.爬楼梯 By Python
    Leetcode 190.颠倒二进制位 By Python
    团体程序设计天梯赛 L1-034. 点赞
    Wannafly挑战赛9 C-列一列
    TZOJ Start
  • 原文地址:https://www.cnblogs.com/w-yumiao/p/8098036.html
Copyright © 2011-2022 走看看