# 装饰器 - @ - 拿到内层函数的引用 - 直接使用内层函数
# 增强加法函数，输出被调用过及调用的参数
def add(x, y):
print("call fun {}, {}+{}".format(add.__name__, x, y)) # 输出到控制台
return x + y
print(add(4, 5))
def add(x, y, file=None):
print("call fun {}, {}+{}".format(add.__name__, x, y), file = file) # 输出到文件
return x + y
print(add(4, 5))
# print 耦合太高
# print 不属于加法业务
# print 叫侵入式代码
# 1 嵌套方式，避免侵入式代码
print('------------------------')
def add(x, y):
return x + y
def logger(fn):
print('begin')
x = fn(4, 5)
print('end')
return x
print(logger(add))
# 2
def add1(x, y):
return x + y
def add2(x, y, z):
return x + y + z
def add3(x, y, *args, z, **kwargs):
return x + y + z
def logger(fn, *args, **kwargs): # 位置参数*args元组, 关键字参数**kwargs字典
print('begin')
x = fn(*args, **kwargs)
print('end')
return x
print(logger(add1, 4, 5))
print(logger(add2, 4, 5, 6))
print(logger(add3, 4, z=5, y=6))
# 3 柯里化
def add1(x, y):
return x + y
def add2(x, y, z):
return x + y + z
def add3(x, y, *args, z, **kwargs):
return x + y + z
def logger(fn):
def _logger(*args, **kwargs):
print('begin')
x = fn(*args, **kwargs)
print('end')
return x
return _logger
foo = logger(add1)
print(foo(10, 10))
print(logger(add1)(10, 100))
add1 = logger(add1)
print(add1(10, 1000))
# 装饰器 @ ***
def logger(fn):
def _logger(*args, **kwargs):
print('begin')
x = fn(*args, **kwargs)
print('end')
return x
return _logger # 返回内层函数的引用**
@logger # 等价于add1 = logger(add1)
def add1(x, y):
return x + y
print(add1(10, 10000))
# 装饰器
# 无参装饰器
# 它是一个函数
# 有一个函数作为它的形参
# 返回值也是一个函数
# 可以使用@functionname方式，简化调用
# 装饰器是高阶函数，即传入函数，又返回函数
import datetime
import time
def logger(fn):
def wrap(*args, **kwargs):
# before 功能增强
print('args={}, kwargs={}'.format(args, kwargs))
start = datetime.datetime.now()
result = fn(*args, **kwargs)
# after 功能增强
duration = datetime.datetime.now() - start
print('function {} took {}s.'.format(fn.__name__, duration.total_seconds()))
return result
return wrap # 返回内层函数的引用**
@logger # 等价于 add = logger(add)
def add(x, y):
print('call add')
time.sleep(2)
return x + y
print(add(10, 10000))
# 装饰器理解 - 避免侵入式
# 装饰器函数 > 前置功能增强 > 被增强函数 > 后置功能增强
# 装饰器函数可以随意更换
# 文档字符串
# 在函数语句块的第一行，且吸管式多行文本，使用三引号
# 惯例是首字母大写，第一行写概述，空一行，第三行写详细描述
# 可以使用特殊属性__doc__访问这个文档
def add(x, y):
"""
This is a function
:param x:
:param y:
:return:
"""
result = x + y
return result
print(add(10, 10))
print(add.__name__, add.__doc__, sep='\n')
print('----------------------------------')
# 文档字符串和装饰器
# 解决被装函数的文档字符串无法显示问题
import datetime
import time
def copyProperties(src, dest): # 包装函数和被包装函数字符文档统一
dest.__name__ = src.__name__
dest.__doc__ = src.__doc__
def logger(fn):
def wrap(*args, **kwargs):
"""
This is wrapper
"""
# before 功能增强
print('args={}, kwargs={}'.format(args, kwargs))
start = datetime.datetime.now()
result = fn(*args, **kwargs)
# after 功能增
duration = datetime.datetime.now() - start
print('function {} took {}s.'.format(fn.__name__, duration.total_seconds()))
return result
copyProperties(fn, wrap)
return wrap # 返回内层函数的引用**
@logger # add = logger(add)
def add(x, y):
"""
This is a function
:param x:
:param y:
:return:
"""
result = x + y
return result
print(add(10, 10000))
print(add.__name__, add.__doc__, sep='\n')
# 带参装饰器***
import datetime
import time
def copyProperties(src): # 包装函数和被包装函数字符文档统一
def copyWrap(dest):
dest.__name__ = src.__name__
dest.__doc__ = src.__doc__
return dest
return copyWrap
def logger(fn):
# @copyProperties(fn)
# 1 先不看@符号，返回copyWrap
# 2 @copyProperties(fn) 将其下面的函数（logWrap）作为参数，再拿到logWrap对象
@copyProperties(fn) # wrap = copyWrap(logger.wrap) 带参装饰器***
def logWrap(*args, **kwargs):
"""
This is wrapper
"""
# before 功能增强
print('args={}, kwargs={}'.format(args, kwargs))
start = datetime.datetime.now()
result = fn(*args, **kwargs)
# after 功能增
duration = datetime.datetime.now() - start
print('function {} took {}s.'.format(fn.__name__, duration.total_seconds()))
return result
return logWrap # 返回内层函数的引用**
@logger # add = logger(add)
def add(x, y):
"""
This is a function
:param x:
:param y:
:return:
"""
result = x + y
return result
print(add(10, 10000))
print(add.__name__, add.__doc__, sep='\n')
# 通过copyProperties函数将被包装函数的属性覆盖掉包装函数
# 凡是被装饰的函数都需要复制这些属性，这个函数很通用
# 可以将复制属性的函数构建成装饰器函数，带参装饰器
# 过滤执行时间过长的函数**
import datetime
import time
def logger(time):
def __logger(fn):
def wrap(*args, **kwargs):
# before 功能增强
start = datetime.datetime.now()
result = fn(*args, **kwargs)
# after 功能增强
duration = (datetime.datetime.now() - start).total_seconds()
if duration > time:
print('function {} took too long time -> {}s.'.format(fn.__name__, duration))
return result
return wrap # 返回内层函数的引用**
return __logger
@logger(3) # 等价于 add = logger(3)(add)，其中logger(3)返回的是__logger
def add(x, y):
print('call add')
time.sleep(5)
return x + y
print(add(4, 5))
# 过滤执行时间在一定范围内的函数**
import datetime
import time
def logger(time1, time2):
def __logger(fn):
def wrap(*args, **kwargs):
# before 功能增强
start = datetime.datetime.now()
result = fn(*args, **kwargs)
# after 功能增强
duration = (datetime.datetime.now() - start).total_seconds()
if duration > time1 and duration < time2:
print('function {} took too long time -> {}s.'.format(fn.__name__, duration))
return result
return wrap # 返回内层函数的引用**
return __logger
@logger(3, 10) # 等价于 add = logger(3)(add)，其中logger(3)返回的是__logger
def add(x, y):
print('call add')
time.sleep(6)
return x + y
print(add(4, 5))
# 带参装饰器
# 它是一个函数
# 函数作为它的形参
# 返回值是一个不带参的装饰器函数
# 使用@functionname(参数列表)方式调用
# 可以看到在装饰器外层又加了一层函数
# 实践：替换print，以便输出到其他存储***
import datetime
import time
def copyProperties(src): # 包装函数和被包装函数字符文档统一
def copyWrap(dest):
dest.__name__ = src.__name__
dest.__doc__ = src.__doc__
return dest
return copyWrap
def logger(duration, func=lambda name, delta:print('function {} took too long time -> {}s.'.format(name, delta))):
def __logger(fn):
# @copyProperties(fn)
# 1 先不看@符号，返回copyWrap
# 2 @copyProperties(fn) 将其下面的函数（logWrap）作为参数，再拿到logWrap对象
@copyProperties(fn) # wrap = copyWrap(logger.wrap) 带参装饰器***
def logWrap(*args, **kwargs):
"""
This is wrapper
"""
# before 功能增强
start = datetime.datetime.now()
result = fn(*args, **kwargs)
# after 功能增
delta = (datetime.datetime.now() - start).total_seconds()
if delta > duration:
func(fn.__name__, delta)
return result
return logWrap # 返回内层函数的引用**
return __logger
@logger(3) # add = logger(add)
def add(x, y):
"""
This is a function
:param x:
:param y:
:return:
"""
time.sleep(5)
result = x + y
return result
print(add(10, 10000))
