我学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
cc3b
):
#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()