楔子
前面我们剖析了字节码的执行流程，本来应该接着介绍一些常见指令的，但因为有几个指令涉及到了局部变量，所以我们单独拿出来说。与此同时，我们还要再度考察一下 local 名字空间，它的背后还隐藏了很多内容。
我们知道函数的参数和函数内部定义的变量都属于局部变量，均是通过静态方式访问的。
x = 123
def foo1():
global x
a = 1
b = 2
# co_nlocals 会返回局部变量的个数
# a 和 b 是局部变量，x 是全局变量，因此是 2
print(foo1.__code__.co_nlocals) # 2
def foo2(a, b):
pass
print(foo2.__code__.co_nlocals) # 2
def foo3(a, b):
a = 1
b = 2
c = 3
print(foo3.__code__.co_nlocals) # 3无论是参数还是内部新创建的变量，本质上都是局部变量。
按照之前的理解，当访问一个全局变量时，会去访问 global 名字空间（也叫全局名字空间）。
那么问题来了，当操作函数的局部变量时，是不是也等价于操作其内部的 local 名字空间（局部名字空间）呢？我们往下看。
如何访问（创建）一个局部变量
之前我们说过 Python 变量的访问是有规则的，会按照本地、闭包、全局、内置的顺序去查找，也就是 LEGB 规则，所以在查找变量时，local 名字空间应该是第一选择。
但不幸的是，虚拟机在为调用的函数创建栈帧对象时，这个至关重要的 local 名字空间并没有被创建。因为栈帧的 f_locals 字段和 f_globals 字段分别指向了局部名字空间和全局名字空间，而创建栈帧时 f_locals 被初始化成了 NULL，所以并没有创建局部名字空间。
我们通过源码来进行验证，不过要先补充一个知识点，就是当调用一个 Python 函数时，底层会调用哪些 C 函数呢？
我们看一下源码：
// Objects/call.c
/*
* Python 函数也是一个对象，当调用 Python 函数时
* 底层会将 Python 函数对象作为参数，调用 _PyFunction_Vectorcall
* 关于函数，我们后续会剖析
*/
PyObject *
_PyFunction_Vectorcall(PyObject *func, PyObject* const* stack,
size_t nargsf, PyObject *kwnames)
{
// ...
// 参数 func 指向函数对象，它内部的 func_code 指向 PyCodeObject 对象
// 如果 co_flags & CO_OPTIMIZED 为真，表示 PyCodeObject 是被优化过的
// 那么对应的函数在调用时，会静态查找本地局部变量
if (((PyCodeObject *)f->func_code)->co_flags & CO_OPTIMIZED) {
// 在这种情况下，会给 _PyEval_Vector 的第三个参数传递 NULL
return _PyEval_Vector(tstate, f, NULL, stack, nargs, kwnames);
}
// ...
}
// Python/ceval.c
/*
* 创建栈帧，调用 _PyEval_EvalFrame，最终执行帧评估函数
* 注意该函数的第三个参数，显然它表示局部名字空间
* 而 _PyFunction_Vectorcall 在调用时传递的是 NULL
*/
PyObject *
_PyEval_Vector(PyThreadState *tstate, PyFunctionObject *func,
PyObject *locals,
PyObject* const* args, size_t argcount,
PyObject *kwnames)
{
// ...
// 执行帧评估函数之前，要先创建栈帧
// 这个过程由 _PyEvalFramePushAndInit 负责
_PyInterpreterFrame *frame = _PyEvalFramePushAndInit(
tstate, func, locals, args, argcount, kwnames);
// ...
return _PyEval_EvalFrame(tstate, frame, 0);
}
/*
* 在当前栈帧之上创建新的栈帧，并推入虚拟机为其准备的 C Stack 中
*/
static _PyInterpreterFrame *
_PyEvalFramePushAndInit(PyThreadState *tstate, PyFunctionObject *func,
PyObject *locals, PyObject* const* args,
size_t argcount, PyObject *kwnames)
{
// ...
// 栈帧创建之后，调用 _PyFrame_Initialize，进行初始化
_PyFrame_Initialize(frame, func, locals, code, 0);
// ...
}
// Include/internal/pycore_frame.h
/*
* 对 frame 进行初始化
*/
staticinlinevoid
_PyFrame_Initialize(
_PyInterpreterFrame *frame, PyFunctionObject *func,
PyObject *locals, PyCodeObject *code, int null_locals_from)
{
frame->f_funcobj = (PyObject *)func;
frame->f_code = (PyCodeObject *)Py_NewRef(code);
frame->f_builtins = func->func_builtins;
frame->f_globals = func->func_globals;
// 将 f_locals 字段初始化为参数 locals
// 而参数 locals 是从 _PyFunction_Vectorcall 一层层传过来的
// 由于 _PyFunction_Vectorcall 传的是 NULL
// 所以栈帧的 f_locals 字段最终会被初始化为 NULL
frame->f_locals = locals;
// ...
}所以我们验证了在调用函数时，栈帧的局部名字空间确实被初始化为 NULL，当然也明白了 C 函数的调用链路。
我们用 Python 代码演示一下：
import inspect
# 模块的栈帧
frame = inspect.currentframe()
# 对于模块而言，局部名字空间和全局名字空间是同一个字典
print(frame.f_locals is frame.f_globals) # True
# 当然啦，局部名字空间和全局名字空间也可以通过内置函数获取
print(
frame.f_locals is locals() is frame.f_globals is globals()
) # True
# 但对于函数而言就不一样了
def foo():
name = "古明地觉"
return inspect.currentframe()
frame = foo()
# global 名字空间全局唯一
# 无论是获取栈帧的 f_globals，还是调用 globals()
# 得到的都是同一份字典
print(frame.f_globals is globals()) # True
# 但每个函数都有自己独立的局部名字空间
print(frame.f_locals) # {'name': '古明地觉'}
# 咦，不是说局部名字空间被初始化为 NULL 吗？
# 那么在 Python 里面获取的话，结果应该是个 None 才对啊
# 关于这一点，我们稍后会解释总之对于函数而言，在创建栈帧时，它的 f_locals 被初始化为 NULL。那么问题来了，局部变量到底存储在什么地方呢？当然，由于变量只是一个名字（符号），而局部变量的名字都存储在符号表中，所以更严谨的说法是，局部变量的值存储在什么地方？
在介绍虚拟机执行字节码的时候我们说过，当函数被调用时，虚拟机会为其创建一个栈帧。栈帧是虚拟机的执行环境，包含了执行时所依赖的上下文，而栈帧内部有一个字段叫 f_localsplus，它是一个数组。
这个数组虽然是一段连续内存，但在逻辑上被分成了 4 份，其中局部变量便存储在 f_localsplus 的第一份空间中。现在我们明白了，局部变量是静态存储在数组中的。
我们举个例子。
def foo(a, b):
c = a + b
print(c)它的字节码如下：
注意里面的 LOAD_FAST 和 STORE_FAST，这两个指令对应的逻辑如下。
TARGET(LOAD_FAST) {
PyObject *value;
#line 192 "Python/bytecodes.c"
// 通过宏 GETLOCAL 获取局部变量的值
value = GETLOCAL(oparg);
assert(value != NULL);
Py_INCREF(value);
#line 90 "Python/generated_cases.c.h"
// 将值压入运行时栈，等价于 PUSH(value)
STACK_GROW(1);
stack_pointer[-1] = value;
DISPATCH();
}
TARGET(STORE_FAST) {
// 获取栈顶元素
PyObject *value = stack_pointer[-1];
#line 209 "Python/bytecodes.c"
// 通过宏 SETLOCAL 创建局部变量
SETLOCAL(oparg, value);
#line 124 "Python/generated_cases.c.h"
// 将 stack_pointer 向栈底移动一个位置，即弹出栈顶元素
// 如果和第一行组合起来的话，等价于 TOP()
STACK_SHRINK(1);
DISPATCH();
}所以 LOAD_FAST 和 STORE_FAST 分别负责加载和创建局部变量，而核心就是里面的两个宏：GETLOCAL、SETLOCAL。
// Python/ceval_macros.h
#define GETLOCAL(i) (frame->localsplus[i])
#define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \
GETLOCAL(i) = value; \
Py_XDECREF(tmp); } while (0)
/* 这里额外再补充一个关于 C 语言的知识点
* 我们看到宏 SETLOCAL 展开之后的结果是 do {...} while (0)
* do while 循环会先执行 do 里面的循环体，然后再判断条件是否满足
* 因此从效果上来说，执行 do {...} while (0) 和直接执行 ... 是等价的
* 那么问题来了，既然效果等价，为啥还要再套一层 do while 呢
* 其实原因很简单，如果宏在展开之后会生成多条语句，那么这些语句要成为一个整体
* 另外由于 C 程序的语句要以分号结尾，所以在调用宏时，我们也会习惯性地在结尾加上分号
* 因此我们希望有这样一种结构，能同时满足以下要求：
* 1）可以将多条语句包裹起来，作为一个整体；
* 2）程序的语义不能发生改变；
* 3）在语法上，要以分号结尾；
* 显然 do while 完美满足以上三个要求，只需将 while 里的条件设置为 0 即可
* 并且当编译器看到 while (0) 时，也会进行优化，去掉不必要的循环控制结构
* 因此以后看到 do {...} while (0) 时，不要觉得奇怪，这是宏的一个常用技巧
*/我们看到操作局部变量，就是在基于索引操作数组 f_localsplus，显然这个过程比操作字典要快。尽管字典是经过高度优化的，但显然再怎么优化，也不可能快过数组的静态操作。
所以此时我们对局部变量的藏身之处已经了然于心，它们就存放在栈帧的 f_localsplus 字段中，而之所以没有使用 local 名字空间的原因也很简单。因为函数内部的局部变量在编译时就已经确定了，个数是不会变的，因此编译时也能确定局部变量占用的内存大小，以及访问局部变量的字节码指令应该如何访问内存。
def foo(a, b):
c = a + b
print(c)
print(
foo.__code__.co_varnames
) # ('a', 'b', 'c')比如变量 c 位于符号表中索引为 2 的位置，这在编译时就已确定。
当创建变量 c 时，只需修改数组 f_localsplus 中索引为 2 的元素即可。
当访问变量 c 时，只需获取数组 f_localsplus 中索引为 2 的元素即可。
这个过程是基于数组索引实现的静态查找，所以操作局部变量和操作全局变量有着异曲同工之妙。操作全局变量本质上是基于 key 操作字典的 value，其中 key 是变量的名称，value 是变量的值；而操作局部变量本质上是基于索引操作数组 f_localsplus 的元素，这个索引就是变量名在符号表中的索引，对应的数组元素就是变量的值。
所以我们说 Python 的变量其实就是个名字，或者说符号，到这里是不是更加深刻地感受到了呢？
但对于局部变量来说，如果想实现静态查找，显然要满足一个前提：变量名在符号表中的索引和与之绑定的值在 f_localsplus 中的索引必须是一致的。毫无疑问，两者肯定是一致的，并且索引是多少在编译阶段便已经确定，会作为指令参数保存在字节码指令序列中。
好，到此可以得出结论，虽然虚拟机为函数实现了 local 名字空间（初始为 NULL），但在操作局部变量时却没有使用它，原因就是为了更高的效率。当然还有所谓的 LEGB，都说变量查找会遵循这个规则，但我们心里清楚，局部变量其实是静态访问的，不过完全可以按照 LEGB 的方式来理解。
解密 local 名字空间
先来看一下全局名字空间：
x = 1
def foo():
globals()["x"] = 2
foo()
print(x) # 2global 空间全局唯一，在 Python 层面上就是一个字典，在任何地方操作该字典，都相当于操作全局变量，即使是在函数内部。
因此在执行完 foo() 之后，全局变量 x 就被修改了。但 local 名字空间也是如此吗？我们尝试一下。
def foo():
x = 1
locals()["x"] = 2
print(x)
foo() # 1我们按照相同的套路，却并没有成功，这是为什么？原因就是上面解释的那样，函数内部有哪些局部变量在编译时就已经确定了，查询的时候是从数组 f_localsplus 中静态查找的，而不是从 local 名字空间中查找。
然后我们打印一下 local 名字空间，看看里面都有哪些内容。
def foo():
name = "satori"
print(locals())
age = 17
print(locals())
gender = "female"
print(locals())
foo()
"""
{'name': 'satori'}
{'name': 'satori', 'age': 17}
{'name': 'satori', 'age': 17, 'gender': 'female'}
"""我们看到打印 locals() 居然也会显示内部的局部变量，相信聪明如你已经猜到 locals() 是怎么回事了。因为局部变量不是从局部名字空间里面查找的，所以它初始为空，但当我们执行 locals() 的时候，会动态构建一个字典出来。
符号表里面存储了局部变量的符号（或者说名字），f_localsplus 里面存储了局部变量的值，当执行 locals() 的时候，会基于符号表和 f_localsplus 创建一个字典出来。
def foo():
name = "satori"
age = 17
gender = "female"
print(locals())
# 符号表：保存了函数中创建的局部变量的名字
print(foo.__code__.co_varnames)
"""
('name', 'age', 'gender')
"""
# 调用函数时会创建栈帧，局部变量的值都保存在 f_localsplus 里面
# 并且符号表中变量名的顺序和 f_localsplus 中变量值的顺序是一致的
f_localsplus = ["satori", 17, "female"]
# 这里就用一个列表来模拟了
我们来看一下变量的创建。
由于符号 name 位于符号表中索引为 0 的位置，那么执行 name = "satori" 时，就会将 "satori" 放在 f_localsplus 中索引为 0 的位置。
由于符号 age 位于符号表中索引为 1 的位置，那么执行 age = 17 时，就会将 17 放在 f_localsplus 中索引为 1 的位置。
由于符号 gender 位于符号表中索引为 2 的位置，那么执行 gender = "female" 时，就会将 "female" 放在 f_localsplus 中索引为 2 的位置。
后续在访问变量的时候，比如访问变量 age，由于它位于符号表中索引为 1 的位置，那么就会通过 f_localsplus[1] 获取它的值，这些符号对应的索引都是在编译阶段确定的。所以在运行时才能实现静态查找，指令 LOAD_FAST 和 STORE_FAST 都是基于索引来静态操作底层数组。
我们用一张图来描述这个过程：
符号表负责存储局部变量的名字，f_localsplus 负责存储局部变量的值（里面的元素初始为 NULL），而在给局部变量赋值的时候，本质上就是将值写在了 f_localsplus 中。并且变量名在符号表中的索引，和变量值在 f_localsplus 中的索引是一致的，因此操作局部变量本质上就是在操作 f_localsplus 数组。
至于 locals() 或者说局部名字空间，它是基于符号表和 f_localsplus 动态创建的。为了方便我们获取已存在的局部变量，执行 locals() 会临时创建一个字典。
所以我们通过 locals() 获取局部名字空间之后，访问里面的局部变量是可以的，只不过此时将静态访问变成了动态访问。
def foo():
name = "satori"
# 会从 f_localsplus 中静态查找
print(name)
# 先基于已有的变量和值创建一个字典
# 然后通过字典实现变量的动态查找
print(locals()["name"])
foo()
"""
satori
satori
"""两种方式都是可以的，但基于 locals() 来访问，在效率上明显会低一些。
另外基于 locals() 访问一个变量是可以的，但无法创建一个变量。
def foo():
name = "satori"
locals()["age"] = 17
try:
print(age)
except NameError as e:
print(e)
foo()
"""
name 'age' is not defined
"""局部变量是静态存储在数组里的，locals() 只是做了一个拷贝而已。往局部名字空间里面添加一个键值对，不等于创建一个局部变量，因为局部变量不是从它这里查找的，因此代码中打印 age 报错了。但如果外部还有一个全局变量 age 的话，那么会打印全局变量 age。
然后再补充一点，我们说全局名字空间在任何地方都是唯一的，而对于函数而言，它的局部名字空间在整个函数内部也是唯一的。不管调用 locals 多少次，拿到的都是同一个字典。
def foo():
name = "satori"
# 执行 locals() 的时候，内部只有一个键值对
d = locals()
print(d) # {'name': 'satori'}
# 再次获取，此时有两个键值对
print(locals()) # {'name': 'satori', 'd': {...}}
# 但两者的 id 相同，因为一个函数只有一个局部名字空间
# 不管调用多少次 locals()，拿到的都是同一个字典
print(id(d) == id(locals())) # True
foo()所以 locals() 和 globals() 指向的名字空间都是唯一的，只不过 locals() 是在某个函数内部唯一，而 globals() 在所有地方都唯一。
因此局部名字空间初始为 NULL，但在第一次执行 locals() 时，会以符号表中的符号作为 key，f_localsplus 中的值作为 value，创建一个字典作为函数的局部名字空间。而后续再执行 locals() 的时候，由于名字空间已存在，就不会再次创建了，直接基于当前的局部变量对字典进行更新即可。
def foo():
# 创建一个字典，由于当前还没有定义局部变量，因此是空字典
print(locals())
"""
{}
"""
# 往局部名字空间添加一个键值对
locals()["a"] = "b"
print(locals())
"""
{'a': 'b'}
"""
# 定义一个局部变量
name = "satori"
# 由于局部名字空间已存在，因此不会再次创建
# 直接将局部变量的名字作为 key、值作为 value，拷贝到字典中
print(locals())
"""
{'a': 'b', 'name': 'satori'}
"""
foo()注意：虽然局部名字空间里面存在 "a" 这个 key，但 a 这个局部变量是不存在的。
local 名字空间的创建过程
目前我们已经知道 local 名字空间是怎么创建的了，也熟悉了它的特性，下面通过源码来看一下它的构建过程。
// Python/bltinmodule.c
static PyObject *
builtin_locals_impl(PyObject *module)
{
// Python 内置函数的源码实现位于 bltinmodule.c 中
// 这里又调用了 _PyEval_GetFrameLocals
return _PyEval_GetFrameLocals();
}
// Python/ceval.c
PyObject *
_PyEval_GetFrameLocals(void)
{
PyThreadState *tstate = _PyThreadState_GET();
_PyInterpreterFrame *current_frame = _PyThreadState_GetFrame(tstate);
if (current_frame == NULL) {
_PyErr_SetString(tstate, PyExc_SystemError, "frame does not exist");
return NULL;
}
// 调用了 _PyFrame_GetLocals
return _PyFrame_GetLocals(current_frame, 1);
}所以核心逻辑位于 _PyFrame_GetLocals 函数中，来看一下它的逻辑。
// Object/frameobject.c
PyObject *
_PyFrame_GetLocals(_PyInterpreterFrame *frame, int include_hidden)
{
// 获取局部名字空间
PyObject *locals = frame->f_locals;
// 如果为 NULL，那么创建一个新字典，作为名字空间
// 所以局部名字空间只会创建一次，后续不会再创建
if (locals == NULL) {
locals = frame->f_locals = PyDict_New();
if (locals == NULL) {
return NULL;
}
}
PyObject *hidden = NULL;
// 在 Include/internal/pycore_code.h 里面有 4 个宏
/* #define CO_FAST_HIDDEN 0x10
* #define CO_FAST_LOCAL 0x20
* #define CO_FAST_CELL 0x40
* #define CO_FAST_FREE 0x80
*/
// 它们分别对应隐藏变量、局部变量、cell 变量、free 变量
// 所谓隐藏变量，指的就是解析式里的临时变量，比如列表解析式
// 解析式具有独立的作用域，里面的临时变量不会污染外部的作用域
// 所以一般我们也不会关注这些隐藏变量，locals() 也不会返回它
// 但如果你真的关注，那么可以将 include_hidden 指定为真
// 那么调用 locals() 时，这些隐藏变量也会一块儿返回
if (include_hidden) {
// 单独创建一个字典，负责保存隐藏变量
hidden = PyDict_New();
if (hidden == NULL) {
return NULL;
}
}
// 初始化 free 变量，这个和闭包有关
// 关于闭包，等剖析完函数之后会说，这里暂时先不关注
frame_init_get_vars(frame);
PyCodeObject *co = frame->f_code;
// co_nlocalsplus 等于局部变量、cell 变量、free 变量的个数之和
// 这些变量都要拷贝到 local 名字空间中
for (int i = 0; i < co->co_nlocalsplus; i++) {
PyObject *value;
// 获取 f_localsplus[i]，在函数内部会对 value 进行修改
if (!frame_get_var(frame, co, i, &value)) {
continue;
}
// f_localsplus[i] 对应局部名字空间的 value
// 那么 co_localsplusnames[i] 显然对应局部名字空间的 key
// 估计有人已经忘记 co_localsplusnames 字段的含义了，我们再解释一下
/* co_localsplusnames：包含所有局部变量、cell 变量、free 变量的名称
* co_nlocalsplus：co_localsplusnames 的长度，或者说这些变量的个数之和
* co_varnames：包含所有局部变量的名称，co_nlocals：局部变量的个数
* co_cellvars：包含所有 cell 变量的名称，co_ncellvars：cell 变量的个数
* co_freevars：包含所有 free 变量的名称，co_nfreevars：free 变量的个数
* 因此不难得出它们之间的关系：
* co_localsplusnames = co_varnames + co_cellvars + co_freevars
* co_nlocalsplus = co_nlocals + co_ncellvars + co_nfreevars
*/
// 所以 co_localsplusnames 也是符号表，并且是 co_varnames 的超集
PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i);
// 到此局部名字空间的 key 和 value 便有了，但还要做一个判断
_PyLocals_Kind kind = _PyLocals_GetKind(co->co_localspluskinds, i);
// 如果变量的类型是隐藏变量，那么添加到 hidden 中
// 所以 co_localsplusnames 其实还包含了隐藏变量的名称
// 但我们基本不会遇到这种情况，因此关于隐藏变量直接忽略掉即可
if (kind & CO_FAST_HIDDEN) {
if (include_hidden && value != NULL) {
if (PyObject_SetItem(hidden, name, value) != 0) {
goto error;
}
}
continue;
}
// 如果不是隐藏变量，那么拷贝到 locals 中，但这里有一个判断很重要
// 当 value 为 NULL 时，如果 key 已存在，那么会将它删掉
// 关于这里的玄机，稍后会解释
if (value == NULL) {
if (PyObject_DelItem(locals, name) != 0) {
if (PyErr_ExceptionMatches(PyExc_KeyError)) {
PyErr_Clear();
}
else {
goto error;
}
}
}
// 到这里说明 value 指向了一块合法的内存
// 也就是变量名和变量值已经完成了绑定，那么将它们添加到 locals 中
else {
if (PyObject_SetItem(locals, name, value) != 0) {
goto error;
}
}
// 继续遍历下一个符号
}
// 隐藏变量保存在 hidden 中，它不会污染 f_locals
if (include_hidden && PyDict_Size(hidden)) {
// 创建一个新字典
PyObject *innerlocals = PyDict_New();
if (innerlocals == NULL) {
goto error;
}
// 合并 locals
if (PyDict_Merge(innerlocals, locals, 1) != 0) {
Py_DECREF(innerlocals);
goto error;
}
// 合并 hidden
if (PyDict_Merge(innerlocals, hidden, 1) != 0) {
Py_DECREF(innerlocals);
goto error;
}
// 重新赋值给 locals，所以返回的结果会包含 hidden 里的键值对
// 但 f_locals 里面是没有隐藏变量的
locals = innerlocals;
}
else {
Py_INCREF(locals);
}
Py_CLEAR(hidden);
// 返回 locals
return locals;
error:
Py_XDECREF(hidden);
return NULL;
}所以逻辑非常简单，如果不考虑隐藏变量（也不需要考虑），那么整个过程就是我们刚才说的：遍历符号表和 f_localsplus，将变量名和变量值组成键值对拷贝到字典中。
但里面有一处细节非常关键。
当变量值为 NULL 时，说明在获取名字空间时，该变量还没有被赋值。要是此时变量已经在局部名字空间中，那么会将它从名字空间中删掉。这一处非常关键，在介绍 exec 的时候你就会明白。
local 名字空间与 exec 函数
我们再来搭配 exec 关键字，结果会更加明显。首先 exec 函数可以将一段字符串当成代码来执行，并将执行结果体现在当前的名字空间中。
def foo():
print(locals()) # {}
exec("x = 1")
print(locals()) # {'x': 1}
try:
print(x)
except NameError as e:
print(e) # name 'x' is not defined
foo()尽管 locals() 变了，但是依旧访问不到 x，因为虚拟机并不知道 exec("x = 1") 是创建一个局部变量，它只知道这是一个函数调用。
事实上 exec 会作为一个独立的编译单元来执行，并且有自己的作用域。
所以 exec("x = 1") 执行完之后，效果就是改变了局部名字空间，里面多了一个 "x": 1 键值对。但关键的是，局部变量 x 不是从局部名字空间中查找的，exec 终究还是错付了人。
由于函数 foo 对应的 PyCodeObject 对象的符号表中并没有 x 这个符号，所以报错了。
补充：exec 默认影响的是 local 名字空间，如果在执行时发现 local 名字空间为 NULL，那么会自动创建一个。所以调用 exec 也可以创建名字空间（当它为 NULL 时）。
exec("x = 1")
print(x) # 1如果放在模块里面是可以的，因为模块的 local 名字空间和 global 名字空间指向同一个字典，所以 global 名字空间会多一个 key 为 "x" 的键值对。而全局变量是从 global 名字空间中查找的，所以这里没有问题。
def foo():
# 此时 exec 影响的是全局名字空间
exec("x = 123", globals())
# 这里不会报错, 但此时的 x 不是局部变量, 而是全局变量
print(x)
foo()
print(x)
"""
123
123
"""可以给 exec 指定要影响的名字空间，代码中 exec 影响的是全局名字空间，打印的 x 也是全局变量。
以上几个例子都比较简单，接下来我们开始上强度了。
def foo():
exec("x = 1")
print(locals()["x"])
foo()
"""
1
"""
def bar():
exec("x = 1")
print(locals()["x"])
x = 123
bar()
"""
Traceback (most recent call last):
File .....
bar()
File .....
print(locals()["x"])
KeyError: 'x'
"""这是什么情况？函数 bar 只是多了一行赋值语句，为啥就报错了呢？其实背后的原因我们之前分析过。
1）函数的局部变量在编译的时候已经确定，并存储在对应的 PyCodeObject 对象的符号表中，这是由语法规则所决定的；
2）函数内的局部变量在其整个作用域范围内都是可见的；
对于 foo 函数来说，exec 执行完之后相当于往 local 名字空间中添加一个键值对，这没有问题。对于 bar 函数而言也是如此，在执行完 exec("x = 1") 之后，local 名字空间也会存在 "x": 1 这个键值对，但问题是下面执行 locals() 的时候又把字典更新了。
因为局部变量可以在函数的任意位置创建，或者修改，所以每一次执行 locals() 的时候，都会遍历符号表和 f_localsplus，然后组成键值对拷贝到名字空间中。
在 bar 函数里面有一行 x = 123，所以知道函数里面存在局部变量 x，符号表里面也会有 "x" 这个符号，这是在编译时就确定的。但我们是在 x = 123 之前调用的 locals，所以此时符号 x 在 f_localsplus 中对应的值还是一个 NULL，没有指向一个合法的 PyObject。换句话说就是，知道里面存在局部变量 x，但此时尚未赋值。
然后在更新名字空间的时候，如果发现值是个 NULL，那么就把名字空间中该变量对应的键值对给删掉。
所以 bar 函数执行 locals()["x"] 的时候，会先获取名字空间，原本里面是有 "x": 1 这个键值对的。但因为赋值语句 x = 123 的存在，导致符号表里面存在 "x" 这个符号，可执行 locals() 的时候又尚未完成赋值，因此值为 NULL，于是又把这个键值对给删掉了。所以执行 locals()["x"] 的时候，出现了 KeyError。
因为局部名字空间体现的是局部变量的值，而调用 locals 的时候，局部变量 x 还没有被创建。所以 locals() 里面不应该存在 key 为 "x" 的键值对，于是会将它删除。
我们将名字空间打印一下：
def foo():
# 创建局部名字空间，并写入键值对 "x": 1
# 此时名字空间为 {"x": 1}
exec("x = 1")
# 获取名字空间，会进行更新
# 但当前不存在局部变量，所以名字空间仍是 {"x": 1}
print(locals())
def bar():
# 创建局部名字空间，并写入键值对 "x": 1
# 此时名字空间为 {"x": 1}
exec("x = 1")
# 获取名字空间，会进行更新
# 由于里面存在局部变量 x，但尚未赋值
# 于是将字典中 key 为 "x" 的键值对给删掉
# 所以名字空间变成了 {}
print(locals())
x = 123
foo() # {'x': 1}
bar() # {}上面代码中，局部变量的创建发生在 exec 之后，如果发生在 exec 之前也是类似的结果。
def foo():
exec("x = 2")
print(locals())
foo() # {'x': 2}
def bar():
x = 1
exec("x = 2")
print(locals())
bar() # {'x': 1}在 exec("x = 2") 执行之后，名字空间也变成了 {"x": 2}。但每次调用 locals，都会对字典进行更新，所以在 bar 函数里面获取名字空间的时候，又把 "x" 对应的 value 给更新回来了。
当然这是在变量冲突的情况下，会保存真实存在的局部变量的值。如果不冲突，比如 bar 函数里面是 exec("y = 2")，那么 locals() 里面就会存在两个键值对，但只有 x 才是真正的局部变量，而 y 则不是。
将 exec("x = 2") 换成 locals()["x"] = 2 也是一样的效果，它们都是往局部名字空间中添加一个键值对，但不会创建一个局部变量。
薛定谔的猫
当 Python 中混进一只薛定谔的猫……，这是《Python 猫》在 19 年更新的一篇文章，里面探讨的内容和我们本文的主题是重叠的。猫哥在文章中举了几个疑惑重重的例子，看看用上面学到的知识能不能合理地解释。
# 例 0
def foo():
exec('y = 1 + 1')
z = locals()['y']
print(z)
foo()
# 输出：2
# 例 1
def foo():
exec('y = 1 + 1')
y = locals()['y']
print(y)
foo()
# 报错：KeyError: 'y'以上是猫哥文章中举的示例，首先例 0 很简单，因为 exec 影响了所在的局部名字空间，里面存在 "y": 2 这个键值对，所以 locals()["y"] 会返回 2。
但例 1 则不同，因为 Python 在语法解析的时候发现了 y = ... 这样的赋值语句，那么它在编译的时候就知道函数里面存在 y 这个局部变量，并写入符号表中。既然符号表中存在，那么调用 locals 的时候就会写入到名字空间中。但问题是变量 y 的值是多少呢？由于对 y 赋值是发生在调用 locals 之后，所以在调用 locals 的时候，y 的值还是一个 NULL，也就是变量还没有赋值。所以会将名字空间中的 "y": 2 这个键值对给删掉，于是报出 KeyError 错误。
再来看看猫哥文章的例 2：
# 例 2
def foo():
y = 1 + 1
y = locals()['y']
print(y)
foo()
# 2locals() 是对真实存在的局部变量的一个拷贝，在调用 locals 之前 y 就已经创建好了。符号表里面有 "y"，数组 f_localsplus 里面有数值 2，所以调用 locals() 的时候，会得到 {"y": 2}，因此函数执行正常。
猫哥文章的例 3：
# 例3
def foo():
exec('y = 1 + 1')
boc = locals()
y = boc['y']
print(y)
foo()
# KeyError: 'y'这个例3 和例 1 是一样的，只不过用变量 boc 将局部名字空间保存起来了。执行 exec 的时候，会创建局部名字空间，写入键值对 "y": 2。
但调用 locals 的时候，发现函数内部存在局部变量 y 并且还尚未赋值，于是又会将 "y": 2 这个键值对给删掉，因此 boc 变成了一个空字典。于是执行 y = boc["y"] 的时候会出现 KeyError。
猫哥文章的例 4：
# 例4
def foo():
boc = locals()
exec('y = 1 + 1')
y = boc['y']
print(y)
foo()
# 2显然在调用 locals 的时候，会返回一个空字典，因为此时的局部变量都还没有赋值。但需要注意的是：boc 已经指向了局部名字空间（字典），而局部名字空间在一个函数里面也是唯一的。
然后执行 exec("y = 1 + 1")，会往局部名字空间中写入一个键值对，而变量 boc 指向的字典也会发生改变，因为是同一个字典，所以程序正常执行。
猫哥文章的例 5：
# 例5
def foo():
boc = locals()
exec('y = 1 + 1')
print(locals())
y = boc['y']
print(y)
foo()
# {'boc': {...}}
# KeyError: 'y'首先在执行 boc = locals() 之后，boc 会指向一个空字典，然后 exec 函数执行之后会往字典里面写入一个键值对 "y": 2。如果在 exec 执行之后，直接执行 y = boc["y"]，那么代码是没有问题的，但问题是在中间插入了一个 print(locals())。
我们说过，当调用 locals 的时候，会对名字空间进行更新，然后返回更新之后的名字空间。由于函数内部存在 y = ... 这样的赋值语句，所以符号表中就存在 "y" 这个符号，于是会进行更新。但更新的时候，发现 y 还没有被赋值，于是又将字典中的键值对 "y": 2 给删掉了。
由于局部名字空间只有一份，所以 boc 指向的字典也会发生改变，换句话说在 print(locals()) 之后，boc 就指向了一个空字典，因此出现 KeyError。
小结
以上我们就探讨了局部变量的存储原理以及它和 local 名字空间的关系。
局部变量在编译时就已经确定，所以会采用数组静态存储，并且在整个作用域内都是可见的。
f_localsplus 的内存被分成了四份，局部变量的值便存储在第一份空间中。
局部名字空间是对真实存在的局部变量的拷贝，调用 locals() 时，会遍历得到每一个符号和与之绑定的值，然后拷贝到局部名字空间。
如果遍历时发现变量值为 NULL，这就说明获取名字空间时，该变量尚未赋值，那么要将它从名字空间中删掉。
