1.函数作用域
1)访问变量时，会首先寻找本作用域是否存在该变量，若没有，则依次寻找外部作用域。
val = 'test'
def foo():
print(id(val))
foo()
print(id(val))
运行结果：38638064 38638064
2)若在本作用域内，赋值一个变量，则该变量是一个全新的局部变量，与外部作用域变量毫无关系
val = 'test'
def foo():
val = 'hello world'
print(id(val))
foo()
print(id(val))
运行结果： 38141744 38900208
同理，以下示例会报错
val = 'test'
def foo():
print(id(val))
val = 'hello world'
print(id(val))
foo()
print(id(val))
运行结果：
UnboundLocalError: local variable 'val' referenced before assignment
因为，作用域内有赋值，则val在该作用域内是个全新的局部变量，和外部val没有丝毫关系，第一个print(id(val))，会先找到本作用域内定义的val，因此会报上述错误。
2.函数的闭包
def foo():
val = 'test'
print(id(val))
def inner():
print(id(val))
return inner
inner = foo()
inner()
运行结果：35428200 35428200
根据上节说的函数作用域，输出结果应该是相同的，没有问题。
问题的关键是，作用域是有范围的，当一个函数执行完毕后，作用域内的对象都释放了。
为什么执行inner()还能访问到外部作用域内的val变量呢？
这就是函数的闭包特性，嵌套函数能够记住它所处的封闭的命名空间（封闭命名空间内的对象不会释放）。
如何查看内嵌函数的闭包空间呢？可以通过函数的__closure__属性。
print(inner.__closure__)
运行结果：
7575400
7575400
(<cell at 0x00000000006B5618: str object at 0x0000000000739768>,)
0x0000000000739768的十进制值是7575400
嵌套函数使用外部函数参数：
def foo(x):
print(id(x))
def inner():
print(id(x))
return inner
inner = foo(1)
inner()
print(inner.__closure__)
运行结果：
1562953392
1562953392
(<cell at 0x0000000002135618: int object at 0x000000005D28C6B0>,)
可见外部函数传入的参数（嵌套函数有使用的）也会存在于闭包空间。
3.装饰器
上例中，如果参数x也是一个函数，如下所示:
def foo(x):
def inner():
return x() + 1
return inner
def myfunc():
return 1
mynewfunc = foo(myfunc)
result = mynewfunc()
print(result)
运行结果：2
内嵌函数对我们的主函数myfunc逻辑重新组织了一番，并且执行外部函数，返回这个新的内嵌函数mynewfunc，替换掉我们的主函数myfunc
执行新的函数mynewfunc即执行内嵌函数，因为闭包空间的存在，调用myfunc函数，并加上1，所以执行结果为2
外部函数foo，就被称作装饰器（重新装饰主函数myfunc，并返回装饰后的函数mynewfunc）
作用是对主函数，进行修饰，减少了主函数代码的复杂性，如增加log等辅助操作。
4.python装饰器符@
在python中，使用装饰器符@，作用于被装饰主函数，特点是简洁明了。
def foo(x):
def inner():
return x() + 1
return inner
@foo
def myfunc():
return 1
result = myfunc()
print(result)
使用@直接将装饰器，放在主函数的上面，调用主函数时，会自动进行上节操作，返回一个拥有闭包空间的函数。
5.*args,kwargs
*args,kwargs表示参数列表，使用这两个参数，就可以解决参数可变的问题，让装饰器变得通用了
def logger(func):
def inner(*args, **kwargs):
print('arguments:%s,%s'%(args,kwargs))
return func(*args, **kwargs)
return inner
@logger
def foo1(x,y=1):
return x*y
@logger
def foo2():
return 2
foo1(5,4)
foo2()
运行结果:
arguments:(5, 4),{}
arguments:(),{}
对于带参数的被装饰函数，装饰函数参数包含被装饰函数名，参数列表（python中可省略）
不管是args类型的参数，还是kwargs类型的参数(存在于闭包空间)，都可以顺利使用装饰器。
6.functools.wraps装饰器
当我们使用装饰器时，实际上是用装饰器重新包装了一个函数，包装后的函数，函数名等都会发生变化。
如何保证函数名这些属性不变呢？使用functools.wraps装饰器，将原函数作为参数，更新装饰器的属性。
def log(func):
def with_log(*args, **kwargs):
print('called..%s' % func.__name__)
return func(*args, **kwargs)
return with_log
@log
def add(x):
return x+1
result = add(1)
print(add.__name__)
print('result..%s' % result)
运行结果：
called..add
with_log
result..2
可以看到，add.__name__函数名称变成了with_log，这是因为add=log(add),经过装饰器重新装饰以后，函数名称已经变成了with_log
如何保持函数名这些属性不变呢？
对with_log函数再次进行装饰，将装饰后的函数名称等修改为func对应的属性。
from functools import wraps
def log(func):
@wraps(func)
def with_log(*args, **kwargs):
print('called..%s' % func.__name__)
return func(*args, **kwargs)
return with_log
@log
def add(x):
return x+1
result = add(1)
print(add.__name__)
print('result..%s' % result)
运行结果：
called..add
add
result..2
wraps对with_log重新装饰，属性值更新为func函数的属性值。