Python | eval、exec | 执行动态代码字符串
文章目录
- Python | eval、exec | 执行动态代码字符串
- 1. 简介
- 2. 使用分析
- 2.1 eval（expression[,globals, locals]
- 2.2 exec(object[,globals, locals]
- 3. 注意
- 3.1 `TypeError: eval（) takes no keyword arguments`
- 3.2 全局变量与局部变量默认传入
- 3.3 globals和locals的优先级
- 3.4 `NameError: name 'XXX' is not defined`
- 3.4.1 `exec(object, globals(), locals())`或`exec(object)`
- 3.4.2 `exec(object, globals(), globals())`或`exec(object, globals())`
- 3.4.3 `exec(object, locals(), locals())`
- 3.4.4 为什么会报错？
- 3.4.5 如何避免此类报错？
1. 简介
通常开发的程序中，逻辑由开发者提前书写完成，程序按照既定的流程运行。
是否可以执行固定工程代码以外的代码块呢？比如由用户后期编写与指定字符串代码块，随时可以调整与变化，常用在动态配置等方面。
那么，如何执行外部提供的Python表达式或代码块？
有两个标准方法：eval①、exec②
①eval用于执行一行逻辑表达式字符串
②exec用于执行字符串方法、字符串代码块等结构化代码字符串集合
2. 使用分析
2.1 eval（expression[,globals, locals]
参数名 | 必输性 | 类型 | 示例 | 推荐 | 备注 |
expression | 是 | String | x+3 | 无 | |
globals | 否 | Dict | {‘sum’:sum, ‘name’:‘Dog’} | globals() | |
locals | 否 | Dict | {‘sum’:sum, ‘name’:‘Dog’} | locals() |
eval通常用于动态字符串对变量赋值的逻辑形式，即：x = eval（‘a+b’)
expression是 一句字符串 表达式，表达式通过运算后返回结果值。
通俗的讲, expression为赋值代码逻辑中，等号右边的字符串表达式。
例如：
# x = a+3
a=1
x=eval（"a+3")
结果等价 x=a+3。expression 即为等号右边的 “a+3”，这时我们没有传递任何全局变量与局部变量。
globals和locals指代字典对象的全局变量与局部变量.
可以在使用eval（)方法时自行指定，也可以直接使用内置函数globals()与locals().
这两个参数为eval中的expression字符串表达式提供所需的环境变量。
例如：
def add(x, y):
return x+y
eval（'add(1,2)',{'add': add},{})
# eval（'add(1,2)', globals(), locals())
第二个参数位为globals，其为expression提供了环境中的add方法，支持其内部执行时使用。
第三个参数位为locals，这里并没有提供任何内容，但理解与globals参数相同。
通常不建议手动维护，而是直接使用globals()与locals()，另外，如果eval（)在类外执行，globals()与locals()内容一致。
2.2 exec(object[,globals, locals]
参数名 | 必输性 | 类型 | 示例 | 推荐 | 备注 |
expression | 是 | String | x+3 | 无 | |
globals | 否 | Dict | {‘sum’:sum, ‘name’:‘Dog’} | globals() | |
locals | 否 | Dict | {‘sum’:sum, ‘name’:‘Dog’} | locals() |
exec通常用于执行动态代码块。与eval不同的是：
eval用于执行表达式并返回结果对变量赋值；
exec用于执行代码块并将处理过程中的变量等，更新到当前执行的环境变量中，不需要进行接收。
object为字符串代码块
#例如
exec_object_str = """
def func(x,y):
return x+y
x=1
y=2
z=func(x,y)
"""
exec(exec_object_str)
print(x, y, z,sep=';')
上面的整体代码结构exec_object_str，用作object。
通俗的讲，object可以书写任意内容，只要语法正确，依赖正常。exec无需接收值，其中执行过程中的变量在执行后，均可在外部代码块中进行使用。
globals和locals与eval方法使用介绍相同；通常不建议手动维护，而是直接使用globals()与locals()。
3. 注意
3.1 TypeError: eval（) takes no keyword arguments
代码默认会按照参数位置进行确认，因为底层直接调用C，为了速度并未做键值对映射转换的功能。
所以eval（)与exec()使用globals与locals参数时，不可使用如下键值对方式传值，否则报错：eval（'add(1,2)',globals={},locals={})exec('y=add(1,2)',globals={},locals={})
eval（)
exec()
3.2 全局变量与局部变量默认传入
eval（)与exec()均不必手动传入globals与locals参数；
通过下面的用例，可以看出它们在使用时，默认使用globals()与locals()，并且使用完成后会将外部globals()与locals()进行更新。
eval
exec()
3.3 globals和locals的优先级
如果globals与locals中出现同名称变量名，将默认使用locals中对应的变量，即locals优先级*高于globals。
3.4 NameError: name 'XXX' is not defined
exec在类外部执行的，最终globals()与locals()相同。exec在类方法中执行，最终globals()与locals()各管各的，使用exec后很可能出现新变量调用时报错，具体可能有以下几种情况。
3.4.1 exec(object, globals(), locals())或exec(object)
可使用全局变量作用域与局部变量作用域；执行完后，如果有新的变量定义，会将新变量更新到局部变量作用域locals()中，通常用法。
3.4.2 exec(object, globals(), globals())或exec(object, globals())
只能使用全局变量作用域；执行完后，如果有新的变量定义，会将新变量更新到全局变量作用域globals()中，少量用法。
3.4.3 exec(object, locals(), locals())
只能使用局部变量作用域；执行完后，`如果有新的变量定义，会将新变量更新到局部变量作用域locals()中，一般不这么用。
3.4.4 为什么会报错？
分为如下几种情况：
- 使用3.4.1的方式，通常
类方法中不会预定义exec中动态生成的新变量，exce执行后，新变量会更新到locals()中。
如果在exec后续代码中使用新变量，系统将在globals()中寻找并返回值。但因3.4.1方式中globals()不更新，所以不会有新变量，就会报错新变量名称未定义，即NameError: name 'XXX' is not defined，其中XXX为object中定义的新变量。。 - 使用3.4.2的方式，如果
exec执行的代码块中存在类方法定义的局部变量，则可能会报错NameError: name 'XXX' is not defined,其中XXX为类方法内局部变量名称。 - 使用3.4.3的方式，如果
exec执行的代码块中存在使用全局变量或全局方法，则可能会报错NameError: name 'XXX' is not defined,其中XXX为全局变量名称或全局方法名称。
提供参考代码如下
# -*- coding:utf-8 -*-
import logging
import dis
_logger = logging.getLogger(__name__)
GlobalVar = '1'
x = 1
y = 2
RewriteVar = 'Out Class.'
_logger.warning('Class外部全局变量与局部变量相等:')
_logger.warning("globals():\n %s\n" % (globals()))
_logger.warning("locals():\n %s\n" % (locals()))
def action_global_add(x, y):
return x + y
class TestClass():
ClassVar = '2'
def action_add(self, x, y):
return x + y
def test_func(self):
FuncVar = 3
RewriteVar = 'Inner Function.'
x = 3
y = 4
_logger.warning('Class内部全局变量与局部变量不同:')
_logger.warning("globals():\n %s\n" % (globals()))
_logger.warning("locals():\n %s\n" % (locals()))
z1 = eval（'self.action_add(x,y)', )
_logger.warning("eval var z1: %s\n" % (z1))
# 等价 exec('z2=action_global_add(1,2);1==1', globals(), locals())
exec('z2=action_global_add(1,2);1==1')
_logger.warning("globals():\n %s\n" % (globals()))
_logger.warning("locals():\n %s\n" % (locals()))
# _logger.warning("z2:\n %s\n" % (z2)) # NameError: name 'z2' is not defined
_logger.warning("z2: %s" % (locals()['z2']))
# exec('z3=FuncVar;1==1;l=locals()', globals()) # NameError: name 'FuncVar' is not defined
# _logger.warning("globals():\n %s\n" % (globals()))
# _logger.warning("locals():\n %s\n" % (locals()))
# _logger.warning("z4: %s" % (z4))
# exec('z4=self.action_add(1,2);1==1', locals())
# _logger.warning("globals():\n %s\n" % (globals()))
# _logger.warning("locals():\n %s\n" % (locals()))
# _logger.warning("z4:\n %s\n" % (z4)) # NameError: name 'z4' is not defined
# _logger.warning("z4: %s" % (locals()['z4']))
test_instance = TestClass()
test_instance.test_func()
_logger.warning(dis.dis(test_instance.test_func))关于dis.dis()
27 0 LOAD_CONST 1 (3)
2 STORE_FAST 1 (FuncVar)
28 4 LOAD_CONST 2 ('Inner Function.')
6 STORE_FAST 2 (RewriteVar)
29 8 LOAD_CONST 1 (3)
10 STORE_FAST 3 (x)
30 12 LOAD_CONST 3 (4)
14 STORE_FAST 4 (y)
31 16 LOAD_GLOBAL 0 (_logger)
18 LOAD_METHOD 1 (warning)
20 LOAD_CONST 4 ('Class内部全局变量与局部变量不同:')
22 CALL_METHOD 1
24 POP_TOP
32 26 LOAD_GLOBAL 0 (_logger)
28 LOAD_METHOD 1 (warning)
30 LOAD_CONST 5 ('globals():\n %s\n')
32 LOAD_GLOBAL 2 (globals)
34 CALL_FUNCTION 0
36 BINARY_MODULO
38 CALL_METHOD 1
40 POP_TOP
33 42 LOAD_GLOBAL 0 (_logger)
44 LOAD_METHOD 1 (warning)
46 LOAD_CONST 6 ('locals():\n %s\n')
48 LOAD_GLOBAL 3 (locals)
50 CALL_FUNCTION 0
52 BINARY_MODULO
54 CALL_METHOD 1
56 POP_TOP
35 58 LOAD_GLOBAL 4 (eval)
60 LOAD_CONST 7 ('self.action_add(x,y)')
62 CALL_FUNCTION 1
64 STORE_FAST 5 (z1)
36 66 LOAD_GLOBAL 0 (_logger)
68 LOAD_METHOD 1 (warning)
70 LOAD_CONST 8 ('eval var z1: %s\n')
72 LOAD_FAST 5 (z1)
74 BINARY_MODULO
76 CALL_METHOD 1
78 POP_TOP
39 80 LOAD_GLOBAL 5 (exec)
82 LOAD_CONST 9 ('z2=action_global_add(1,2);1==1')
84 CALL_FUNCTION 1
86 POP_TOP
40 88 LOAD_GLOBAL 0 (_logger)
90 LOAD_METHOD 1 (warning)
92 LOAD_CONST 5 ('globals():\n %s\n')
94 LOAD_GLOBAL 2 (globals)
96 CALL_FUNCTION 0
98 BINARY_MODULO
100 CALL_METHOD 1
102 POP_TOP
41 104 LOAD_GLOBAL 0 (_logger)
106 LOAD_METHOD 1 (warning)
108 LOAD_CONST 6 ('locals():\n %s\n')
110 LOAD_GLOBAL 3 (locals)
112 CALL_FUNCTION 0
114 BINARY_MODULO
116 CALL_METHOD 1
118 POP_TOP
43 120 LOAD_GLOBAL 0 (_logger)
122 LOAD_METHOD 1 (warning)
124 LOAD_CONST 10 ('z2: %s')
126 LOAD_GLOBAL 3 (locals)
128 CALL_FUNCTION 0
130 LOAD_CONST 11 ('z2')
132 BINARY_SUBSCR
134 BINARY_MODULO
136 CALL_METHOD 1
138 POP_TOP
140 LOAD_CONST 0 (None)
142 RETURN_VALUE3.4.5 如何避免此类报错？
- 使用3.4.1模式，可使用
全局域和局部域。
后续取值使用不要直接用新变量的名称，而需要从locals()中进行手动获取，如：z2 = locals()[‘z2’]。 - 使用3.4.2模式，仅可用
全局域资源；
此时使用新变量将从globals()中获取并返回，不会报错。
但需注意如果全局变量中有同名参数，方法执行完后此同名全局变量将被更新。 - 使用3.4.3模式，仅可用
局部域资源；
后续取值使用不要直接用新变量的名称，而需要从locals()中进行手动获取，如：z2 = locals()[‘z2’]。
