闭包
1.函数引用
def test1():
print("---in test1 func---")
#调用函数
test1()
#引用函数
ret=test1
print(id(ret))
print(id(test1))
#通过引用调用函数
ret()
运行结果：
---in test1 func---
123456789000
123456789000
---in test1 func---
2.什么是闭包
#定义一个函数
def test(number):
#在函数内部在定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数称为闭包
def test_in(number_in):
print("in test_in 函数，number_in is %d"%number_in)
return number+number_in
return test_in
#给test函数赋值，这个10就是给参数number
ret=test(10)
#注意这里的100其实给参数number_in
print(ret(100))
#注意这里的200其实给参数number_in
print(ret(200))
运行结果：
in test_in函数，number_in is 100
110
in test_in函数，number_in is 200
210
3.重讲闭包
内部函数对外部函数作用域里变量的引用（非全局变量）则称内部函数为闭包。
#test2.py
def counter(start=0):
count=[start]
def incr():
count[0]+=1
return count[0]
return incr
应用test2.py
import test2
c1=test2.counter(10)
print(c1())
结果：11
print(c1())
结果：12
nonlocal访问外部函数的局部变量
def counter(start=0):
def incr():
nonlocal start
start+=1
return start
return incr
c1=counter(5)
print(c1())
print(c1())
c2=counter(50)
print(c2())
print(c2())
print(c1())
print(c1())
print(c2())
print(c2())
4.实例
def line_conf(a,b):
def line(x):
return a*x+b
return line
line1=line_conf(1,2)
line2=line_conf(3,4)
print(line1(5))
print(line2(6))
在这个例子中，函数line与变量a，b构成闭包，在创建闭包的时候，我们通过line_conf的参数a,b说明了这两个变量的取值，这样，我们就确定了函数的最终形式（y=x+2和y=3x+4）。我们只需要变化参数a，b，就可以获得不同的直线表达函数，因此，我们可以看到，闭包也具有提高代码可复用性的作用。
如果没有闭包，我们需要每次创建直线函数的时候同时说明a，b，x。这样，我们就需要传递更多的参数
装饰器
1.首先理解一段代码
def foo():
print('foo')
foo #表示是函数
foo() #表示执行foo函数
def foo():
print('foo')
foo=lambda x: x+1
foo() #执行下面的lambda表达式，而不是原来的foo函数
2.需求
某公司由N个业务部门和一个基础平台部门构成，基础平台负责提供底层的功能，如：数据库操作、redis调用、监控API等功能。业务部门使用基础功能时，只需调用基础平台提供的功能即可。如：
"""基础平台提供的功能如下"""
def f1():
print('f1')
def f2():
print('f2')
def f3():
print('f3')
def f4():
print('f4')
"""业务部门a调用基础平台提供的功能"""
f1()
f2()
f3()
f4()
"""业务部门b调用基础平台提供的功能"""
f1()
f2()
f3()
f4()
基础平台提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构，为平台提供所有功能添加验证机制，既要在执行功能前进行验证。
程序员A的做法：
"""基础平台提供的功能"""
def f1():
#验证1
#验证2
#验证3
print('f1')
def f2():
#验证1
#验证2
#验证3
print('f2')
def f3():
#验证1
#验证2
#验证3
print('f3')
def f4():
#验证1
#验证2
#验证3
print('f4')
"""业务部门代码不变"""
"""A,B分别调用"""
f1()
f2()
f3()
f4()
程序员B的做法：
只对基础平台的代码进行重构，其他业务部门无需做任何修改
"""基础平台提供的功能如下"""
def check_login():
#验证1
#验证2
#验证3
pass
def f1():
check_login()
print('f1')
def f2():
check_login()
print('f2')
def f3():
check_login()
print('f3')
def f4():
check_login()
print('f4')
程序员C的做法：
写代码遵循开放封闭原则，虽然在这个原则是用面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的代码不允许被修改，但可以被扩展即：
- 封闭：对实现的功能代码块
- 开放：对扩展开发
若实现上述需求，则不允许在f1、f2、f3、f4内部进行修改代码，实现方案：
def w1(func):
def inner():
#验证1
#验证2
#验证3
func()
return inner
@w1
def f1():
print('f1')
def f2():
print('f2')
def f3():
print('f3')
def f4():
print('f4')
执行过程
python解释器将代码从上至下进行解释：
- def w1(func):将函数w1加载到内存；
- @w1
f1=w1(f1)
表面上解释器仅仅会解释这两句代码，因为函数在没有被调用之前其内部代码不会被执行。
从表面上看解释器会执行这两句，但是@w1这一句在python中是一种语法糖（@函数名）
@w1内部会执行以下操作
执行w1函数
执行w1函数，并将@w1下面的函数作为w1函数的参数，即：@w1等价于w1（f1）。所以，内部就会去执行：
def inner():
#验证1
#验证2
#验证3
f1() #func是参数，此时func等于f1
return inner #返回的inner，inner代表的是函数，非执行函数，
w1的返回值
将执行完的2w1函数返回值赋值为@w1下面的函数f1，即将w1的返回值再重新赋值为w1，即：
新
f1=def inner():
#验证1
#验证2
#验证3
原f1()
return inner
所以，以后业务部门想要执行f1函数时，就会执行新f1函数，在新f1函数内部先执行验证，在执行原来的f1函数，然后将原来f1函数的返回值返给了业务调用者。
如此一来，即执行了验证功能，又执行了原来f1函数的内容，并将原f1函数返回给业务调用者。
3.再议装饰器
#定义函数：完成数据包裹
def makeBold(fn):
def wrapped():
return "<b>"+fn()+"</b>"
return wrapped
#定义函数：完成数据包裹
def makeItalic(fn):
def wrapped():
return "<i>"+fn()+"</i>"
return wrapped
@makeBold
def test1():
return "hello world-1"
@makeItalic
def test2():
return "hello world-2"
@makeBold
@makeItalic
def test3():
return "hello world-3"
print(test1())
print(test2())
print(test3())
运行结果：
<b>hello world-1</b>
<i>hello world-2</i>
<b><i>hello world-3</i></b>
4.装饰器（decorator）功能
- 引入日志
- 函数执行时间统计
- 执行函数前预备处理
- 执行函数后清理功能
- 权限校验等场景
- 缓存
5.示例
例1.无参数的函数
from time import ctime,sleep
def timefun(func):
def wrappedfunc():
print("%s called at %s"%(func.__name__,ctime()))
func()
return wrappedfunc
@timefun
def foo():
print("I am foo")
foo()
sleep(2)
foo()
上面代码装饰器执行过程可表述为：
foo=timefun(foo)
#foo先作为参数赋值给func后，foo接收指向timefun返回的wrappedfunc
foo()
#调用foo()，即等价于调用wrappedfunc（）
#内部函数wrappedfunc被引用，所以外部函数的func变量（自由变量）并没有释放
#func里保存的是原foo函数对象
代码执行结果
执行结果.png
例2.被装饰的函数有参数
from time import ctime,sleep
def timefun(func):
def wrappedfunc(a,b):
print("%s called at %s"%(func.__name__,ctime()))
print(a,b)
func(a,b)
return wrappedfunc
@timefun
def foo(a,b):
print(a+b)
foo(2,8)
sleep(2)
foo(4,6)
执行结果
执行结果.png
例3.被装饰的函数有不定长参数
from time import ctime,sleep
def timefun(func):
def wrappedfunc(*args,**kwargs):
print("%s called at %s"%(func.__name__,ctime()))
func(*args,**kwargs)
return wrappedfunc
@timefun
def foo(a,b,c):
print(a+b+c)
foo(1,3,5)
sleep(2)
foo(2,4,6)
执行结果
执行结果.png
例4，装饰器中的return
from time import ctime,sleep
def timefun(func):
def wrappedfunc():
print("%s called at %s"%(func.__name__,ctime()))
func()
return wrappedfunc
@timefun
def foo():
print('I am foo')
@timefun
def getInfo():
return '---hello---'
foo()
sleep(2)
foo()
print(getInfo())
运行结果
执行结果.png
如果修改装饰器为return func，则运行结果为：
执行结果.png
或者参考如下代码
from time import ctime,sleep
def timefun(func):
def wrappedfunc():
print("%s called at %s"%(func.__name__,ctime()))
ret=func() #保存返回来的hello
return ret #把hello返回给调用函数
return wrappedfunc
@timefun
def foo():
print('I am foo')
@timefun
def getInfo():
return '---hello---'
foo()
sleep(2)
foo()
print(getInfo())
例5.装饰器带参数，在原有装饰器的基础上，设置外部变量
from time import ctime, sleep
def timefun_arg(pre="hello"):
def timefun(func):
def wrappedfunc():
print("%s called at %s %s"%(func.__name__, ctime(), pre))
return func()
return wrappedfunc
return timefun
@timefun_arg("itcast")
def foo():
print("I am foo")
@timefun_arg("python")
def too():
print("I am too")
foo()
sleep(2)
foo()
too()
sleep(2)
too()
可以理解为：
foo()==timefun_arg("itcast")(foo)()
