闭包
闭包的理解
在一个函数中定义了另外一个函数，内函数使用了外函数的临时变量，外函数返回内函数的引用，那么**这个内部函数和它环境变量【外函数的临时变量】**合在一起，就形成了一个闭包。
和其他对象一样，函数对象也有其存活的范围，也就是函数对象的作用域。函数对象是使用def语句定义的，函数对象的作用域与def所在的层级相同。对于作用域以外的参数，我们称为该函数的环境变量。
举个栗子，假设我们需要通过定义一个函数，实现不同直线方程上点的求解，我们可以借助闭包实现：
def line(k,b):
def creat(x):
print(k*x+b) #传入外函数的变量
return creat #不带括号，返回内函数的引用；带括号就变成了函数的调用
line1 = line(2,3)
line1(3) ---> y = 2*3+3
line1(4) ---> y = 2*4+3
out:
9
11
我们通过变换参数k,b，就可以获得不同的直线表达函数，通过传入x可以求得不同直线方程上点的值。如果没有闭包，实现以上功能，我们需要每次创建直线函数的时候同时传入k,b,x。
闭包的特点（优势）：
闭包可以提高代码的可复用性，传入的参数变少了，简化了代码的调用方式。普通函数调用结束后，保存的信息将被撤销，但闭包可以保存局部信息不被撤销，方便下次调用。
内函数中修改外函数的值
闭包可以将外层的参数在内存中进行保留，方便重复调用。如果想要在内函数中修改外函数的值，可以使用关键字 nonlocal。
def line(k, b):
def creat(x):
nonlocal k
a = 3
print(k * x + b)
return creat
line1 = line(2, 3)
line1(5)
out:
18
应用场景
1.装饰器
2.作为实参进行传递。闭包作为参数传递时，我们传入的是功能 + 数据
装饰器
概述：
将一个函数（类）的引用作为实参，传递到一个闭包的外部函数中去，**实现对原函数功能的扩展（**函数的调用形式不变）
类别
装饰器自身不带参数
1.对无参无返回值的函数进行装饰
2.对有参无返回值的函数进行装饰【装饰器中的内函数也需要接受原函数对应的参数】
3.对无参有返回值的函数进行装饰【装饰器中的内函数中对应的函数也需要加return】
4.通用装饰器【适应于以上所有的类型，以下对通用装饰器进行举例】
#通用装饰器示例
def set_func(func):
print("开始装饰...")
def call_func(*args,**kwargs):
#此处需要接收原函数对应的参数，一般使用不定长参数【不管原函数有没有参数都不会报错】
print(">>>函数执行前对应的操作<<<") #此处加入对原函数的一些功能拓展，执行原函数前都会先执行这些操作
return func(*args,**kwargs)
#此处传入原函数对应的参数，进行拆包操作；同理此处加上return语句【不管原函数有没有返回值都不会报错】
return call_func #[不加括号]
def test(*args,**kwargs):
print("传入元组参数：",args)
print("传入字典参数",kwargs)
return "OK"
#对test函数进行装饰，只需要执行如下操作：
test = set_func(test)
# 将一个新函数的引用赋值给tset, 这样test在调用时还是和以前一样，但是每次执行test函数前，都会先执行一些其它操作
a = (1,2)
b = {
"姓名":"zhangsan","年龄":18}
print(test(a,b))
out:
开始装饰...
>>>函数执行前对应的操作<<<
传入元组参数： ((1, 2), {
'姓名': 'zhangsan', '年龄': 18})
传入字典参数 {
}
OK
通过以上示例，我们通过装饰器完成了函数test()功能的简单拓展。在实际应用中装饰器一般通过@进行实现，故以上示例可以改写为如下形式
def set_func(func):
print("开始装饰...")
def call_func(*args,**kwargs):
#此处需要接收原函数对应的参数，一般使用不定长参数【不管原函数有没有参数都不会报错】
print(">>>函数执行前对应的操作<<<") #此处加入对原函数的一些功能拓展，执行原函数前都会先执行这些操作
return func(*args,**kwargs)
#此处传入原函数对应的参数，进行拆包操作；同理此处加上return语句【不管原函数有没有返回值都不会报错】
return call_func #[不加括号]
@set_func #此处完成对test函数的装饰
def test(*args,**kwargs):
print("传入元组参数：",args)
print("传入字典参数",kwargs)
return "OK"
a = (1,2)
b = {
"姓名":"zhangsan","年龄":18}
print(test(a,b))
在被装饰函数前加入@用来装饰的函数，即可完成装饰。在上例中在test()函数前加入@set_func，等效于执行以下操作：
test = set_func(test)
装饰器的作用可以理解为对原函数功能的一种拓展。通过装饰器的处理，函数的调用形式和以前一样，没有任何的差别，但是却能在执行函数前完成其它额外的操作。
自身传入参数的装饰器（采用三层函数定义装饰器）
- 传入不同的装饰函数，执行不同的功能
- 需要在原函数的基础上再加一层函数的实现
- 先调用外部函数，传入参数的同时，返回一个函数的引用，后面用返回的这个函数进行装饰
def login(text):
def decorator(func):
def wrapper(*args,**kargs):
print('%s---%s'(text,func.name))
return func(*args,**kargs)
return wrapper
return decorator
#等价于==>（login（text））（f）==>返回wrapper
@login('this is a parameter of decorator')
def f():
print('2019-06-13')
#等价于==>（login（text））（f）（）==>调用wrapper（）并返回f（）f（）
#输出：
#=>this is a parameter of decorator----f
#=>2019-06-13
上面的login是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我们使用@login(‘this is a parameter of decorator’)调用的时候，Python能够发现这一层的封装，并把参数传递到装饰器的环境中。
类装饰器
相比函数装饰器，类装饰器具有灵活度大、封装性等优点。基于类装饰器的实现，必须实现__call__和__init__两个内置函数。
- __ init__：接收被装饰函数;
- __ call__：实现装饰逻辑，调用装饰函数。
当使用@形式将装饰器附加到函数上时，就会调用类中的__call__方法【被装饰函数调用时才执行】。
class Foo(object):
def __init__(self, func):
self._func=func
def __call__(self):
print(' class decorator runing')
self._func()
print(' class decorator ending')
@ Foo
def bar():
print(' bar')
bar()
out:
class decorator runing
bar
class decorator ending
多个装饰器对同一个函数进行装饰
装饰顺序：从下到上进行装饰，从上到下进行执行
@a
@b
@c
def f ():
pass
#等效于执行
f = a(b(c(f)))
格式
@fun_1 #用来装饰的函数
def fun_2(): #被装饰的函数
pass
所谓装饰：就是将@下面的函数（被装饰函数）作为实参，传入到@后面的函数（装饰函数）中，执行一遍并返回一个新的函数引用【这个函数一般是对原函数功能的拓展】
装饰时间
当python解释器执行到**@ *****代码时，就开始自动对函数（类）进行装饰。即在python代码解析阶段就已经完成了装饰，而不是等到调用的时候。
其它
- 同一个装饰器可以装饰多个函数；
- 可以对函数和类进行装饰；
- 可以用函数或类进行装饰