使用Python字符串访问与修改局部变量

方萧

在Python中定义一个函数时，就会把变量空间划分为全局变量(global)与局部变量(local)，如果是定义在一个类的成员函数中，那么就还有额外的成员变量(self)空间。那么，如果在实际操作中，想把这几种不同的变量空间做一个分离的话，有没有办法呢？
1.读取和修改局部变量

首先来看一下局部变量的读取，一般有locals()、vars()和sys._getframe(0).f_code.co_varnames这几种方法，另外有一种sys._getframe(0).f_locals的方法，其实等价于locals()，相关的实现代码如下：

1. x = 0
3. class Obj:
4.     def __init__(self,y):
5.         self.func(y)
6.         
7.     def func(y, z=1):
8.         m = 2
9.         print (locals())
10.         print (vars())
11.         print (__import__('sys')._getframe(0).f_code.co_varnames)
13. if __name__ == '__main__':
14.     Obj(2)

复制代码

该代码的运行结果如下：

1. {'self': <__main__.Obj object at 0x7f5cf5e74e50>, 'y': 2, 'z': 1, 'm': 2}
2. {'self': <__main__.Obj object at 0x7f5cf5e74e50>, 'y': 2, 'z': 1, 'm': 2}
3. ('self', 'y', 'z', 'm')

复制代码

在vars方法不加具体变量名的时候，就是等价于locals方法，两者返回的结果都是字典格式。如果是一个类中的成员函数下执行locals或者vars，会附带一个__main__.Obj object的变量，相当于所有self的成员变量，其实也是局部变量的一部分。而如果使用co_varnames的方法，那么得到的就是所有局部变量的名称，我们也可以在例子中额外定义一个self的成员变量：

1. x = 0
3. class Obj:
4.     def __init__(self, y):
5.         self.p = 5
6.         self.func(y)
8.     def func(self, y, z=1):
9.         m = 2
10.         print(locals())
11.         print(vars())
12.         print(__import__('sys')._getframe(0).f_code.co_varnames)
14. if __name__ == '__main__':
15.     Obj(2)
16.     # {'self': <__main__.Obj object at 0x7fe9aac0ce50>, 'y': 2, 'z': 1, 'm': 2}
17.     # {'self': <__main__.Obj object at 0x7fe9aac0ce50>, 'y': 2, 'z': 1, 'm': 2}
18.     # ('self', 'y', 'z', 'm')

复制代码

可以发现，所有的成员变量都被放在了self中。并且需要注意的是，全局变量x自始至终都没有在局部变量中出现。那么既然我们可以通过这种方式分离出局部变量，或者是局部变量的名称，那我们如何去调整或者修改这些局部变量呢？首先我们需要知道，locals()方法返回的变量是一个copy，也就是说即使修改了locals方法返回的结果，也不能真正的改变局部变量本身的值，这样描述可能有点抽象，我们直接看下这个案例：

1. x = 0
3. class Obj:
4.     def __init__(self,y):
5.         self.func(y)
7.     def func(self, y, z=1):
8.         m = 2
9.         vars()['z']=2
10.         locals()['n']=3
11.         print (locals())
12.         print (z)
14. if __name__ == '__main__':
15.     Obj(2)

复制代码

在这个案例中分别通过vars方法和locals方法去修改局部变量的值，最终的输出结果如下：

1. {'self': <__main__.Obj object at 0x7f74d9470e50>, 'y': 2, 'z': 1, 'm': 2, 'n': 3}
2. 1

复制代码

首先要解释一下为什么这个案例中没有打印n这个变量，前面提到vars和locals的返回值都是真实变量的一个copy，因此我们不管是修改也好，新增也好，内容不会同步到变量空间中去，也就是说，此时的局部变量n还是处于一个没有定义的状态，只是在locals或者vars的字典中存在，此时打印只会报错NameError。而z的最终打印输出是1，这表明z的值确实没有受到对vars的变量修改的影响。那到底有没有办法可以通过字符串去修改局部变量呢（不同步到全局变量）？答案是有的，但是这个方案非常的hacky，请看如下示例：

1. import ctypes
3. x = 0
5. class Obj:
6.     def __init__(self,y):
7.         self.func(y)
9.     def func(self, y, z=1):
10.         m = 2
11.         __import__('sys')._getframe(0).f_locals.update({
12.             'z': 2,'n': 3
13.         })
14.         ctypes.pythonapi.PyFrame_LocalsToFast(
15.             ctypes.py_object(__import__('sys')._getframe(0)), ctypes.c_int(0))
16.         print (locals())
17.         print (z)
19. if __name__ == '__main__':
20.     Obj(2)

复制代码

这个案例是使用了Cython的方案直接去修改了数据帧的内容，而这里所使用的f_locals其实本质上就是locals。经过一番运行，输出结果如下：

1. {'self': <__main__.Obj object at 0x7fea2e2
2. a1e80>, 'y': 2, 'z': 2, 'm': 2, 'n': 3}
3. 2

复制代码

此时局部变量z是被成功修改了的，但是在前面提到的，即使我们通过这种方法修改了局部变量的值，但是依然不能通过这个方案去创建一个新的局部变量，此时去执行print (n)的话，依然会有报错提示。
2.读取和修改全局变量

相比于修改局部变量，其实查看修改全局变量要显的更加容易。首先我们用一个示例演示一下如何查看所有的全局变量：

1. x = 0
3. class Obj:
4.     def __init__(self,y):
5.         self.func(y)
7.     def func(self, y, z=1):
8.         m = 2
9.         print (globals())
11. if __name__ == '__main__':
12.     Obj(2)

复制代码

获取局部变量的方式有很多，但是获取全局变量一般就是globals或者等价的f_globals。上述代码执行输出如下：

1. {'__name__': '__main__', '__doc__': None, '__package__': None,
2. '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x7f202632ac40>,
3. '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
4. '__file__': 'xxx.py', '__cached__': None, 'x': 0, 'Obj': <class '__main__.Obj'>}

复制代码

用这种方法我们发现了全局变量x，而在同一个函数内的几个局部变量，就没有显示在globals的key中。而不同于locals变量的是，globals函数返回的是一个真实的数据，是可以直接修改，并且在全局生效的。
比如我们在函数内定义或者修改全局变量：

1. x = 0
3. class Obj:
4.     def __init__(self,y):
5.         self.func(y)
7.     def func(self, y, z=1):
8.         global m
9.         m = 2
10.         globals()['x']=3
12. if __name__ == '__main__':
13.     Obj(2)
14.     print(globals()['x'])
15.     print(globals()['m'])
16.     # 3
17.     # 2

复制代码

在这个例子中我们就可以发现，不仅仅是修改的x值生效了，新建的m也同步到了全局变量中，这样就可以比较容易的划分全局变量和局部变量再进行统一赋值或者修改。
3.读取和修改成员变量

在python中每一个定义的object都有一个隐藏属性__dict__，这是一个字典，其中包含了所有的成员变量名和成员变量值。在前一篇博客中，我们就介绍了通过__dict__去给类中的成员变量进行赋值，非常的方便。我们可以通过一个示例来看看__dict__中所包含的内容：

1. x = 0
3. class Obj:
4.     def __init__(self,y):
5.         self.m = 2
6.         self.func(y)
8.     def func(self, y, z=1):
9.         print (self.__dict__)
10. #学习中遇到问题没人解答？小编创建了一个Python学习交流群：711312441
11. if __name__ == '__main__':
12.     Obj(2)
13.     # {'m': 2}

复制代码

从输出结果中我们就可以看到，__dict__输出的内容非常的纯净，就是所有的成员变量名和变量值。而成员变量虽然是一个对象的属性，但是其操作方式跟全局变量globals是非常接近的，不像locals一样只读，具体示例如下：

1. x = 0
3. class Obj:
4.     def __init__(self,y):
5.         self.m = 2
6.         self.func(y)
8.     def func(self, y, z=1):
9.         self.m = 5
10.         self.__dict__['n'] = 6
11.         print (self.__dict__)
12.         print (self.m, self.n)
14. if __name__ == '__main__':
15.     Obj(2)
16.     # {'m': 5, 'n': 6}
17.     # 5
18.     # 6

复制代码

在这个案例中，我们修改了成员变量的值，也使用__dict__新建了一个成员变量的值，可以看到最终都有同步到变量空间中，这样就完成了成员变量的修改。
4.总结

Python本身是一门比较灵活便捷的编程语言，但是便捷往往有可能伴随着一些风险，比如exec和eval等内置函数的实现，有可能导致sandbox escaping的问题。而有时候我们又需要一些批量化的操作，比如批量化的创建或者修改局部、全局或者是成员变量，这样就需要我们首先要把所有的变量名存成字符串，在需要的时候再作为变量名去调用。
在这篇文章中，我们介绍了一系列非exec和eval的操作（并不是说没有风险，也引用了ctype和sys定义的数据帧），来查看和定义、修改所需的各种变量。

来源:https://www.cnblogs.com/djdjdj123/p/17517019.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！