个人中心
gpt4 book ai didi

详解Python locals()的陷阱

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章详解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()的陷阱的文章就讲到这里了,如果你想了解更多关于详解Python locals()的陷阱的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： C++迷宫问题的求解算法
文章推荐： HarmonyOS ArkUI之自定义组件侧滑菜单（JS）
文章推荐： C++迷宫的实现代码
文章推荐： C++利用递归实现走迷宫
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com