?Dalam artikel ini, Encik Yun Duo akan belajar dengan anda dari dua aspek berikut.

• Cara Python’s eval() berfungsi
• Cara menggunakan eval() untuk mengira secara dinamik input berasaskan rentetan atau kod yang dikompilasi

Selain itu, siaran kemudian akan mempelajari cara menggunakan Python's ?eval()? untuk mengekodkan aplikasi yang menilai secara interaktif ungkapan matematik. Dengan contoh ini, kami akan menggunakan semua yang kami pelajari tentang eval() kepada masalah dunia sebenar.

Python’s eval()

Kita boleh menggunakan Python eval()[1] terbina dalam untuk menilai secara dinamik ungkapan daripada input berasaskan rentetan atau kod yang disusun. Jika kita menghantar rentetan kepada eval()?, maka fungsi itu menghuraikannya, menyusunnya kepada bytecode[2], dan menilainya sebagai ungkapan Python. Tetapi jika kita memanggil eval() dengan objek kod yang dihimpun, maka fungsi itu hanya melakukan langkah pengiraan, yang sangat mudah jika kita memanggil eval() beberapa kali dengan input yang sama.

Python’s eval() ditakrifkan seperti berikut.

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

Fungsi ini memerlukan parameter pertama, dipanggil ungkapan, yang mengandungi ungkapan yang perlu dikira. eval() juga memerlukan dua parameter pilihan.

1. globals
2. orang tempatan

Dalam kandungan berikut, kita akan mengetahui apakah parameter ini dan cara eval() menggunakannya untuk membuat instantiate Evaluate Python expression .

Nota: Kami juga boleh menggunakan exec()[3] untuk melaksanakan kod Python secara dinamik. Perbezaan utama antara eval()? dan exec()? ialah eval()? hanya boleh melaksanakan atau menilai ungkapan, manakala exec() boleh melaksanakan mana-mana bahagian kod Python.

Parameter pertama: ungkapan

Parameter pertama eval()? dipanggil ungkapan?, iaitu parameter yang diperlukan yang digunakan untuk menyimpan input Kod berasaskan rentetan atau kompilasi fungsi . Apabila eval() dipanggil, kandungan ungkapan dinilai sebagai ungkapan Python. Di bawah ialah contoh menggunakan input berasaskan rentetan.

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

Apabila eval()? dipanggil dengan rentetan sebagai parameter, fungsi mengembalikan hasil pengiraan pada rentetan input. Secara lalai, eval()? mempunyai akses kepada nama pembolehubah global, seperti x dalam contoh di atas.

Untuk menilai ungkapan berasaskan rentetan, eval() Python menjalankan langkah berikut.

1. Menghuraikan ungkapan
2. Kompilasikannya kepada bytecode
3. Nilainya sebagai ungkapan Python
4. Kembalikan hasil penilaian

Ungkapan parameter pertama eval() menekankan bahawa fungsi ini hanya bertindak pada ungkapan, bukan pernyataan majmuk [4]. Dokumentasi Python mentakrifkan ungkapan seperti berikut.

ungkapan

Sintaks yang boleh dinilai kepada nilai. Dalam erti kata lain, ungkapan ialah pengumpulan elemen ungkapan, seperti literal, nama, capaian harta, pengendali atau panggilan fungsi, yang kesemuanya mengembalikan nilai. Berbeza dengan banyak bahasa lain, tidak semua binaan bahasa adalah ungkapan. Terdapat juga beberapa pernyataan yang tidak boleh digunakan sebagai ungkapan, seperti while. Selain itu, tugasan juga merupakan pernyataan, bukan ungkapan.

Sebaliknya, pernyataan Python mempunyai definisi berikut.

penyataan

penyata ialah sebahagian daripada suite ("blok" kod). pernyataan ialah sama ada ungkapan atau salah satu daripada beberapa struktur dengan kata kunci, seperti jika, sementara, atau untuk.

Jika anda menghantar pernyataan kompaun kepada eval()?, anda akan mendapat SyntaxError. Contoh berikut menggunakan eval() untuk melaksanakan pernyataan if.

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

Ralat yang dilaporkan di atas adalah kerana eval() hanya menerima ungkapan. Sebarang pernyataan lain, seperti if, for, while, import, def, atau class, akan menimbulkan ralat.

Nota: Gelung for ialah pernyataan majmuk, tetapi kata kunci for juga boleh digunakan dalam terbitan, dalam hal ini ia dianggap sebagai ungkapan. Derivasi boleh dinilai menggunakan eval(), walaupun mereka menggunakan kata kunci for.

eval() juga tidak membenarkan operasi tugasan.

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

Jika kita lulus operasi tugasan sebagai parameter kepada eval()?, kita akan mendapat SyntaxError. Operasi tugasan ialah pernyataan, bukan ungkapan, dan pernyataan tidak dibenarkan digunakan dengan eval().

Anda juga mendapat SyntaxError apabila penghurai tidak memahami ungkapan input. Contoh berikut menilai ungkapan yang melanggar sintaks 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() 來(lái)計(jì)算它。

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

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

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

mode指定了我們想得到哪種編譯后的代碼。如果我們想用eval()?來(lái)處理編譯后的代碼，那么這個(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()? 來(lái)編譯要傳遞給eval()?的表達(dá)式，那么eval()會(huì)經(jīng)過(guò)以下步驟。

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í)間和過(guò)度的內(nèi)存消耗。

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

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

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

在字典中傳遞給 globals 的所有名字在執(zhí)行時(shí)都可以提供給 eval()? 。請(qǐng)看下面的例子，它展示了如何使用一個(gè)自定義的字典來(lái)為 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)部訪問(wèn)。這就是為什么當(dāng)你試圖在上述代碼中訪問(wèn) y 時(shí)，Python 會(huì)引發(fā)一個(gè) NameError。傳遞給 globals 的字典不包括 y。

可以通過(guò)在字典中列出名字來(lái)插入 globals，然后這些名字在求值過(guò)程中就會(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?沒(méi)有在當(dāng)前的全局范圍內(nèi)定義，但是這個(gè)變量在全局中的值是300，此時(shí)eval()?可以訪問(wèn)z，就像它是一個(gè)全局變量一樣。

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

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

下面的例子表明，即使給 globals 提供了一個(gè)空的字典，對(duì) eval() 的調(diào)用仍然可以訪問(wèn) 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í)就可以完全訪問(wèn)所有 Python 的內(nèi)置名字。

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

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

當(dāng)調(diào)用 eval()? 而不提供 globals 參數(shù)時(shí)，該函數(shù)使用 globals()? 返回的字典作為其全局命名空間來(lái)計(jì)算表達(dá)式。所以，在上面的例子中，我們可以自由地訪問(wèn) 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)可見(jiàn)。我們?cè)诰帉?xiě)函數(shù)時(shí)定義這些變量名。

因?yàn)?eval()? 已經(jīng)寫(xiě)好了，所以不能在它的代碼或局部范圍內(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è)局部變量。換句話說(shuō)，它被看作是在 eval() 中定義的一個(gè)變量。

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

和 globals 一樣，可以向 locals 傳遞任何可見(jiàn)的變量（全局、局部或非局部）。也可以傳遞自定義的鍵值對(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 字典。

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

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

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

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

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

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

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

在這一節(jié)中，我們將學(xué)習(xí)如何使用 Python 的 eval() 來(lái)計(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()來(lái)計(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() 來(lái)處理使用以下任何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()?來(lái)計(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è)常見(jiàn)用例是對(duì)基于字符串的輸入進(jìn)行 math? 表達(dá)式的計(jì)算。例如，創(chuàng)建一個(gè) Python 計(jì)算器，那么可以使用 eval() 來(lái)計(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()?來(lái)計(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)建、屬性訪問(wèn)、列表推導(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()??來(lái)執(zhí)行一些系統(tǒng)命令。我們可以用這個(gè)功能做大量有用的事情。然而，eval()也會(huì)有一些嚴(yán)重的安全風(fēng)險(xiǎn)，比如允許一個(gè)惡意的用戶在我們的機(jī)器中運(yùn)行系統(tǒng)命令或任何任意的代碼。

Atas ialah kandungan terperinci Fungsi eval Python secara dinamik menilai ungkapan matematik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!