Python | eval、exec | 执行动态代码字符串

原创已于 2022-08-18 13:19:48 修改 · 2.4k 阅读

7 ·

CC 4.0 BY-SA版权

文章标签：

#python #eval #exec #globals #locals

于 2022-08-18 01:54:40 首次发布

Python - 基础专栏收录该内容

60 篇文章

订阅专栏

本文详细介绍了Python中用于动态执行代码的eval和exec函数，包括它们的使用方法、参数解析及注意事项。eval用于执行表达式并返回结果，而exec则用于执行代码块。在使用时，应注意全局变量和局部变量的作用域以及如何避免`NameError`。文章通过实例展示了不同参数组合下的执行效果，并给出了避免错误的解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Python | eval、exec | 执行动态代码字符串

文章目录

Python | eval、exec | 执行动态代码字符串

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_VALUE

3.4.5 如何避免此类报错？

使用3.4.1模式，可使用全局域和局部域。
后续取值使用不要直接用新变量的名称，而需要从locals()中进行手动获取，如：z2 = locals()[‘z2’]。
使用3.4.2模式，仅可用全局域资源；
此时使用新变量将从globals()中获取并返回，不会报错。
但需注意如果全局变量中有同名参数，方法执行完后此同名全局变量将被更新。
使用3.4.3模式，仅可用局部域资源；
后续取值使用不要直接用新变量的名称，而需要从locals()中进行手动获取，如：z2 = locals()[‘z2’]。