Python's eval()

Nous pouvons utiliser le Python eval()[1] intégré pour extraire dynamiquement des données à partir de codes basés sur des cha?nes ou compilés. entrée basée. évaluer les expressions. Si nous transmettons une cha?ne à eval(), la fonction l'analyse, la compile en bytecode[2] et l'évalue comme une expression Python. Mais si nous appelons eval() avec un objet code compilé, alors la fonction effectue uniquement l'étape de calcul, ce qui est très pratique si nous appelons eval() plusieurs fois avec la même entrée.

L'eval() de Python est défini comme suit.

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

Cette fonction nécessite un premier paramètre, appelé expression, qui contient l'expression à calculer. eval() nécessite également deux paramètres facultatifs.

1. globals

2. locals

#?? ??# Dans ce qui suit, nous apprendrons quels sont ces paramètres et comment eval() les utilise pour évaluer les expressions Python à la volée.

Veuillez noter?: le code Python peut être exécuté dynamiquement via exec()[3]. La principale différence entre eval() et exec() est que eval() ne peut exécuter ou évaluer que des expressions, tandis que exec() peut exécuter n'importe quel morceau de code Python.

Premier paramètre?: expression

Le premier paramètre de eval() est appelé expression, qui est un paramètre obligatoire utilisé pour enregistrer le fichier basé sur une cha?ne ou basé sur compilé et entrée décodée. Lors de l'utilisation de la fonction eval(), Python évalue l'expression en tant qu'expression. Vous trouverez ci-dessous un exemple utilisant une entrée basée sur une cha?ne.

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

Lorsque eval() est appelée avec une cha?ne comme argument, la fonction renvoie le résultat d'une évaluation de la cha?ne d'entrée. Par défaut, eval() peut accéder aux noms de variables globales, tels que x dans l'exemple ci-dessus.

Pour évaluer une expression basée sur une cha?ne, eval() de Python exécute les étapes suivantes.

1. Analyser l'expression

2. Compilez-la en bytecode

3. évaluez-le comme une expression Python

4. Renvoyer le résultat du calcul

# ????#Le premier L'expression du paramètre de la fonction eval() souligne qu'elle n'est utilisée que pour les expressions, pas pour les instructions composées [4]. La documentation Python définit l'expression comme suit.

expression

Une syntaxe qui peut être évaluée à une certaine valeur. Une expression est composée de plusieurs éléments, notamment des littéraux, des noms, des accès aux propriétés, des appels d'opérateur ou de fonction, etc., dont le résultat cumulé est une valeur. Contrairement à de nombreux autres langages, toutes les constructions linguistiques ne sont pas des expressions. Certaines instructions ne peuvent pas non plus être utilisées comme expressions, comme while. De plus, l’affectation est également une déclaration et non une expression.

D'un autre c?té, l'instruction Python a la définition suivante.

statement

Statement fait partie d'une suite (un bloc de code).. L'instruction est soit une expression, soit l'une des nombreuses structures contenant des mots-clés, tels que if, while ou for.

Si vous transmettez une instruction composée à eval(), vous obtiendrez une SyntaxError. L'exemple suivant utilise eval() pour exécuter une instruction if.

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

L'erreur signalée ci-dessus est due au fait que eval() n'accepte que les expressions. Si vous utilisez une autre instruction, telle que if, for, while, import, def ou class, une erreur se produira.

Remarque : La boucle for est une instruction composée, mais le mot-clé for peut également être utilisé dans une compréhension, auquel cas il est considéré comme une expression. Les mots-clés de la boucle For peuvent être utilisés dans des expressions de compréhension et évalués à l'aide de eval().

eval() n'autorise pas non plus les opérations d'affectation.

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

Lorsque nous utilisons une opération d'affectation comme paramètre de eval(), une erreur de syntaxe (SyntaxError) se produira. Les opérations d'affectation sont des instructions, pas des expressions, et les instructions ne peuvent pas être utilisées avec eval().

Si l'expression d'entrée ne peut pas être comprise par l'analyseur, une SyntaxError peut être déclenchée. L'exemple suivant évalue une expression qui viole la syntaxe Python.

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

Donc, vous ne pouvez pas transmettre une expression qui viole la syntaxe Python à eval(). Dans l'exemple ci-dessus, une SyntaxError est levée lorsque nous essayons d'évaluer une expression incomplète ("5 + 7 *") car l'analyseur ne comprend pas la syntaxe de l'expression.

Nous pouvons également transmettre des objets de code compilé à eval() . Vous pouvez donc utiliser la fonction compile()[7], une fonction intégrée qui compile la cha?ne d'entrée en un objet code[8] ou un objet AST[9], afin qu'elle puisse être évaluée avec eval().

Les détails sur l'utilisation de compile() dépassent le cadre de cet article, mais voici un aper?u rapide de ses trois premiers paramètres nécessaires.

source Enregistrez le code source que nous souhaitons compiler. Ce paramètre peut accepter des cha?nes ordinaires, des cha?nes d'octets [10] et des objets AST.

filename donne le fichier à partir duquel le code est lu. Si nous allons utiliser une entrée basée sur une cha?ne, alors la valeur de ce paramètre doit être "

".

mode spécifie le type de code compilé que nous voulons obtenir. Si vous souhaitez utiliser eval() pour traiter le code compilé, vous devez définir le paramètre sur "eval".

Nous pouvons utiliser compile() pour fournir un objet code à eval() au lieu d'une cha?ne normale.

>>> # 算術(shù)運算
>>> code = compile("5 + 4", "", "eval")
>>> eval(code)
9
>>> code = compile("(5 + 7) * 2", "", "eval")
>>> eval(code)
24
>>> import math
>>> # 一個球體的體積
>>> code = compile("4 / 3 * math.pi * math.pow(25, 3)", "", "eval")
>>> eval(code)
65449.84694978735

當我們通過 compile() 進行表達式編譯后，eval() 將按照以下順序執(zhí)行。

1. 計算編譯后的代碼

2. 返回計算的結(jié)果

如果使用編譯碼為輸入并調(diào)用 eval()，那么該函數(shù)將執(zhí)行操作并立即返回結(jié)果。當需要多次計算同一個表達式時，這可能很方便。為了最佳效果，在接下來的 eval() 調(diào)用中，最好預(yù)先編譯表達式并重用所生成的字節(jié)碼。

預(yù)編譯輸入表達式后連續(xù)多次調(diào)用eval()的執(zhí)行速度更快，因為省略了重復(fù)的解析和編譯步驟。當計算復(fù)雜的表達式時，不必要的重復(fù)計算會大大增加CPU時間和內(nèi)存消耗。

第二個參數(shù)：globals

eval() 的第二個參數(shù) globals，可選的，字典類型，為 eval() 提供一個全局命名空間。使用 globals 可以指定在 eval() 計算表達式時使用哪些全局變量名。

全局變量名是所有那些在當前全局范圍或命名空間中可用的變量名。可以從代碼的任何地方訪問它們。

所有在 globals 中傳遞給字典的名稱都可以在 eval() 執(zhí)行時提供。下面是一個例子，展示如何利用自定義字典為 eval() 提供全局命名空間。

>>> x = 100# 一個全局變量
>>> eval("x + 100", {"x": x})
200
>>> y = 200# 另一個全局變量
>>> eval("x + y", {"x": x})
Traceback (most recent call last):
File "", line 1, inFile "", line 1, inNameError: name 'y' is not defined

如果為 eval() 的 globals 參數(shù)提供一個自定義字典，那么 eval() 將只接受這些名字作為 globals。在這個自定義字典之外定義的任何全局變量名都不能從 eval() 內(nèi)部訪問。這就是為什么當你試圖在上述代碼中訪問 y 時，Python 會引發(fā)一個 NameError。傳遞給 globals 的字典不包括 y。

可以通過在字典中列出名字來插入 globals，然后這些名字在求值過程中就會出現(xiàn)。例如，如果在 globals 中插入了 y，那么在上面的例子中對 "x + y" 的求值將如期進行。

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

因為把 y 添加到了自定義 globals 字典中，所以成功計算 "x + y" 的值，得到的預(yù)期返回值 300。

我們也可以提供不存在于當前全局范圍的變量名。此時需要為每個名字提供一個具體的值。eval()在運行時將把這些變量名解釋為全局變量名。

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

盡管z沒有在當前的全局范圍內(nèi)定義，但是這個變量在全局中的值是300，此時eval()可以訪問z，就像它是一個全局變量一樣。

globals 背后的機制是相當靈活的，可以向 globals 傳遞任何可見的變量（全局、局部、或者非局部）。還可以傳遞自定義的鍵值對，比如上面例子中的 "z": 300，那么eval() 將把它們?nèi)孔鳛槿肿兞刻幚怼?/p>

關(guān)于 globals 中的注意事項，如果我們提供給它的自定義字典不包含鍵值 "__builtins__"，那么在表達式被解析之前，對內(nèi)置字典的引用將自動插入 "__builtins__" 下面。這可以確保 eval() 在計算表達式時可以完全訪問所有的 Python 內(nèi)置變量名。

下面的例子表明，即使給 globals 提供了一個空的字典，對 eval() 的調(diào)用仍然可以訪問 Python 的內(nèi)置變量名。

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

我們已經(jīng)提供了一個空字典 ({}) 給 globals 在上述代碼中。由于這個字典不包含一個叫做 "__builtins__" 的鍵，Python 會自動插入一個指向 builtins 中名字的引用。通過這種方式，eval() 能夠完全獲取到所有 Python 內(nèi)置名稱，以便解析表達式。

如果調(diào)用 eval() 而沒有將自定義字典傳遞給 globals ，那么參數(shù)將默認為在調(diào)用 eval()的環(huán)境中 globals() 返回的字典:

>>> x = 100#一個全局變量
>>> y = 200# 另一個全局變量
>>> eval("x + y")# 訪問兩個全局變量
300

當調(diào)用 eval() 而不提供 globals 參數(shù)時，該函數(shù)使用 globals() 返回的字典作為其全局命名空間來計算表達式。在上述示例中，x和y是全局變量，在當前的全局范圍內(nèi)可以隨意訪問。

第三個參數(shù)：locals

Python 的函數(shù) eval() 可以通過第三個可選參數(shù) locals 傳入一個字典類型的參數(shù)。此時這個字典包含了 eval() 在計算表達式時作為局部變量名使用的變量。

我們在一個函數(shù)內(nèi)定義的名稱（變量、函數(shù)、類等等）就是局部變量名。局部名稱只在封閉的函數(shù)內(nèi)可見。我們在編寫函數(shù)時定義這些變量名。

在 eval() 的代碼或局部范圍內(nèi)添加局部變量名是不允許的，因為 eval() 已經(jīng)被編寫完成?？梢酝ㄟ^將字典傳遞給locals，讓eval()將這些名稱視為本地名稱。

>>> eval("x + 100", {}, {"x": 100})
200
>>> eval("x + y", {}, {"x": 100})
Traceback (most recent call last):
File "", line 1, inFile "", line 1, inNameError: name 'y' is not defined

第一個調(diào)用 eval() 的第二個字典保存了變量 x。這個變量被 eval() 解釋為一個局部變量。換句話說，它被看作是在 eval() 中定義的一個變量。

我們可以在表達式中使用 x，并且 eval() 可以訪問它。相反，如果使用y，那么會得到一個 NameError，因為y沒有定義在 globals 命名空間或 locals 命名空間。

和 globals 一樣，可以向 locals 傳遞任何可見的變量（全局、局部或非局部）。也可以傳遞自定義的鍵值對，比如 "x"。eval()將把它們?nèi)孔鳛榫植孔兞刻幚怼?/p>

注意，要給 locals 提供一個字典，首先需要給 globals 提供一個字典。不能在 eval() 中使用關(guān)鍵字參數(shù)。

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

若在使用關(guān)鍵字參數(shù)來調(diào)用 eval()，則會引發(fā) TypeError 異常。這是因為 eval() 不接受關(guān)鍵字參數(shù)，所以在提供 locals 字典之前，需要先提供一個 globals 字典。

如果沒有傳遞字典給 locals 參數(shù)，它將默認使用傳遞給 globals 參數(shù)的字典。這里有一個例子，給 globals 傳遞了一個空的字典，而 locals 沒有傳遞任何值。

>>> x = 100
>>> eval("x + 100", {})
Traceback (most recent call last):
File "", line 1, inFile "", line 1, inNameError: name 'x' is not defined

如果沒有為locals參數(shù)提供自定義字典，則它將默認傳遞給globals參數(shù)的字典。因為 globals 持有空字典，所以現(xiàn)在無法通過 eval() 訪問 x。

globals 和 locals 之間的主要實際區(qū)別是，如果"__builtins__"鍵不存在，Python 會自動插入 globals 中。這個事件將會發(fā)生，不論我們是否提供一個定制的字典給 globals。此外，如果我們給 locals 提供了一個自定義的字典，那么在執(zhí)行 eval() 的過程中，這個字典將保持不變。

用 eval() 計算表達式

我們可以使用Python的eval()來計算任何一種Python表達式，但不包括Python語句，如基于關(guān)鍵字的復(fù)合語句或賦值語句。

當我們需要動態(tài)地計算表達式，而使用其它 Python 技術(shù)或工具會大大增加我們的開發(fā)時間和精力時，eval() 可以很方便。

在這一節(jié)中，我們將學(xué)習(xí)如何使用 Python 的 eval() 來計算布爾、數(shù)學(xué)和通用的 Python 表達式。

布爾表達式

布爾表達式 是Python表達式，當解釋器對其進行計算時返回一個真值(True 或者 False)。它們通常用在if語句中，以檢查某些條件是否為真或假。由于布爾表達式不是復(fù)合語句，我們可以使用eval()來計算它們。

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

我們可以用 eval() 來處理使用以下任何Python運算符的布爾表達式。

• 值比較運算符：< , > ,

  <=,>=, ==, !=

• 邏輯（布爾）運算符：and,or,not

• 成員測試運算符：in,not in

• 身份運算符：is,is not

在所有情況下，該函數(shù)都會返回正在計算的表達式的真值。

我們思考，為什么我應(yīng)該使用eval()而不是直接使用布爾表達式呢？假設(shè)需要實現(xiàn)一個條件語句，但我們想臨時改變條件。

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

Func() calculates the supplied condition using eval(), and returns a+b or a-b based on the result of the calculation.。在上面的例子中，只使用了幾個不同的條件，但還可以使用任何數(shù)量的其他條件，只要堅持使用我們在func()中定義的名稱a和b。

現(xiàn)在想象一下，如果不使用Python的eval()，我們將如何實現(xiàn)這樣的東西。那會花更少的代碼和時間嗎？不可能！

數(shù)學(xué)表達式

常見的Python eval()用例之一是用于計算基于字符串的數(shù)學(xué)表達式。舉個例子，我們可以創(chuàng)建一個 Python 計算器，利用 eval() 對用戶輸入進行計算，并返回結(jié)果。

下面的例子演示了如何使用eval()與數(shù)學(xué)一起進行math運算。

>>> # Arithmetic operations
>>> eval("5 + 7")
12
>>> eval("5 * 7")
35
>>> eval("5 ** 7")
78125
>>> eval("(5 + 7) / 2")
6.0
>>> import math
>>> # 一個圓的面積
>>> eval("math.pi * pow(25, 2)")
1963.4954084936207
>>> # 球體的體積
>>> eval("4 / 3 * math.pi * math.pow(25, 3)")
65449.84694978735
>>> # 直角三角形的斜邊
>>> eval("math.sqrt(math.pow(10, 2) + math.pow(15, 2))")
18.027756377319946

當我們使用eval()來計算數(shù)學(xué)表達式時，我們可以傳入任何種類或復(fù)雜程度的表達式，eval()會解析它們，計算它們，如果一切正常，就會給我們預(yù)期結(jié)果。

通用表達式

前面我們已經(jīng)學(xué)會了如何在布爾和 math 表達式中使用 eval() 。然而，我們可以在更復(fù)雜的 Python 表達式中使用 eval() ，這些表達式包括函數(shù)調(diào)用、對象創(chuàng)建、屬性訪問、列表推導(dǎo)式等等。

例如，可以調(diào)用一個內(nèi)置函數(shù)或用標準或第三方模塊導(dǎo)入的函數(shù)。

>>> # 運行echo命令
>>> import subprocess
>>> eval("subprocess.getoutput('echo Hello, World')")
'Hello, World'
>>> # 啟動Firefox（如果有的話）
>>> eval("subprocess.getoutput('firefox')")
''

在這個例子中，我們使用 Python 的 eval() 函數(shù)來執(zhí)行一些操作系統(tǒng)命令。我們可以用這個功能做大量有用的事情。然而，eval()也會有一些嚴重的安全風(fēng)險，比如允許一個惡意的用戶在我們的機器中運行系統(tǒng)命令或任何任意的代碼。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!