摘要：在工作中有時(shí)候會(huì)遇到一種情況動(dòng)態(tài)地進(jìn)行變量賦值不管是局部變量還是全局變量在我們絞盡腦汁的時(shí)候已經(jīng)為我們解決了這個(gè)問題的命名空間通過一種字典的形式來體現(xiàn)而具體到函數(shù)也就是和分別對(duì)應(yīng)著局部命名空間和全局命名空間于是我們也就能通過這些方法去實(shí)現(xiàn)我

在工作中, 有時(shí)候會(huì)遇到一種情況: 動(dòng)態(tài)地進(jìn)行變量賦值, 不管是局部變量還是全局變量, 在我們絞盡腦汁的時(shí)候, Python已經(jīng)為我們解決了這個(gè)問題.

Python的命名空間通過一種字典的形式來體現(xiàn), 而具體到函數(shù)也就是locals() 和 globals(), 分別對(duì)應(yīng)著局部命名空間和全局命名空間. 于是, 我們也就能通過這些方法去實(shí)現(xiàn)我們"動(dòng)態(tài)賦值"的需求.

例如:

def test():
    globals()["a2"] = 4
test()
print a2   # 輸出 4

很自然, 既然 globals能改變?nèi)置臻g, 那理所當(dāng)然locals應(yīng)該也能修改局部命名空間.修改函數(shù)內(nèi)的局部變量.

但事實(shí)真是如此嗎? 不是!

def aaaa():
    print locals()
    for i in ["a", "b", "c"]:
        locals()[i] = 1
    print locals()
    print a
aaaa()

輸出:

{}
{"i": "c", "a": 1, "c": 1, "b": 1}
Traceback (most recent call last):
  File "5.py", line 17, in 
    aaaa()
  File "5.py", line 16, in aaaa
    print a
NameError: global name "a" is not defined

程序運(yùn)行報(bào)錯(cuò)了!

但是在第二次print locals()很清楚能夠看到, 局部空間是已經(jīng)有那些變量了, 其中也有變量a并且值也為1, 但是為什么到了print a卻報(bào)出NameError異常?

再看一個(gè)例子:

def aaaa():
    print locals()
    s = "test"                    # 加入顯示賦值 s       
    for i in ["a", "b", "c"]:
        locals()[i] = 1
    print locals()
    print s                       # 打印局部變量 s 
    print a
aaaa()

輸出:

{}
{"i": "c", "a": 1, "s": "test", "b": 1, "c": 1}
test
Traceback (most recent call last):
  File "5.py", line 19, in 
    aaaa()
  File "5.py", line 18, in aaaa
    print a
NameError: global name "a" is not defined

上下兩段代碼, 區(qū)別就是, 下面的有顯示賦值的代碼, 雖然也是同樣觸發(fā)了NameError異常, 但是局部變量s的值被打印了出來.

這就讓我們覺得很納悶, 難道通過locals()改變局部變量, 和直接賦值有不同? 想解決這個(gè)問題, 只能去看程序運(yùn)行的真相了, 又得上大殺器dis~

直接對(duì)第二段代碼解析:

13           0 LOAD_GLOBAL              0 (locals)
              3 CALL_FUNCTION            0
              6 PRINT_ITEM
              7 PRINT_NEWLINE

 14           8 LOAD_CONST               1 ("test")
             11 STORE_FAST               0 (s)

 15          14 SETUP_LOOP              36 (to 53)
             17 LOAD_CONST               2 ("a")
             20 LOAD_CONST               3 ("b")
             23 LOAD_CONST               4 ("c")
             26 BUILD_LIST               3
             29 GET_ITER
        >>   30 FOR_ITER                19 (to 52)
             33 STORE_FAST               1 (i)

 16          36 LOAD_CONST               5 (1)
             39 LOAD_GLOBAL              0 (locals)
             42 CALL_FUNCTION            0
             45 LOAD_FAST                1 (i)
             48 STORE_SUBSCR
             49 JUMP_ABSOLUTE           30
        >>   52 POP_BLOCK

 17     >>   53 LOAD_GLOBAL              0 (locals)
             56 CALL_FUNCTION            0
             59 PRINT_ITEM
             60 PRINT_NEWLINE

 18          61 LOAD_FAST                0 (s)
             64 PRINT_ITEM
             65 PRINT_NEWLINE

 19          66 LOAD_GLOBAL              1 (a)
             69 PRINT_ITEM
             70 PRINT_NEWLINE
             71 LOAD_CONST               0 (None)
             74 RETURN_VALUE
None

在上面的字節(jié)碼可以看到:

locals() 對(duì)應(yīng)的字節(jié)碼是: LOAD_GLOBAL

s="test" 對(duì)應(yīng)的字節(jié)碼是: LOAD_CONST 和 STORE_FAST

print s 對(duì)應(yīng)的字節(jié)碼是: LOAD_FAST

print a 對(duì)應(yīng)的字節(jié)碼是: LOAD_GLOBAL

從上面羅列出來的幾個(gè)關(guān)鍵語句的字節(jié)碼可以看出, 直接賦值/讀取 和 通過locals()賦值/讀取 本質(zhì)是很大不同的. 那么觸發(fā)NameError異常, 是否證明通過 locals()[i] = 1 存儲(chǔ)的值, 和真正的局部命名空間 是不同的兩個(gè)位置?

想要回答這個(gè)問題, 我們得先確定一個(gè)東西, 就是真正的局部命名空間如何獲取? 其實(shí)這個(gè)問題, 在上面的字節(jié)碼上, 已經(jīng)給出了標(biāo)準(zhǔn)答案了!

真正的局部命名空間, 其實(shí)是存在 STORE_FAST 這個(gè)對(duì)應(yīng)的數(shù)據(jù)結(jié)構(gòu)里面. 這個(gè)是什么鬼, 這個(gè)需要源碼來解答:

// ceval.c  從上往下, 依次是相應(yīng)函數(shù)或者變量的定義
// 指令源碼
TARGET(STORE_FAST)
{
    v = POP();
    SETLOCAL(oparg, v);
    FAST_DISPATCH();
}
--------------------
// SETLOCAL 宏定義      
#define SETLOCAL(i, value)      do { PyObject *tmp = GETLOCAL(i); 
                                     GETLOCAL(i) = value; 
                                     Py_XDECREF(tmp); } while (0)
-------------------- 
// GETLOCAL 宏定義                                    
#define GETLOCAL(i)     (fastlocals[i])     

-------------------- 
// fastlocals 真面目
PyObject * PyEval_EvalFrameEx(PyFrameObject *f, int throwflag){
    // 省略其他無關(guān)代碼
   fastlocals = f->f_localsplus;
....
}
                            

看到這里, 應(yīng)該就能明確了, 函數(shù)內(nèi)部的局部命名空間, 實(shí)際是就是幀對(duì)象的f的成員f_localsplus, 這是一個(gè)數(shù)組, 了解函數(shù)創(chuàng)建的童鞋可能會(huì)比較清楚, 在CALL_FUNCTION時(shí), 會(huì)對(duì)這個(gè)數(shù)組進(jìn)行初始化, 將形參賦值什么都會(huì)按序塞進(jìn)去, 在字節(jié)碼 18 61 LOAD_FAST 0 (s)中, 第四列的0, 就是將f_localsplus第 0 個(gè)成員取出來, 也就是值 "s".

所以STORE_FAST才是真正的將變量存入局部命名空間, 那locals()又是什么鬼? 為什么看起來就跟真的一樣?

這個(gè)就需要分析locals, 對(duì)于這個(gè), 字節(jié)碼可能起不了作用, 直接去看內(nèi)置函數(shù)如何定義的吧:

// bltinmodule.c
static PyMethodDef builtin_methods[] = {
    ...
    // 找到 locals 函數(shù)對(duì)應(yīng)的內(nèi)置函數(shù)是 builtin_locals 
    {"locals",          (PyCFunction)builtin_locals,     METH_NOARGS, locals_doc},
    ...
}

-----------------------------

// builtin_locals 的定義
static PyObject *
builtin_locals(PyObject *self)
{
    PyObject *d;

    d = PyEval_GetLocals();
    Py_XINCREF(d);
    return d;
}
-----------------------------

PyObject *
PyEval_GetLocals(void)
{
    PyFrameObject *current_frame = PyEval_GetFrame();  // 獲取當(dāng)前堆棧對(duì)象
    if (current_frame == NULL)
        return NULL;
    PyFrame_FastToLocals(current_frame); // 初始化和填充 f_locals
    return current_frame->f_locals;
}
-----------------------------

// 初始化和填充 f_locals 的具體實(shí)現(xiàn)
void
PyFrame_FastToLocals(PyFrameObject *f)
{
    /* Merge fast locals into f->f_locals */
    PyObject *locals, *map;
    PyObject **fast;
    PyObject *error_type, *error_value, *error_traceback;
    PyCodeObject *co;
    Py_ssize_t j;
    int ncells, nfreevars;
    if (f == NULL)
        return;
    locals = f->f_locals;
    
    // 如果locals為空, 就新建一個(gè)字典對(duì)象
    if (locals == NULL) {
        locals = f->f_locals = PyDict_New();  
        if (locals == NULL) {
            PyErr_Clear(); /* Can"t report it :-( */
            return;
        }
    }
    
    co = f->f_code;
    map = co->co_varnames;
    if (!PyTuple_Check(map))
        return;
    PyErr_Fetch(&error_type, &error_value, &error_traceback);
    fast = f->f_localsplus;
    j = PyTuple_GET_SIZE(map);
    if (j > co->co_nlocals)
        j = co->co_nlocals;
        
    // 將 f_localsplus 寫入 locals
    if (co->co_nlocals)
        map_to_dict(map, j, locals, fast, 0);
    ncells = PyTuple_GET_SIZE(co->co_cellvars);
    nfreevars = PyTuple_GET_SIZE(co->co_freevars);
    if (ncells || nfreevars) {
        // 將 co_cellvars 寫入 locals
        map_to_dict(co->co_cellvars, ncells,
                    locals, fast + co->co_nlocals, 1);
                    
        if (co->co_flags & CO_OPTIMIZED) {
            // 將 co_freevars 寫入 locals
            map_to_dict(co->co_freevars, nfreevars,
                        locals, fast + co->co_nlocals + ncells, 1);
        }
    }
    PyErr_Restore(error_type, error_value, error_traceback);
}

從上面PyFrame_FastToLocals已經(jīng)看出來, locals() 實(shí)際上做了下面幾件事:

判斷幀對(duì)象 的 f_f->f_locals 是否為空, 若是, 則新建一個(gè)字典對(duì)象.

分別將 localsplus, co_cellvars 和 co_freevars 寫入 f_f->f_locals.

在這簡(jiǎn)單介紹下上面幾個(gè)分別是什么鬼:

localsplus: 函數(shù)參數(shù)(位置參數(shù)+關(guān)鍵字參數(shù)), 顯示賦值的變量.

co_cellvars 和 co_freevars: 閉包函數(shù)會(huì)用到的局部變量.

通過上面的源碼, 我們已經(jīng)很明確知道locals() 看到的, 的確是函數(shù)的局部命名空間的內(nèi)容, 但是它本身不能代表局部命名空間, 這就好像一個(gè)代理, 它收集了A, B, C的東西, 展示給我看, 但是我卻不能簡(jiǎn)單的通過改變這個(gè)代理, 來改變A, B, C真正擁有的東西!

這也就是為什么, 當(dāng)我們通過locals()[i] = 1的方式去動(dòng)態(tài)賦值時(shí), print a卻觸發(fā)了NameError異常, 而相反的, globals()確實(shí)真正的全局命名空間, 所以一般會(huì)說

locals() 只讀,    globals() 可讀可寫

歡迎各位大神指點(diǎn)交流, QQ討論群: 258498217
轉(zhuǎn)載請(qǐng)注明來源: https://segmentfault.com/a/11...