python 函数及变量作用域及装饰器decorator @详解
>>> global_v = '全局变量'
>>> def func():
... local_v = '局部变量'
... print(locals()) #调用locals()输出局部变量local_v
>>> func()
{'local_v': '局部变量'} #命名空间中都是以字典形式保存
>>> print(globals())
{.........,'global_v': '全局变量', 'func': <function foo at 0x00000092446C7F28>} #可以看到除了变量，函数名也作为索引，映射函数内存地址，是主程序命名空间的内容
可以看到内置函数globals()返回了一个所有python能识别的变量的字典，而func 拥有自己的命名空间，里面包含了一个{'local_v': '局部变量'}元素
- 在python中的变量作用域规则是：
1.变量的创建，变量的创建总是会在函数命名空间创建一个新的变量。
2.变量的访问，是先在函数内部，访问局部变量所在的函数命名空间，当找不到后再到外层，再到整个外层作用域去寻找该变量。 LEGB法则：索变量名的优先级：局部作用域 > 嵌套作用域 > 全局作用域 > 内置作用域
当在函数中使用未确定的变量名时，Python会按照优先级依次搜索4个作用域，以此来确定该变量名的意义。首先搜索局部作用域(L)，之后是上一层嵌套结构中def或lambda函数的嵌套作用域(E)，之后是全局作用域(G)，最后是内置作用域(B)。按这个查找原则，在第一处找到的地方停止。找不到就报错。NameError: name 'xxx' is not defined
3.变量的修改，当函数尝试修改外层变量时，这是不行的，函数只能修改自己命名空间的变量。
如果你非改不可，那只能在变量前面声明global 这样就可以改了
>>> name = 'lina'
>>> age = 22
>>> list_1 = [1, 2, 3]
>>> def fun():
... name = 'alex' #1 尝试修改，重赋值alex 给name
... print(name)
... print(age) #2 尝试查找函数命名空间中不存在的变量age， 没找到就去外层作用域找到
... list_1.append('local') # 4 此处修改list_1
... list_1.pop(0)
... print(list_1)
>>> fun()
'alex'
22
[2, 3, 'local']
>>> print(name) #3 查看全局变量name 是否被函数修改成功，显然没有
'lina'
>>> print(list_1)
[2, 3, 'local'] #4 此处修改成功
通过上一个例子，我们可以从#1处看到，尝试给name赋值，在函数中成功了。
可是在#3处发现并没有改变name的值，这是因为函数已经开辟内存复制了一份name的值到自己的命名空间中，创建一个同名的新变量name，当fun()运行结束后该内存释放，而在#3处python寻找变量时直接在自己的作用域中找到name = 'lina'。
2处在自身的内存空间没有找到age变量，就去外层找到age= 22输出。
而在#1处就是所说的函数只能修改自身的变量，#4处对于列表、字典这种，可变对象，传过来的是内存地址，函数是复制了内存地址，然后直接去内存地址修改了，不能同变量混为一谈
>>> def fun(parameter): #形式参数
... parameter = parameter*2
... print(parameter)
>>> fun(2) #实际参数
4
>>> def out_fun():
... a = '外层变量'
... def inner():
... print(a) #1
... inner() #2
>>> out_fun()
外层变量
- 处inner搜索自身命名空间，没找到变量a然后在外层的out_fun的局部变量中寻找到，inner作为内嵌函数拥有访问外层作用域的权限（有读和修改的权限-指复制到自身命名空间后修改）当函数调用结束就释放了。
- 处函数out_fun在自身命名空间中找到变量名'inner'，拿到内存地址然后执行函数
>>> def out_fun():
... a = 'out变量'
... def inner():
... print(a) #1
... return inner
>>> fun = out_fun()
>>> fun.__closure__
(<cell at 0x000000A3B57F0B28: str object at 0x000000A3B5AC3088>,)
现在来理解下这个函数，如果按照变量的作用域规则，在#1处inner首先会在自己的命名空间中去寻找变量a，没找到然后再去外层out_fun寻找。
所以当我们执行由out_fun()返回的fun时，按照道理这个程序是会报错的。因为当out_fun()执行完毕后就会释放内存，a变量就不存在了，所以当你执行fun时，inner无法找到a变量就会报错。我们试试看结果如何：
>>> def out_fun():
... a = 'out变量'
... def inner():
... print(a)
... return inner
>>> fun = out_fun()
>>> fun()
out变量
程序并没有报错，这并不矛盾，因为python支持一个名为闭包的特性，从fun.__closure__属性我们看见了，cell at 0x000000A3B57F0B28: str object at 0x000000A3B5AC3088，
即在不是全局的定义中，定义函数inner（即嵌套函数）时，会记录下外层函数的命名空间，这个对象就保存在.__closure__属性中，去这儿就是找到外层函数的命名空间。
>>> def out_fun(fun): #1接受函数作为参数
... def inner(a, b= 0, *args):
... print('装饰器先运行0.0')
... result = fun(a) + b #2运行传过来的被装饰函数
... print('装饰后结果为：',result)
... return result
... return inner
>>> def foo(x): #3定义foo函数
... print('---------------\n这是被装饰函数')
... result = 2*x
... print('被装饰函数执行结果为:{}\n--------------'.format(result))
... return 2*x
>>> decorate_foo = out_fun(foo) #4将foo函数作为jout_fun参数执行out_fun
>>> foo =decorate_foo #把装饰过的foo函数decorate_foo 重赋值给foo，再调用foo()
>>> foo()
装饰器先运行0.0
---------------
这是被装饰函数
被装饰执行结果为:4
---------------
装饰后结果为： 2
现在来理解下这段程序，#1处定义了一个函数，他只接受函数作为参数,#2出运行传过来的被装饰函数，#3定义了一个函数，#4处将#3定义的foo作为参数传给out_fun(foo)得到被装饰后decorate_foo，然后再将装饰后的函数重新赋值给foo,然后当你再次运行foo函数的时候，永远都是得到被装饰后的结果了。
讲到这儿就说个实际应用列子吧！
如汽车在公路上行驶，按照某地交通规则，在国道上限速最高80迈，无下限，高速公路上最低60迈最高120迈。
我们原始程序，通过测速传感器传来的参数计算出汽车当前速度，并返回该速度。
>>> status = 1
>>> def car_speed(angular_speed, radius = 0.35) #根据传来的角速度参数，以及半径计算出当前速度
... current_speed = angular_speed*radius*3.6
... return current_speed
>>>
>>> def slowdown():
... pass #假设调用此函数是调用刹车、减速系统，会减慢汽车速度
>>>
>>> def decorate_fun(fun):
... def inner(*args, **kwargs):
... current_speed = fun(args[0]) if len(args) = 1 else fun(args[0], radius = args[1])
... if current_speed >110:
... sys.stdout.write('您已超速！')
... sys.stdout.flush()
... elif current_speed > 160:
... sys.stdout.write('超速50%系统已限速，请注意安全')
... sys.stdout.flush()
... slowdown()
... elif current_speed < 60:
... sys.stdout.write('该路段限速60，请注意')
... sys.stdout.flush()
... else: pass
... return current_speed
... return inner
>>>
>>> decorator_car_speed = decorate_fun(car_speed)
>>> decorato_car_speed(120)
您已超速！
这段程序，当汽车在国道等非限速区域是，直接调用car_speed()函数就可以得到速度，而当行驶上高速公路后，就存在边界值问题，我们可以使用装饰后的decorate_car_speed()函数来处理。
>>> def decorator_foo(fun):
... def inner(*args, **kwargs):
... fun(*args, **kwargs)
... pass
... return inner
>>>
>>> @decorator_foo #1
>>> def foo(*args, **kwargs): #2
... pass
>>>
在#1处@decorator_foo 使用@符号+装饰器函数，在被装饰函数的上方，记住一定要正上方挨着不能空行，就等于前面所学的decorator = decorator_foo(foo) + foo = decorator() 这样以后你调用foo就是调用的被装饰后的foo了
- 当然我们如果在每一个函数内都做一次验证，那代码重复就太多了，所以选择用装饰器，不失为一个好方法。可是现在们要求，根据不同的函数，home、bbs、member都在本地数据库验证,而index做ldap验证，意思就是我们要在一个装饰器里面，根据不同的函数做不同的验证。
一般的验证：
def _authentication(r):
print('假设使用这个函数做本地用户认证，过了返回True，错误返回False')
return #返回验证结果
def auth(fun): #装饰器函数
def wrapper(request, *args, **kwargs):
if _authentication(request): #调用验证函数
result = fun(request)
return result
else:
return '用户名或密码错了，重新登录吧！'
return wrapper
@auth
def index(request):
pass
@auth
def home(request):
pass
@auth
def bbs(request):
pass
@auth
def member(request):
pass
全部代码我就不写了，太多复杂了，就用伪代码，逻辑描述来代替了。
可以看出来，我们这个函数可以实现用户验证功能，不管你使用cookie也好，去本地数据库取数据也罢。但是我们上面说的需求，把index来的请求分离出来，做ldap验证，显然这样的装饰器是没法做到的。无法识别谁来的请求。
@装饰器还提供了一功能，能解决这个问题，往下看：
def _authentication(r):
print('假设使用这个函数做本地用户认证，过了返回True，错误返回False')
return #返回验证结果
def _ldap(r):
print('ldap验证')
return #返回ldap验证结果
def auth(souce_type):
#这儿的souce_type参数就是@auth(v)运行时传过来的参数
def outer(fun):
def wrapper(request, *args, **kwargs):
if souce_type == 'local': #* 1 如果请求来源标记是'local'就本地验证
if _authentication(request):
result = fun(request)
return result
else:
return '用户名或密码错了，重新登录吧！'
elif souce_type == 'ldap': #* 1 如果请求来源标记是'ldap'就ldap验证
if _ldap(request):
return fun(request)
else:
return '用户名或密码错了，重新登录吧！'
return wrapper
return outer
@auth(souce_type = 'ldap') #3 装饰
def index(request):
pass
@auth(souce_type = 'local') #4
def home(request):
pass
- 注意#3，#4处，我们把auth('parameter')加参数运行了一次，而装饰器函数auth里面进行了三层嵌套，auth---->outer----->wrapper，你可以这样理解，原来的@auth @符号会把后面的内容auth运行一次直接就返回了wrapper， 现在，我们自己把auth('parameter')加参数运行了一次得到outer，@auth(parameter)就等同于 @outer，@符号把后面的outer运行一次后再得到wrapper并赋给被修饰函数，而函数souce_type来源也被我们带进了装饰器。
