最近看 scala ，看到了它的作用域，特此回顾一下python的变量作用域问题。
A = 10
B = 100
print A #10
print globals() #{'A': 10, 'B': 100, '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'E:/PycharmProjects/untitled/test1.py', '__package__': None, '__name__': '__main__', '__doc__': None}
def mu(x,y):
B = 9
print locals() #{'y': 9, 'x': 10,'B':9}
if A == 10:
B = 19
print locals() #{'y':9,'x':10,'B':19}
return x+y
else:
return x-y
m = mu(10,9)
print(m) # 19
print locals() #{'A': 10, 'B': 100, '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'E:/PycharmProjects/untitled/test1.py', 'm': 19, '__package__': None, 'mu': <function mu at 0x02ADA430>, '__name__': '__main__', '__doc__': None}
print globals()#{'A': 10, 'B': 100, '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'E:/PycharmProjects/untitled/test1.py', 'm': 19, '__package__': None, 'mu': <function mu at 0x02ADA430>, '__name__': '__main__', '__doc__': None} # 全局作用域的 locals 和globals 内的变量内容是一样的。
print __name__ # __main__
print __file__ #E:/PycharmProjects/untitled/test1.py
print __doc__ # None
print __package__ # None
print B # 100
global
A = 10
B = 100
print A # 10
print globals()#{'A': 10, 'B': 100, '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'E:/PycharmProjects/untitled/test1.py', '__package__': None, '__name__': '__main__', '__doc__': None}
def mu(x,y):
global B
B +=1
print(B) #101
print locals() #{'y': 9, 'x': 10} 进过global 作用， 本地变量中不会创建新的本地变量 B 了。而是直接用的全局的 B。
if A == 10:
B = 20
print locals() #{'y': 9, 'x': 10}
return x+y
else:
return x-y
m = mu(10,9)
print(m)
print locals() #{'A': 10, 'B': 20, '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'E:/PycharmProjects/untitled/test1.py', 'm': 19, '__package__': None, 'mu': <function mu at 0x02A8A430>, '__name__': '__main__', '__doc__': None}
print globals()#{'A': 10, 'B': 20, '__builtins__': <module '__builtin__' (built-in)>, '__file__': 'E:/PycharmProjects/untitled/test1.py', 'm': 19, '__package__': None, 'mu': <function mu at 0x02A8A430>, '__name__': '__main__', '__doc__': None}
print B#20 因为函数中使用了 global 关键字， 函数中使用的是全局变量B ，并且对其做出了修改，所以这个B也就变成了 20
赋值 操作
A = 10
B = 100
print A
print globals()
def mu(x,y):
# B = B +1 # 这么做会报错 因为赋值操作会查找 本地变量 然而本地变量中并没有B 变量 并不是想象中的 B = 100 +1 ，只要出现赋值语句，就会遮蔽外层变量，而在此之前，本地变量中并未定义B。
# print(B) #100
print locals()
if A == 10:
if B == 100: #这么做不会报错，它会查找到全局变量
print "haha"
print locals() #{'y': 9, 'x': 10}
return x+y
else:
return x-y
m = mu(10,9)
print(m)
print locals()
print globals()
print B #100
以下为python3 操作
>>> def a(x):
... print(x)
... def b():
... print(x) # 参数作用域，父函数的参数可以 被子函数所使用，这也就是闭包。scala 作用域与此效果类似，内部函数，可以直接使用外部函数的变量。
... b()
...
>>>
>>> a(10)
10
10
>>> def a(x):
... print(x)
... def b():
... print(x) #这里会报错，因为在一旦在函数内部出现赋值操作，那么就会对外层的变量产生遮蔽效果，无论这赋值参数在本函数内部的位置是否在前，或者是在后，只要出现，就会出现遮蔽效果，此时如果在赋值操作之前使用该变量，就会出现未定义该变量的错误。 scala 的变量作用域效果与此类似。
... x = 20
... print(x)
... b()
...
>>> a(10)
10
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 7, in a
File "<stdin>", line 4, in b
UnboundLocalError: local variable 'x' referenced before assignment
>>> def a(x):
... print(x)
... def b():
... nonlocal x #python3 的 nonlocal 语句可以内部函数直接使用外部函数
... x = 20
... print(x)
... b()
... print(x)
...
>>> a(10)
10
20
20
>>> def a(x):
... print(locals())
... def b():
... print(x)
... print(locals())
... b()
...
>>> a(1)
{'x': 1}
1
{'x': 1}
>>> def a(x):
... print(locals())
... def b():
... print(locals()) #虽然赋值操作在本打印语句之后，但是仍然 可以看出，x 已经被遮蔽了
... x = 20 #由于未使用nonlocal，此时的x 是一个和外部x 同名的全新的本地变量，所以，对他的任何修改，仅限于本函数内部，不会影响到外部。
... print(locals())
... print(x)
... b()
... print(x) # 这是 遮蔽效果的证明
...
>>> a(10)
{'x': 10}
{}
{'x': 20}
20
10
>>>
闭包
def a():
x = 20
def b(y):
return y+x # 注意闭包内部是直接使用 外层函数的变量，而没有对外层函数变量进行赋值操作。
return b(10)
def c():
x = 20
def b(y):
x += 12 # 这里对x 进行了赋值操作。 x = x+12 ,这会报错，这其实已经不是闭包了，由于出现了赋值操作，所以，这里的 x 是一个和外层同名的变量，但是在本函数内部，本等式之前，并未进行 x 的宣告。所以会报错
return x +y
return b(10)
print(c())
贴一段scala 的闭包代码：
object PackageStudy {
def main(args: Array[String]): Unit = {
def a(): Int = {
var x = 10
def b(y: Int): Int = {
x += 13 // scala 可以做此操作，对捕获的自由变量进行了修改，但是 python 不行，因为这个操作在python 内部是一个重新宣告x，重新赋值的操作，这会产生屏蔽效果，python 宣告变量 是“贴签”操作。所以，python貌似是不支持对捕获变量的修改。也就没有 所谓在函数内部进行修改，会影响 外部的自由变量的值 这种情况的出现。
x + y
}
def c(z: Int): Int = {
x + z
}
println(x) //10
println(b(10)) //33 第一次捕获的自由变量的值是 x =10，所以此时的函数字面量中 x 绑定的是10
println(x) //23 //在闭包内部对捕获的自由变量的修改，也会影响到外面的自由变量。
println(c(3)) //26 自由变量经过 b() 的修改，c(3)再次捕获x时，x 已经是 23 了，此时的 函数字面量中绑定的x 是23
0
}
println(a())
}
}
python引用变量的顺序： 当前作用域局部变量->外层作用域变量->当前模块中的全局变量->python内置变量 。