Python locals() 的陷阱

googollee 發布于2019-07-30 15:21 / 614人閱讀

摘要：在工作中有時候會遇到一種情況動態地進行變量賦值不管是局部變量還是全局變量在我們絞盡腦汁的時候已經為我們解決了這個問題的命名空間通過一種字典的形式來體現而具體到函數也就是和分別對應著局部命名空間和全局命名空間于是我們也就能通過這些方法去實現我

在工作中, 有時候會遇到一種情況: 動態地進行變量賦值, 不管是局部變量還是全局變量, 在我們絞盡腦汁的時候, Python已經為我們解決了這個問題.

Python的命名空間通過一種字典的形式來體現, 而具體到函數也就是locals() 和 globals(), 分別對應著局部命名空間和全局命名空間. 于是, 我們也就能通過這些方法去實現我們"動態賦值"的需求.

例如:

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

很自然, 既然 globals能改變全局命名空間, 那理所當然locals應該也能修改局部命名空間.修改函數內的局部變量.

但事實真是如此嗎? 不是!

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

程序運行報錯了!

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

再看一個例子:

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

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

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

根源探討

直接對第二段代碼解析:

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

在上面的字節碼可以看到:

locals() 對應的字節碼是: LOAD_GLOBAL

s="test" 對應的字節碼是: LOAD_CONST 和 STORE_FAST

print s 對應的字節碼是: LOAD_FAST

print a 對應的字節碼是: LOAD_GLOBAL

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

想要回答這個問題, 我們得先確定一個東西, 就是真正的局部命名空間如何獲取? 其實這個問題, 在上面的字節碼上, 已經給出了標準答案了!

真正的局部命名空間, 其實是存在 STORE_FAST 這個對應的數據結構里面. 這個是什么鬼, 這個需要源碼來解答:

// ceval.c  從上往下, 依次是相應函數或者變量的定義
// 指令源碼
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){
    // 省略其他無關代碼
   fastlocals = f->f_localsplus;
....
}

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

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

這個就需要分析locals, 對于這個, 字節碼可能起不了作用, 直接去看內置函數如何定義的吧:

// bltinmodule.c
static PyMethodDef builtin_methods[] = {
    ...
    // 找到 locals 函數對應的內置函數是 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();  // 獲取當前堆棧對象
    if (current_frame == NULL)
        return NULL;
    PyFrame_FastToLocals(current_frame); // 初始化和填充 f_locals
    return current_frame->f_locals;
}
-----------------------------

// 初始化和填充 f_locals 的具體實現
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為空, 就新建一個字典對象
    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已經看出來, locals() 實際上做了下面幾件事:

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

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

在這簡單介紹下上面幾個分別是什么鬼:

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

co_cellvars 和 co_freevars: 閉包函數會用到的局部變量.

結論

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

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

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

歡迎各位大神指點交流, QQ討論群: 258498217
轉載請注明來源: https://segmentfault.com/a/11...

GPU云服務器云服務器 locals 面試陷阱創業陷阱陷阱清單

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/41198.html

當Python中混進一只薛定諤的貓……

摘要：薛定諤的貓以上內容是前提，友情提示，如你有理解模糊之處，請先閱讀對應的文章。這個例子告訴大家薛定諤的貓混入了的字典中，而且答案是，打開籠子，這只貓就會死亡。 showImg(https://segmentfault.com/img/remote/1460000019217212?w=1880&h=1253); 本文原創并首發于公眾號【Python貓】，未經授權，請勿轉載。原文地址：ht...

wua_wua2012 2019-07-31 10:26 評論0 收藏0
深度辨析 Python 的 eval() 與 exec()

摘要：內置函數們能夠被提拔出來，這就意味著它們皆有獨到之處，有用武之地。因此，掌握內置函數的用法，就成了我們應該點亮的技能。報錯包含了內置命名空間中的名稱，在控制臺中輸入，就能發現很多內置函數異常和其它屬性的名稱。 Python 提供了很多內置的工具函數（Built-in Functions），在最新的 Python 3 官方文檔中，它列出了 69 個。大部分函數是我們經常使用的，例如 p...

AndroidTraveler 2019-07-31 10:13 評論0 收藏0
流暢的python

摘要：流暢的中有很多奇技淫巧，整本書都在強調如何最大限度地利用標準庫。常見的扁平序列包括，，等。數組支持所有跟可變序列有關的操作，包括和。和用于指定列表的區間，默認是使用整個列表。但是元組的賦值不被允許，當異發生時流暢的python中有很多奇技淫巧，整本書都在強調如何最大限度地利用Python 標準庫。介紹了很多python的不常用的數據類型、操作、庫等，對于入門python后想要提升對p...

Alan 2019-07-30 17:52 評論0 收藏0
Python進階：如何將字符串常量轉化為變量？

摘要：例如，整數浮點數字符串等基本類型，就是字面量。所以，取出的字符串內容，并不能直接用作變量名，需要另想辦法。總結抽象一下最初的問題，它實際問的是如何將字符串內容作為其它對象的變量名，更進一步地講是如何將常量轉化為變量。前幾天，我們Python貓交流學習群里的 M 同學提了個問題。這個問題挺有意思，經初次討論，我們認為它無解。然而，我認為它很有價值，應該繼續思考怎么解決，所以就在私密...

lolomaco 2019-07-31 10:10 評論0 收藏0