评估，执行和编译之间的区别是什么？

Question

我一直在研究Python代码的动态评估，并访问 eval（）和 compile（）函数，以及 exec 语句。

有人可以解释 eval 和 exec 以及 compile（）的不同模式如何适合 exec exec 之间的区别吗？

Answer 1

简短的答案或tl; dr

基本上是 evary> evary < << /a>用于 eval uate单个动态生成的python表达式， exec 用于 exec ute仅用于其副作用，动态生成的python代码。

evary 和 exec 有这两个区别：

1. eval 仅接受单个表达式， exec 可以采用具有python语句的代码块：loops，尝试：excesef：， class and function/method def def initions and and code>很快。

   python中的一个表达式是您可以拥有的变量分配中的值：

     a_variable =（您可以在这些括号内放置的任何内容都是表达式）
    

2. eval 返回给定表达式的值，而 exec 忽略从其代码中的返回值，并且始终返回 none （在Python 2中，这是一个语句，不能用作表达式，因此它确实不会返回任何内容）。

在版本1.0-2.7中， exec 是一个语句，因为CPYTHON需要为使用 exec 在功能中使用 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' mode中，将任何数量的语句编译成一个字节，隐含地始终返回 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'模式下代码包含语句或单个表达式以外的其他内容：

>>> 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 source代码）时才适用到评估。然后使用“ noreferrer”> compile（source，'＆gt＆gt＆gt＆gt＆gt; ;'，'eval'） 这是差异真正来自的地方。

如果代码对象（其中包含Python bytecode ）将传递给 exec 或 ext ，他们的行为相同的，除了 exec 忽略返回值以下事实外，仍然返回 none 总是。 则可以使用 eval 执行具有语句的内容

>>> eval(compile('if 1: print("Hello")', '<string>', 'exec'))
Hello
>>>

因此，如果您只是 compile d ， 编译的代码包含语句。它仍然返回无，因为这是从 compile 返回的代码对象的返回值。

在'eval'模式下代码包含语句或单个表达式以外的其他任何内容：

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

答案越长，又称gory详细信息

exec 和 eval

exec 函数（ python 2中的语句用于执行动态创建的语句或程序：

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

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

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

exec and est 既接受要运行的程序/表达式 代码对象包含Python字节码。

如果 str / unicode / bytes 包含源代码的传递给 exec

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

代码>评估类似的行为等同于：

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

---

由于所有表达式都可以用作Python中的语句（这些称为 expr python 摘要语法;相反的是不正确的），您可以随时使用 exec ，如果不需要返回值。也就是说，您可以使用 eval（'my_func（42）'）或 exec（'my_func（42）'），区别在于> deal 返回 my_func 返回的值， exec dovers it：

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

of 2，仅 exec 接受包含语句的源代码，例如 def ，， while ，， import ，或 class ，分配语句（aka 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 和 evar> eval 接受2个附加位置参数 - globals 和当地人 - 是代码看到的全局和本地变量范围。这些默认为 globals（）和 locals（）在称为 exec 或 eval 的范围内字典可用于 Globals 和任何映射 当地人（当然包括 dict ）。这些不仅可以用来限制/修改代码看到的变量，而且通常也用于捕获 exec uted代码创建的变量：（

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

如果您显示整个<的值代码> g ，它将更长的时间，因为 exec 和 eval 将内置模块添加为 ______enins ____________________ 如果丢失了）。

在Python 2中， exec 语句的官方语法实际上是 exec code in Globals，locals ，如在

>>> exec 'global a; a, b = 123, 42' in g, l

替代语法 exec（代码，全球范围，当地人，当地人） ）也一直被接受（见下文）。

compile

compile> compile（source，filename，filename，mode，mode，mode ，flags = 0，dont_inherit = false，optimize = -1） 可以使用内置的内置 - 用 exec 或加快相同代码的重复调用通过将源汇编为代码对象，请评估。 模式参数控制代码片段的种类 compile 函数接受以及它产生的字节码的种类。选择是'eval'，'exec'和'single'：

• 'eval'eval'模式期望单个表达式，并会产生字节码，即运行将返回的值，该表达式：

   ＆gt;＆gt;＆gt; dis.dis（compile（'a + b'，'＆lt; string＆gt;'，'eval'））
    1 0 load_name 0（a）
                3 load_name 1（b）
                6 Binary_add
                7 return_value
   

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

   ＆gt;＆gt;＆gt; dis.dis（compile（'a + b'，'＆lt; string＆gt;'，'exec'））））
    1 0 load_name 0（a）
                3 load_name 1（b）
                6 Binary_add
                7 pop_top＆lt;  - 丢弃结果
                8 load_const 0（none）＆lt;  - 堆栈上无负载
               11 return_value＆lt;  - 返回堆栈的顶部
   

• '单'是'exec'exec'的有限形式，它接受包含单个语句（或由; 分隔的多个语句）如果最后一个语句是表达式语句，则结果字节也 也打印了 repr 该表达式对标准输出的值（！）。

  一个如果 - elif - else 链，带有 else> else 的环，尝试< /code>及其除外，<代码> else 和最后块被视为一个单个语句。

  一个包含2个顶级语句的源片段是'single''的错误代码；只有第一个是编译的；其余的被忽略：

  在Python 2.7.8：

  中

   ＆gt;＆gt;＆gt; exec（compile（'a = 5 \ na = 6'，'＆lt; string＆gt;'，'single'））
  ＆gt;＆gt;＆gt;一个
  5
   

  和python 3.4.2：

   ＆gt;＆gt;＆gt; exec（compile（'a = 5 \ na = 6'，'＆lt; string＆gt;'，'single'））
  Trackback（最近的最新电话）：
    文件“＆lt; stdin＆gt;”，第1行，in＆lt; module＆gt;
    文件“＆lt; string＆gt;”，第1行
      a = 5
          ^
  SyntaxError：编译单个语句时发现的多个语句
   

  这对于制作交互式Python壳非常有用。但是，即使您 eval> eval ，表达式的值是未返回的

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

---

除了将源代码编译到字节码外，编译支持编译 抽象的语法树 （Python代码的解析树）中代码对象；将源代码和抽象语法树（ ast.parse >编写为python），只需调用 compile（source，filename，mode，pycf_only_ast）））;例如，这些用于即时修改源代码，也用于动态代码创建，因为在复杂情况下通常更容易将代码作为节点树而不是文本行进行代码。

---

eval 仅允许您评估包含单个表达式的字符串，但您可以 eval 一个完整的语句，甚至可以 compile> compile 代码> d到bytecode;也就是说，使用Python 2， print 是一个语句，不能直接 led直接：

>>> 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'exec' /code>模式进入代码对象，您可以 eval it ; eval 功能将返回无。

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

如果一个人看和 exec source source source Cpython 3中的代码，这是非常明显的。他们都在使用相同参数的情况下调用 pyeval_evalcode ，唯一的区别是 exec 明确返回 none 。

Python 2和Python 3之间

exec 的语法差异在 是一个内置功能（两者都是Python 3中的内置功能）。
众所周知的事实是，python 2中的 exec 的官方语法是 exec code [in Globals [，当地人]] 。

与python 2-3 ， exec cpython 2中的语句也可以与外观 恰好的语法一起使用在Python 3中。原因是Python 0.9.9具有 exec（代码，全球，当地人）内置功能！并用 exec 语句在Python 1.0发行之前的某个地方。

由于希望不要与python 0.9.9，：如果代码是长度2或3的元组， Globals and code> 未传递到 exec 语句中，否则，代码将被解释为元组的第二个和第三个元素是 globals 和当地人分别。即使在;因此，在记录再次：：

第一个表达式也可能是长度2或3的元组。在这种情况下，必须省略可选零件。表单 exec（expr，Globals）等于 exec expr ，而表单 exec（expr，expr，globals，locals）是等效的到 GLOBALS中的Exec Expr，当地人。 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（也有密切的无证件行为）。

您在Pythons 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

： 始终返回无），或将引用传递到 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

滥用列表综合（使用循环的！）。

Answer 2

1. exec 不是一个表达式：python 2.x中的语句，而在python 3.x中的函数。它编译并立即评估字符串中包含的语句或一组语句。示例：

     exec（'print（5）'）＃打印5。
    ＃执行'PRINT 5'如果使用Python 2.x，则exec no ecec都不是print the Print属于函数
    exec（'print（5）\ nprint（6）'）＃打印5 {newline} 6。
    exec（'如果是true：print（6）'）＃打印6。
    exec（'5'）＃什么都不做，什么也没返回。
    

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

     x = eval（'5'）＃x＆lt;  -  5
    x = eval（'％d + 6'％x）＃x＆lt;  -  11
    x = eval（'abs（％d）'％-100）＃x＆lt;  -  100
    x = estar（'x = 5'）＃无效;分配不是表达式。
    x = estar（'如果1：x = 4'）＃无效;如果是陈述，而不是表达式。
    

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

4. compile（字符串，''，'eval'）返回如果您完成 eval（contry）（String）的代码对象。 。请注意，您不能在此模式下使用语句；只有（单个）表达式有效。

   


5. compile（字符串，'，'exec'）返回如果您完成 exec（String），将执行的代码对象。您可以在此处使用任何数量的语句。

6. compile（字符串，''，'single'）就像 exec 模式，但会完全期望一个表达式/语句，例如 compile（'a = 1如果1 else 3'，'myf'，mode ='single'）

Answer 3

Exec用于语句，不返回任何内容。
评估用于表达和返回表达的价值。

表达意味着“某物”，而语句则表示“做某事”。