一、闭包函数
闭包函数=函数嵌套定义+函数对象+名称空间与作用域
闭包函数
1、闭：指的是该函数是定义在一个函数内部的函数
2、包：值得是该函数访问了一个来自于外层函数的变量
为函数体传参：
方案一：直接使用参数的形式传递
def wrapper(x):
print(x)
wrapper(111)
wrapper(222)
方案二：把函数体想要的参数包给它
def outter(x):
# x = 111
def wrapper(): # wrapper = 闭包函数的内存地址
print(x)
return wrapper # 一定不要加括号
# return 闭包函数的内存地址
f1 = outter(111) # f = 闭包函数的内存地址
f2 = outter(222) # f = 闭包函数的内存地址
二、无参装饰器
常用三连：
1、什么是装饰器
器：工具
装饰：为被装饰者添加额外的功能
2、为何要有装饰器
软件一旦上线运行之后，就应该遵循开放封闭原则：
1、开放指的是对拓展新功能开放
2、封闭指的是对修改源代码封闭
定义装饰器的目的：
定义装饰器就是为了在遵循1和2的前提下来为其他函数添加新功能的
ps：
不修改被装饰对象指的是定义与调用都不能修改
所以下述行为都违反了开放封闭原则：
(1)、修改被装饰对象定义时的源代码
(2)、修改被装饰对象的调用方式
3、如何用装饰器
一、被装饰器对象index如下：
import time
def index(x,y):
time.sleep(1)
print('index===>',x,y)
index(1,2)
二、为index添加新功能（顺流而下地步步接近装饰器）
2.1 方案一：直接修改源代码为被装饰对象index添加新功能
问题：修改了源代码
import time
def index(x,y):
start_time = time.time()
time.sleep(1)
print('index===>',x,y)
stop_time = time.time()
print('run time is: %s' %(stop_time - start_time))
index(1,2)
2.2 方案二：找到所有调用index的位置，然添加代码
问题：需要写好多段重复代码
import time
def index(x,y):
time.sleep(1)
print('index===>',x,y)
start_time = time.time()
index(1,2)
stop_time = time.time()
print('run time is: %s' %(stop_time - start_time))
2.3 方案三：把装饰功能写到一个函数内
问题：装饰功能被写死了，只能用来装饰index函数了
import time
def index(x,y):
time.sleep(1)
print('index===>',x,y)
def wrapper():
start_time = time.time()
index(1,2)
stop_time = time.time()
print('run time is: %s' %(stop_time - start_time))
wrapper()
2.4 方案四：把wrapper函数内的index修改为参数的形式
问题：直接为wrapper函数传参的方案不行，因为原函数的调用
是在全局调用index(1,2), 而现在的调用统一都变成了wrapper(index)，着修改被装饰的调用方式
import time
def index(x,y):
time.sleep(1)
print('index===>',x,y)
def wrapper(func):
start_time = time.time()
func(1,2)
stop_time = time.time()
print('run time is: %s' %(stop_time - start_time))
wrapper(index)
2.5 方案五：基于闭包函数把wrapper函数想要的参数包给它，然后基于函数对象把闭包函数wrapper返回到全局，赋值给原函数名
问题：把index伪装成了wrapper，但伪装的不够像：参数的传递与原函数不一致
import time
def index(x,y):
time.sleep(1)
print('index===>',x,y)
def outter(func):
# func = index
def wrapper():
start_time = time.time()
func(1,2)
stop_time = time.time()
print('run time is: %s' %(stop_time - start_time))
return wrapper
index=outter(index)
index()
2.6 方案六：在方案五的基础上基于args,*kwargs把wrapper的参数伪装成跟被装饰函数一模一样
问题：返回值与原函数不一致
import time
def index(x,y):
time.sleep(1)
print('index===>',x,y)
def home(name):
time.sleep(0.5)
print('welcome %s to home page' %name)
return 123
def outter(func):
# func = index
def wrapper(*args,**kwargs):
start_time = time.time()
func(*args,**kwargs)
stop_time = time.time()
print('run time is: %s' %(stop_time - start_time))
return wrapper
index=outter(index)
home=outter(home)
# index(1,2)
res=home('egon')
print(res)
2.7 方案七：在方案六的基础上把wrapper函数的返回值与被装饰函数保持一致
问题：装饰器的使用不够简洁
import time
from functools import wraps
def timmer(func):
# func = index
@wraps(func)
def wrapper(*args,**kwargs):
start_time = time.time()
res=func(*args,**kwargs)
stop_time = time.time()
print('run time is: %s' %(stop_time - start_time))
return res
return wrapper
def index(x,y):
time.sleep(1)
print('index===>',x,y)
def home(name):
"home的文档注释"
time.sleep(0.5)
print('welcome %s to home page' %name)
return 123
help(home)
2.8 方案八：在方案7的基础上使用装饰器的语法糖@符号让装饰器的使用变得简洁
import time
from functools import wraps
def timmer(func):
# func = index
@wraps(func)
def wrapper(*args,**kwargs):
start_time = time.time()
res=func(*args,**kwargs)
stop_time = time.time()
print('run time is: %s' %(stop_time - start_time))
return res
return wrapper
@timmer # index=timmer(index)
def index(x,y):
time.sleep(1)
print('index===>',x,y)
@timmer # home=timmer(home)
def home(name):
"home的文档注释"
time.sleep(0.5)
print('welcome %s to home page' %name)
return 123
res=index(1,2)
res=home('yan')
三、装饰器叠加
1、无参装饰器的模板
def outter(func):
def wrapper(*args,**kwargs):
res=func(*args,**kwargs)
return res
return wrapper
2、叠加多个装饰器
加载顺序:自下而上
执行顺序:自上而下运行内层的wrapper函数
def deco1(func1): # func1 = wrapper2的内存地址
def wrapper1(*args,**kwargs):
print('wrapper1====>')
res1=func1(*args,**kwargs)
return res1
return wrapper1
def deco2(func2): # func2 = wrapper3的内存地址
def wrapper2(*args,**kwargs):
print('wrapper2====>')
res2=func2(*args,**kwargs)
return res2
return wrapper2
def deco3(func3): # func3 = 最原始的那个被装饰函数的内存地址
def wrapper3(*args,**kwargs):
print('wrapper3====>')
res3=func3(*args,**kwargs)
return res3
return wrapper3
# index=wrapper1的内存地址
@deco1 # deco1(wrapper2的内存地址)=>wrapper1的内存地址
@deco2 # deco2(wrapper3的内存地址)=>wrapper2的内存地址
@deco3 # deco3(最原始的那个被装饰函数的内存地址)=>wrapper3的内存地址
def index(x,y):
print('index=>',x,y)
index(1,2)
预测输出结果：
"""
wrapper1====>'
wrapper2====>
wrapper3====>
index=>1,2
"""
3 案例
import time
# 计算某个函数运行时间的装饰器
def deco1(func1):
def wrapper1(*args,**kwargs):
start_time = time.time()
res1=func1(*args,**kwargs)
stop_time = time.time()
print(stop_time - start_time)
return res1
return wrapper1
# 简单的认证登录装饰器
def deco2(func2):
def wrapper2(*args,**kwargs):
inp_name = input('username>>>: ').strip()
inp_pwd = input('password>>>: ').strip()
if inp_name == "yan" and inp_pwd == "123":
print('login successful')
res2=func2(*args,**kwargs)
return res2
else:
print('username or password error')
return wrapper2
@deco2
@deco1
def index(x,y):
time.sleep(1)
print('index=>',x,y)
index(1,2)
四、有参装饰器
有参装饰器的模板：
def outter2(x,y,z,a,b):
def outter1(func):
def wrapper(*args,**kwargs):
res=func(*args,**kwargs)
return res
return wrapper
return outter1
案例：
def outter(engine = 'file'):
def deco2(func2):
def wrapper2(*args,**kwargs):
inp_name = input('username>>>: ').strip()
inp_pwd = input('password>>>: ').strip()
if engine == "file":
print('基于file的认证')
if inp_name == "yan" and inp_pwd == "123":
print('login successful')
res2=func2(*args,**kwargs)
return res2
else:
print('username or password error')
elif engine == 'mysql':
print('基于mysql的认证')
elif engine == 'ldap':
print('基于ldap的认证')
else:
print('未知的engine')
return wrapper2
return deco2
@outter(engine='mysql') # @deco2 # index=deco2(index)
def index(x,y):
print('index=>',x,y)
index(1,2) # index=>wrapper
网友评论