# 首先虛擬機(jī)從上到下執(zhí)行字節(jié)碼
name = "古明地覺"
age = 17

# 啪，很快啊，出現(xiàn)了一個(gè) def
def foo():
    pass

# 出現(xiàn)了 def，虛擬機(jī)就知道源代碼進(jìn)入了一個(gè)新的作用域了
# 也就是遇到一個(gè)新的 PyCodeObject 對(duì)象了
# 而通過 def 關(guān)鍵字知道這是一個(gè)函數(shù)，于是會(huì)進(jìn)行封裝
# 將 PyCodeObject 封裝成 PyFunctionObject，同時(shí)包含了全局名字空間
# 所以當(dāng)執(zhí)行完 def 語句之后，一個(gè)函數(shù)就被創(chuàng)建了
# 然后將變量名 foo 和函數(shù)體（PyFunctionObject）組成鍵值對(duì)存放在當(dāng)前的 local 空間中
# 當(dāng)然對(duì)于模塊而言，local 空間也是 global 空間
print({k: v for k, v in locals().items() if k == "foo"})
"""
{'foo': <function foo at 0x102d5bf40>}
"""

# 函數(shù)內(nèi)部也保存了 global 空間
print(foo.__globals__ is globals() is locals())
"""
True
"""
print(foo.__globals__["foo"] is foo is locals()["foo"])
"""
True
"""

import dis

code_string = """
name = "satori"
def foo(a, b):
    print(a, b)

foo(1, 2)
"""

dis.dis(compile(code_string, "<func>", "exec"))

0 RESUME                   0

 # name = "satori"
 2 LOAD_CONST               0 ('satori')
 4 STORE_NAME               0 (name)

 # 我們看到 PyCodeObject 也會(huì)作為常量被靜態(tài)收集
 # 這里是將常量池中索引為 1 的 PyCodeObject 壓入運(yùn)行時(shí)棧
 6 LOAD_CONST               1 (<code object foo at 0x7f5d...>)
 # 從棧中彈出 PyCodeObject，然后構(gòu)建函數(shù)對(duì)象
 # 將函數(shù)對(duì)象（的指針）再壓入運(yùn)行時(shí)棧
 8 MAKE_FUNCTION            0
 # 從棧中彈出函數(shù)對(duì)象，并用符號(hào) foo 綁定起來
 # 到此函數(shù)就創(chuàng)建完畢了
10 STORE_NAME               1 (foo)
 
 # 以下是 foo(1, 2) 對(duì)應(yīng)的字節(jié)碼
12 PUSH_NULL
 # 加載全局變量 foo 并壓棧
14 LOAD_NAME                1 (foo)
 # 加載常量 1 和 2 并壓棧
16 LOAD_CONST               2 (1)
18 LOAD_CONST               3 (2)
 # 從棧中彈出函數(shù)和參數(shù)，然后調(diào)用
 # 將調(diào)用結(jié)果、即函數(shù)的返回值壓入棧中
20 CALL                     2
 # 從棧頂彈出返回值，因?yàn)槲覀儧]有使用變量保存，所以會(huì)直接丟棄
 # 如果使用變量保存了，比如 res = foo(1, 2)，那么這里的字節(jié)碼就是 STORE_NAME
28 POP_TOP
30 RETURN_CONST             4 (None)
 
 # 以上是模塊對(duì)應(yīng)的字節(jié)碼指令，下面是函數(shù)對(duì)應(yīng)的字節(jié)碼指令
Disassembly of <code object foo at 0x7f5d..., file "<func>", line 3>:
 0 RESUME                   0
 
 # 比較簡(jiǎn)單，就是 print(a, b) 對(duì)應(yīng)的字節(jié)碼
 2 LOAD_GLOBAL              1 (NULL + print)
12 LOAD_FAST                0 (a)
14 LOAD_FAST                1 (b)
16 CALL                     2
24 POP_TOP
26 RETURN_CONST             0 (None)

TARGET(MAKE_FUNCTION) {
    // 獲取 PyCodeObject 對(duì)象
    PyObject *codeobj = stack_pointer[-1];

    // 編譯時(shí)，解釋器能夠靜態(tài)檢測(cè)出函數(shù)有沒有閉包變量、類型注解等屬性，并體現(xiàn)在 oparg 中
    // 構(gòu)建函數(shù)時(shí)，通過 oparg 和一系列標(biāo)志位做按位與，來判斷函數(shù)是否包含指定屬性
    // 由于 oparg 是指令參數(shù)，所以這些屬性是否存在、以及如何訪問，在編譯階段就已經(jīng)確定了
    PyObject *closure = (oparg & 0x08) ? stack_pointer[...] : NULL;
    PyObject *annotations = (oparg & 0x04) ? stack_pointer[...] : NULL;
    PyObject *kwdefaults = (oparg & 0x02) ? stack_pointer[...] : NULL;
    PyObject *defaults = (oparg & 0x01) ? stack_pointer[...] : NULL;
    PyObject *func;
    #line 3267 "Python/bytecodes.c"
    
    // 基于 PyCodeObject 和全局名字空間，來構(gòu)建 PyFunctionObject
    PyFunctionObject *func_obj = (PyFunctionObject *)
        PyFunction_New(codeobj, GLOBALS());

    Py_DECREF(codeobj);
    if (func_obj == NULL) {
        goto error;
    }
    // 設(shè)置閉包變量、類型注解、默認(rèn)值等屬性
    if (oparg & 0x08) {
        assert(PyTuple_CheckExact(closure));
        func_obj->func_closure = closure;
    }
    if (oparg & 0x04) {
        assert(PyTuple_CheckExact(annotations));
        func_obj->func_annotations = annotations;
    }
    if (oparg & 0x02) {
        assert(PyDict_CheckExact(kwdefaults));
        func_obj->func_kwdefaults = kwdefaults;
    }
    if (oparg & 0x01) {
        assert(PyTuple_CheckExact(defaults));
        func_obj->func_defaults = defaults;
    }

    func_obj->func_version = ((PyCodeObject *)codeobj)->co_version;
    // 函數(shù)創(chuàng)建之后，將棧里的元素彈出，然后將函數(shù)對(duì)象壓入棧中
    func = (PyObject *)func_obj;
    #line 4534 "Python/generated_cases.c.h"
    STACK_SHRINK(((oparg & 0x01) ? 1 : 0) + ((oparg & 0x02) ? 1 : 0) + 
        ((oparg & 0x04) ? 1 : 0) + ((oparg & 0x08) ? 1 : 0));
    stack_pointer[-1] = func;
    DISPATCH();
}

// Objects/funcobject.c
PyObject *
PyFunction_New(PyObject *code, PyObject *globals)
{
    return PyFunction_NewWithQualName(code, globals, NULL);
}


PyObject *
PyFunction_NewWithQualName(PyObject *code, 
                           PyObject *globals, 
                           PyObject *qualname)
{
    assert(globals != NULL);
    assert(PyDict_Check(globals));
    // 給全局名字空間增加引用計(jì)數(shù)
    Py_INCREF(globals);
    // 獲取線程狀態(tài)對(duì)象
    PyThreadState *tstate = _PyThreadState_GET();
    // 給 PyCodeObject 對(duì)象增加引用計(jì)數(shù)
    PyCodeObject *code_obj = (PyCodeObject *)Py_NewRef(code);

    assert(code_obj->co_name != NULL);
    // 獲取 co_name 并增加引用計(jì)數(shù)
    PyObject *name = Py_NewRef(code_obj->co_name);
    
    // 獲取 co_qualname，如果存在，增加引用計(jì)數(shù)
    if (!qualname) {
        qualname = code_obj->co_qualname;
    }
    assert(qualname != NULL);
    Py_INCREF(qualname);
    
    // 獲取常量池
    PyObject *consts = code_obj->co_consts;
    assert(PyTuple_Check(consts));
    // 函數(shù)的 docstring 也會(huì)被收集到常量池中，并且是常量池的第一個(gè)元素
    // 如果函數(shù)沒有 docstring，那么常量池的第一個(gè)元素會(huì)是 None
    PyObject *doc;
    if (PyTuple_Size(consts) >= 1) {
        doc = PyTuple_GetItem(consts, 0);
        // 如果第一個(gè)元素不是字符串，則說明函數(shù)沒有 docstring
        if (!PyUnicode_Check(doc)) {
            doc = Py_None;
        }
    }
    else {
        doc = Py_None;
    }
    Py_INCREF(doc);

    // 獲取 __module__，并增加引用計(jì)數(shù)
    PyObject *module = PyDict_GetItemWithError(
            globals, &_Py_ID(__name__));
    PyObject *builtins = NULL;
    if (module == NULL && _PyErr_Occurred(tstate)) {
        goto error;
    }
    Py_XINCREF(module);
    // 獲取 __builtins__，并增加引用計(jì)數(shù)
    builtins = _PyEval_BuiltinsFromGlobals(tstate, globals);
    if (builtins == NULL) {
        goto error;
    }
    Py_INCREF(builtins);
    
    // 為函數(shù)對(duì)象申請(qǐng)內(nèi)存空間
    PyFunctionObject *op = PyObject_GC_New(
            PyFunctionObject, &PyFunction_Type);
    if (op == NULL) {
        goto error;
    }
    
    // 初始化函數(shù)對(duì)象的內(nèi)部屬性
    op->func_globals = globals;
    op->func_builtins = builtins;
    op->func_name = name;
    op->func_qualname = qualname;
    op->func_code = (PyObject*)code_obj;
    op->func_defaults = NULL;    
    op->func_kwdefaults = NULL;  
    op->func_closure = NULL;
    op->func_doc = doc;
    op->func_dict = NULL;
    op->func_weakreflist = NULL;
    op->func_module = module;
    op->func_annotations = NULL;
    op->func_typeparams = NULL;
    op->vectorcall = _PyFunction_Vectorcall;
    op->func_version = 0;
    _PyObject_GC_TRACK(op);
    handle_func_event(PyFunction_EVENT_CREATE, op, NULL);
    return (PyObject *)op;

error:
    Py_DECREF(globals);
    Py_DECREF(code_obj);
    Py_DECREF(name);
    Py_DECREF(qualname);
    Py_DECREF(doc);
    Py_XDECREF(module);
    Py_XDECREF(builtins);
    return NULL;
}

import dis

code_string = """
name = "satori"
def foo(a: int = 1, b: int = 2):
    print(a, b)
"""

dis.dis(compile(code_string, "<func>", "exec"))

0 RESUME                   0

 2 LOAD_CONST               0 ('satori')
 4 STORE_NAME               0 (name)

 6 LOAD_CONST               5 ((1, 2))
 8 LOAD_CONST               1 ('a')
10 LOAD_NAME                1 (int)
12 LOAD_CONST               2 ('b')
14 LOAD_NAME                1 (int)
16 BUILD_TUPLE              4
18 LOAD_CONST               3 (<code object foo at 0x7f...>)
20 MAKE_FUNCTION            5 (defaults, annotations)
22 STORE_NAME               2 (foo)
......

def foo(a: int = 1, b: int = 2):
    print(a, b)

print(foo.__defaults__)
"""
(1, 2)
"""
print(foo.__annotations__)
"""
{'a': <class 'int'>, 'b': <class 'int'>}
"""

def foo():
    pass

print(foo.__name__)  # foo

bar = foo
print(bar.__name__)  # foo

code_string = """
def foo():
    pass
"""

code_obj = compile(code_string, "<func>", "exec")
# 我們是以模塊的形式編譯的，它里面只有一個(gè)變量 foo
# 所以符號(hào)表就是 ('foo',)
print(code_obj.co_names)  # ('foo',)

# 然后常量池里面存在一個(gè) PyCodeObject
# 這個(gè) PyCodeObject 便是函數(shù)對(duì)應(yīng)的 PyCodeObject
print(code_obj.co_consts[0])  # <code object foo ...>
print(code_obj.co_consts[0].co_name)  # foo

# 構(gòu)建函數(shù)時(shí)，PyCodeObject 的 co_name 會(huì)被賦值給函數(shù)的 func_name
# 所以嚴(yán)格意義上講，def foo() 中的 foo 只能算做是變量名
# 而真正的函數(shù)名是函數(shù)對(duì)象的 func_name，它來自于 co_name
# 只不過在編譯成 PyCodeObject 對(duì)象時(shí)，會(huì)進(jìn)行詞法分析
# 因?yàn)?def 后面是 foo，所以編譯之后的 PyCodeObject 的 co_name 也是 foo

# 當(dāng)然其它對(duì)象也是如此
class A:
    pass

# 這里的 A 指向了類型對(duì)象，但類型對(duì)象的名稱是保存在類型對(duì)象里面的
print(A.__name__)  # A
# A.__name__ 才是類名，class 后面的 A 只是一個(gè)變量名

# 這里同樣創(chuàng)建了一個(gè)類
B = type("B1", (object,), {})
print(B.__name__)  # B1
# 但是我們看到類名不是 B，而是 B1
# 所以我們需要明白，不管是變量賦值、還是定義函數(shù)、類、方法，導(dǎo)入模塊
# 我們得到的只是一個(gè)變量，這個(gè)變量指向了具體的對(duì)象（它們是字典中的一個(gè)鍵值對(duì)）
# 而對(duì)象的名稱、類型等信息，都保存在對(duì)象里面，和變量無關(guān)
# 因?yàn)樽兞恐皇且粋€(gè)符號(hào)，或者理解為代號(hào)，每個(gè)對(duì)象都可以有不同的代號(hào)

def foo():
    pass

# 名稱也可以自由更改
foo.__name__ = "foo1"
# 在更改過后，函數(shù)的名字就變成了 foo1
print(foo.__name__)  # foo1

# bar = foo 之后，這個(gè)函數(shù)對(duì)象就有了兩個(gè)代號(hào)，你通過 foo 和 bar 都可以找到它
# 但函數(shù)對(duì)象的名字是不變的，還是 foo1，因?yàn)樗?__name__ 屬性的值是 foo1
bar = foo
print(bar.__name__)  # foo1

name = "古明地覺"

def foo():
    pass

class A:
    pass

import os

print("name" in locals())  # True
print("foo" in locals())  # True
print("A" in locals())  # True
print("os" in locals())  # True

def foo():
    pass

print(type(foo))  # <class 'function'>
# lambda 匿名函數(shù)的類型也是 function
print(type(lambda: None))  # <class 'function'>

gender = "female"

def foo(name, age):
    return f"name: {name}, age: {age}, gender: {gender}"

# 得到 PyCodeObject 對(duì)象
code = foo.__code__
# 根據(jù) class function 創(chuàng)建函數(shù)對(duì)象
# 接收三個(gè)參數(shù): PyCodeObject 對(duì)象、名字空間、函數(shù)名
new_foo = type(foo)(code, globals(), "根據(jù) foo 創(chuàng)建的 new_foo")

# 打印函數(shù)名
print(new_foo.__name__)
"""
根據(jù) foo 創(chuàng)建的 new_foo
"""

# 調(diào)用函數(shù)
print(new_foo("古明地覺", 17))
"""
name: 古明地覺, age: 17, gender: female
"""

gender = "female"

def foo(name, age):
    return f"name: {name}, age: {age}, gender: {gender}"

code = foo.__code__
# 第二個(gè)參數(shù)必須是一個(gè)字典，不能傳 None
new_foo = type(foo)(code, {}, "根據(jù) foo 創(chuàng)建的 new_foo")

try:
    print(new_foo("古明地覺", 17))
except NameError as e:
    print(e)  # name 'gender' is not defined

gender = "female"

def foo(name, age):
    return f"name: {name}, age: {age}, gender: {gender}"

code = foo.__code__
new_foo = type(foo)(code, {"gender": "萌妹子"}, "根據(jù) foo 創(chuàng)建的 new_foo")

# 我們可以手動(dòng)傳遞一個(gè)字典進(jìn)去
# 此時(shí)傳遞的字典對(duì)于函數(shù)來說就是 global 名字空間
print(new_foo("古明地覺", 17))
"""
name: 古明地覺, age: 17, gender: 萌妹子
"""
# 所以此時(shí)的 gender 不再是外部的 "female", 而是我們指定的 "萌妹子"

def foo(name, age, gender):
    return f"name: {name}, age: {age}, gender: {gender}"

# 必須接收一個(gè) PyTupleObject 對(duì)象
foo.__defaults__ = ("古明地覺", 17, "female")
print(foo())
"""
name: 古明地覺, age: 17, gender: female
"""

def foo(name, age, gender):
    return f"name: {name}, age: {age}, gender: {gender}"

foo.__defaults__ = (15, "female")
print(foo("古明地戀"))
"""
name: 古明地戀, age: 15, gender: female
"""

def foo(name=15, age="female", gender):
    return f"name: {name}, age: {age}, gender: {gender}"

def foo(name, age, gender):
    return f"name: {name}, age: {age}, gender: {gender}"

foo.__defaults__ = ("古明地覺", "古明地戀", 15, "female")
print(foo())
"""
name: 古明地戀, age: 15, gender: female
"""

import copy

def foo(a, b):
    return [a, b]

# 但是問題來了，這樣能否實(shí)現(xiàn)深度拷貝呢？
new_foo = copy.deepcopy(foo)
# 修改 foo 的默認(rèn)值
foo.__defaults__ = (2, 3)
# 但是 new_foo 也會(huì)受到影響
print(new_foo())  # [2, 3]

from types import FunctionType

def foo(a, b):
    return "result"

# FunctionType 就是函數(shù)的類型對(duì)象
# 它也是通過 type 得到的
new_foo = FunctionType(foo.__code__,
                       foo.__globals__,
                       foo.__name__,
                       foo.__defaults__,
                       foo.__closure__)
# 顯然 function 還可以接收第四個(gè)參數(shù)和第五個(gè)參數(shù)
# 分別是函數(shù)的默認(rèn)值和閉包

# 然后別忘記將屬性字典也拷貝一份
# 由于函數(shù)的屬性字典幾乎用不上，這里就淺拷貝了
new_foo.__dict__.update(foo.__dict__)

foo.__defaults__ = (2, 3)
print(foo.__defaults__)  # (2, 3)
print(new_foo.__defaults__)  # None

def foo(a, b, /, c, d, *args, e, f, **kwargs):
    g = 1
    h = 2

print(foo.__code__.co_varnames)
"""
('a', 'b', 'c', 'd', 'e', 'f', 'args', 'kwargs', 'g', 'h')
"""

def foo(a, b, /, c, d, *args, e, f, **kwargs):
    g = 1
    h = 2

varnames = foo.__code__.co_varnames
# 1. 尋找必須通過位置參數(shù)傳遞的參數(shù)
posonlyargcount = foo.__code__.co_posonlyargcount
print(posonlyargcount)  # 2
print(varnames[: posonlyargcount])  # ('a', 'b')

# 2. 尋找可以通過位置參數(shù)或者關(guān)鍵字參數(shù)傳遞的參數(shù)
argcount = foo.__code__.co_argcount
print(argcount)  # 4
print(varnames[: argcount])  # ('a', 'b', 'c', 'd')
print(varnames[posonlyargcount: argcount])  # ('c', 'd')

# 3. 尋找必須通過關(guān)鍵字參數(shù)傳遞的參數(shù)
kwonlyargcount = foo.__code__.co_kwonlyargcount
print(kwonlyargcount)  # 2
print(varnames[argcount: argcount + kwonlyargcount])  # ('e', 'f')

# 4. 尋找 *args 和 **kwargs
flags = foo.__code__.co_flags
# 在介紹 PyCodeObject 的時(shí)候，我們說里面有一個(gè) co_flags 成員
# 它是函數(shù)的標(biāo)識(shí)，可以對(duì)函數(shù)類型和參數(shù)進(jìn)行檢測(cè)
# 如果 co_flags 和 4 按位與之后為真，那么就代表有 *args，否則沒有
# 如果 co_flags 和 8 按位與之后為真，那么就代表有 **kwargs，否則沒有
step = argcount + kwonlyargcount
if flags & 0x04:
    print(varnames[step])  # args
    step += 1

if flags & 0x08:
    print(varnames[step])  # kwargs

def f(a, b, *, c):
    pass


# 符號(hào)表里面只有 a、b、c
print(f.__code__.co_varnames)  # ('a', 'b', 'c')

# 顯然此時(shí)也都為假
print(f.__code__.co_flags & 0x04)  # 0
print(f.__code__.co_flags & 0x08)  # 0