Pythons eval()

Wir k?nnen das integrierte Python eval()[1] verwenden, um Ausdrücke aus stringbasierten oder kompilierten Code-basierten Eingaben dynamisch auszuwerten. Wenn wir einen String an eval() übergeben, analysiert die Funktion ihn, kompiliert ihn zu Bytecode[2] und wertet ihn als Python-Ausdruck aus. Wenn wir jedoch eval() mit einem kompilierten Codeobjekt aufrufen, führt die Funktion nur den Berechnungsschritt aus, was sehr praktisch ist, wenn wir eval() mehrmals mit derselben Eingabe aufrufen.

Pythons eval() ist wie folgt definiert.

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

Diese Funktion erfordert einen ersten Parameter namens Ausdruck, der den Ausdruck enth?lt, der berechnet werden muss. eval() erfordert au?erdem zwei optionale Parameter.

1. globals

2. locals

Im folgenden Inhalt erfahren wir, was diese Parameter sind und wie eval() sie verwendet, um Python-Ausdrücke im laufenden Betrieb auszuwerten.

Bitte beachten Sie: Python-Code kann dynamisch über exec()[3] ausgeführt werden. Der Hauptunterschied zwischen eval() und exec() besteht darin, dass eval() nur Ausdrücke ausführen oder auswerten kann, w?hrend exec() jeden beliebigen Teil des Python-Codes ausführen kann.

Erster Parameter: Ausdruck Der erste Parameter von

eval() hei?t Ausdruck, ein erforderlicher Parameter, der zum Speichern der stringbasierten oder codierungsbasierten Eingabe der Funktion verwendet wird. Bei Verwendung der Funktion eval() wertet Python den Ausdruck als Ausdruck aus. Unten finden Sie ein Beispiel für die Verwendung einer stringbasierten Eingabe.

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

Wenn eval() mit einer Zeichenfolge als Argument aufgerufen wird, gibt die Funktion das Ergebnis der Berechnung für die Eingabezeichenfolge zurück. Standardm??ig kann eval() auf globale Variablennamen zugreifen, wie z. B. x im obigen Beispiel.

Um einen stringbasierten Ausdruck auszuwerten, führt Pythons eval() die folgenden Schritte aus.

1. Parsen Sie den Ausdruck.

2. Kompilieren Sie ihn in Bytecode.

3. Bewerten Sie ihn als Python-Ausdruck Es wird nur für Ausdrücke verwendet, nicht für zusammengesetzte Anweisungen [4]. Die Python-Dokumentation definiert den Ausdruck wie folgt.

4. Ausdruck
   Eine Syntax, die auf einen bestimmten Wert berechnet werden kann. Ein Ausdruck besteht aus mehreren Elementen, einschlie?lich Literalen, Namen, Eigenschaftszugriffen, Operator- oder Funktionsaufrufen usw., deren kumulatives Ergebnis ein Wert ist. Im Gegensatz zu vielen anderen Sprachen sind nicht alle Sprachkonstrukte Ausdrücke. Es gibt auch einige Anweisungen, die nicht als Ausdrücke verwendet werden k?nnen, z. B. while. Darüber hinaus ist die Zuweisung auch eine Aussage und kein Ausdruck.

Andererseits hat die Python-Anweisung die folgende Definition.

Statement

Statement ist Teil einer Suite (einem Codeblock). Die Anweisung ist entweder ein Ausdruck oder eine von mehreren Strukturen mit Schlüsselw?rtern wie if, while oder for.

Wenn Sie eine zusammengesetzte Anweisung an eval() übergeben, erhalten Sie einen SyntaxError. Das folgende Beispiel verwendet eval(), um eine if-Anweisung auszuführen.

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

Der oben gemeldete Fehler liegt daran, dass eval() nur Ausdrücke akzeptiert. Wenn Sie eine andere Anweisung verwenden, z. B. if, for, while, import, def oder class, tritt ein Fehler auf.

Hinweis: Die for-Schleife ist eine zusammengesetzte Anweisung, aber das for-Schlüsselwort kann auch in einem Verst?ndnis verwendet werden. In diesem Fall wird es als Ausdruck betrachtet. For-Schleifenschlüsselw?rter k?nnen in Verst?ndnisausdrücken verwendet und mit eval() ausgewertet werden.

eval() erlaubt auch keine Zuweisungsoperationen.

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

Wenn wir eine Zuweisungsoperation als Parameter von eval() verwenden, tritt ein Syntaxfehler (SyntaxError) auf. Zuweisungsoperationen sind Anweisungen, keine Ausdrücke, und Anweisungen dürfen nicht mit eval() verwendet werden.

Wenn der Eingabeausdruck vom Parser nicht verstanden werden kann, kann ein SyntaxError ausgel?st werden. Das folgende Beispiel wertet einen Ausdruck aus, der gegen die Python-Syntax verst??t.

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

Sie k?nnen also keinen Ausdruck an eval() übergeben, der die Python-Syntax verletzt. Im obigen Beispiel wird ein SyntaxError ausgel?st, wenn wir versuchen, einen unvollst?ndigen Ausdruck (?5 + 7 *“) auszuwerten, weil der Parser die Syntax des Ausdrucks nicht versteht.

Wir k?nnen das kompilierte Codeobjekt auch an eval() übergeben. Sie k?nnen also die Funktion ?compile()[7]“ verwenden, eine integrierte Funktion, die die Eingabezeichenfolge in ein Codeobjekt[8] oder ein AST-Objekt[9] kompiliert, damit sie mit eval() ausgewertet werden kann.

Die Details zur Verwendung von ?compile()“ würden den Rahmen dieses Artikels sprengen, aber hier ist ein kurzer Blick auf die ersten drei notwendigen Parameter.

source speichert den Quellcode, den wir kompilieren m?chten. Dieser Parameter kann normale Zeichenfolgen, Bytezeichenfolgen [10] und AST-Objekte akzeptieren.

Dateiname gibt die Datei an, aus der der Code gelesen wird. Wenn wir eine stringbasierte Eingabe verwenden würden, sollte der Wert dieses Parameters ?

mode gibt an, welche Art von kompiliertem Code wir erhalten m?chten. Wenn Sie eval() zum Verarbeiten von kompiliertem Code verwenden m?chten, müssen Sie den Parameter auf ?eval“ setzen.

Wir k?nnen Compile() verwenden, um eval() ein Codeobjekt anstelle einer normalen Zeichenfolge bereitzustellen.

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

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

1. 計(jì)算編譯后的代碼

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

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

預(yù)編譯輸入表達(dá)式后連續(xù)多次調(diào)用eval()的執(zhí)行速度更快，因?yàn)槭÷粤酥貜?fù)的解析和編譯步驟。當(dāng)計(jì)算復(fù)雜的表達(dá)式時(shí)，不必要的重復(fù)計(jì)算會(huì)大大增加CPU時(shí)間和內(nèi)存消耗。

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

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

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

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

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

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

如果調(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是全局變量，在當(dāng)前的全局范圍內(nèi)可以隨意訪問。

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

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

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

在 eval() 的代碼或局部范圍內(nèi)添加局部變量名是不允許的，因?yàn)?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

第一個(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 "", line 1, inTypeError: eval() takes no keyword arguments

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

如果沒有傳遞字典給 locals 參數(shù)，它將默認(rèn)使用傳遞給 globals 參數(shù)的字典。這里有一個(gè)例子，給 globals 傳遞了一個(gè)空的字典，而 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ù)提供自定義字典，則它將默認(rèn)傳遞給globals參數(shù)的字典。因?yàn)?globals 持有空字典，所以現(xiàn)在無法通過 eval() 訪問 x。

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

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

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

當(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語句中，以檢查某些條件是否為真或假。由于布爾表達(dá)式不是復(fù)合語句，我們可以使用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è)條件語句，但我們想臨時(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() calculates the supplied condition using eval(), and returns a+b or a-b based on the result of the calculation.。在上面的例子中，只使用了幾個(gè)不同的條件，但還可以使用任何數(shù)量的其他條件，只要堅(jiān)持使用我們?cè)趂unc()中定義的名稱a和b。

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

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

常見的Python eval()用例之一是用于計(jì)算基于字符串的數(shù)學(xué)表達(dá)式。舉個(gè)例子，我們可以創(chuàng)建一個(gè) Python 計(jì)算器，利用 eval() 對(duì)用戶輸入進(jìn)行計(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() 函數(shù)來執(zhí)行一些操作系統(tǒng)命令。我們可以用這個(gè)功能做大量有用的事情。然而，eval()也會(huì)有一些嚴(yán)重的安全風(fēng)險(xiǎn)，比如允許一個(gè)惡意的用戶在我們的機(jī)器中運(yùn)行系統(tǒng)命令或任何任意的代碼。

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Python-Bewertungsfunktion. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!