1,闭包
- 根据这句话,其实我们自己就可以总结出在python语言中形成闭包的三个条件,缺一不可:
- 1)必须有一个内嵌函数(函数里定义的函数)——这对应函数之间的嵌套
- 2)内嵌函数必须引用一个定义在闭合范围内(外部函数里)的变量——内部函数引用外部变量
- 3)外部函数必须返回内嵌函数——必须返回那个内部函数
- 例如:
def outfunc(a,b):
def innerfunc(x):
return x*a+b
return innerfunc
闭包的优点
- 避免使用全局变量
- 可以提供部分数据的隐藏
- 可以提供更优雅的面向对象实现
- 优点1,2 就不说了,很容易理解,关于第三个,例如当在一个类中实现的方法很少时,或者仅有一个方法时,就可以选择使用闭包。
# 用类实现一个加法的类是这样
class _Add(object):
def __init__(self, a, b):
self.a = a
self.b = b
def add(self):
return self.a + self.b
# 用闭包实现
def _Add(a):
def add(b):
return a + b
return add
ad = _Add(1) # 是不是很像类的实例化
print(ad(1)) # out:2
print(ad(2)) # out:3
print(ad(3)) # out:4
2,闭包的延迟绑定
- 结合一个题目来说明:
def multipliers():
return [lambda x : i*x for i in range(4)]
print [m(2) for m in multipliers()]
output:
# [6, 6, 6, 6]
- 其实这个题目,可能目的是想输出:[0, 2, 4, 6],如何改进才能输出这个结果呢?
def multipliers():
# 添加了一个默认参数i=i
return [lambda x, i=i: i*x for i in range(4)]
print [m(2) for m in multipliers()]
output:
# [0, 2, 4, 6]
- 下面来解释为什么输出结果是[6,6,6,6]。
- 运行代码,代码从第6行开始运行,解释器碰到了一个列表解析,循环取multipliers()函数中的值,而multipliers()函数返回的是一个列表对象,这个列表中有4个元素,每个元素都是一个匿名函数(实际上说是4个匿名函数也不完全准确,其实是4个匿名函数计算后的值,因为后面for i 的循环不光循环了4次,同时提还提供了i的变量引用,等待4次循环结束后,i指向一个值i=3,这个时候,匿名函数才开始引用i=3,计算结果。所以就会出现[6,6,6,6],因为匿名函数中的i并不是立即引用后面循环中的i值的,而是在运行嵌套函数的时候,才会查找i的值,这个特性也就是延迟绑定)
# 为了便于理解,你可以想象下multipliers内部是这样的(这个是伪代码,并不是准确的):
def multipliers():
return [lambda x: 3 * x, lambda x: 3 * x, lambda x: 3 * x, lambda x: 3 * x]
- 因为Python解释器,遇到lambda(类似于def),只是定义了一个匿名函数对象,并保存在内存中,只有等到调用这个匿名函数的时候,才会运行内部的表达式,而for i in range(4) 是另外一个表达式,需等待这个表达式运行结束后,才会开始运行lambda 函数,此时的i 指向3,x指向2
- 那我们来看下,添加了一个i=i,到底发生了什么?
def multipliers():
# 添加了一个默认参数i=i
return [lambda x, i=i: i*x for i in range(4)]
添加了一个i=i后,就给匿名函数,添加了一个默认参数,而python函数中的默认参数,是在python 解释器遇到def(i=i)或lambda 关键字时,就必须初始化默认参数,此时for i in range(4),每循环一次,匿名函数的默认参数i,就需要找一次i的引用,i=0时,第一个匿名函数的默认参数值就是0,i=1时,第二个匿名函数的默认参数值就是1,以此类推。
# 为了便于理解,你可以想象下multipliers内部是这样的(这个是伪代码只是为了理解):
def multipliers():
return [lambda x,i=0: i*x, lambda x,i=1: i*x, lambda x,i=2: i*x, lambda x,i=3:i*x i=3]
# x的引用是2 所以output的结果就是:[0,2,4,6]
- Python的延迟绑定其实就是只有当运行嵌套函数的时候,才会引用外部变量i,不运行的时候,并不是会去找i的值,这个就是第一个函数,为什么输出的结果是[6,6,6,6]的原因。
3,装饰器的本质-闭包
- 装饰器的作用:在不违反开放封闭的原则下对现有的函数进行功能扩充,比如插入日志、性能测试、事务处理、缓存、权限的校验等场景,有了装饰器就可以抽离出大量的与函数功能本身无关的雷同代码。
- 函数计时的装饰器:
#既不需要侵入,也不需要函数重复执行
import time
def deco(func):
def wrapper():
startTime = time.time()
func()
endTime = time.time()
msecs = (endTime - startTime)*1000
print("time is %d ms" %msecs)
return wrapper
@deco
def func():
print("hello")
time.sleep(1)
print("world")
if __name__ == '__main__':
f = func #这里f被赋值为func,执行f()就是执行func()
f()
- 序运行到装饰器的时候,会立即对下面的函数进行装饰
- 这里的deco函数就是最原始的装饰器,它的参数是一个函数,然后返回值也是一个函数。其中作为参数的这个函数func()就在返回函数wrapper()的内部执行。然后在函数func()前面加上@deco,func()函数就相当于被注入了计时功能,现在只要调用func(),它就已经变身为“新的功能更多”的函数了。
所以这里装饰器就像一个注入符号:有了它,拓展了原来函数的功能既不需要侵入函数内更改代码,也不需要重复执行原函数。 - ### 被装饰的函数带参数的装饰器:
#被装饰的函数带有参数的装饰器
import time
def deco(func):
def wrapper(a,b):
startTime = time.time()
func(a,b)
endTime = time.time()
msecs = (endTime - startTime)*1000
print("time is %d ms" %msecs)
return wrapper
@deco
def func(a,b):
print("hello,here is a func for add :")
time.sleep(1)
print("result is %d" %(a+b))
if __name__ == '__main__':
f = func
f(3,4)
#func()
#被装饰的函数带有不定参数的装饰器
import time
def deco(func):
def wrapper(*args, **kwargs):
startTime = time.time()
func(*args, **kwargs)
endTime = time.time()
msecs = (endTime - startTime)*1000
print("time is %d ms" %msecs)
return wrapper
@deco
def func(a,b):
print("hello,here is a func for add :")
time.sleep(1)
print("result is %d" %(a+b))
@deco
def func2(a,b,c):
print("hello,here is a func for add :")
time.sleep(1)
print("result is %d" %(a+b+c))
if __name__ == '__main__':
f = func
func2(3,4,5)
f(3,4)
#func()
# 带有参数的装饰器
import time
def decoc(key):
def deco(func):
def wrapper(*args, **kwargs):
startTime = time.time()
# 装饰器参数传递进来的参数 key
print(key)
func(*args, **kwargs)
endTime = time.time()
msecs = (endTime - startTime)*1000
print("time is %d ms" %msecs)
return wrapper
return deco
@decoc('999')
def func(a,b):
print("hello,here is a func for add :")
time.sleep(1)
print("result is %d" %(a+b))
@decoc('666')
def func2(a,b,c):
print("hello,here is a func for add :")
time.sleep(1)
print("result is %d" %(a+b+c))
if __name__ == '__main__':
f = func
func2(3,4,5)
f(3,4)
# output
666
hello,here is a func for add :
result is 12
time is 1000 ms
999
hello,here is a func for add :
result is 7
time is 1000 ms
#被装饰的函数被多个装饰器
import time
def deco01(func):
def wrapper(*args, **kwargs):
print("this is deco01")
startTime = time.time()
func(*args, **kwargs)
endTime = time.time()
msecs = (endTime - startTime)*1000
print("time is %d ms" %msecs)
print("deco01 end here")
return wrapper
def deco02(func):
def wrapper(*args, **kwargs):
print("this is deco02")
func(*args, **kwargs)
print("deco02 end here")
return wrapper
@deco01
@deco02
def func(a,b):
print("hello,here is a func for add :")
time.sleep(1)
print("result is %d" %(a+b))
if __name__ == '__main__':
f = func
f(3,4)
#func()
'''
this is deco01
this is deco02
hello,here is a func for add :
result is 7
deco02 end here
time is 1003 ms
deco01 end here
'''
- 多个装饰器执行的顺序就是从最后一个装饰器开始,执行到第一个装饰器,再执行函数本身。
def dec1(func):
print("1111")
def one():
print("2222")
func()
print("3333")
return one
def dec2(func):
print("aaaa")
def two():
print("bbbb")
func()
print("cccc")
return two
@dec1
@dec2
def test():
print("test test")
test()
# output
aaaa
1111
2222
bbbb
test test
cccc
3333
参考:Python 装饰器:https://blog.csdn.net/xiangxianghehe/article/details/77170585
Python 中实现装饰器时使用 @functools.wraps 的理由
- Python 中使用装饰器对在运行期对函数进行一些外部功能的扩展。但是在使用过程中,由于装饰器的加入导致解释器认为函数本身发生了改变,在某些情况下——比如测试时——会导致一些问题。Python 通过
functool.wraps
为我们解决了这个问题:在编写装饰器时,在实现前加入@functools.wraps(func)
可以保证装饰器不会对被装饰函数造成影响。比如,在 Flask 中,我们要自己重写login_required
装饰器,但不想影响被装饰器装饰的方法,则login_required
装饰器本身可以写成下面的样子:
import functools
def login_required_(func):
@functools.wraps(func)
def decorated_view(*args, **kwargs):
if current_app.login_manager._login_disabled:
return func(*args, **kwargs)
elif not current_user.is_authenticated:
# return current_app.login_manager.unauthorized()
return redirect(url_for("login.loginPage", next=request.url))
return func(*args, **kwargs)
return decorated_view