eval、exec 和 compile 有啥区别？
Posted
技术标签:
【中文标题】eval、exec 和 compile 有啥区别？【英文标题】：What's the difference between eval, exec, and compile?eval、exec 和 compile 有什么区别？ 【发布时间】：2011-01-14 07:26:13 【问题描述】：我一直在研究 Python 代码的动态评估，遇到了 eval() 和 compile() 函数，以及 exec 语句。
谁能解释一下eval和exec之间的区别，以及compile()的不同模式如何适应？
【问题讨论】：
【参考方案1】：简短的回答，或 TL;DR
基本上，eval 用于评估单个动态生成的 Python 表达式，exec 用于执行仅针对其动态生成的 Python 代码副作用。
eval和exec有这两个区别：
eval 只接受一个单个表达式，exec 可以采用包含 Python 语句的代码块：循环、try: except:、class 和函数/方法definitions 和很快。
Python 中的表达式可以作为变量赋值中的任何值：
a_variable = (anything you can put within these parentheses is an expression)
eval 返回给定表达式的值，而 exec 忽略其代码中的返回值，并始终返回 None（在 Python 2 中它是一个语句并且不能用作表达式，所以它真的不返回任何东西）。
在 1.0 - 2.7 版本中，exec 是一个语句，因为 CPython 需要为使用 exec 的函数生成不同类型的代码对象，因为它在函数内部产生副作用。
在 Python 3 中，exec 是一个函数；它的使用对使用它的函数的编译字节码没有影响。
因此基本上：
>>> a = 5
>>> eval('37 + a') # it is an expression
42
>>> exec('37 + a') # it is an expression statement; value is ignored (None is returned)
>>> exec('a = 47') # modify a global variable as a side effect
>>> a
47
>>> eval('a = 47') # you cannot evaluate a statement
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1
a = 47
^
SyntaxError: invalid syntax
compile 在'exec' 模式下将任意数量的语句编译成隐式总是返回None 的字节码，而在'eval' 模式下它将单个 表达式编译成 em>返回该表达式的值。
>>> eval(compile('42', '<string>', 'exec')) # code returns None
>>> eval(compile('42', '<string>', 'eval')) # code returns 42
42
>>> exec(compile('42', '<string>', 'eval')) # code returns 42,
>>> # but ignored by exec
在'eval' 模式下（如果传入字符串，则使用eval 函数），如果源代码包含语句或超出单个表达式的任何其他内容，compile 将引发异常：
>>> compile('for i in range(3): print(i)', '<string>', 'eval')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1
for i in range(3): print(i)
^
SyntaxError: invalid syntax
实际上，“eval 只接受一个表达式” 语句仅适用于将字符串（包含 Python 源代码）传递给 eval 时。然后使用compile(source, '<string>', 'eval')在内部编译成字节码，这才是真正的区别所在。
如果将 code 对象（包含 Python 字节码）传递给 exec 或 eval，它们的行为相同，除了 @ 987654375@ 忽略返回值，始终返回None。所以可以使用eval 来执行有语句的东西，如果你只是在compiled 之前把它转换成字节码而不是将它作为字符串传递：
>>> eval(compile('if 1: print("Hello")', '<string>', 'exec'))
Hello
>>>
即使编译后的代码包含语句，也可以正常工作。它仍然返回None，因为这是从compile返回的代码对象的返回值。
在'eval' 模式下（如果传入字符串，则使用eval 函数），如果源代码包含语句或超出单个表达式的任何其他内容，compile 将引发异常：
>>> compile('for i in range(3): print(i)', '<string>'. 'eval')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1
for i in range(3): print(i)
^
SyntaxError: invalid syntax
更长的答案，也就是血淋淋的细节
exec 和 eval
exec 函数（原为a statement in Python 2）用于执行动态创建的语句或程序：
>>> program = '''
for i in range(3):
print("Python is cool")
'''
>>> exec(program)
Python is cool
Python is cool
Python is cool
>>>
eval 函数对single expression 执行相同的操作，并且返回表达式的值：
>>> a = 2
>>> my_calculation = '42 * a'
>>> result = eval(my_calculation)
>>> result
84
exec 和 eval 都接受程序/表达式作为包含源代码的 str、unicode 或 bytes 对象运行，或者作为 code 对象运行 em> 其中包含 Python 字节码。
如果将包含源代码的str/unicode/bytes 传递给exec，则其行为等同于：
exec(compile(source, '<string>', 'exec'))
和eval 的行为类似：
eval(compile(source, '<string>', 'eval'))
由于所有表达式都可以用作 Python 中的语句（这些在 Python 中称为 Expr 节点 abstract grammar；反之则不然），如果您不需要返回，则始终可以使用 exec价值。也就是说eval('my_func(42)')或者exec('my_func(42)')都可以使用，区别在于eval返回的是my_func返回的值，而exec将其丢弃：
>>> def my_func(arg):
... print("Called with %d" % arg)
... return arg * 2
...
>>> exec('my_func(42)')
Called with 42
>>> eval('my_func(42)')
Called with 42
84
>>>
在这 2 个中，只有 exec 接受包含语句的源代码，例如 def、for、while、import 或 class，赋值语句（又名 a = 42），或整个程序：
>>> exec('for i in range(3): print(i)')
0
1
2
>>> eval('for i in range(3): print(i)')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1
for i in range(3): print(i)
^
SyntaxError: invalid syntax
exec 和 eval 都接受 2 个额外的位置参数 - globals 和 locals - 这是代码看到的全局和局部变量范围。这些默认为globals() 和locals() 在称为exec 或eval 的范围内，但任何字典都可以用于globals 和任何mapping 用于locals（当然包括dict ）。这些不仅可以用来限制/修改代码看到的变量，还经常用于捕获executed 代码创建的变量：
>>> g = dict()
>>> l = dict()
>>> exec('global a; a, b = 123, 42', g, l)
>>> g['a']
123
>>> l
'b': 42
（如果显示整个g 的值，会更长，因为exec 和eval 将内置模块作为__builtins__ 自动添加到全局变量中，如果它缺失）。
在 Python 2 中，exec 语句的官方语法实际上是 exec code in globals, locals，如
>>> exec 'global a; a, b = 123, 42' in g, l
不过，替代语法 exec(code, globals, locals) 也一直被接受（见下文）。
compile
通过预先将源代码编译为code 对象，可以使用内置的compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1) 来加速使用exec 或eval 重复调用相同的代码。 mode 参数控制compile 函数接受的代码片段类型以及它产生的字节码类型。选项有'eval'、'exec' 和'single'：
'eval' 模式需要一个表达式，并且会生成字节码，运行时会返回那个表达式的值：
>>> dis.dis(compile('a + b', '<string>', 'eval'))
1 0 LOAD_NAME 0 (a)
3 LOAD_NAME 1 (b)
6 BINARY_ADD
7 RETURN_VALUE
'exec' 接受从单个表达式到整个代码模块的任何类型的 python 构造，并像执行模块***语句一样执行它们。代码对象返回None：
>>> dis.dis(compile('a + b', '<string>', 'exec'))
1 0 LOAD_NAME 0 (a)
3 LOAD_NAME 1 (b)
6 BINARY_ADD
7 POP_TOP <- discard result
8 LOAD_CONST 0 (None) <- load None on stack
11 RETURN_VALUE <- return top of stack
'single' 是'exec' 的有限形式，如果最后一个语句是表达式语句，则它接受包含单个 语句（或由; 分隔的多个语句）的源代码，结果字节码还将该表达式的值的repr 打印到标准输出（！）。
if-elif-else 链、带有else 和try 及其except、else 和finally 块的循环被视为单个语句。
包含 2 个***语句的源代码片段对于 'single' 来说是一个错误，但在 Python 2 中存在一个错误，有时允许代码中有多个***语句；只有第一个被编译；其余的被忽略：
在 Python 2.7.8 中：
>>> exec(compile('a = 5\na = 6', '<string>', 'single'))
>>> a
5
在 Python 3.4.2 中：
>>> exec(compile('a = 5\na = 6', '<string>', 'single'))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1
a = 5
^
SyntaxError: multiple statements found while compiling a single statement
这对于制作交互式 Python shell 非常有用。但是，表达式的值不会返回，即使你eval 得到的代码也是如此。
因此exec 和eval 的最大区别实际上来自compile 函数及其模式。
除了将源代码编译成字节码，compile还支持将abstract syntax trees（Python代码的解析树）编译成code对象；并将源代码转换为抽象语法树（ast.parse 是用 Python 编写的，只调用 compile(source, filename, mode, PyCF_ONLY_AST)）；例如，它们用于动态修改源代码，也用于动态代码创建，因为在复杂情况下，将代码作为节点树而不是文本行来处理通常更容易。
虽然eval 只允许您评估包含单个表达式的字符串，但您可以eval 整个语句，甚至可以将整个模块compiled 转换为字节码；也就是说，在 Python 2 中，print 是一个语句，不能直接为evalled：
>>> eval('for i in range(3): print("Python is cool")')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1
for i in range(3): print("Python is cool")
^
SyntaxError: invalid syntax
compile它与'exec'模式转换成一个code对象，你可以eval它; eval 函数将返回 None。
>>> code = compile('for i in range(3): print("Python is cool")',
'foo.py', 'exec')
>>> eval(code)
Python is cool
Python is cool
Python is cool
如果查看 CPython 3 中的 eval 和 exec 源代码，这是非常明显的；他们都使用相同的参数调用PyEval_EvalCode，唯一的区别是exec explicitly returns None。
Python 2 和 Python 3 之间exec 的语法差异
Python 2 的主要区别之一是exec 是一个语句，eval 是一个内置函数（两者都是 Python 3 中的内置函数）。
众所周知，Python 2 中exec 的官方语法是exec code [in globals[, locals]]。
与大多数 Python 2-to-3 porting guides seem to suggest 不同，CPython 2 中的 exec 语句也可以与 看起来 完全是类似于 Python 3 中的 exec 函数调用。原因是 Python 0.9.9 具有 exec(code, globals, locals) 内置函数！并且该内置函数被替换为exec 语句somewhere before Python 1.0 release。
由于不希望破坏与 Python 0.9.9 的向后兼容性，Guido van Rossum added a compatibility hack in 1993：如果 code 是长度为 2 或 3 的元组，并且 globals 和 locals 未传递到 @ 987654511@ 声明，否则，code 将被解释为元组的第二个和第三个元素分别是 globals 和 locals。即使在Python 1.4 documentation (the earliest available version online) 中也没有提到兼容性黑客；因此，许多移植指南和工具的作者并不知道，直到 documented 又是 in November 2012：
第一个表达式也可以是长度为 2 或 3 的元组。在这种情况下，必须省略可选部分。
exec(expr, globals)等价于exec expr in globals，而exec(expr, globals, locals)等价于exec expr in globals, locals。exec的元组形式提供了与 Python 3 的兼容性，其中exec是一个函数而不是语句。
是的，在 CPython 2.7 中，它被方便地称为前向兼容选项（为什么人们会因为完全有后向兼容选项而感到困惑）， 当它实际上已经存在了 20 年的向后兼容性。
因此，exec 在 Python 1 和 Python 2 中是一个语句，在 Python 3 和 Python 0.9.9 中是一个内置函数，
>>> exec("print(a)", globals(), 'a': 42)
42
可能在每个广泛发布的 Python 版本中都有相同的行为；并在 Jython 2.5.2、PyPy 2.3.1 (Python 2.7.6) 和 IronPython 2.6.1 中工作（对他们密切关注 CPython 的未记录行为表示赞赏）。
在 Python 1.0 - 2.7 及其兼容性黑客中，你不能做的是将 exec 的返回值存储到一个变量中：
Python 2.7.11+ (default, Apr 17 2016, 14:00:29)
[GCC 5.3.1 20160413] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> a = exec('print(42)')
File "<stdin>", line 1
a = exec('print(42)')
^
SyntaxError: invalid syntax
（这在 Python 3 中也没有用，因为 exec 总是返回 None），或者传递对 exec 的引用：
>>> call_later(exec, 'print(42)', delay=1000)
File "<stdin>", line 1
call_later(exec, 'print(42)', delay=1000)
^
SyntaxError: invalid syntax
某人可能实际使用过的模式，尽管不太可能；
或者在列表推导中使用它：
>>> [exec(i) for i in ['print(42)', 'print(foo)']
File "<stdin>", line 1
[exec(i) for i in ['print(42)', 'print(foo)']
^
SyntaxError: invalid syntax
这是对列表推导的滥用（请改用for 循环！）。
【讨论】：
[i for i in globals().values() if hasattr(i, '__call__')][0] 是语句还是表达式？如果是表达式，为什么不能用@作为装饰器呢？
这是一个表达式。 42 也是一个表达式，不能和@ 一起作为装饰器使用。
装饰器语法为decorator ::= "@" dotted_name ["(" [parameter_list [","]] ")"] NEWLINE；即你不能使用任意表达式作为装饰器，只能使用一个（可能是虚线的）标识符，后跟可选的调用参数。
没有任何东西可以放在赋值的右侧并且仍然可以编译是表达式。例如，a = b = c 是一个完全有效的语句，它的右侧 b = c 也是如此 - 这不是一个表达式。
值得一提的是ast.literal_eval，它比eval 和exec 更受限制但使用起来也更安全。我经常使用它来评估可能代表bool、int、float、...的字符串。【参考方案2】：
exec 不是表达式：Python 2.x 中的语句和 Python 3.x 中的函数。它编译并立即评估字符串中包含的语句或语句集。示例：
exec('print(5)') # prints 5.
# exec 'print 5' if you use Python 2.x, nor the exec neither the print is a function there
exec('print(5)\nprint(6)') # prints 5newline6.
exec('if True: print(6)') # prints 6.
exec('5') # does nothing and returns nothing.
eval 是一个内置函数（不是语句），它计算表达式并返回表达式产生的值。示例：
x = eval('5') # x <- 5
x = eval('%d + 6' % x) # x <- 11
x = eval('abs(%d)' % -100) # x <- 100
x = eval('x = 5') # INVALID; assignment is not an expression.
x = eval('if 1: x = 4') # INVALID; if is a statement, not an expression.
compile 是exec 和eval 的较低级别版本。它不会执行或评估您的语句或表达式，而是返回一个可以执行此操作的代码对象。模式如下：
compile(string, '', 'eval') 返回如果你完成eval(string) 将会执行的代码对象。请注意，您不能在此模式下使用语句；只有一个（单个）表达式是有效的。
compile(string, '', 'exec') 返回如果您完成exec(string) 将执行的代码对象。您可以在此处使用任意数量的语句。
compile(string, '', 'single') 类似于exec 模式，但只需要一个表达式/语句，例如compile('a=1 if 1 else 3', 'myf', mode='single')
【讨论】：
在 Python 3 中，exec() 现在实际上是一个函数。
因为（正如您所指出的），exec 是您所针对的版本中的一个声明，包含这些括号具有欺骗性，如果您尝试使用 in globals, locals，也会出现问题。
@MikeGraham exec 支持括号和 Python 2 中类似调用的函数。
@AnttiHaapala 就分配“支持括号”而言，因为您可以执行x = (y)，这可能是真的。另一个语句转函数是print；在python 2和3中比较print(1, 2, 3)的结果。
@habnabit 不是这样的。请在此处阅读my answer 的底部并感到惊讶。【参考方案3】：
exec 是 for 语句，不返回任何内容。 eval 用于表达式，返回表达式的值。
表达式的意思是“某事”，而语句的意思是“做某事”。
【讨论】：
第二段被简化得几乎成了一个谎言，一个表达式如果包含一个函数调用就可以做很多事情。以上是关于eval、exec 和 compile 有啥区别？的主要内容，如果未能解决你的问题，请参考以下文章