eval、exec 和compile 之间有什么区别？

Question

我一直在研究 Python 代码的动态评估，并遇到了 eval() 和 compile() 函数以及 exec 语句。

有人可以解释一下 eval 和 exec 之间的区别，以及 compile() 的不同模式如何适应吗？

Answer 1

简短的答案，或者 TL;DR

基本上， eval< /a> 用于评估评估单个动态生成的 Python 表达式，exec 用于execute动态生成的Python代码，只是为了它的副作用。

eval 和 exec 有两个区别：

1. eval 只接受单个表达式，exec 可以采用包含 Python 语句的代码块：循环、try: except:、class 和函数/方法 definitions 和很快。

   Python 中的表达式是可以作为变量赋值中的值的任何内容：

   a_variable =（括号内可以放入的任何内容都是表达式）
   

2. 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

---

'exec' 模式下的 compile 将任意数量的语句编译为隐式始终返回 None 的字节码，而在 'eval' 模式它将单个表达式编译为字节码，返回该表达式的值。

>>> 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 源代码）时才适用到评估。然后使用 compile(source, '在内部将其编译为字节码;', 'eval')这就是差异的真正来源。

如果将 code 对象（包含 Python 字节码）传递给 exec 或 eval，它们的行为完全相同，除了 exec 忽略返回值，仍然始终返回 None。因此，如果您之前只是将其编译为字节码而不是将其作为字符串传递，那么可以使用 eval 来执行具有语句的内容：

>>> 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

org/3/library/functions.html#exec" rel="noreferrer">exec 函数（这是 Python 2 中的语句) 用于执行动态创建的语句或程序：

>>> program = '''
for i in range(3):
    print("Python is cool")
'''
>>> exec(program)
Python is cool
Python is cool
Python is cool
>>> 

eval 函数对 单个表达式，和返回表达式的值：

>>> a = 2
>>> my_calculation = '42 * a'
>>> result = eval(my_calculation)
>>> result
84

exec和eval 都接受程序/表达式作为包含源代码的 str、unicode 或 bytes 对象运行，或者作为code 对象，其中包含 Python 字节码。

如果将包含源代码的 str/unicode/bytes 传递给 exec，则其行为等同于：

exec(compile(source, '<string>', 'exec'))

和 < code>eval 的行为类似地相当于：

eval(compile(source, '<string>', 'eval'))

---

由于所有表达式都可以用作 Python 中的语句（这些在 Python 抽象语法；相反则不然），如果你不需要返回值。也就是说，您可以使用 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 - 这是代码看到的全局和局部变量范围。这些默认为调用 exec 或 eval 范围内的 globals() 和 locals()，但任何字典可用于全局变量和本地变量的任何映射（当然包括字典）。这些不仅可以用于限制/修改代码看到的变量，而且通常还可以用于捕获 exec 代码创建的变量：（

>>> g = dict()
>>> l = dict()
>>> exec('global a; a, b = 123, 42', g, l)
>>> g['a']
123
>>> l
{'b': 42}

如果显示整个 < code>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(源、文件名、模式, flags=0, dont_inherit=False, optimize=-1) 内置可用于加速使用 exec 或 重复调用相同代码eval 通过预先将源代码编译为 code 对象。 mode 参数控制 compile 函数接受的代码片段类型及其生成的字节码类型。选项有 'eval'、'exec' 和 'single'：

• 'eval' 模式需要单个表达式，并将生成字节码，运行时将返回该表达式的值：

  <前><代码>>>> dis.dis(编译('a + b', '', 'eval'))
  1 0 LOAD_NAME 0 (a)
  3 LOAD_NAME 1 (b)
  6 二进制添加
  7 返回值
  

• < code>'exec' 接受从单个表达式到整个代码模块的任何类型的 python 构造，并像执行模块顶级语句一样执行它们。代码对象返回None：

  <前><代码>>>> dis.dis(编译('a + b', '', 'exec'))
  1 0 LOAD_NAME 0 (a)
  3 LOAD_NAME 1 (b)
  6 二进制添加
  7 POP_TOP <- 丢弃结果
  8 LOAD_CONST 0（无）<- 在堆栈上加载无
  11 RETURN_VALUE <- 返回栈顶
  

• 'single' 是 'exec' 的有限形式，它接受包含 的源代码>单个语句（或由;分隔的多个语句）如果最后一个语句是表达式语句，则生成的字节码还会打印该语句的repr该表达式的值到标准输出（！）。

  一个 if-elif-else 链，一个带有 else 的循环，以及 try< /code> 及其 except、else 和 finally 块被视为单个语句。

  包含 2 个顶级语句的源代码片段是 'single' 的错误，但在 Python 2 中，存在有时允许多个顶级语句的错误代码；仅编译第一个；其余的被忽略：

  在 Python 2.7.8 中：

  <前><代码>>>> exec(编译('a = 5\na = 6', '<字符串>', '单个'))
>>>>>一个
5


  在 Python 3.4.2 中：

  <前><代码>>>> exec(编译('a = 5\na = 6', '<字符串>', '单个'))
  回溯（最近一次调用最后一次）：
  文件“”，第 1 行，在中
  文件“”，第 1 行
  一个= 5
  ^
  SyntaxError：编译单个语句时发现多个语句

  这对于制作交互式 Python shell 非常有用。但是，即使您评估生成的代码，表达式的值也不会返回。

因此，exec 和 eval 的最大区别实际上来自于 compile 函数及其模式。

---

除了将源代码编译为字节码之外，compile还支持编译抽象语法树（Python代码的解析树）为code对象；和源代码到抽象语法树中（ast.parse是用Python编写的，只调用compile(source, filename, mode, PyCF_ONLY_AST)）；例如，它们用于动态修改源代码，也用于动态代码创建，因为在复杂情况下将代码作为节点树而不是文本行处理通常更容易。

---

虽然eval只允许您计算包含单个表达式的字符串，但您可以eval整个语句，甚至是已编译的整个模块 code>d 转换为字节码；也就是说，在 Python 2 中，print 是一条语句，不能直接通过 eval 引导：

>>> 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

使用 'exec'< compile 它/code> 模式转换为 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

如果有人查看 eval 和 exec 源CPython 3 中的代码，这一点非常明显；它们都使用相同的参数调用 PyEval_EvalCode ，唯一的区别是 exec 显式返回 None。

Python 2 和 Python 3 之间 exec 的语法差异

Python 2 中的主要区别之一是 exec 是一条语句，而 eval 是一个内置函数（两者都是Python 3中的内置函数）。
众所周知，Python 2 中 exec 的官方语法是 exec code [in globals[, locals]]。

与大多数 Python 2 到 3 移植 指南 似乎 建议，CPython 2 中的 exec 语句也可以与 看起来 完全类似于 exec 函数调用的语法一起使用在Python 3中。原因是Python 0.9.9有exec(code, globals, locals)内置函数！该内置函数已替换为 exec 语句 Python 1.0 发布之前的某个地方。

由于希望不破坏与 Python 0.9.9 的向后兼容性， Guido van Rossum 在 1993 年添加了一个兼容性 hack：如果 code 是长度为 2 或 3 的元组，以及 globals 和 locals > 没有传递到 exec 语句中，否则，code 将被解释为就好像元组的第二个和第三个元素是 globals 并且分别是当地人。即使在 Python 1.4 文档（最早的在线版本）中也没有提到兼容性黑客）；因此，许多移植指南和工具的作者并不知道它，直到 于 2012 年 11 月再次记录：

第一个表达式也可以是长度为 2 或 3 的元组。在这种情况下，必须省略可选部分。 exec(expr, globals) 形式等效于 globals 中的 exec expr，而 exec(expr, globals, locals) 形式等效到 exec expr in globals, locals。 exec 的元组形式提供了与 Python 3 的兼容性，其中 exec 是函数而不是语句。

是的，在 CPython 2.7 中，它被方便地称为向前兼容选项（为什么要让人们对向后兼容选项感到困惑），
当它实际上已经存在向后兼容二十年时。

因此，虽然 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 循环！）。

Answer 2

1. exec 不是表达式：Python 2.x 中的语句，Python 3.x 中的函数。它编译并立即计算字符串中包含的一条语句或一组语句。示例：

    exec('print(5)') # 打印 5。
    # exec 'print 5' 如果你使用 Python 2.x，exec 和 print 都不是那里的函数
    exec('print(5)\nprint(6)') # 打印 5{newline}6.
    exec('if True: print(6)') # 打印 6.
    exec('5') # 不执行任何操作，也不返回任何内容。
   

2. eval 是一个内置函数（不是语句），它计算表达式并返回表达式生成的值。示例：

    x = eval('5') # x <- 5
    x = eval('%d + 6' % x) # x <- 11
    x = eval('abs(%d)' % -100) # x <- 100
    x = eval('x = 5') # 无效;赋值不是表达式。
    x = eval('如果 1: x = 4') # 无效; if 是一个语句，而不是一个表达式。
   

3. compile 是 exec 和 eval 的较低级别版本。它不会执行或评估您的语句或表达式，但返回可以执行此操作的代码对象。模式如下：

4. compile(string, '', 'eval') 返回如果执行 eval(string) 则将执行的代码对象。请注意，您不能在此模式下使用语句；只有（单个）表达式有效。

5. compile(string, '', 'exec') 返回执行 exec(string) 后将执行的代码对象。您可以在此处使用任意数量的语句。

6. compile(string, '', 'single') 类似于 exec 模式，但只需要一个表达式/语句，例如 compile('a= 1 if 1 else 3', 'myf', mode='single')

Answer 3

exec 是 for 语句，不返回任何内容。
eval 用于表达式并返回表达式的值。

表达式的意思是“某事”，而陈述的意思是“做某事”。