?Dans cet article, M. Yun Duo étudiera avec vous sous les deux aspects suivants.

• Comment fonctionne eval() de Python
• Comment utiliser eval() pour calculer dynamiquement une entrée basée sur une cha?ne arbitraire ou basée sur un code compilé

De plus, les tweets ultérieurs apprendront comment utiliser Python ensemble? eval ()? pour coder une application qui évalue de manière interactive des expressions mathématiques. Avec cet exemple, nous appliquerons tout ce que nous avons appris sur eval() à un problème du monde réel.

Python's eval()

Nous pouvons utiliser le Python eval()[1] intégré pour évaluer dynamiquement des expressions à partir d'une entrée basée sur une cha?ne ou basée sur un code compilé. Si nous transmettons une cha?ne à eval()?, alors 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 le contenu suivant, nous apprendrons quels sont ces paramètres et comment eval() les utilise pour évaluer les expressions Python à la volée.

Remarque?: nous pouvons également utiliser exec()[3] pour exécuter dynamiquement du code Python. 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

eval()? Le premier paramètre est appelé expression?, qui est un paramètre obligatoire utilisé pour enregistrer l'entrée basée sur une cha?ne ou une compilation de la fonction. Lorsque eval()? est appelé, le contenu de l'expression est évalué comme une expression Python. 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 du calcul sur 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-la comme une expression Python
4. Renvoyer le résultat du calcul

La première expression de paramètre de eval() souligne que cette fonction ne fonctionne que C'est une expression, pas une déclaration composée [4]. La documentation Python définit l'expression comme suit.

expression

Une syntaxe qui peut être calculée jusqu'à une certaine valeur. En d’autres termes, une expression est une accumulation d’éléments d’expression, tels que des littéraux, des noms, des accès à des propriétés, des opérateurs ou des appels de fonction, qui renvoient tous 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'autre part, 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 "<string>", 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. Toute autre instruction, telle que if, for, while, import, def ou class, générera une erreur.

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 dérivations peuvent être évaluées à l’aide de eval()?, même si elles utilisent le mot-clé for.

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

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

Si nous passons une opération d'affectation en paramètre à eval()?, nous obtiendrons une SyntaxError. Les opérations d'affectation sont des instructions, pas des expressions, et les instructions ne peuvent pas être utilisées avec eval().

Vous obtiendrez également une SyntaxError lorsque l'analyseur ne comprend pas l'expression d'entrée. L'exemple suivant évalue une expression qui viole la syntaxe Python.

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

所以，不能把一個(gè)違反 Python 語(yǔ)法的表達(dá)式傳給 eval()? 。在上面的例子中，我們嘗試計(jì)算一個(gè)不完整的表達(dá)式 ("5 + 7 *") 時(shí)拋出一個(gè) SyntaxError，因?yàn)榉治銎鞑焕斫獗磉_(dá)式的語(yǔ)法。

我們也可以把已編譯的代碼對(duì)象傳遞給 eval()? 。因此可以使用函數(shù) compile()[7] ，一個(gè)內(nèi)置函數(shù)，可以將輸入的字符串編譯成代碼對(duì)象[8] 或 AST 對(duì)象[9]，這樣就可以用 eval() 來計(jì)算它。

如何使用compile()的細(xì)節(jié)超出了本文的范圍，但這里可以快速了解一下它的前三個(gè)必要參數(shù)。

source保存我們要編譯的源代碼。這個(gè)參數(shù)可以接受普通字符串、字節(jié)字符串[10]和AST對(duì)象。

filename給出讀取代碼的文件。如果我們要使用一個(gè)基于字符串的輸入，那么這個(gè)參數(shù)的值應(yīng)該是""。

mode指定了我們想得到哪種編譯后的代碼。如果我們想用eval()?來處理編譯后的代碼，那么這個(gè)參數(shù)應(yīng)該被設(shè)置為"eval"。

我們可以使用 compile()? 向eval()提供代碼對(duì)象，而不是普通的字符串。

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

如果我們使用 compile()? 來編譯要傳遞給eval()?的表達(dá)式，那么eval()會(huì)經(jīng)過以下步驟。

1. 計(jì)算編譯后的代碼
2. 返回計(jì)算的結(jié)果

如果使用基于編譯碼的輸入調(diào)用 eval()? ，那么該函數(shù)會(huì)執(zhí)行計(jì)算步驟并立即返回結(jié)果。當(dāng)需要多次計(jì)算同一個(gè)表達(dá)式時(shí)，這可能很方便。在這種情況下，最好預(yù)先編譯表達(dá)式，并在隨后調(diào)用 eval() 時(shí)重復(fù)使用產(chǎn)生的字節(jié)碼。

如果我們事先編譯了輸入表達(dá)式，那么連續(xù)調(diào)用eval()將運(yùn)行得更快，因?yàn)槲覀儾粫?huì)重復(fù)解析和編譯的步驟。如果我們正在計(jì)算復(fù)雜的表達(dá)式，不需要的重復(fù)會(huì)導(dǎo)致高的CPU時(shí)間和過度的內(nèi)存消耗。

第二個(gè)參數(shù)：globals

eval()? 的第二個(gè)參數(shù) globals，可選的，字典類型，為 eval()? 提供一個(gè)全局命名空間。通過 globals 告訴 eval() 在計(jì)算表達(dá)式時(shí)要使用哪些全局變量名。

全局變量名是所有那些在當(dāng)前全局范圍或命名空間中可用的變量名?？梢詮拇a的任何地方訪問它們。

在字典中傳遞給 globals 的所有名字在執(zhí)行時(shí)都可以提供給 eval()? 。請(qǐng)看下面的例子，它展示了如何使用一個(gè)自定義的字典來為 eval() 提供一個(gè)全局命名空間。

>>> x = 100# 一個(gè)全局變量
>>> eval("x + 100", {"x": x})
200
>>> y = 200# 另一個(gè)全局變量
>>> 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

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

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

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

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

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

>>> 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?沒有在當(dāng)前的全局范圍內(nèi)定義，但是這個(gè)變量在全局中的值是300，此時(shí)eval()?可以訪問z，就像它是一個(gè)全局變量一樣。

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

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

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

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

在上面的代碼中，我們向 globals 提供了一個(gè)空的字典 ({}?)。由于這個(gè)字典不包含一個(gè)叫做 "__builtins__?" 的鍵，Python 會(huì)自動(dòng)插入一個(gè)指向 builtins 中名字的引用。這樣，eval() 在解析表達(dá)式時(shí)就可以完全訪問所有 Python 的內(nèi)置名字。

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

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

當(dāng)調(diào)用 eval()? 而不提供 globals 參數(shù)時(shí)，該函數(shù)使用 globals()? 返回的字典作為其全局命名空間來計(jì)算表達(dá)式。所以，在上面的例子中，我們可以自由地訪問 x? 和 y，因?yàn)樗鼈兪前谖覀儺?dāng)前全局范圍內(nèi)的全局變量。

第三個(gè)參數(shù)：locals

Python 的 eval()? 第三個(gè)參數(shù) locals ，可選參數(shù)，字典類型。此時(shí)這個(gè)字典包含了 eval() 在計(jì)算表達(dá)式時(shí)作為局部變量名使用的變量。

局部變量名是那些我們?cè)谝粋€(gè)給定的函數(shù)內(nèi)定義的名稱（變量、函數(shù)、類等等）。局部名稱只在封閉的函數(shù)內(nèi)可見。我們?cè)诰帉懞瘮?shù)時(shí)定義這些變量名。

因?yàn)?eval()? 已經(jīng)寫好了，所以不能在它的代碼或局部范圍內(nèi)添加局部變量名。然而可以向 locals? 傳遞一個(gè)字典，eval()會(huì)把這些名字當(dāng)作本地名字。

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

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

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

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

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

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

如果在調(diào)用 eval()? 時(shí)使用關(guān)鍵字參數(shù)，那么拋出一個(gè) TypeError。這是因?yàn)?eval() 不接受關(guān)鍵字參數(shù)，所以在提供 locals 字典之前，需要先提供一個(gè) globals 字典。

如果沒有給 locals 傳遞一個(gè)字典，那么它就默認(rèn)為傳遞給 globals 的字典。這里有一個(gè)例子，給 globals 傳遞了一個(gè)空的字典，而 locals 沒有傳遞任何值。

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

鑒于沒有給 locals 提供一個(gè)自定義的字典，這個(gè)參數(shù)默認(rèn)為傳遞給 globals 的字典。此時(shí)eval()? 無(wú)法訪問 x，因?yàn)?globals 持有一個(gè)空的字典。

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

用 eval() 計(jì)算表達(dá)式

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

當(dāng)我們需要?jiǎng)討B(tài)地計(jì)算表達(dá)式，而使用其它 Python 技術(shù)或工具會(huì)大大增加我們的開發(fā)時(shí)間和精力時(shí)，eval() 可以很方便。

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

布爾表達(dá)式

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

>>> 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運(yùn)算符的布爾表達(dá)式。

• 值比較運(yùn)算符：< , > , <=, >=, ==, !=
• 邏輯（布爾）運(yùn)算符：and?,or?,not
• 成員測(cè)試運(yùn)算符：in?,not in
• 身份運(yùn)算符：is?,is not

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

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

>>> 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()?中，使用eval()?來計(jì)算所提供的條件，并根據(jù)計(jì)算的結(jié)果返回a+b?或a-b?。在上面的例子中，只使用了幾個(gè)不同的條件，但還可以使用任何數(shù)量的其他條件，只要堅(jiān)持使用我們?cè)趂unc()?中定義的名稱a?和b。

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

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

Python 的 eval()? 的一個(gè)常見用例是對(duì)基于字符串的輸入進(jìn)行 math? 表達(dá)式的計(jì)算。例如，創(chuàng)建一個(gè) Python 計(jì)算器，那么可以使用 eval() 來計(jì)算用戶的輸入并返回計(jì)算結(jié)果。

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

>>> # Arithmetic operations
>>> eval("5 + 7")
12
>>> eval("5 * 7")
35
>>> eval("5 ** 7")
78125
>>> eval("(5 + 7) / 2")
6.0
>>> import math
>>> # 一個(gè)圓的面積
>>> 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

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

通用表達(dá)式

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

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

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

在這個(gè)例子中，我們使用 Python 的?eval()??來執(zhí)行一些系統(tǒng)命令。我們可以用這個(gè)功能做大量有用的事情。然而，eval()也會(huì)有一些嚴(yán)重的安全風(fēng)險(xiǎn)，比如允許一個(gè)惡意的用戶在我們的機(jī)器中運(yùn)行系統(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!