Python 变量的作用域 - 生命周期

Python 中变量的访问权限取决于其赋值的位置，这个位置被称为变量的作用域。

Python语法规定：

在函数体中有赋值语句时，编译的时候就认为定义了局部变量，从而保证函数封装性。
如果在函数体内要使用全局变量，可以使用global关键字将变量限定为全局变量。但这种代码要小心，因为很容易就改变了全局变量。

Python 的作用域共有四种

1. 局部作用域（Local，简写为 L）
2. 作用于闭包函数外的函数中的作用域（Enclosing，简写为 E）
3. 全局作用域（Global，简写为 G）
4. 内置作用域（即内置函数所在模块的范围，Built-in，简写为 B）。

变量在作用域中查找的顺序是L→E→G→B，即当在局部找不到时会去局部外的局部找（例如闭包），再找不到会在全局范围内找，最后去内置函数所在模块的范围中找。

分别在 L、E、G 范围内定义的变量的例子如下：

# 全局变量：写在函数和类的外面。注意：变量前不需要加任何标识符
global_var = 0         # 全局作用域
def outer():
	# “闭包函数外的函数中”这句话比较绕口，也不好理解
	# 我的理解是：enclosing_var为函数outer()的局部变量，作用域在outer()函数内部。
	# 但是，outer()函数内又定义了内置函数inner()，enclosing_var的作用域覆盖了inner()，但是其不是inner()的局部函数
	# 即：次低级作用域的局部变量。其实内置函数的外部变量，但是其又不是全局变量。
    enclosing_var = 1    # 闭包函数外的函数中
    def inner():
    	# 最低级作用域的局部变量
        local_var = 2            # 局部作用域 

内置作用域

内置作用域则是通过 builtins 模块实现的，可以使用以下代码查看当前 Python 版本的预定义变量：

import builtins
dir(builtins)

上述代码的运行结果如下所示：

>>> import builtins
>>> dir(builtins)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']

局部作用域与全局作用域

定义在函数内部的变量拥有一个局部作用域（作用域在函数内），定义在函数外的变量拥有全局作用域（作用域为整个py文件，例如：b.py，如果该b.py文件被a.py引用，则作用域扩展到a.py）。

局部变量只能在其声明语句所在的函数内部访问，全局变量可以在整个程序范围内访问。

调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

当内部作用域想修改外部作用域的变量(包括全局作用域变量和次低级作用域的局部变量)时，需要使用 global 和 nonlocal 关键字声明外部作用域的变量，例如：

global_num = 1
def func1():
    enclosing_num = 2
    global global_num    # 使用global关键字声明
    print(global_num)
    global_num = 123
    print(global_num)
    def func2():
        nonlocal enclosing_num
        print(enclosing_num)       # 使用nonlocal关键字声明
        enclosing_num = 456
    func2 ()
    print(enclosing_num)
func1 ()
print(global_num)

上述代码的运行结果如下所示：

>>> global_num = 1
>>> def func1():
...          enclosing_num = 2
...          global global_num    #使用global关键字声明
...          print(global_num)
...          global_num = 123
...          print(global_num)
...          def func2():
...              nonlocal enclosing_num
...              print(enclosing_num)       #使用nonlocal关键字声明
...              enclosing_num = 456
...          func2 ()
...          print(enclosing_num)
   
>>> func1 ()
1
123
2
456
>>> print(global_num)
123

只有模块（module），类（class）和函数（def、lambda）才会引入新的作用域，if/elif/else/、try/except、for/while 等语句则不会引入新的作用域（注意：这点与C++不同），即外部可以访问在这些语句内定义的变量。

闭包与nonlocal

在这里，不得不提下闭包这个概念。在看过很多概念性定义之后，最后在《你不知道的JavaScript》这本书中，终于有了实质性的收获：

当函数可以记住并访问所在的词法作用域时， 就产生了闭包， 即使函数是在当前词法作用域之外执行。

如下代码，在内层函数add中，访问了外层函数中变量count。

每次调用fn都返回一个函数对象，该对象可以在当前全局模块环境中执行，也就是在fn函数词法作用域之外执行。

def fn():
	count = 0	# count 次低级局部变量，作用域范围fn()
	
	def add(dt = 0):
		r = count + dt	 # count 局部变量，作用域add()  即：fn().count 与 add().count 不是一个变量
		print(r)
	return add

# 执行如下代码
fn().add at 0x7efcd433e048>
add = fn()
add()
# 结果为  0

add(1)
# 结果为 1

add(123)
# 结果为 123

some = fn()
some()
# 结果为 0

some(123)
# 结构为 123

但是，当我们想要在内层函数直接赋值给外层函数中的变量时，问题就来了。
下面的代码，遇到了上面一样的错误：
语句count += dt给count赋值了，Python认为定义了一个局部变量count，+=运算要先取到count的值，但此时内层函数中count没有绑定值，于是报错了。

def fn():
	count = 0
	
	def add(dt = 0):
		count += dt			# 编译器报错，这个count为局部变量（作用域add()），但是count没有初始值，因此运行+=时需要先取值，因此会报错
		print(count)
	return add

# 执行
some = fn()
some()

Traceback (most recent call last):
File "", line 1, in
File "", line 4, in add
UnboundLocalError: local variable 'count' referenced before assignment

可以使用nonlocal关键字来解决这个问题。

注意如下每次函数对象调用的结果，每次调用fn返回的函数对象，该对象持有一份count变量副本，每次调用都针对当前函数对象。

def fn():
    count = 0
    print("fn().count = ", count)

    def add(dt=0):
        nonlocal count  # 这个count变量为 fn().count变量，而非add()内的局部变量
        count += dt
        print("add().count = ", count)

    return add


# 运行
# 重温一下闭包概念：当函数可以记住并访问所在的词法作用域时，就产生了闭包，即使函数是在当前词法作用域之外执行
some = fn()  # 该语句产生了一个闭包
some()
# 结果：0

some(1)
# 结果：1

some(123)
# 结果：124    注意：结果为124，说明fn().count变量被保存了，这是闭包，需要着重理解

some(1)
# 结果： 125

# 更换
test2 = fn()  # 该语句产生了一个闭包
test2()
# 结果：0     注意：这里结果为0，说明fn().count复位了，some与any属于不同的闭包。

test2(1)
# 结果：1

test2(1)
# 结果：2

运行结果：

C:\ProgramData\Anaconda3\python.exe D:/Python_X64/pythonProjectTest1/test.py
fn().count =  0
add().count =  0
add().count =  1
add().count =  124
add().count =  125
fn().count =  0
add().count =  0
add().count =  1
add().count =  2

进程已结束,退出代码0

深入理解闭包

从上例的运行结果看，有点出乎我的预料。再仔细观察代码，发现如下

def fn():
count = 0
print("fn().count = ", count)

def add(dt=0):
    nonlocal count  # 这个count变量为 fn().count变量，而非add()内的局部变量
    count += dt
    print("add().count = ", count)

return add

函数fn()返回值为函数add的引用（注意：return add add后面没有括号）。

因此，在执行语句 test2 = fn()时，输出了fn().count = 0，并没有输出add().count = 0，这是因为没有执行add()。
在执行test2() 时，实际执行的就是add(0)，因此输出为add().count = 0。
在执行test2(1) 时，实际执行的就是add(1)，因此输出为add().count = 1。
再次执行test2(1) 时，实际执行的就是add(1)，因此输出为add().count = 2。

结合闭包的定义进行理解：

闭包：当函数可以记住并访问所在的词法作用域时，就产生了闭包，即使函数是在当前词法作用域之外执行。

当执行test2 = fn()时test2记住 fn().add()方法（也可以说此时test2就是add()的别名）；

当执行test2()时，访问了add()之外的fn().count变量，此时test2()成为了闭包；因此闭包外的fn().count变量作用域延伸到了整个test2()的执行期间。