标签：4.6 它的 模拟 tar 用户输入 函数对象 编写 section 执行时间
装饰器（Decorator）本质是函数，功能是为其他函数添加附加功能，定义一个装饰器需要满足以下两个原则：
装饰器 = 高阶函数 + 函数嵌套 + 闭包
高阶函数定义：
满足以上任意一个条件就是高阶函数。
def calc():
print(‘calc 运行完毕~‘)
f = calc
f()由于函数也是对象，因此函数也可以赋值给一个变量，调用这个变量就是调用函数。函数对象有一个 __name__属性，用于查看函数的名字：
calc.__name__
f.__name__
‘calc‘
‘calc‘需求：
在不修改 calc 源代码的前提下，为 calc函数添加一个代码计时功能（计算 calc运行时间）。
使用高阶函数模拟装饰器实现calc计时功能。
import time
def timmer(func):
start_time = time.time()
func()
stop_time = time.time()
print(‘函数 %s 运行时间为：%s‘ % (func.__name__, stop_time - start_time))
def calc():
time.sleep(2)
print(‘calc 运行完毕~‘)
timmer(calc)calc 运行完毕~
calc 运行时间为：2.0011146068573虽然为 calc 增加了计时功能，但 calc 原来的执行方式是 calc()，而现在是调用高阶函数timmer(calc)，改变了调用方式。
import time
def timmer(func): # func: calc
start_time = time.time()
func() # func(): calc()
stop_time = time.time()
print(‘函数 %s 运行时间为：%s‘ % (func.__name__, stop_time - start_time))
return func # func: calc (<function calc at 0x00000000052D6D90>) 内存地址
def calc():
time.sleep(2)
print(‘calc 运行完毕~‘)
calc = timmer(calc) # calc = timmer(calc): calc = <function calc at 0x00000000052D6D90>
calc()calc 运行完毕~
calc 的运行时间是：2.0001144409179688
calc 运行完毕~没有改变 calc 的调用方式，但也没为其添加新功能。
使用高阶函数实现装饰器功能 ：
函数中嵌套另一个函数
def father(name):
print(‘I am %s‘ % name)
def son():
print(‘My father is %s‘ % name)
def grandson():
print(‘My grandfather is %s‘ % name)
grandson()
son()
father(‘tom‘)I am tom
My father is tom
My grandfather is tom闭包也是函数嵌套，如果在一个内部函数里调用外部作用域（不是全局作用域）的变量，那么这个内部函数就是闭包（closure）
def father(name):
print(‘I am %s‘ % name)
def son():
name = ‘john‘
def grandson():
print(‘My father is %s‘ % name)
grandson()
son()
father(‘tom‘)I am tom
My father is john内部函数 grandson 调用了它的外部函数 son 的变量 name=‘john‘，那么 grandson就是一个闭包。
无参数装饰器 = 高阶函数 + 函数嵌套
# 实现一个装饰器的基本框架
def timmer(func):
def wrapper():
func()
return wrapperdef timmer(func):
def wrapper(*args, **kwargs):
func(*args, **kwargs)
return wrapperimport time
def timmer(func):
def wrapper(*args, **kwargs):
"""计时功能"""
start_time = time.time()
func(*args, **kwargs)
stop_time = time.time()
print(‘函数 %s 运行时间：%s‘ % (func, stop_time - start_time))
return wrapperimport time
def timmer(func):
def wrapper(*args, **kargs):
start_time = time.time()
res = func(*args, **kwargs)
stop_time = time.time()
print(‘函数 %s 运行时间：%s‘ % (func, stop_time - start_time))
return res
return wrapperdef calc():
time.sleep(2)
print(‘calc 运行完毕~‘)
return ‘calc 返回值‘
calc = timmer(calc)
calc()@timmer # 相当于 calc = timmer(calc)
def calc():
time.sleep(2)
print(‘calc 运行完毕~‘)
calc()使用无参数装饰器，为 calc添加计时功能（统计 calc代码运行时间）
import timmer
def timmer(func): # func: calc
"""装饰器函数"""
def wrapper(*args, **kwargs): # args:<class ‘tuple‘>:(‘rose‘, 18, ‘female‘)
start_time = time.time() # kwargs={}
res = func(*args, **kwargs) # res: ‘calc 返回值‘
stop_time = time.time()
print(‘函数 %s 运行时间：%s‘ % (func.__name__, stop_time - start_time))
return res # func: calc (<function calc at 0x00000000052D6D90>) 内存地址
return wrapper
@timmer # @timmer: calc=timmer(calc) ——>calc = <function wrapper at 0x00000000052D6D90>
def calc(name, age, gender):
"""被修饰函数"""
time.sleep(2)
print(‘calc 运行完毕~‘)
print(‘名字：%s，年龄：%d，性别：%s‘ % (name, age, gender))
return ‘calc 返回值‘
s = calc(‘rose‘, 18, ‘female‘) # 相当于执行 s = wrapper(‘rose‘, 18, ‘female‘)
print(s) calc 运行完毕
名字：rose，年龄：18，性别：female
函数 calc 运行时间：2.0001144409179688
calc 返回值由于 timmer() 是一个装饰器函数，返回一个函数 wrapper。所以 calc()函数仍然存在，只是现在同名的 calc 变量指向了新的函数，于是调用 calc() 执行的是wrapper()函数。
有参数装饰器 = 高阶函数 + 函数嵌套 + 闭包
如果装饰器本山需要传入参数，就需要再编写一个 decorator的高阶函数。比如给 calc函数添加一个日志功能，能够打印日志，其基本框架如下：
def log(text):
def timmer(func):
def wrapper(*args, **kwargs):
func(*args, **kwargs)
return wrapper
return timmer
@log(‘文本内容‘)
def calc():
pass示例：
import timmer
def log(text): # text: ‘文本内容‘
def timmer(func): # func: calc
"""装饰器函数"""
def wrapper(*args, **kwargs): # args:<class ‘tuple‘>:(‘rose‘, 18, ‘female‘)
start_time = time.time() # kwargs={}
res = func(*args, **kwargs) # res: ‘calc 返回值‘
stop_time = time.time()
print(‘函数 %s 运行时间：%s‘ % (func.__name__, stop_time - start_time))
return res # func: calc (<function calc at 0x00000000052D6D90>) 内存地址
return wrapper
return timmer
@log(‘文本内容‘) # 相当于 calc = log(‘自定义文本‘)(calc) ——> timmer(calc) ——> calc=wrapper
def calc(name, age, gender):
"""被修饰函数"""
time.sleep(2)
print(‘calc 运行完毕~‘)
print(‘名字：%s，年龄：%d，性别：%s‘ % (name, age, gender))
return ‘calc 返回值‘
s = calc(‘rose‘, 18, ‘female‘) # 相当于执行 s = wrapper(‘rose‘, 18, ‘female‘)
print(s) 与两层嵌套效果的decorator相比，三层效果是这样的：
calc = log(‘自定义文本‘)(calc) # 即 calc = wrapper首先执行 log(‘自定义文本‘)，返回timmer函数，再调用返回参数（timmer(calc)），参数是 calc，返回值是wrapper函数，最后再调用wrapper()。
函数也是对象，也有__name__属性（返回函数名）。但经过装饰的calc函数，它的__name__
从原来的calc变成了wrapper。
>>> calc.__name__
‘wrapper‘有些需要依赖函数签名的代码因为__name__改变，而出现某些错误，所以需要将原calc的__name__属性复制到wrapper()函数中。
import functools
....
@functools.wraps(func)
def wrapper(*args, **kwargs)
...实例 1
请设计一个decorator，它可作用于任何函数上，并打印该函数的执行时间：
import time
import functools
def metric(fn):
@functools.wraps(fn)
def wrapper(*args, **kwargs):
start_time = time.time()
res = fn(*args, **kwargs)
stop_time =time.time()
print(‘%s executed in %s ms‘ % (fn.__name__, stop_time - start_time))
return res
return wrapper
@metric # fast=metric(calc)
def fast(x, y):
time.sleep(0.0012)
return x + y
@metric
def slow(x, y, z):
time.sleep(0.1234)
return x * y * z
f = fast(11, 22)
s = slow(11, 22, 33)
print(f, s)fast executed in 0.0019998550415039062 ms
slow executed in 0.1240072250366211 ms
33 7986实例 2
实现一个购物网站基本功能，其功能如下：
import time
import functools
# 模拟存储用户名、密码数据库
user_list=[
{‘name‘:‘alex‘,‘passwd‘:‘123‘},
{‘name‘:‘linhaifeng‘,‘passwd‘:‘123‘},
{‘name‘:‘wupeiqi‘,‘passwd‘:‘123‘},
{‘name‘:‘yuanhao‘,‘passwd‘:‘123‘},
]
current_dic = {‘username‘: None, ‘login‘: False} # 用于保存登录记录，None，False 为没有登录
def auth_func(func):
"""装饰器函数"""
@functools.wraps(func)
def wrapper(*args, **kwargs):
# 仅供 home、shopping 调用（因为不需要再输入用户名和密码）
if current_dic[‘username‘] and current_dic[‘login‘]:
res = func(*args, **kwargs)
return res
username = input(‘用户名：‘).strip()
passwd = input(‘密码：‘).strip()
# 遍历循环用户名、密码数据库，比对用户输入的用户名和密码
for user_dic in user_list:
if username == user_dic[‘name‘] and passwd == user_dic[‘passwd‘]:
# 用户保持会话，即保持用户登录状态，赋值
current_dic[‘username‘] = username
current_dic[‘login‘] = True
res = func(*args, **kwargs)
return res
else:
print(‘用户名或密码错误‘)
return wrapper
@auth_func
def index():
"""主页（需要登录）"""
print(‘欢迎来到xxx主页！‘)
@auth_func
def home(name):
"""用户登录成功后的界面"""
print(‘欢迎回家 %s‘ % name)
@auth_func
def shopping_car(name):
"""购物车"""
print(‘%s购物车里有：[%s,%s,%s]‘ % (name, ‘游艇‘, ‘车子‘, ‘飞机‘))
print(‘before-->‘,current_dic)
index()
print(‘after-->‘,current_dic)
home(‘rose‘)
shopping_car(‘rose‘)before--> {‘username‘: None, ‘login‘: False}
用户名：alex
密码：123
欢迎来到京东主页！
after--> {‘username‘: ‘alex‘, ‘login‘: True}
欢迎回家 rose
rose购物车里有：[游艇,车子,飞机]带参数装饰器（需要认证类型）：
import time
import functools
user_list=[
{‘name‘:‘alex‘,‘passwd‘:‘123‘},
{‘name‘:‘linhaifeng‘,‘passwd‘:‘123‘},
{‘name‘:‘wupeiqi‘,‘passwd‘:‘123‘},
{‘name‘:‘yuanhao‘,‘passwd‘:‘123‘},
]
current_dic={‘username‘:None,‘login‘:False}
def auth(auth_type=‘filedb‘):
def auth_func(func):
@funtools.wraps(func)
def wrapper(*args,**kwargs):
print(‘认证类型是‘,auth_type)
if auth_type == ‘filedb‘:
if current_dic[‘username‘] and current_dic[‘login‘]:
res = func(*args, **kwargs)
return res
username=input(‘用户名：‘).strip()
passwd=input(‘密码：‘).strip()
for user_dic in user_list:
if username == user_dic[‘name‘] and passwd == user_dic[‘passwd‘]:
current_dic[‘username‘]=username
current_dic[‘login‘]=True
res = func(*args, **kwargs)
return res
else:
print(‘用户名或者密码错误‘)
elif auth_type == ‘ldap‘:
print(‘ldap 认证类型‘)
res = func(*args, **kwargs)
return res
else:
print(‘不知道什么认证方式‘)
res = func(*args, **kwargs)
return res
return wrapper
return auth_func
# 相当于 auth_func = auth(auth_type=‘filedb‘)(auth_func)
@auth(auth_type=‘filedb‘)
def index():
print(‘欢迎来到xxx主页‘)
@auth(auth_type=‘ldap‘)
def home(name):
print(‘欢迎回家%s‘ %name)
#
@auth(auth_type=‘sssssss‘)
def shopping_car(name):
print(‘%s的购物车里有［%s,%s,%s］‘ %(name,‘奶茶‘,‘妹妹‘,‘娃娃‘))
# print(‘before-->‘,current_dic)
# index()
# print(‘after--->‘,current_dic)
# home(‘产品经理‘)
shopping_car(‘产品经理‘)标签：4.6 它的 模拟 tar 用户输入 函数对象 编写 section 执行时间
原文地址：https://www.cnblogs.com/midworld/p/10301463.html
