Python eval()：动态评估表达式

目录

Pythoneval()允许您从基于字符串或基于编译代码的输入中评估任意 Python表达式。当您尝试从作为字符串或编译代码对象出现的任何输入动态评估 Python 表达式时，此函数会很方便。

尽管 Pythoneval()是一个非常有用的工具，但该函数具有一些重要的安全隐患，您在使用它之前应该考虑这些问题。在本教程中，您将了解它的eval()工作原理以及如何在 Python 程序中安全有效地使用它。

在本教程中，您将学习：

• Python 的eval()工作原理
• 如何使用eval()，以动态评估任意基于字符串或基于编译的代码输入
• 如何eval()使您的代码不安全以及如何最大程度地减少相关的安全风险

此外，您将学习如何使用 Pythoneval()编写交互式计算数学表达式的应用程序。通过此示例，您将把学到的所有知识应用eval()到实际问题中。如果您想获取此应用程序的代码，则可以单击下面的框：

理解 Python 的 eval()

您可以使用内置 Pythoneval()从基于字符串或基于编译代码的输入动态计算表达式。如果您将字符串传递给eval()，则该函数会解析它，将其编译为bytecode，并将其作为 Python 表达式进行计算。但是，如果您eval()使用编译后的代码对象调用，则该函数仅执行求值步骤，如果您eval()使用相同的输入多次调用，这将非常方便。

Python 的签名eval()定义如下：

eval(expression[, globals[, locals]])

该函数采用第一个参数，称为expression，它保存您需要计算的表达式。eval()还需要两个可选参数：

1. globals
2. locals

在接下来的三个部分中，您将了解这些参数是什么以及如何eval()使用它们即时评估 Python 表达式。

第一个论点： expression

的第一个参数eval()称为expression。它是一个必需的参数，用于保存函数的基于字符串或基于编译代码的输入。当您调用 时eval()， 的内容expression被评估为 Python 表达式。查看以下使用基于字符串的输入的示例：

>>> eval("2 ** 8")
256
>>> eval("1024 + 1024")
2048
>>> eval("sum([8, 16, 32])")
56
>>> x = 100
>>> eval("x * 2")
200

当您eval()使用字符串作为参数调用时，该函数将返回对输入字符串求值的结果。默认情况下，eval()可以访问x上面示例中的全局名称。

要评估基于字符串的expression，Pythoneval()运行以下步骤：

1. 解析 expression
2. 编译成字节码
3. 将其作为 Python 表达式进行评估
4. 返回评估结果

第expression一个参数的名称eval()强调了该函数仅适用于表达式而不适用于复合语句。的Python文档定义表达式如下：

表达

可以评估为某个值的一段语法。换句话说，表达式是表达式元素的累积，如文字、名称、属性访问、运算符或函数调用，它们都返回一个值。与许多其他语言相比，并非所有语言结构都是表达式。还有一些不能用作表达式的语句，例如while. 赋值也是语句，而不是表达式。（来源）

另一方面，Python语句具有以下定义：

陈述

语句是套件（代码“块”）的一部分。语句是一个表达式或几个带有关键字的结构之一，例如if,while或for。（来源）

如果您尝试将复合语句传递给eval()，那么您将得到一个SyntaxError. 看看下面的例子中，你试图执行的if语句使用eval()：

>>> x = 100
>>> eval("if x: print(x)")
  File "<string>", line 1
    if x: print(x)
    ^
SyntaxError: invalid syntax

如果您尝试使用 Python 的 评估复合语句eval()，那么您将SyntaxError在上面的traceback 中得到类似的结果。那是因为eval()只接受表达式。任何其他语句，例如if, for, while, import, def, or class，都会引发错误。

赋值操作不允许用于eval()：

>>> eval("pi = 3.1416")
  File "<string>", line 1
    pi = 3.1416
       ^
SyntaxError: invalid syntax

如果您尝试将赋值操作作为参数传递给 Python 的eval()，那么您将得到一个SyntaxError. 赋值操作是语句而不是表达式，并且语句不允许与eval().

SyntaxError每当解析器不理解输入表达式时，您也会得到一个。请看下面的示例，在该示例中，您尝试评估违反 Python 语法的表达式：

>>> # Incomplete expression
>>> eval("5 + 7 *")
  File "<string>", line 1
    5 + 7 *
          ^
SyntaxError: unexpected EOF while parsing

你不能传递一个eval()违反 Python 语法的表达式。在上面的示例中，您尝试计算一个不完整的表达式 ( "5 + 7 *") 并得到 a，SyntaxError因为解析器不理解该表达式的语法。

您还可以将编译后的代码对象传递给 Python 的eval(). 要编译您要传递给 的代码eval()，您可以使用compile(). 这是一个内置函数，可以将输入字符串编译为代码对象或AST 对象，以便您可以使用eval().

如何使用的细节compile()超出了本教程的范围，但这里快速浏览一下它的前三个必需参数：

1. source保存要编译的源代码。此参数接受普通字符串、字节字符串和 AST 对象。
2. filename给出从中读取代码的文件。如果要使用基于字符串的输入，则此参数的值应为"<string>".
3. mode指定要获得哪种编译代码。如果要使用 处理编译后的代码eval()，则应将此参数设置为"eval"。

您可以使用compile()代码对象来eval()代替普通字符串。查看以下示例：

>>> # Arithmetic operations
>>> code = compile("5 + 4", "<string>", "eval")
>>> eval(code)
9
>>> code = compile("(5 + 7) * 2", "<string>", "eval")
>>> eval(code)
24
>>> import math
>>> # Volume of a sphere
>>> code = compile("4 / 3 * math.pi * math.pow(25, 3)", "<string>", "eval")
>>> eval(code)
65449.84694978735

如果您compile()用来编译要传递给 的表达式eval()，则eval()执行以下步骤：

1. 评估编译的代码
2. 返回评估结果

如果您eval()使用基于编译代码的输入调用 Python ，则该函数执行评估步骤并立即返回结果。当您需要多次评估同一个表达式时，这会很方便。在这种情况下，最好预编译表达式并在后续调用eval().

如果您事先编译输入表达式，那么连续调用eval()将运行得更快，因为您不会重复解析和编译步骤。如果您正在评估复杂的表达式，不必要的重复会导致高 CPU 时间和过多的内存消耗。

第二个论点： globals

的第二个参数eval()称为globals。它是可选的，并拥有一个字典，提供了一个全球命名空间来eval()。使用globals，您可以判断eval()在评估时使用哪些全局名称expression。

全局名称是在您当前的全局范围或命名空间中可用的所有名称。您可以从代码中的任何位置访问它们。

传递给globals字典的所有名称eval()在执行时都可用。看看下面的例子，用它展示了如何提供一个全球性的自定义词典的命名空间来eval()：

>>> x = 100  # A global variable
>>> eval("x + 100", {"x": x})
200
>>> y = 200  # Another global variable
>>> eval("x + y", {"x": x})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'y' is not defined

如果您为 的globals参数提供自定义字典eval()，eval()则将仅将这些名称作为全局变量。无法从内部访问在此自定义字典之外定义的任何全局名称eval()。这就是为什么NameError当您尝试y在上面的代码中访问时Python 引发 a 的原因：传递给的字典globals不包含y.

您可以globals通过在字典中列出名称来插入名称，然后这些名称将在评估过程中可用。例如，如果您插入y到globals，则"x + y"上面示例中的 评估将按预期工作：

>>> eval("x + y", {"x": x, "y": y})
300

由于您添加y到您的自定义globals字典， 的评估"x + y"成功并且您获得 的预期返回值300。

您还可以提供当前全局范围内不存在的名称。为此，您需要为每个名称提供一个具体的值。eval()运行时将这些名称解释为全局名称：

>>> eval("x + y + z", {"x": x, "y": y, "z": 300})
600
>>> z
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'z' is not defined

即使z未在您当前的全局作用域中定义，该变量也会globals以300. 在这种情况下，eval()可以z像访问全局变量一样访问。

背后的机制globals相当灵活。您可以将任何可见变量（全局、本地或非本地）传递给globals. 您还可以像"z": 300上面的示例一样传递自定义键值对。eval()将所有这些都视为全局变量。

重要的一点globals是，如果您向其提供不包含 key 值的自定义字典"__builtins__"，则在解析之前builtins将自动插入对字典的引用。这确保在评估."__builtins__"expressioneval()expression

以下示例表明，即使您向 提供了一个空字典globals，对 的调用eval()仍然可以访问 Python 的内置名称：

>>> eval("sum([2, 2, 2])", {})
6
>>> eval("min([1, 2, 3])", {})
1
>>> eval("pow(10, 2)", {})
100

在上面的代码中，您向 提供了一个空字典 ( {}) globals。由于该字典不包含名为 的键"__builtins__"，Python 会自动插入一个引用builtins. 这样，eval()在解析expression.

如果调用时eval()未将自定义字典传递给globals，则参数将默认为在调用globals()的环境中返回的字典eval()：

>>> x = 100  # A global variable
>>> y = 200  # Another global variable
>>> eval("x + y")  # Access both global variables
300

当您在eval()不提供globals参数的情况下调用时，该函数expression使用返回的字典globals()作为其全局命名空间进行计算。因此，在上面的示例中，您可以自由访问x并且y因为它们是包含在当前全局范围内的全局变量。

>>> eval("x + 100", {}, {"x": 100})
200
>>> eval("x + y", {}, {"x": 100})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'y' is not defined

>>> eval("x + 100", locals={"x": 100})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: eval() takes no keyword arguments

>>> x = 100
>>> eval("x + 100", {})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'x' is not defined

>>> x = 100
>>> y = 100
>>> eval("x != y")
False
>>> eval("x < 200 and y > 100")
False
>>> eval("x is y")
True
>>> eval("x in {50, 100, 150, 200}")
True

>>> def func(a, b, condition):
...     if eval(condition):
...         return a + b
...     return a - b
...
>>> func(2, 4, "a > b")
-2
>>> func(2, 4, "a < b")
6
>>> func(2, 2, "a is b")
4

>>> # Arithmetic operations
>>> eval("5 + 7")
12
>>> eval("5 * 7")
35
>>> eval("5 ** 7")
78125
>>> eval("(5 + 7) / 2")
6.0
>>> import math
>>> # Area of a circle
>>> eval("math.pi * pow(25, 2)")
1963.4954084936207
>>> # Volume of a sphere
>>> eval("4 / 3 * math.pi * math.pow(25, 3)")
65449.84694978735
>>> # Hypotenuse of a right triangle
>>> eval("math.sqrt(math.pow(10, 2) + math.pow(15, 2))")
18.027756377319946

>>> # Run the echo command
>>> import subprocess
>>> eval("subprocess.getoutput('echo Hello, World')")
'Hello, World'
>>> # Launch Firefox (if available)
>>> eval("subprocess.getoutput('firefox')")
''

"__import__('subprocess').getoutput('rm –rf *')"

>>> # Avoid access to names in the caller's current scope
>>> x = 100
>>> eval("x * 5", {}, {})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'x' is not defined

>>> eval("sum([5, 5, 5])", {}, {})
15
>>> eval("__import__('math').sqrt(25)", {}, {})
5.0
>>> eval("__import__('subprocess').getoutput('echo Hello, World')", {}, {})
'Hello, World'

>>> eval("__import__('math').sqrt(25)", {"__builtins__": {}}, {})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name '__import__' is not defined

>>> "".__class__.__base__
<class 'object'>
>>> [].__class__.__base__
<class 'object'>
>>> {}.__class__.__base__
<class 'object'>
>>> ().__class__.__base__
<class 'object'>

>>> for sub_class in ().__class__.__base__.__subclasses__():
...     print(sub_class.__name__)
...
type
weakref
weakcallableproxy
weakproxy
int
...

>>> input_string = """[
...     c for c in ().__class__.__base__.__subclasses__()
...     if c.__name__ == "range"
... ][0](10)"""
>>> list(eval(input_string, {"__builtins__": {}}, {}))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> def eval_expression(input_string):
...     # Step 1
...     allowed_names = {"sum": sum}
...     # Step 2
...     code = compile(input_string, "<string>", "eval")
...     # Step 3
...     for name in code.co_names:
...         if name not in allowed_names:
...             # Step 4
...             raise NameError(f"Use of {name} not allowed")
...     return eval(code, {"__builtins__": {}}, allowed_names)

>>> eval_expression("3 + 4 * 5 + 25 / 2")
35.5
>>> eval_expression("sum([1, 2, 3])")
6
>>> eval_expression("len([1, 2, 3])")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 10, in eval_expression
NameError: Use of len not allowed
>>> eval_expression("pow(10, 2)")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 10, in eval_expression
NameError: Use of pow not allowed

>>> def eval_expression(input_string):
...     code = compile(input_string, "<string>", "eval")
...     if code.co_names:
...         raise NameError(f"Use of names not allowed")
...     return eval(code, {"__builtins__": {}}, {})
...
>>> eval_expression("3 + 4 * 5 + 25 / 2")
35.5
>>> eval_expression("sum([1, 2, 3])")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in eval_expression
NameError: Use of names not allowed

>>> from ast import literal_eval
>>> # Evaluating literals
>>> literal_eval("15.02")
15.02
>>> literal_eval("[1, 15]")
[1, 15]
>>> literal_eval("(1, 15)")
(1, 15)
>>> literal_eval("{'one': 1, 'two': 2}")
{'one': 1, 'two': 2}
>>> # Trying to evaluate an expression
>>> literal_eval("sum([1, 15]) + 5 + 8 * 2")
Traceback (most recent call last):
  ...
ValueError: malformed node or string: <_ast.BinOp object at 0x7faedecd7668>

>>> eval(input("Enter a math expression: "))
Enter a math expression: 15 * 2
30
>>> eval(input("Enter a math expression: "))
Enter a math expression: 5 + 8
13

首先，启动您最喜欢的代码编辑器。创建一个名为的新Python 脚本mathrepl.py，然后添加以下代码：

 1import math
 2
 3__version__ = "1.0"
 4
 5ALLOWED_NAMES = {
 6    k: v for k, v in math.__dict__.items() if not k.startswith("__")
 7}
 8
 9PS1 = "mr>>"
10
11WELCOME = f"""
12MathREPL {__version__}, your Python math expressions evaluator!
13Enter a valid math expression after the prompt "{PS1}".
14Type "help" for more information.
15Type "quit" or "exit" to exit.
16"""
17
18USAGE = f"""
19Usage:
20Build math expressions using numeric values and operators.
21Use any of the following functions and constants:
22
23{', '.join(ALLOWED_NAMES.keys())}
24"""

在这段代码中，您首先导入 Python 的math模块。该模块将允许您使用预定义的函数和常量执行数学运算。该常量ALLOWED_NAMES包含一个字典，其中包含 中的非特殊名称math。这样，您就可以将它们与eval().

您还定义了另外三个字符串常量。您将使用它们作为脚本的用户界面，并根据需要将它们打印到屏幕上。

现在您已准备好编写应用程序的核心功能。在这种情况下，您希望编写一个函数，该函数接收数学表达式作为输入并返回其结果。为此，您编写了一个名为 的函数evaluate()：

26def evaluate(expression):
27    """Evaluate a math expression."""
28    # Compile the expression
29    code = compile(expression, "<string>", "eval")
30
31    # Validate allowed names
32    for name in code.co_names:
33        if name not in ALLOWED_NAMES:
34            raise NameError(f"The use of '{name}' is not allowed")
35
36    return eval(code, {"__builtins__": {}}, ALLOWED_NAMES)

该函数的工作原理如下：

1. 在行26，你定义evaluate()。此函数将字符串expression作为参数并返回一个浮点数，该浮点数表示将字符串作为数学表达式求值的结果。

2. 在行29，你用compile()把输入的字符串expression为编译的Python代码。SyntaxError如果用户输入无效表达式，编译操作将引发 a 。

3. 在line 中32，您启动一​​个for循环来检查其中包含的名称expression并确认它们可以在最终表达式中使用。如果用户提供的名称不在允许的名称列表中，则您会引发NameError.

4. 在行36中，执行数学表达式的实际评价。请注意，您将自定义词典传递给globals并locals按照良好实践的建议。ALLOWED_NAMES保存中定义的函数和常量math。

使用自定义的值globals和locals参数，其名称在检查沿着线33，让您以最小的安全风险与使用相关eval()。

当您在main(). 在此函数中，您将定义程序的主循环并关闭读取和评估用户在命令行中输入的表达式的循环。

对于此示例，应用程序将：

1. 向用户打印欢迎信息
2. 显示准备读取用户输入的提示
3. 提供获取使用说明和终止应用程序的选项
4. 读取用户的数学表达式
5. 评估用户的数学表达式
6. 将评估结果打印到屏幕上

查看以下实现main()：

38def main():
39    """Main loop: Read and evaluate user's input."""
40    print(WELCOME)
41    while True:
42        # Read user's input
43        try:
44            expression = input(f"{PS1} ")
45        except (KeyboardInterrupt, EOFError):
46            raise SystemExit()
47
48        # Handle special commands
49        if expression.lower() == "help":
50            print(USAGE)
51            continue
52        if expression.lower() in {"quit", "exit"}:
53            raise SystemExit()
54
55        # Evaluate the expression and handle errors
56        try:
57            result = evaluate(expression)
58        except SyntaxError:
59            # If the user enters an invalid expression
60            print("Invalid input expression syntax")
61            continue
62        except (NameError, ValueError) as err:
63            # If the user tries to use a name that isn't allowed
64            # or an invalid value for a given math function
65            print(err)
66            continue
67
68        # Print the result if no error occurs
69        print(f"The result is: {result}")
70
71if __name__ == "__main__":
72    main()

在里面main()，您首先打印WELCOME消息。然后您在try语句中读取用户的输入以捕获KeyboardInterrupt和EOFError。如果发生这些异常中的任何一个，则您终止应用程序。

如果用户输入该help选项，则应用程序会显示您的USAGE指南。同样，如果用户输入quit或exit，则应用程序终止。

最后，您使用evaluate()评估用户的数学表达式，然后将结果打印到屏幕上。请务必注意，调用 可能evaluate()会引发以下异常：

• SyntaxError：当用户输入不遵循 Python 语法的表达式时会发生这种情况。
• NameError：当用户尝试使用不允许的名称（函数、类或属性）时会发生这种情况。
• ValueError：当用户尝试使用不允许的值作为math.

请注意，在 中main()，您捕获所有这些异常并相应地向用户打印消息。这将允许用户查看表达式、解决问题并再次运行程序。

而已！您已经使用 Python 的eval(). 要运行该应用程序，请打开系统的命令行并键入以下命令：

$ python3 mathrepl.py

此命令将启动数学表达式计算器的命令行界面(CLI)。您会在屏幕上看到类似这样的内容：

MathREPL 1.0, your Python math expressions evaluator!
Enter a valid math expression after the prompt "mr>>".
Type "help" for more information.
Type "quit" or "exit" to exit.

mr>>

到达那里后，您可以输入和计算任何数学表达式。例如，键入以下表达式：

mr>> 25 * 2
The result is: 50
mr>> sqrt(25)
The result is: 5.0
mr>> pi
The result is: 3.141592653589793

如果您输入有效的数学表达式，则应用程序会对其进行评估并将结果打印到您的屏幕上。如果您的表达式有任何问题，那么应用程序会告诉您：

mr>> 5 * (25 + 4
Invalid input expression syntax
mr>> sum([1, 2, 3, 4, 5])
The use of 'sum' is not allowed
mr>> sqrt(-15)
math domain error
mr>> factorial(-15)
factorial() not defined for negative values

在第一个示例中，您错过了右括号，因此您会收到一条消息，告诉您语法不正确。然后您调用sum()，这是不允许的，您会收到一条解释性错误消息。最后，您调用math具有无效输入值的函数，应用程序会生成一条消息，标识您输入中的问题。

好了，您的数学表达式评估器已准备就绪！随意添加一些额外的功能。一些帮助您入门的想法包括扩大允许名称的字典和添加更详细的警告消息。试一试，并在评论中告诉我们进展如何。

结论

您可以使用 Python从基于字符串或基于代码的输入eval()评估 Python表达式。当您尝试动态计算 Python 表达式并且希望避免从头开始创建自己的表达式计算器的麻烦时，此内置函数非常有用。

在本教程中，您学习了eval()工作原理以及如何安全有效地使用它来评估任意 Python 表达式。

您现在可以：

• 使用 Pythoneval()动态评估基本 Python 表达式
• 运行更复杂的语句像函数调用，对象的创建和属性访问使用eval()
• 最小化与使用 Python 相关的安全风险eval()

此外，您还编写了一个应用程序，该应用程序用于使用命令行界面eval()以交互方式计算数学表达式。您可以通过单击以下链接下载应用程序的代码：