装饰器-初级
在不改变原有函数逻辑功能的基础上，为函数添加新的逻辑功能。使代码可读性更高、结构更加清晰、冗余度更低
- 简介
"""
闭包： 函数嵌套的格式就是闭包。写装饰器的闭包是外层函数的返回值就是内层函数
装饰器：一种特殊的闭包 加上 语法糖[@语法]组成的
其作用：在不修改原有功能的基础上，为该功能添加其他新的需求。不管在函数中添加多少装饰，函数的名字没有变化 在函数中的使用
装饰器的特殊闭包：在外层函数中声明一个内层函数，外等函数的返回值是内层函数
外层函数的参数是：func 接受是给哪一个函数添加装饰
def out(func): 给nomal函数装饰时，此时 func === nomal() | 给diff函数装饰时，此时 func === diff()
def inner():
pass 装饰器的新增功能是 写在内层函数中的，写在外层函数没有效果
return inner 需添加装饰的函数：在普通函数添加装饰器的语法糖，@特殊闭包的外层函数名
@out
def nomal():
pass
@out
def diff()
pass
"""
# 特殊的闭包
def outter():
print("这是一个外部函数")
def inner():
# 装饰器的新增功能是 写在内层函数中的
print("这是一个内部函数")
return inner # 外部函数的返回值是内部函数
res = outter()
print('res =',res) # res指向的是内部函数的内存地址。
# 执行结果：这是一个外部函数 res = <function outter.<locals>.inner at 0x1027e88c8>
res()
# 执行结果 ：这是一个内部函数。 调用res函数等价于 在outter内部直接调用innner函数 """======================================================================"""
- 实例
# 在不改变原有函数的基础上，为函数增加新的功能。 # 装饰器的闭包，实现功能是：新增计算该功能函数的执行时间
def get_time(func): # func的作用是 明确为哪一个函数添加装饰器；为哪个函数添加就代表哪一个函数
def inner():
import time
start_time = time.time()
# 执行被装饰的功能函数
func()
end_time = time.time()
print("消耗的时间为：",end_time - start_time)
return inner @get_time
def print_table():
for row in range(1,10):
for col in range(1,row + 1):
print(col, "*" ,row, "=", row*col, end="\t")
print() # 不管给该功能函数添加了多少装饰，执行的时候还是调用该函数的名字
print_table()
"""
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81
消耗的时间为： 0.0011630058288574219
"""
# 在不改变原有函数的基础上，为函数增加新的功能。 # 装饰器的闭包，实现功能是：新增计算该功能函数的执行时间
def get_time(func): # func的作用是明确给哪一个函数添加装饰器
def inner():
import time
start_time = time.time()
# 执行被装饰的功能函数
func()
end_time = time.time()
print("消耗的时间为：",end_time - start_time)
return inner """九九乘法表"""
@get_time
def print_table():
for row in range(1,10):
for col in range(1,row + 1):
print(col, "*" ,row, "=", row*col, end="\t")
print()
# 不管给该功能函数添加了多少装饰，执行的时候还是调用该函数的名字
print_table()
"""九九加法表"""
@get_time
def print_add_table():
for row in range(1,10):
for col in range(1,row + 1):
print(col, "+" ,row, "=", row+col, end="\t")
print()
print_add_table()
多个函数添加同一个装饰器
装饰器的执行流程
- 基本流程
def get_time(func): # func的作用是明确给哪一个函数添加装饰器
print("这是装饰器的外层函数。在添加@语法糖时执行，且只会被执行一次")
def inner():
import time
start_time = time.time()
func() # 执行被装饰的功能函数
end_time = time.time()
print("消耗的时间为：",end_time - start_time)
return inner
"""九九加法表"""
@get_time
def print_add_table():
for row in range(1,10):
for col in range(1,row + 1):
print(col, "+" ,row, "=", row+col, end="\t")
print()
print_add_table()
print_add_table() # 无论调用几次被装饰的函数，装饰器的外层函数只会被执行一次
"""
为什么在装饰器中增加的新功能要在内层函数中添加？
因为在装饰器函数中 无论调用几次被装饰的函数，
装饰器外层函数的语句只会被执行一次，
第二次调用被装饰函数时不会执行装饰器外层函数语句 当语法糖添加装饰器的时候，内部执行流程：
1。当使用语法糖给当前函数添加装饰器的时候[添加@时]，装饰器特殊闭包的外层函数就已经被调用执行了
注意：外层函数的执行会有一个结果的返回，这个结果就是其中的内层函数 2。为哪一个功能函数添加的装饰器 就使用该功能函数名字作为变量名，用于接收外层函数执行的返回结果(即内层函数)
此时 print_add_table = get_time(print_add_table) # 装饰器函数的参数 是 被装饰的函数 3。现在此时 print_add_table 代表的是：装饰器特殊闭包中的内层函数；装饰器的参数func 代表的是被装饰的方法函数
"""
- 装饰器的完善
def get_time(func): # func的作用是明确给哪一个函数添加装饰器
def inner(*values,**kwargs): # 带参数的功能函数添加装饰器 所传的值
import time
start_time = time.time()
res = func(*values,**kwargs) # 执行被装饰的功能函数; values 传的参数
end_time = time.time()
print("消耗的时间为：",end_time - start_time)
return res
return inner
"""
计算两个数求和功能的执行时间。即带参数的功能函数 添加装饰器
"""
@get_time
def add(a,b):
return a + b
res = add(12,34)
print(res)
def one_oper(func):
flag = False # 设置一个标记位。让装饰器只能返回一次结果
def inner(*value,**kwargs):
nonlocal flag
if not flag:
res = func(*value,**kwargs)
flag = True
return res
return None
return inner
@one_oper
def add(a,b):
return a + b res = add(12,34)
print(res) # 结果：46
res = add(34,12)
print(res) # 结果：None
唯一输出
多个装饰器的执行流程
- 代码
"""
一个装饰器可以装饰多个功能函数
一个功能函数可以被多个装饰器装饰 执行顺序采用就近原则执行[先执行距离被装饰函数近的]
""" def outer1(func):
print("这是第一个装饰器的外部函数")
def inner1(*value,**kwargs):
print("第一个装饰器的内部函数")
res = func(*value,**kwargs)
if res != None:
return res
return inner1
def outer2(func):
print("这是第二个装饰器的外部函数")
def inner2(*value,**kwargs):
print("第二个装饰器的内部函数")
res = func(*value,**kwargs)
if res != None:
return res
return inner2
def outer3(func):
print("这是第三个装饰器的外部函数")
def inner3(*value,**kwargs):
print("第三个装饰器的内部函数")
res = func(*value,**kwargs)
if res != None:
return res
return inner3 @outer1
@outer2
@outer3
def show():
print("演示添加多个装饰器的功能")
# 被添加装饰器的功能函数只会被执行一次，而且是在最后才执行
show()
- 结果
"""
执行结果：
这是第三个装饰器的外部函数
这是第二个装饰器的外部函数
这是第一个装饰器的外部函数
第一个装饰器的内部函数
第二个装饰器的内部函数
第三个装饰器的内部函数
演示添加多个装饰器的功能
执行流程：
@outer3 此时执行outer3外层函数
---> show = outer3(show)
show === inner3此内部函数
@outer2 此时执行outer2外层函数
---> show = outer2(show)[注意：执行上一个装饰器的时候，show已经被更改数据了]
此时型参func=show=innner3 当作实际参数传递给show ===> 即上一个inner3
这个时候被赋值的变量show又拥有了新值 inner2
@outer1
---> show = outer1(show)[注意：执行上一个装饰器的时候，show已经被更改数据了]
此时型参func=show=innner2 当作实际参数传递给show ===> 即上一个inner2
这个时候被赋值的变量show又拥有了新值 inner1 所有的装饰器走完之后，此时的show === inner1
inner1执行完后，此时的show === inner2
inner2执行完后，此时的show === inner3
inner3执行完后，此时的show === 被装饰的功能函数
"""
装饰器-进阶
带参数的函数装饰器
之前的例子中装饰器是不能接收参数的，其用法只能适用于一些简单的场景。不传参的装饰器，只能对被装饰函数执行固定逻辑。
装饰器本身就是一个函数，不传参数的装饰器，只能对被装饰的函数执行固定的逻辑，会大大限制其能力。
若要用两个内容大体一致，但是某些地方不同的逻辑，若不能传参数的话，就需要写两个装饰器。
# 装饰器实现传参需要两层嵌套
def say_hello(contry): # 外层函数的型参 接收 装饰器传来的实参
def wrapper(func): # 中层函数的型参 接收 被添加装饰器函数
def deco(*args, **kwargs): # 内层函数的型参 接收 被添加装饰器的带参数功能函数所传的实参
if contry == "china":
print("你好!")
elif contry == "america":
print('hello.')
else:
return
func(*args, **kwargs) # 真正执行函数的地方。
return deco
return wrapper @say_hello("america")
def american():
print("I am from America。")
@say_hello("china")
def chinese():
print("我来自中国。") american()
chinese()
"""
结果：
hello.
I am from America。
你好!
我来自中国。
"""
装饰器-高级
不带参数的类装饰器
"""
基于类实现的装饰器，需要两个类方法来实现
__init__ : 接收被装饰的函数
__call__ : 实现装饰器的逻辑
"""
class Text(object):
def __init__(self, func): # 接收被装饰的函数
self.func = func
def __call__(self, *args, **kwargs): # 实现装饰器的逻辑
print("正在被装饰的函数是：{func}".format(func=self.func.__name__))
return self.func(*args, **kwargs)
@Text
def func(something):
print("函数的参数是：{}!".format(something)) func("hello")
"""
结果：
正在被装饰的函数是：func
函数的参数是：hello!
"""
带有参数的类装饰器
"""
带参数的类装饰器
__init__ ：不再接收被装饰的函数，而是接收传入的参数。
__call__ ：接收被装饰函数，实现装饰逻辑。
"""
class logger(object):
def __init__(self, level='INFO'): # 接收装饰器传入的参数
self.level = level
def __call__(self, func): # 接受被装饰的函数
def wrapper(*args, **kwargs):
print("[{level}]: the function {func}() is running..."\
.format(level=self.level, func=func.__name__))
func(*args, **kwargs) # 真正执行被装饰的函数的语句
return wrapper # 返回内层函数 @logger(level='WARNING')
def say(something):
print("say {}!".format(something))
say("hello")
@logger(level='DEBUG')
def say(something):
print("say {}!".format(something))
say("hello")
"""
结果：
[WARNING]: the function say() is running...
say hello!
[DEBUG]: the function say() is running...
say hello!
"""
系统提供的装饰器
Python语言本身提供的property内建装饰器，通常存在于类中的方法属性化。详情见 类的方法属性化 笔记整理
"""
Python语言本身提供的property内建装饰器，通常存在于类中的方法属性化
可以将一个方法函数定义成一个属性，属性的值就是该函数return的内容。
"""
# 用@property装饰过的函数，会将一个函数定义成一个属性，属性的值就是该函数return的内容。即方法属性化
class Student(object):
def __init__(self, name):
self.name = name
self.name = None
@property
def age(self):
return self._age
@age.setter
def age(self, value):
if not isinstance(value, int):
raise ValueError('输入不合法：年龄必须为数值!')
if not 0 < value < 100:
raise ValueError('输入不合法：年龄范围必须0-100')
self._age=value
@age.deleter
def age(self):
del self._age
XiaoMing = Student("小明") # 设置属性
XiaoMing.age = 25
# 查询属性
age = XiaoMing.age
print(age)
# 删除属性。删除后再去查询该属性就会报错
del XiaoMing.age
age = XiaoMing.age
print(age)