python 內置函數eval()、exec()、compile()

 eval

函數的作用：

    計算指定表達式的值。也就是說它要執行的python代碼只能是單個表達式，而不是復雜的代碼邏輯。
    eval(source, globals=None, locals=None, /)

參數說明：
    source：必選參數，可以是字符串，也可以是一個任意的code(代碼)對象實例（可以通過complie函數創建）。
    如果它是一個字符串，它會被當作一個（使用globals和locals參數作為全局和本地命名空間的）python表達式進行分析和解釋。

    globals：可選參數，表示全局命名空間（存放全局變量），如果被提供，則必須是一個字典對象。

    locals：可選參數，表示全局命名空間（存放局部變量），如果被提供，可以是任何映射對象。如果參數被忽略，那么它將會取與globals相同的值。

    如果globals與locals都被忽略，那么它們將取eval()函數被調用環境下的全局命名空間和局部命名空間。

 

返回值：
    如果source是一個code對象，且創建該code對象時，complie函數的mode參數是‘exec’，那么eval()函數的返回值是None；

    否則，如果source是一個輸出語句，如print()，則eval()返回結果為None；

    否則，source表達式的結果就是eval()函數的返回值

 

A. 能夠實現以下轉換：

    str --> list
    str --> dict
    str --> tuple

 

將str類型轉換為list

li = '[1,2,3,4]'

print(eval(li))
print(type(eval(li)))

# 執行結果：
# [1, 2, 3, 4]
# <class 'list'>

 

將str類型轉換為dict

dic = "{'a':1, 'b':2, 'c':3}"

print(eval(dic))
print(type(eval(dic)))

# 執行結果：
# {'c': 3, 'a': 1, 'b': 2}
# <class 'dict'>

 

將str類型轉換為tuple

tu = '(1, 2, 3, 4, 5)'

print(eval(tu))
print(type(eval(tu)))

# 執行結果：
# (1, 2, 3, 4, 5)
# <class 'tuple'>

 

B. 如果str是python解釋器能夠識別的代碼，則直接執行代碼

s1 = 'print("hello world")'
eval(s1)

# 執行結果：
# hello world

 

基於 eval 有這樣的潛在功能，應該盡量少用 eval，避免造成安全漏洞

 

C. 如果str是python能夠識別的計算表達式，則直接計算出結果

s1 = '1+2+3+4'

print(eval(s1))

# 執行結果：
# 10

 

 exec

函數的作用：
    動態執行python代碼，也就是說exec可以執行復雜的python代碼，而不像eval函數那樣只能計算一個表達式的值
    
exec(source, globals=None, locals=None, /)

source：必選參數，表示需要被指定的python代碼。它必須是字符串或code對象。如果source是一個字符串，
該字符串會先被解析為一組python語句，然后執行。如果source是一個code對象，那么它只是被簡單的執行。

返回值：

exec函數的返回值永遠為None。

eval()函數和exec()函數的區別：

eval()函數只能計算單個表達式的值，而exec()函數可以動態運行代碼段。

eval()函數可以有返回值，而exec()函數返回值永遠為None。

x = 10
def func():
    y = 20
    a = exec("x+y")
    print("a:",a)
    b = exec("x+y",{"x":1,"y":2})
    print("b:",b)
    c = exec("x+y",{"x":1,"y":2},{"y":3,"z":4})
    print("c:",c)
    d = exec("print(x,y)")
    print("d:",d)
func()

# exec 不會有任何返回值

# 執行結果：
# a: None
# b: None
# c: None
# 10 20
# d: None

 

exec能夠執行復雜的python代碼

x = 10
expr = """
z = 30
sum = x + y + z   #一大包代碼
print(sum)
"""
def func():
    y = 20
    exec(expr)   #10+20+30
    exec(expr,{'x':1,'y':2}) #30+1+2
    exec(expr,{'x':1,'y':2},{'y':3,'z':4}) #30+1+3，x是定義全局變量1，y是局部變量

func()

# 執行結果：
# 60  # 10+20+30
# 33  # 30+1+2
# 34  # 30+1+3

 

 complie函數

函數的作用：

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

 

參數說明：

source：字符串或AST對象，表示需要進行編譯的python代碼

filename：指定需要編譯的代碼文件，如果不是文件讀取代碼則傳遞一些可辨認的值。

mode：用於標識必須當做那類代表來編譯；如果source是由一個代碼語句序列組成，則指定mode=‘exec’，
如果source由單個表達式組成，則指定mode=‘eval’；如果source是由一個單獨的交互式語句組成，則指定modo=‘single’。必須要制定，不然肯定會報錯。

s = """              #一大段代碼
for x in range(10):
    print(x, end='')  
print()
"""
code_exec = compile(s, '<string>', 'exec')   #必須要指定mode，指定錯了和不指定就會報錯。
code_eval = compile('10 + 20', '<string>', 'eval')   #單個表達式
code_single = compile('name = input("Input Your Name: ")', '<string>', 'single')   #交互式

a = exec(code_exec)   使用的exec，因此沒有返回值
b = eval(code_eval)  

c = exec(code_single)  交互
d = eval(code_single)

print('a: ', a)
print('b: ', b)
print('c: ', c)
print('name: ', name)
print('d: ', d)
print('name; ', name)


執行結果：
0123456789
Input Your Name: hkey
Input Your Name: hkey
a:  None
b:  30
c:  None
name:  hkey
d:  None
name;  hkey