我学python（5）-- 十一步让你理解python装饰器

第一步

基本函数

def school():
    print('开开心心去上学')

#调用函数
school()

第二步

扩展功能（不能直接修改原来的函数）

def zhuangshi(func):  #func 接收你要装饰的函数
    #1 扩展功能1
    print('上学之前，先交学费')
    #2 原有的函数功能
    func()   #相当于调用school 这个函数
    #3 扩展功能 2
    print('上学之后，天天写作业')

def school():
    print('交了学费去上学')

#装饰步骤（调用）
school = zhuangshi(school)
#因为装饰函数没有返回值，school 接收的是None
school()

所以结果会报错

第三步

实现基本装饰器功能

#定义用于扩展函数的函数
def zhuangshi(func):  #func 接收school的函数
    #inner 就是扩展后的school 函数
    def inner():
        # 1 扩展功能1
        print('上学之前，先交学费')
        # 2 原有的函数功能
        func()  # 相当于调用school 这个函数
        # 3 扩展功能 2
        print('上学之后，天天写作业')
    #返回值必须是函数，因为school 原来是函数
    return inner
def school():
    print('交了学费去上学')

#装饰步骤（调用）
school = zhuangshi(school)
#可以使用装饰器装饰school 函数了
school()

第四步

语法糖方式实现装饰器

#定义用于扩展函数的函数
def zhuangshi(func):  #func 接收school的函数
    #inner 就是扩展后的school 函数
    def inner():
        # 1 扩展功能1
        print('上学之前，先交学费')
        # 2 原有的函数功能
        func()  # 相当于调用school 这个函数
        # 3 扩展功能 2
        print('上学之后，天天写作业')
    #返回值必须是函数，因为school 原来是函数
    return inner

#装饰步骤（调用）
@zhuangshi   #相当于school = zhuangshi(school)
def school():
    print('交了学费去上学')
#调用函数
school()

第五步

(一)： 带有参数的函数的装饰器

def zhuangshi(func):
    #定义内部函数  （扩展功能）
    def inner(a,b):
        #1 扩展功能
        print('上学之前，先交学费')
        #原有函数功能
        func(a,b)  #相当于调用school
        #扩展功能
        print('上学之后，天天写作业')
    #返回内部函数（未来的school函数）
    return inner

@zhuangshi  #装饰步骤（调用）
def school(who,where):
    print(who + '交了学费去' + where+'上学')

#调用函数
school('盖伦','召唤师峡谷')
school('赵信','对面野区')

(二) ： 带有返回值的函数装饰器

def zhuangshi(func):
    #定义内部函数  扩展功能
    def inner():
        #1 扩展功能
        print('上学之前，先交学费')
        #2 原有函数功能
        var = func()
        #3 扩展功能
        print('上学之后，天天写作业')
        return var
    #返回内部函数（未来的school函数）
    return inner

@zhuangshi
def school():
    print('交了学费去上学')
    return '痛并快乐着'

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

第六步

带有收集参数的函数的装饰器

def zhuangshi(func):
    #定义内部函数
    def inner(*args,**hh):
        #1 扩展功能
        print('上学之前，先交学费')
        # 2 原有函数功能
        func(*args,**hh)  #相当于调用school函数
        # 3 扩展功能
        print('上学之后，天天写作业')
    return inner

@zhuangshi
def school(*who ,**where):
    print(who,'和',where ,'去抓人')

#调用函数
school('纳尔','石头人','猴子',mo = '莫甘娜',nq = '女枪')

第七步

带有参数的装饰器

#外层函数
def outer(arg):
    #装饰器函数
    def zhuangshi(func):
        #扩展函数
       def inner():#未来的school 函数
            #1 扩展功能
            #判断装饰哪个函数
            if arg == '高中':
                print('上高中之前，憧憬未来')
            elif arg == '大学':
                print('上大学之前，终于解放')
            func()
            #扩展功能2
            if arg == '高中':
                print('上高中之后，做不完的数学题')
            elif arg == '大学':
                print('上大学之后，写不完的论文')
        #返回未来的school函数
       return inner
    #返回装饰器函数
    return zhuangshi

@outer('高中')  #@outer() 的结果-》 @装饰器函数
def school():
    print('交完学费去上学')
#调用函数
school()

@outer('大学')  #@outer() 的结果-》 @装饰器函数
def school():
    print('交完学费去上学')
#调用函数
school()

第八步

使用类作为装饰器的参数

class Sx:
    #方法1 school 之前
    def before():   #不能加self
        print('上学之前，先交学费')

    def after():
        print('上学之后，天天作业')

def outer(arg):
    #定义装饰器
    def zhuangshi(func):
        #定义未来的school函数
        def inner():
            #扩展功能
            arg.before()
            #原有函数功能
            func()
            #扩展功能
            arg.after()
        #返回未来的school函数
        return inner
    return zhuangshi
@outer(Sx)
def school():
    print('交完学费去上学')

#调用
school()

第九步

使用类作为装饰器

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

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

    #声明内部函数
    def inner(self):#inner
        #扩展功能
        print('上学之前，先交学费')
        #school函数
        self.func()
        #扩展功能
        print('上学之后，天天作业')
@Decor('arg接收这个实参') # 相当于  @对象  ——》 @装饰器
def school():
    print('交完学费，去上学')

school()

第十步

为类添加装饰器

#装饰器
def zhuangshi(cls):
    #未来的Human类的结果
    def inner():
        #扩展功能
        print('上学之前，先交学费')
        #inner的结果也是对象
        var = cls()
        #扩展功能
        print('上学之后，作业好难')
        return var
    #返回未来的函数
    return inner

@zhuangshi
class Human:
    pass
#实例化对象
res = Human()# 类的调用结果为对象
print(res)#打印的只是一个对象<__main__.Human object at 0x00574530>

第十一步

装饰器的嵌套

#装饰器 1
def zhuangshi1(func):
    def inner():
        #扩展功能
        print('上学之前，先交学费')
        func()
        #扩展功能2
        print('上学之后，天天作业')
    return inner

#装饰器 2
def zhuangshi2(func):
    def inner():
        #扩展功能
        print('上学之前，先交学费')
        func()
        #扩展功能2
        print('上学之后，天天作业')
    return inner

@zhuangshi1
@zhuangshi2  # 
def school():
    print('好好学习天天向上')

school()