目录
问题说明
在刷leetcode题目的时候，遇到诸多在一个函数中嵌套另一个函数的写法，因此就涉及对不同函数间变量的传递问题的分析，因此本文的目的就是一次性将不同层级函数间的变量作用域、嵌套函数、闭包函数与装饰器之间的关系进行说明。
一、变量作用域
1.1 全局变量与局部变量
局部变量：只能在特定的函数中可以访问的变量
全局变量：定义在所有函数最外面的变量
分辨局部变量与全局变量的规则
假设有一个变量为a，它出现在函数f()里面，可以使用如下规则来判断：
- 如果有
global关键字修饰变量a，则a为全局变量 - 否则，假如
a是参数或者出现在等号左边，则a是局部变量 - 否则，
a与函数f()外层的变量a的属性相同a = 1 # 全局变量 def F3(): def F(): global a # a是最外层的全局变量 print("In F3's F, a =", a) a = 3 # a出现在等号的左边，所以此处的a就是一个F3()函数中的局部变量 F() print(a) F3() >>> In F3's F, a = 1 3 # 如果将上述代码中global a这一行注释掉，那么最终的输出将变成如下所示： >>> In F3's F, a = 3 3 """ 可以看到，global定义的变量a，是一个全局变量，不管在其他函数中如何将其进行重新赋值，都不会改变其作用范围 """
局部变量可以在外部被赋值，但不可以在外部被调用
所以可以看出，每个变量都有自身的作用域，即其作用范围是有限的，例如上例中a=3的作用域就局限于函数F3()中
二、嵌套函数
2.1 嵌套函数
- 嵌套函数是指在函数内定义的函数
- 定义在其他函数内部的函数称为内建函数，包含有内建函数的函数称为外部函数
- 嵌套函数如同局部变量，是局部函数，它只能在外层定义它的函数中使用
嵌套函数类似于嵌套循环，就是函数内又嵌套着函数。先看一种容易理解的情况：
def func2(): #定义一个函数
print('我是第二个函数')
def func1(): #再定义一个函数
print('我是第一个函数')
func2()
func1()
>>>
我是第一个函数
我是第二个函数
如果把被调用函数写在函数内部呢，那就是嵌套函数了。如下：
>>>def outer(): #定义外层函数
print('我是外层函数')
def inner(): #定义内层函数
print('我是内层函数')
inner() #执行内层函数
>>>outer()
我是外层函数
我是内层函数
调用外部函数outer()后，先执行print('我是外层函数')，最后执行inner()，而inner函数内是print('我是内层函数')，所以最后输出了两句话。
2.2 嵌套函数下的局部和全局变量
假设有一个变量a，它出现在函数f里面，可以使用如下规则来判断：
- 如果有
global关键字修饰变量a，那么不管函数f()是不是嵌套函数，a都为全局变量 - 否则，假如
a是参数或者出现在等号左边，则a是局部变量 - 否则，
a应继承上层函数中a的属性- 如果函数
f不是嵌套函数，那么a为全局变量 - 如果函数
f是嵌套函数，那么a就是上层的a
相关理解案例：
- 如果函数
a = 1 # 全局变量
def F3():
def F():
global a # a是最外层的全局变量
print("In F3's F, a =", a)
a = 3
F()
F3()
>>>
In F3's F, a = 1
a = 1
def F4():
global a
def F():
a = 2 # a是F的局部变量
print("In F4's F,a=", a)
F()
print("In F4, a =", a) # a是全局变量
F4()
>>>
In F4's F,a= 2
In F4, a = 1
a = 1
def F5():
def F(): # a不是F的局部变量，那就继承上层函数中a的属性
print("In F5's F,a =", a)
a = 3
F()
F5()
>>>
In F5's F,a = 3
上述嵌套函数的引入，看似好像没啥用，还直接将代码的复杂度提升上去了，搞这么复杂干嘛呢？？别着急，往下面看。
三、闭包函数
3.1 闭包函数
以上外层函数和内层函数都没有变量，和参数，那如果传入参数和变量呢？然后把外层函数返回值指向内层函数名：
def outer(): #定义外层函数
a=1
print('我是外层函数')
def inner(): #定义内层函数
print('我是内层函数')
print('内层函数打印',a)
return inner #返回内层函数名
f=outer() #调用外层函数，并把结果赋值给f
>>>我是外层函数
看到结果只执行了外层函数的print，内层函数没有执行。我们看一下f的含义，此时f其实就代表inner，指向inner的内存空间。如果要执行需要f(),我们看一下结果：
def outer(): #定义外层函数
a=1
print('我是外层函数')
def inner(): #定义内层函数
print('我是内层函数')
print('内层函数打印',a)
return inner #执行内层函数
f=outer() #调用外层函数，并把结果赋值给f
f()
>>>我是外层函数
我是内层函数
内层函数打印 1
看到内层函数和外层函数都执行了，并且外层函数中的变量a被打印出来。这就是闭包函数，外层函数的变量可以被内层函数调用，这样外层函数变量和内层函数一起构成了类似‘’肚子里的一块区域‘’，这块区域被保护起来，变量只供内层函数‘’享用‘’。类似于封装的效果。内层函数不会立马被执行，当再次调用f时，内层函数才会执行。
调用f()方法打印的a值是1，也就是说在inner()中使用的是外部方法outer()中定义的变量a。但是在调用f()时，outer()函数已经返回了，本地的作用域也不存在了，那么是如何访问到a的值呢？实际上此处就涉及到了变量的作用域相关问题。
闭包函数需要有三个条件，缺一不可：
1.必须有一个内嵌函数
2.内部函数引用外部函数变量
3.外部函数必须返回内嵌函数
3.2 闭包函数作用域
再把上面的代码变形
def outer(): #定义外层函数
a=1
print('我是外层函数')
def inner(): #定义内层函数
a=10
print('我是内层函数')
print('内层函数打印',a)
return inner #执行内层函数
f=outer() #调用外层函数，并把结果赋值给f
f()
>>>我是外层函数
我是内层函数
内层函数打印 10
在内层函数中又有a=10，此时并不是改变的外层函数中的a，而是在内层函数中定义的新变量，是两个不同的东西。从结果也能看出来。这就是作用域的问题。
内层函数中调用的变量首先会从内层函数中找，找不到就去外层函数中找，再找不到就到函数外代码中找，再找不到就到内置的模块中找，最后还是找不到，就报错。
在内层函数中修改外层函数中的变量
在内层函数中修改外部函数中的变量a,此时会报错
def outer(): #定义外层函数
a=1
print('我是外层函数')
def inner(): #定义内层函数
a+=10
print('我是内层函数')
print('内层函数打印',a)
return inner #执行内层函数
f=outer() #调用外层函数，并把结果赋值给f
f()
>>>我是外层函数
Traceback (most recent call last):
File "C:\Users\13061\PycharmProjects\huaweidata\迭代器.py", line 14, in <module>
f()
File "C:\Users\13061\PycharmProjects\huaweidata\迭代器.py", line 9, in inner
a+=10
UnboundLocalError: local variable 'a' referenced before assignment
也就是说，我们在inner()中使用a+=10时，相当于a = a + 10，此时对a进行赋值时，python会默认a是局部变量，但是inner内并没有定义a，所以会报错。
但是如果是将a改为list()类型，可以不可以呢？
def outer():
num = [10]
def inner():
num[0] += 1
return num[0]
return inner
test = outer()
test()
>>>
11
通过运行，我们发现可以得到想要的结果，因为list是可变类型，此时num指向的是自由变量num，并对num中的数据进行了改变。
但是这样每次都把不可变数据转换成可变数据进行传递太麻烦了，所以python3引入了nonlocal声明，作用是把变量标记为自由变量，即使在函数中为变量赋予了新值，也会变成自由变量。
如果想修改外部函数中的变量，必须加一个nonlocal的声明，修改如下。这和在函数中修改全局变量，加global 有异曲同工之妙
def outer(): #定义外层函数
a=1
print('我是外层函数')
def inner(): #定义内层函数
nonlocal a
a+=10
print('我是内层函数')
print('内层函数打印',a)
return inner #执行内层函数
f=outer() #调用外层函数，并把结果赋值给f
f()
python2没有nonlocal，所以需要把变量存储为可变变量的元素或属性，并把对象绑定给自由变量。
闭包函数的意义：
1、上面讲了一点就是把某些变量和函数代码保护到‘’肚子里‘’，这样可以起到保护的作用。
2、可以构造一个新函数，上面例子中外层函数和内层函数都没有传变量，那么如果传入变量呢。
请看：
def outer(a): #定义函数要一杯不同类型的饮料
def inner(b): #定义内层函数，饮料的容量
print(f'要一杯{a}')
print(f'容量是{b}毫升')
return inner #执行内层函数
blacktea=outer('红茶') #调用外层函数，并把结果赋值给f
greentea=outer('绿茶')
blacktea(300)
greentea(500)
>>>要一杯红茶
容量是300毫升
要一杯绿茶
容量是500毫升
四、装饰器
4.1 装饰器基础
对方法进行装饰，在方法运行前后添加其他功能
import time
def outer(func):
def inner():
time1 = time.time()
func()
time2 = time.time()
return time2 - time1
return inner
@outer
def test():
print("test")
相当于：test = outer(test)，此装饰器就是用来计算方法运行时间的
4.2 装饰器的执行顺序
装饰器在被装饰的函数定义之后立即运行，通常是在导入时（即python加载模块时）
def outer(func):
print("%s outer running" % func)
def inner():
print("%s inner running" % func)
return func
return inner
@outer
def test1():
print("test1 runing")
@outer
def test2():
print("test2 runing")
def test3():
print("test3 runing")
def main():
print("main runing")
test1()
test2()
test3()
if __name__ == "__main__":
main()
结果为：
<function test1 at 0x104b4bd90> outer running
<function test2 at 0x104b4bea0> outer running
main runing
<function test1 at 0x104b4bd90> inner running
<function test2 at 0x104b4bea0> inner running
test3 runing
可以看出，在函数test1、test2定义后，装饰器outer立即被执行。
4.3 参数化装饰器
参数化装饰器即为带参数的装饰器，如果装饰器需要额外的参数，就可以创建一个装饰器工厂函数，把参数传给它，如下例：
register = set()
def dec(active=True):
def outer(func):
print("running %s (active=%s)" % (func, active))
if active:
register.add(func)
else:
register.discard(func)
return func
return outer
@dec(active=False)
def test1():
return "runing test1"
@dec()
def test2():
print("runing test2")
def test3():
print("running test3")
def main():
print("main runing")
test1()
test2()
test3()
print(register)
if __name__ == "__main__":
main()
运行结果如下：
running <function test1 at 0x106c71e18> (active=False)
running <function test2 at 0x106c71ea0> (active=True)
main runing
runing test2
running test3
{<function test2 at 0x106c71ea0>}
可以看出，active作为了额外参数传到装饰器outer中对register内的参数进行了控制
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
