内容简介:Python locals() 的陷阱
在工作中, 有时候会遇到一种情况: 动态地进行变量赋值, 不管是局部变量还是全局变量, 在我们绞尽脑汁的时候, Python已经为我们解决了这个问题.
Python的命名空间通过一种字典的形式来体现, 而具体到函数也就是 locals()
和 globals()
, 分别对应着局部命名空间和全局命名空间. 于是, 我们也就能通过这些方法去实现我们"动态赋值"的需求.
例如:
def test(): globals()['a2'] = 4 test() print a2 # 输出 4
很自然, 既然 globals
能改变全局命名空间, 那理所当然 locals
应该也能修改局部命名空间.修改函数内的局部变量.
但事实真是如此吗? 不是!
def aaaa(): print locals() for i in ['a', 'b', 'c']: locals()[i] = 1 print locals() print a aaaa()
输出:
{} {'i': 'c', 'a': 1, 'c': 1, 'b': 1} Traceback (most recent call last): File "5.py", line 17, in <module> aaaa() File "5.py", line 16, in aaaa print a NameError: global name 'a' is not defined
程序运行报错了!
但是在第二次 print locals()
很清楚能够看到, 局部空间是已经有那些变量了, 其中也有 变量a
并且值也为 1
, 但是为什么到了 print a
却报出 NameError异常
?
再看一个例子:
def aaaa(): print locals() s = 'test' # 加入显示赋值 s for i in ['a', 'b', 'c']: locals()[i] = 1 print locals() print s # 打印局部变量 s print a aaaa()
输出:
{} {'i': 'c', 'a': 1, 's': 'test', 'b': 1, 'c': 1} test Traceback (most recent call last): File "5.py", line 19, in <module> aaaa() File "5.py", line 18, in aaaa print a NameError: global name 'a' is not defined
上下两段代码, 区别就是, 下面的有显示赋值的代码, 虽然也是同样触发了 NameError异常
, 但是局部变量 s
的值被打印了出来.
这就让我们觉得很纳闷, 难道通过 locals()
改变局部变量, 和直接赋值有不同? 想解决这个问题, 只能去看程序运行的真相了, 又得上大杀器 dis
~
根源探讨
直接对第二段代码解析:
13 0 LOAD_GLOBAL 0 (locals) 3 CALL_FUNCTION 0 6 PRINT_ITEM 7 PRINT_NEWLINE 14 8 LOAD_CONST 1 ('test') 11 STORE_FAST 0 (s) 15 14 SETUP_LOOP 36 (to 53) 17 LOAD_CONST 2 ('a') 20 LOAD_CONST 3 ('b') 23 LOAD_CONST 4 ('c') 26 BUILD_LIST 3 29 GET_ITER >> 30 FOR_ITER 19 (to 52) 33 STORE_FAST 1 (i) 16 36 LOAD_CONST 5 (1) 39 LOAD_GLOBAL 0 (locals) 42 CALL_FUNCTION 0 45 LOAD_FAST 1 (i) 48 STORE_SUBSCR 49 JUMP_ABSOLUTE 30 >> 52 POP_BLOCK 17 >> 53 LOAD_GLOBAL 0 (locals) 56 CALL_FUNCTION 0 59 PRINT_ITEM 60 PRINT_NEWLINE 18 61 LOAD_FAST 0 (s) 64 PRINT_ITEM 65 PRINT_NEWLINE 19 66 LOAD_GLOBAL 1 (a) 69 PRINT_ITEM 70 PRINT_NEWLINE 71 LOAD_CONST 0 (None) 74 RETURN_VALUE None
在上面的字节码可以看到:
-
locals()
对应的字节码是:LOAD_GLOBAL
-
s='test'
对应的字节码是:LOAD_CONST
和STORE_FAST
-
print s
对应的字节码是:LOAD_FAST
-
print a
对应的字节码是:LOAD_GLOBAL
从上面罗列出来的几个关键语句的字节码可以看出, 直接赋值/读取 和 通过 locals()
赋值/读取 本质是很大不同的. 那么触发 NameError异常
, 是否证明通过 locals()[i] = 1
存储的值, 和真正的局部命名空间 是不同的两个位置?
想要回答这个问题, 我们得先确定一个东西, 就是真正的局部命名空间如何获取? 其实这个问题, 在上面的字节码上, 已经给出了标准答案了!
真正的局部命名空间, 其实是存在 STORE_FAST
这个对应的数据结构里面. 这个是什么鬼, 这个需要源码来解答:
// ceval.c 从上往下, 依次是相应函数或者变量的定义 // 指令源码 TARGET(STORE_FAST) { v = POP(); SETLOCAL(oparg, v); FAST_DISPATCH(); } -------------------- // SETLOCAL 宏定义 #define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \ GETLOCAL(i) = value; \ Py_XDECREF(tmp); } while (0) -------------------- // GETLOCAL 宏定义 #define GETLOCAL(i) (fastlocals[i]) -------------------- // fastlocals 真面目 PyObject * PyEval_EvalFrameEx(PyFrameObject *f, int throwflag){ // 省略其他无关代码 fastlocals = f->f_localsplus; .... }
看到这里, 应该就能明确了, 函数内部的局部命名空间, 实际是就是帧对象的f的成员 f_localsplus
, 这是一个数组, 了解函数创建的童鞋可能会比较清楚, 在 CALL_FUNCTION
时, 会对这个数组进行初始化, 将形参赋值什么都会按序塞进去, 在字节码 18 61 LOAD_FAST 0 (s)
中, 第四列的0, 就是将 f_localsplus
第 0 个成员取出来, 也就是值 "s".
所以 STORE_FAST
才是真正的将变量存入局部命名空间, 那 locals()
又是什么鬼? 为什么看起来就跟真的一样?
这个就需要分析 locals
, 对于这个, 字节码可能起不了作用, 直接去看内置函数如何定义的吧:
// bltinmodule.c static PyMethodDef builtin_methods[] = { ... // 找到 locals 函数对应的内置函数是 builtin_locals {"locals", (PyCFunction)builtin_locals, METH_NOARGS, locals_doc}, ... } ----------------------------- // builtin_locals 的定义 static PyObject * builtin_locals(PyObject *self) { PyObject *d; d = PyEval_GetLocals(); Py_XINCREF(d); return d; } ----------------------------- PyObject * PyEval_GetLocals(void) { PyFrameObject *current_frame = PyEval_GetFrame(); // 获取当前堆栈对象 if (current_frame == NULL) return NULL; PyFrame_FastToLocals(current_frame); // 初始化和填充 f_locals return current_frame->f_locals; } ----------------------------- // 初始化和填充 f_locals 的具体实现 void PyFrame_FastToLocals(PyFrameObject *f) { /* Merge fast locals into f->f_locals */ PyObject *locals, *map; PyObject **fast; PyObject *error_type, *error_value, *error_traceback; PyCodeObject *co; Py_ssize_t j; int ncells, nfreevars; if (f == NULL) return; locals = f->f_locals; // 如果locals为空, 就新建一个字典对象 if (locals == NULL) { locals = f->f_locals = PyDict_New(); if (locals == NULL) { PyErr_Clear(); /* Can't report it :-( */ return; } } co = f->f_code; map = co->co_varnames; if (!PyTuple_Check(map)) return; PyErr_Fetch(&error_type, &error_value, &error_traceback); fast = f->f_localsplus; j = PyTuple_GET_SIZE(map); if (j > co->co_nlocals) j = co->co_nlocals; // 将 f_localsplus 写入 locals if (co->co_nlocals) map_to_dict(map, j, locals, fast, 0); ncells = PyTuple_GET_SIZE(co->co_cellvars); nfreevars = PyTuple_GET_SIZE(co->co_freevars); if (ncells || nfreevars) { // 将 co_cellvars 写入 locals map_to_dict(co->co_cellvars, ncells, locals, fast + co->co_nlocals, 1); if (co->co_flags & CO_OPTIMIZED) { // 将 co_freevars 写入 locals map_to_dict(co->co_freevars, nfreevars, locals, fast + co->co_nlocals + ncells, 1); } } PyErr_Restore(error_type, error_value, error_traceback); }
从上面 PyFrame_FastToLocals
已经看出来, locals()
实际上做了下面几件事:
-
判断帧对象 的
f_f->f_locals
是否为空, 若是, 则新建一个字典对象. -
分别将
localsplus
,co_cellvars
和co_freevars
写入f_f->f_locals
.
在这简单介绍下上面几个分别是什么鬼:
-
localsplus
: 函数参数(位置参数+关键字参数), 显示赋值的变量. -
co_cellvars
和co_freevars
: 闭包函数会用到的局部变量.
结论
通过上面的源码, 我们已经很明确知道 locals()
看到的, 的确是函数的局部命名空间的内容, 但是它本身不能代表局部命名空间, 这就好像一个代理, 它收集了A, B, C的东西, 展示给我看, 但是我却不能简单的通过改变这个代理, 来改变A, B, C真正拥有的东西!
这也就是为什么, 当我们通过 locals()[i] = 1
的方式去动态赋值时, print a
却触发了 NameError异常
, 而相反的, globals()
确实真正的全局命名空间, 所以一般会说
locals() 只读, globals() 可读可写
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网
猜你喜欢:本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们。
Fortran 95/2003程序设计
中国电力出版社 / 2009-8 / 88.00元
Fortran是计算世界最早出现的高级程序设计语言之一,随着面向对象编程时代的到来,Fortran语言不仅保持了发展的步伐,而且继续在科学计算方面领先。《Fortran95/2003程序设计(第3版)》在第2~7章介绍了Fortan语言基础知识,为初学者提供入门学习资料;在第8~15章介绍了Fortran语言高级特性,为深入用好Fortran语言提供支持;在第16章讲述了Fortran语言面向对象......一起来看看 《Fortran 95/2003程序设计》 这本书的介绍吧!