Python中locals()的作用是什么

本篇文章給大家分享的是有關Python中locals()的作用是什么，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

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

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

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

2. s='test' 對應的字節碼是: LOAD_CONST 和 STORE_FAST

3. print s 對應的字節碼是: LOAD_FAST

4. 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() 實際上做了下面幾件事:

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

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

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

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

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

以上就是Python中locals()的作用是什么，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。