x = 123

def foo1():
    global x
    a = 1
    b = 2

# co_nlocals 會(huì)返回局部變量的個(gè)數(shù)
# a 和 b 是局部變量，x 是全局變量，因此是 2
print(foo1.__code__.co_nlocals)  # 2


def foo2(a, b):
    pass

print(foo2.__code__.co_nlocals)  # 2


def foo3(a, b):
    a = 1
    b = 2
    c = 3

print(foo3.__code__.co_nlocals)  # 3

// Objects/call.c
/*
 * Python 函數(shù)也是一個(gè)對(duì)象，當(dāng)調(diào)用 Python 函數(shù)時(shí)
 * 底層會(huì)將 Python 函數(shù)對(duì)象作為參數(shù)，調(diào)用 _PyFunction_Vectorcall
 * 關(guān)于函數(shù)，我們后續(xù)會(huì)剖析
 */
PyObject *
_PyFunction_Vectorcall(PyObject *func, PyObject* const* stack,
                       size_t nargsf, PyObject *kwnames)
{
    // ...
    
    // 參數(shù) func 指向函數(shù)對(duì)象，它內(nèi)部的 func_code 指向 PyCodeObject 對(duì)象
    // 如果 co_flags & CO_OPTIMIZED 為真，表示 PyCodeObject 是被優(yōu)化過的
    // 那么對(duì)應(yīng)的函數(shù)在調(diào)用時(shí)，會(huì)靜態(tài)查找本地局部變量
    if (((PyCodeObject *)f->func_code)->co_flags & CO_OPTIMIZED) {
        // 在這種情況下，會(huì)給 _PyEval_Vector 的第三個(gè)參數(shù)傳遞 NULL
        return _PyEval_Vector(tstate, f, NULL, stack, nargs, kwnames);
    }
    // ...
}


// Python/ceval.c
/*
 * 創(chuàng)建棧幀，調(diào)用 _PyEval_EvalFrame，最終執(zhí)行幀評(píng)估函數(shù)
 * 注意該函數(shù)的第三個(gè)參數(shù)，顯然它表示局部名字空間
 * 而 _PyFunction_Vectorcall 在調(diào)用時(shí)傳遞的是 NULL
 */
PyObject *
_PyEval_Vector(PyThreadState *tstate, PyFunctionObject *func,
               PyObject *locals,
               PyObject* const* args, size_t argcount,
               PyObject *kwnames)
{
    // ...
    
    // 執(zhí)行幀評(píng)估函數(shù)之前，要先創(chuàng)建棧幀
    // 這個(gè)過程由 _PyEvalFramePushAndInit 負(fù)責(zé)
    _PyInterpreterFrame *frame = _PyEvalFramePushAndInit(
        tstate, func, locals, args, argcount, kwnames);
    // ...
    return _PyEval_EvalFrame(tstate, frame, 0);
}

/*
 * 在當(dāng)前棧幀之上創(chuàng)建新的棧幀，并推入虛擬機(jī)為其準(zhǔn)備的 C Stack 中
 */
static _PyInterpreterFrame *
_PyEvalFramePushAndInit(PyThreadState *tstate, PyFunctionObject *func,
                        PyObject *locals, PyObject* const* args,
                        size_t argcount, PyObject *kwnames)
{
    // ...

    // 棧幀創(chuàng)建之后，調(diào)用 _PyFrame_Initialize，進(jìn)行初始化
    _PyFrame_Initialize(frame, func, locals, code, 0);
    // ...
}

// Include/internal/pycore_frame.h
/*
 * 對(duì) frame 進(jìn)行初始化
 */
staticinlinevoid
_PyFrame_Initialize(
    _PyInterpreterFrame *frame, PyFunctionObject *func,
    PyObject *locals, PyCodeObject *code, int null_locals_from)
{
    frame->f_funcobj = (PyObject *)func;
    frame->f_code = (PyCodeObject *)Py_NewRef(code);
    frame->f_builtins = func->func_builtins;
    frame->f_globals = func->func_globals;
    // 將 f_locals 字段初始化為參數(shù) locals
    // 而參數(shù) locals 是從 _PyFunction_Vectorcall 一層層傳過來的
    // 由于 _PyFunction_Vectorcall 傳的是 NULL
    // 所以棧幀的 f_locals 字段最終會(huì)被初始化為 NULL
    frame->f_locals = locals;
    // ...
}

import inspect

# 模塊的棧幀
frame = inspect.currentframe()
# 對(duì)于模塊而言，局部名字空間和全局名字空間是同一個(gè)字典
print(frame.f_locals is frame.f_globals)  # True
# 當(dāng)然啦，局部名字空間和全局名字空間也可以通過內(nèi)置函數(shù)獲取
print(
    frame.f_locals is locals() is frame.f_globals is globals()
)  # True


# 但對(duì)于函數(shù)而言就不一樣了
def foo():
    name = "古明地覺"
    return inspect.currentframe()

frame = foo()
# global 名字空間全局唯一
# 無論是獲取棧幀的 f_globals，還是調(diào)用 globals()
# 得到的都是同一份字典
print(frame.f_globals is globals())  # True
# 但每個(gè)函數(shù)都有自己獨(dú)立的局部名字空間
print(frame.f_locals)  # {'name': '古明地覺'}

# 咦，不是說局部名字空間被初始化為 NULL 嗎？
# 那么在 Python 里面獲取的話，結(jié)果應(yīng)該是個(gè) None 才對(duì)啊
# 關(guān)于這一點(diǎn)，我們稍后會(huì)解釋

def foo(a, b):
    c = a + b
    print(c)

TARGET(LOAD_FAST) {
    PyObject *value;
    #line 192 "Python/bytecodes.c"
    // 通過宏 GETLOCAL 獲取局部變量的值
    value = GETLOCAL(oparg);
    assert(value != NULL);
    Py_INCREF(value);
    #line 90 "Python/generated_cases.c.h"
    // 將值壓入運(yùn)行時(shí)棧，等價(jià)于 PUSH(value)
    STACK_GROW(1);
    stack_pointer[-1] = value;
    DISPATCH();
}

TARGET(STORE_FAST) {
    // 獲取棧頂元素
    PyObject *value = stack_pointer[-1];
    #line 209 "Python/bytecodes.c"
    // 通過宏 SETLOCAL 創(chuàng)建局部變量
    SETLOCAL(oparg, value);
    #line 124 "Python/generated_cases.c.h"
    // 將 stack_pointer 向棧底移動(dòng)一個(gè)位置，即彈出棧頂元素
    // 如果和第一行組合起來的話，等價(jià)于 TOP()
    STACK_SHRINK(1);
    DISPATCH();
}

// Python/ceval_macros.h

#define GETLOCAL(i)     (frame->localsplus[i])

#define SETLOCAL(i, value)      do { PyObject *tmp = GETLOCAL(i); \
                                     GETLOCAL(i) = value; \
                                     Py_XDECREF(tmp); } while (0)
/* 這里額外再補(bǔ)充一個(gè)關(guān)于 C 語言的知識(shí)點(diǎn)
 * 我們看到宏 SETLOCAL 展開之后的結(jié)果是 do {...} while (0) 
 * do while 循環(huán)會(huì)先執(zhí)行 do 里面的循環(huán)體，然后再判斷條件是否滿足
 * 因此從效果上來說，執(zhí)行 do {...} while (0) 和直接執(zhí)行 ... 是等價(jià)的
 * 那么問題來了，既然效果等價(jià)，為啥還要再套一層 do while 呢
 * 其實(shí)原因很簡單，如果宏在展開之后會(huì)生成多條語句，那么這些語句要成為一個(gè)整體
 * 另外由于 C 程序的語句要以分號(hào)結(jié)尾，所以在調(diào)用宏時(shí)，我們也會(huì)習(xí)慣性地在結(jié)尾加上分號(hào)
 * 因此我們希望有這樣一種結(jié)構(gòu)，能同時(shí)滿足以下要求：
 *   1）可以將多條語句包裹起來，作為一個(gè)整體；
 *   2）程序的語義不能發(fā)生改變；
 *   3）在語法上，要以分號(hào)結(jié)尾；
 * 顯然 do while 完美滿足以上三個(gè)要求，只需將 while 里的條件設(shè)置為 0 即可
 * 并且當(dāng)編譯器看到 while (0) 時(shí)，也會(huì)進(jìn)行優(yōu)化，去掉不必要的循環(huán)控制結(jié)構(gòu)
 * 因此以后看到 do {...} while (0) 時(shí)，不要覺得奇怪，這是宏的一個(gè)常用技巧
 */

def foo(a, b):
    c = a + b
    print(c)

print(
    foo.__code__.co_varnames
)  # ('a', 'b', 'c')

x = 1

def foo():
    globals()["x"] = 2
    
foo()
print(x)  # 2

def foo():
    x = 1
    locals()["x"] = 2
    print(x)


foo()  # 1

def foo():
    name = "satori"
    print(locals())
    age = 17
    print(locals())
    gender = "female"
    print(locals())

foo()
"""
{'name': 'satori'}
{'name': 'satori', 'age': 17}
{'name': 'satori', 'age': 17, 'gender': 'female'}
"""

def foo():
    name = "satori"
    age = 17
    gender = "female"
    print(locals())

# 符號(hào)表：保存了函數(shù)中創(chuàng)建的局部變量的名字
print(foo.__code__.co_varnames)
"""
('name', 'age', 'gender')
"""
# 調(diào)用函數(shù)時(shí)會(huì)創(chuàng)建棧幀，局部變量的值都保存在 f_localsplus 里面
# 并且符號(hào)表中變量名的順序和 f_localsplus 中變量值的順序是一致的
f_localsplus = ["satori", 17, "female"]
# 這里就用一個(gè)列表來模擬了

def foo():
    name = "satori"
    # 會(huì)從 f_localsplus 中靜態(tài)查找
    print(name)
    # 先基于已有的變量和值創(chuàng)建一個(gè)字典
    # 然后通過字典實(shí)現(xiàn)變量的動(dòng)態(tài)查找
    print(locals()["name"])

foo()
"""
satori
satori
"""

def foo():
    name = "satori"
    locals()["age"] = 17
    try:
        print(age)
    except NameError as e:
        print(e)

foo()
"""
name 'age' is not defined
"""

def foo():
    name = "satori"
    # 執(zhí)行 locals() 的時(shí)候，內(nèi)部只有一個(gè)鍵值對(duì)
    d = locals()
    print(d)  # {'name': 'satori'}
    # 再次獲取，此時(shí)有兩個(gè)鍵值對(duì)
    print(locals())  # {'name': 'satori', 'd': {...}}
    
    # 但兩者的 id 相同，因?yàn)橐粋€(gè)函數(shù)只有一個(gè)局部名字空間
    # 不管調(diào)用多少次 locals()，拿到的都是同一個(gè)字典
    print(id(d) == id(locals()))  # True

foo()

def foo():
    # 創(chuàng)建一個(gè)字典，由于當(dāng)前還沒有定義局部變量，因此是空字典
    print(locals())
    """
    {}
    """
    # 往局部名字空間添加一個(gè)鍵值對(duì)
    locals()["a"] = "b"
    print(locals())
    """
    {'a': 'b'}
    """
    # 定義一個(gè)局部變量
    name = "satori"
    # 由于局部名字空間已存在，因此不會(huì)再次創(chuàng)建
    # 直接將局部變量的名字作為 key、值作為 value，拷貝到字典中
    print(locals())
    """
    {'a': 'b', 'name': 'satori'}
    """

foo()

// Python/bltinmodule.c
static PyObject *
builtin_locals_impl(PyObject *module)
{
    // Python 內(nèi)置函數(shù)的源碼實(shí)現(xiàn)位于 bltinmodule.c 中
    // 這里又調(diào)用了 _PyEval_GetFrameLocals
    return _PyEval_GetFrameLocals();
}

// Python/ceval.c
PyObject *
_PyEval_GetFrameLocals(void)
{
    PyThreadState *tstate = _PyThreadState_GET();
     _PyInterpreterFrame *current_frame = _PyThreadState_GetFrame(tstate);
    if (current_frame == NULL) {
        _PyErr_SetString(tstate, PyExc_SystemError, "frame does not exist");
        return NULL;
    }
    // 調(diào)用了 _PyFrame_GetLocals
    return _PyFrame_GetLocals(current_frame, 1);
}

// Object/frameobject.c
PyObject *
_PyFrame_GetLocals(_PyInterpreterFrame *frame, int include_hidden)
{
    // 獲取局部名字空間
    PyObject *locals = frame->f_locals;
    // 如果為 NULL，那么創(chuàng)建一個(gè)新字典，作為名字空間
    // 所以局部名字空間只會(huì)創(chuàng)建一次，后續(xù)不會(huì)再創(chuàng)建
    if (locals == NULL) {
        locals = frame->f_locals = PyDict_New();
        if (locals == NULL) {
            return NULL;
        }
    }
    PyObject *hidden = NULL;

    // 在 Include/internal/pycore_code.h 里面有 4 個(gè)宏
    /* #define CO_FAST_HIDDEN  0x10
     * #define CO_FAST_LOCAL   0x20
     * #define CO_FAST_CELL    0x40
     * #define CO_FAST_FREE    0x80
     */
    // 它們分別對(duì)應(yīng)隱藏變量、局部變量、cell 變量、free 變量
    // 所謂隱藏變量，指的就是解析式里的臨時(shí)變量，比如列表解析式
    // 解析式具有獨(dú)立的作用域，里面的臨時(shí)變量不會(huì)污染外部的作用域
    // 所以一般我們也不會(huì)關(guān)注這些隱藏變量，locals() 也不會(huì)返回它
    // 但如果你真的關(guān)注，那么可以將 include_hidden 指定為真
    // 那么調(diào)用 locals() 時(shí)，這些隱藏變量也會(huì)一塊兒返回
    if (include_hidden) {
        // 單獨(dú)創(chuàng)建一個(gè)字典，負(fù)責(zé)保存隱藏變量
        hidden = PyDict_New();
        if (hidden == NULL) {
            return NULL;
        }
    }
    // 初始化 free 變量，這個(gè)和閉包有關(guān)
    // 關(guān)于閉包，等剖析完函數(shù)之后會(huì)說，這里暫時(shí)先不關(guān)注
    frame_init_get_vars(frame);

    PyCodeObject *co = frame->f_code;
    // co_nlocalsplus 等于局部變量、cell 變量、free 變量的個(gè)數(shù)之和
    // 這些變量都要拷貝到 local 名字空間中
    for (int i = 0; i < co->co_nlocalsplus; i++) {
        PyObject *value;
        // 獲取 f_localsplus[i]，在函數(shù)內(nèi)部會(huì)對(duì) value 進(jìn)行修改
        if (!frame_get_var(frame, co, i, &value)) {
            continue;
        }
        // f_localsplus[i] 對(duì)應(yīng)局部名字空間的 value
        // 那么 co_localsplusnames[i] 顯然對(duì)應(yīng)局部名字空間的 key
        // 估計(jì)有人已經(jīng)忘記 co_localsplusnames 字段的含義了，我們?cè)俳忉屢幌?        /* co_localsplusnames：包含所有局部變量、cell 變量、free 變量的名稱
         * co_nlocalsplus：co_localsplusnames 的長度，或者說這些變量的個(gè)數(shù)之和

         * co_varnames：包含所有局部變量的名稱，co_nlocals：局部變量的個(gè)數(shù)
         * co_cellvars：包含所有 cell 變量的名稱，co_ncellvars：cell 變量的個(gè)數(shù)
         * co_freevars：包含所有 free 變量的名稱，co_nfreevars：free 變量的個(gè)數(shù)
         
         * 因此不難得出它們之間的關(guān)系：
         * co_localsplusnames = co_varnames + co_cellvars + co_freevars
         * co_nlocalsplus = co_nlocals + co_ncellvars + co_nfreevars
         */
        // 所以 co_localsplusnames 也是符號(hào)表，并且是 co_varnames 的超集
        PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i);
        // 到此局部名字空間的 key 和 value 便有了，但還要做一個(gè)判斷
        _PyLocals_Kind kind = _PyLocals_GetKind(co->co_localspluskinds, i);
        // 如果變量的類型是隱藏變量，那么添加到 hidden 中
        // 所以 co_localsplusnames 其實(shí)還包含了隱藏變量的名稱
        // 但我們基本不會(huì)遇到這種情況，因此關(guān)于隱藏變量直接忽略掉即可
        if (kind & CO_FAST_HIDDEN) {
            if (include_hidden && value != NULL) {
                if (PyObject_SetItem(hidden, name, value) != 0) {
                    goto error;
                }
            }
            continue;
        }
        // 如果不是隱藏變量，那么拷貝到 locals 中，但這里有一個(gè)判斷很重要
        // 當(dāng) value 為 NULL 時(shí)，如果 key 已存在，那么會(huì)將它刪掉
        // 關(guān)于這里的玄機(jī)，稍后會(huì)解釋
        if (value == NULL) {
            if (PyObject_DelItem(locals, name) != 0) {
                if (PyErr_ExceptionMatches(PyExc_KeyError)) {
                    PyErr_Clear();
                }
                else {
                    goto error;
                }
            }
        }
        // 到這里說明 value 指向了一塊合法的內(nèi)存
        // 也就是變量名和變量值已經(jīng)完成了綁定，那么將它們添加到 locals 中
        else {
            if (PyObject_SetItem(locals, name, value) != 0) {
                goto error;
            }
        }
        // 繼續(xù)遍歷下一個(gè)符號(hào)
    }
    // 隱藏變量保存在 hidden 中，它不會(huì)污染 f_locals
    if (include_hidden && PyDict_Size(hidden)) {
        // 創(chuàng)建一個(gè)新字典
        PyObject *innerlocals = PyDict_New();
        if (innerlocals == NULL) {
            goto error;
        }
        // 合并 locals
        if (PyDict_Merge(innerlocals, locals, 1) != 0) {
            Py_DECREF(innerlocals);
            goto error;
        }
        // 合并 hidden
        if (PyDict_Merge(innerlocals, hidden, 1) != 0) {
            Py_DECREF(innerlocals);
            goto error;
        }
        // 重新賦值給 locals，所以返回的結(jié)果會(huì)包含 hidden 里的鍵值對(duì)
        // 但 f_locals 里面是沒有隱藏變量的
        locals = innerlocals;
    }
    else {
        Py_INCREF(locals);
    }
    Py_CLEAR(hidden);
    // 返回 locals
    return locals;

  error:
    Py_XDECREF(hidden);
    return NULL;
}

def foo():
    print(locals())  # {}
    exec("x = 1")
    print(locals())  # {'x': 1}
    try:
        print(x)
    except NameError as e:
        print(e)  # name 'x' is not defined
        
foo()

exec("x = 1")
print(x)  # 1

def foo():
    # 此時(shí) exec 影響的是全局名字空間
    exec("x = 123", globals())
    # 這里不會(huì)報(bào)錯(cuò), 但此時(shí)的 x 不是局部變量, 而是全局變量
    print(x)

foo()
print(x)
"""
123
123
"""

def foo():
    exec("x = 1")
    print(locals()["x"])

foo()
"""
1
"""

def bar():
    exec("x = 1")
    print(locals()["x"])
    x = 123

bar()
"""
Traceback (most recent call last):
  File .....
    bar()
  File .....
    print(locals()["x"])
KeyError: 'x'
"""

def foo():
    # 創(chuàng)建局部名字空間，并寫入鍵值對(duì) "x": 1
    # 此時(shí)名字空間為 {"x": 1}
    exec("x = 1")
    # 獲取名字空間，會(huì)進(jìn)行更新
    # 但當(dāng)前不存在局部變量，所以名字空間仍是 {"x": 1}
    print(locals())

def bar():
    # 創(chuàng)建局部名字空間，并寫入鍵值對(duì) "x": 1
    # 此時(shí)名字空間為 {"x": 1}
    exec("x = 1")
    # 獲取名字空間，會(huì)進(jìn)行更新
    # 由于里面存在局部變量 x，但尚未賦值
    # 于是將字典中 key 為 "x" 的鍵值對(duì)給刪掉
    # 所以名字空間變成了 {}
    print(locals())
    x = 123


foo()  # {'x': 1}
bar()  # {}

def foo():
    exec("x = 2")
    print(locals())

foo()  # {'x': 2}


def bar():
    x = 1
    exec("x = 2")
    print(locals())

bar()  # {'x': 1}

# 例 0
def foo():
    exec('y = 1 + 1')
    z = locals()['y']
    print(z)

foo()
# 輸出：2


# 例 1
def foo():
    exec('y = 1 + 1')
    y = locals()['y']
    print(y)

foo()
# 報(bào)錯(cuò)：KeyError: 'y'

# 例 2
def foo():
    y = 1 + 1
    y = locals()['y']
    print(y)

foo()
# 2

# 例3
def foo():
    exec('y = 1 + 1')
    boc = locals()
    y = boc['y']
    print(y)

foo()
# KeyError: 'y'

# 例4
def foo():
    boc = locals()
    exec('y = 1 + 1')
    y = boc['y']
    print(y)

foo()
# 2

# 例5
def foo():
    boc = locals()
    exec('y = 1 + 1')
    print(locals())
    y = boc['y']
    print(y)

foo()

# {'boc': {...}} 
# KeyError: 'y'