闭包函数
定义:闭是封闭(函数内部的函数),闭包指的是内部函数包含对外部作用域而非全局作用域的引用。
函数对象:可以将定义在函数内的函数返回到全局使用,从而打破函数的层级限制。
def outter(): x = 1 def inner(): print(x) return inner f = outter() def f2(): x = 2 f() f2() # 1
为函数传参的两种方式
1.使用参数的形式
def func(x): print(x) func(1) func(1) func(1) ''' 1 1 1 '''
2.包给函数
ef outter(x): x = 1 def inner(): print(x) return inner f = outter(1) f() f() f() ''' 1 1 1 '''
闭包函数的应用
闭包的意义:返回的函数对象,不仅仅是一个函数对象,在该函数外还包裹了一层作用域,这使得,该函数无论在何处调用,优先使用自己外层包裹的作用域。
# 普通的传参的方式 每用一次需要传一次参数,显得极其麻烦 import requests def get(url): response = requests.get(url) print(f"done: {url}") get('https://www.baidu.com') get('https://www.baidu.com') get('https://www.baidu.com') get('https://www.cnblogs.com/linhaifeng') get('https://www.cnblogs.com/linhaifeng') get('https://www.cnblogs.com/linhaifeng')
# 把传的参数包给函数后,把内层函数对象返回到外层,在外层直接调用该函数对象即可,不用频繁的传值了。 import requests def outter(url): def get(): response = requests.get(url) print(f"done: {url}") return get baidu=outter('https://www.baidu.com') python = outter('https://www.python.org') baidu() baidu() python() python()
装饰器
1. 什么是装饰器
器:指的是具备某一功能的工具
装饰:指的是为被装饰器对象添加新功能
装饰器就是用来为被装饰器对象添加新功能的工具
注意:装饰器本身可以是任意可调用对象,被装饰器的对象也可以是任意可调用对象
2. 为何要用装饰器
开放封闭原则:封闭指的是对修改封闭,对扩展开放
装饰器的实现必须遵循两大原则:
1). 不修改被装饰对象的源代码
2). 不修改被装饰器对象的调用方式
装饰器的目标:就是在遵循1和2原则的前提下为被装饰对象添加上新功能
3.装饰器的应用(装饰器其实也是闭包函数的一种应用场景)
上面的这张图中outter()的功能就是装饰器,它装饰了index函数,他在没有改变被调用对象的源代码和调用方式的前提下,实现了统计函数运行时间的功能,感官体验好像还是index()的调用。
装饰器升级版:装饰器同时装饰两个函数。下图中outter()函数是装饰器,index函数和home函数是被装饰对象。index()函数(其实是wrapper函数)不需要传参,而home()函数(其实是wrapper函数)需要传参,那么要想外部调用home()(其实是wrapper函数)就需要给定义阶段的wrapper()传形参,比如wrapper(name),然后调用wrapper()阶段才能传实参,但一个装饰器在同时需要兼顾两个函数,一个需要传值,另一个不需要传值,同时调用,就会报错。那么我们该如何解决呢????这时我们就需要对装饰器outter()内部函数wrapper()传入两个参数了叫做*args和**kwargs,众所周知这两个参数的作用(在形参中,这两个参数可以接收实参传来的多余位置参数和关键字参数;在实参中,*args这个参数可以将其后面的元组打散成位置实参给位置形参传值,**kwargs这个参数可以将其后面的字典形式的关键字参数打散,传给形参中的关键字参数),所以上图中index不传参,*args和**kwargs没有接收到多余的参数,形成了一个空的()和空的{},在下面调用func()的时候,func括号中(即index括号中)的*args将空元组打散,**kwarg将空字典打散,就没有什么参数传给index函数了。而home()传了位置实参“zhang”,wrapper()形参中的*args默认接收了形参中多余的位置实参‘zhang’,将‘zhang’存元组的形式,而此时**kwargs还是一个空字典,到下面遇到func(*args,**kwargs),*args将(‘zhang’)打散成字符串原封不动的传给了*args,**kwargs的一个空字典被打散没有了。这样两个函数都被装饰上了,添加上了新的功能,也并没有改变原函数的代码,也没改变他们的调用方式。
注意:现在以home函数为例,如果home函数内部有个返回值(return 234),那么加上装饰器outter(),接收outter(home)的返回值,print(res=outter(home)) 返回值是None,因为这里的home()就是wrapper()。
装饰器的语法糖
在被装饰函数上面一行加上@+装饰器,即,例如:
@timmer
def func()
表示装饰func()函数,意思是func=timmer(func),func是最原始的那个func的内存地址。
运行原理:
python解释器一旦运行到@装饰器的名字,就会调用装饰器,然后将被装饰函数的内存地址当作参数
传给装饰器,最后将装饰器调用的结果赋值给原函数名
装饰器模板
import time
def outter(func):
def wrapper(*args,**kwargs):
#在调用函数前加功能
res=func(*args,**kwargs) #调用被装饰的\也就是最原始的那个函数
在调用函数后加功能
return res
return wrapper
@outter #index=outter(index) #index=wrapper
def index():
print('welcome to index page')
time.sleep(3)
index()
叠加多个装饰器
import time def timmer(func): #func=wrapper2 def wrapper1(*args,**kwargs): start=time.time() res=func(*args,**kwargs) #res=wrapper2(*args,**kwargs) stop=time.time() print('run time is %s' %(stop - start)) return res return wrapper1 def auth(func): #func=最原始的那个index的内存地址 def wrapper2(*args,**kwargs): inp_user = input('please input your username: ').strip() inp_pwd = input('please input your password: ').strip() if inp_user == 'zhang' and inp_pwd == '123': print('login successfull') res=func(*args,**kwargs) # 调用最原始的那个/也就是被装饰的那个函数 return res else: print('username or password error') return wrapper2 # 解释@语法的时候是自下而上运行 # 而执行装饰器内的那个wrapper函数时的是自上而下 @timmer # index=timmer(wrapper2) #index=wrapper1 @auth # index=auth(最原始的那个index的内存地址) #index=wrapper2 def index(): print('welcome to index page') time.sleep(3) index() #wrapper1() # 首先调用wrapper1函数
''' 有参装饰器由于需要外部传值,而原无参装饰器外层和内层括号内参数又不能动,所以只能在外层再定义一层函数,
利用必报函数的思想,为内部传值,而且不限定传值的个数,所以装饰器最多也只有三层
''' # 有参装饰器的模板 def outter1(x,y,z): def outter2(func): def wrapper(*args,**kwargs): res=func(*args,**kwargs) return res return wrapper return outter2 # 无参装饰器的模板 def outter(func): def wrapper(*args,**kwargs): res=func(*args,**kwargs) return res return wrapper
有参装饰器应用实例:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import time current_user={'username':None} # 补充:所有的数据类型的值自带布尔值,可以直接当作条件去用,只需要记住布尔值为假的那一些值即可(0,空,None) def login(engine='file'): #engine='mysql' def auth(func): #func=最原始那个index的内存地址 def wrapper(*args,**kwargs): if current_user['username']: print('已经登录过了,无需再次登陆') res=func(*args,**kwargs) return res if engine == 'file': inp_user = input('please input your username: ').strip() inp_pwd = input('please input your password: ').strip() if inp_user == 'egon' and inp_pwd == '123': print('login successfull') current_user['username']=inp_user # 在登陆成功之后立刻记录登录状态 res=func(*args,**kwargs) # res=最原始那个index的内存地址(*args,**kwargs) return res else: print('username or password error') elif engine == 'mysql': print('基于mysql的认证机制') elif engine == 'ldap': print('基于ldap的认证机制') else: print('无法识别的认证源') return wrapper return auth @login('file') #@auth # index=auth(最原始那个index的内存地址) #index=wrapper def index(): print('welcome to index page') time.sleep(3) @login('file') def home(name): print('welcome %s to home page' %name) time.sleep(2) return 123 index() #wrapper() res=home('egon') print(res)
伪装真正的装饰器
''' wraps装饰器应该加到装饰器最内层的函数上,wraps是别人已经写好的装饰器,加在装饰器内层函数上,括号内将原函数名写上,就可以将原函数中的全部内置方法赋值给
最内层对应函数的内置方法上,以达到真正的装饰效果,即客户调用index.__name__或help(index),查到wrapper的内存地址。 ''' from functools import wraps import time def deco(func): @wraps(func) def wrapper(*args, **kwargs): res = func(*args, **kwargs) return res # wrapper.__name__=func.__name__ # wrapper.__doc__=func.__doc__ return wrapper @deco #index=deco(index) #index=wrapper函数的内存地址 def index(): """ index 功能 """ print('welcome to index page') time.sleep(3) # print(index.__name__) # 仍然是wrapper,如果客户查看index的函数名,发现是wrapper就露馅了, # print(help(index)) #index.__doc__ __doc__查看函数内部注释信息 # index() # wrapper print(index.__name__) print(index.__doc__)