您的位置:首页 > 脚本大全 > > 正文

详解Python locals()的陷阱(详解Python locals的陷阱)

更多 时间:2021-10-26 11:25:22 类别:脚本大全 浏览量:1514

详解Python locals()的陷阱

详解Python locals的陷阱

在工作中, 有时候会遇到一种情况: 动态地进行变量赋值, 不管是局部变量还是全局变量, 在我们绞尽脑汁的时候, python已经为我们解决了这个问题.

python的命名空间通过一种字典的形式来体现, 而具体到函数也就是locals() 和 globals(), 分别对应着局部命名空间和全局命名空间. 于是, 我们也就能通过这些方法去实现我们"动态赋值"的需求.

例如:

  • ?
  • 1
  • 2
  • 3
  • 4
  • def test():
  •   globals()['a2'] = 4
  • test()
  • print a2  # 输出 4
  • 很自然, 既然 globals能改变全局命名空间, 那理所当然locals应该也能修改局部命名空间.修改函数内的局部变量.

    但事实真是如此吗? 不是!

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 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异常?

    再看一个例子:

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 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~

    根源探讨

    直接对第二段代码解析:

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 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
  • 在上面的字节码可以看到:

    1. locals() 对应的字节码是: load_global
    2. s='test' 对应的字节码是: load_const 和 store_fast
    3. print s 对应的字节码是: load_fast
    4. print a 对应的字节码是: load_global

    从上面罗列出来的几个关键语句的字节码可以看出, 直接赋值/读取 和 通过locals()赋值/读取 本质是很大不同的. 那么触发nameerror异常, 是否证明通过 locals()[i] = 1 存储的值, 和真正的局部命名空间 是不同的两个位置?

    想要回答这个问题, 我们得先确定一个东西, 就是真正的局部命名空间如何获取? 其实这个问题, 在上面的字节码上, 已经给出了标准答案了!

    真正的局部命名空间, 其实是存在 store_fast 这个对应的数据结构里面. 这个是什么鬼, 这个需要源码来解答:

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • // 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, 对于这个, 字节码可能起不了作用, 直接去看内置函数如何定义的吧:

  • ?
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • // 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() 实际上做了下面几件事:

    1. 判断帧对象 的 f_f->f_locals 是否为空, 若是, 则新建一个字典对象.
    2. 分别将 localsplus, co_cellvars 和 co_freevars 写入 f_f->f_locals.

    在这简单介绍下上面几个分别是什么鬼:

    1. localsplus: 函数参数(位置参数+关键字参数), 显示赋值的变量.
    2. co_cellvars 和 co_freevars: 闭包函数会用到的局部变量.

    结论

    通过上面的源码, 我们已经很明确知道locals() 看到的, 的确是函数的局部命名空间的内容, 但是它本身不能代表局部命名空间, 这就好像一个代理, 它收集了a, b, c的东西, 展示给我看, 但是我却不能简单的通过改变这个代理, 来改变a, b, c真正拥有的东西!

    这也就是为什么, 当我们通过locals()[i] = 1的方式去动态赋值时, print a却触发了nameerror异常, 而相反的, globals()确实真正的全局命名空间, 所以一般会说

    locals() 只读, globals() 可读可写

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持开心学习网。

    原文链接:https://segmentfault.com/a/1190000012724861

    标签:Python locals
    您可能感兴趣