typedef?struct?{
????/*?頭部信息，無需多說?*/
????PyObject_HEAD
????/*?函數(shù)對應(yīng)的?PyCodeObject?對象
???????因為函數(shù)也是基于?PyCodeObject?對象構(gòu)建的?*/
????PyObject?*func_code;???
????/*?函數(shù)的?global?名字空間?*/?????
????PyObject?*func_globals;?????
????/*?函數(shù)參數(shù)的默認值，一個元組或者空?*/???
????PyObject?*func_defaults;????
????/*?只能通過關(guān)鍵字的方式傳遞的?"參數(shù)"?和?"該參數(shù)的默認值"?組成的字典?
???????或者空?*/???
????PyObject?*func_kwdefaults;??
????/*?閉包?*/
????PyObject?*func_closure;?????
????/*?函數(shù)的?docstring?*/
????PyObject?*func_doc;??
????/*?函數(shù)名?*/???????
????PyObject?*func_name;??????
????/*?函數(shù)的屬性字典，一般為空?*/??
????PyObject?*func_dict;?
????/*?弱引用列表，對函數(shù)的弱引用都會保存在里面?*/???????
????PyObject?*func_weakreflist;?
????/*?函數(shù)所在的模塊?*/
????PyObject?*func_module;??
????/*?函數(shù)的類型注解?*/????
????PyObject?*func_annotations;?
????/*?函數(shù)的全限定名?*/
????PyObject?*func_qualname;??
????/*?Python?函數(shù)在底層也是某個類（PyFunction_Type）的實例對象
???????調(diào)用時會執(zhí)行類型對象的?tp_call，在?Python?里面就是?__call__
???????但函數(shù)比較特殊，它創(chuàng)建出來就是為了調(diào)用的，所以不能走通用的?tp_call
???????為了優(yōu)化調(diào)用效率，引入了?vectorcall?*/??
????vectorcallfunc?vectorcall;
}?PyFunctionObject;

def?foo(a,?b,?c):
????pass

code?=?foo.__code__
print(code)??#?<code?object?foo?at?......>
print(code.co_varnames)??#?('a',?'b',?'c')

def?foo(a,?b,?c):
????pass

name?=?"古明地覺"
print(foo.__globals__)??#?{......,?'name':?'古明地覺'}
#?拿到的其實就是外部的?global名字空間
print(foo.__globals__?is?globals())??#?True

def?foo(name="古明地覺",?age=16):
????pass

#?打印的是默認值
print(foo.__defaults__)??#?('古明地覺',?16)


def?bar():
????pass

#?沒有默認值的話，__defaults__?為?None
print(bar.__defaults__)??#?None

def?foo(name="古明地覺",?age=16):
????pass

#?打印為?None，這是因為雖然有默認值
#?但并不要求必須通過關(guān)鍵字參數(shù)的方式傳遞
print(foo.__kwdefaults__)??#?None


def?bar(*,?name="古明地覺",?age=16):
????pass

print(
????bar.__kwdefaults__
)??#?{'name':?'古明地覺',?'age':?16}

def?foo():
????name?=?"古明地覺"
????age?=?16

????def?bar():
????????nonlocal?name
????????nonlocal?age

????return?bar

#?查看的是閉包里面使用的外層作用域的變量
#?所以 foo().__closure__?是一個包含兩個元素的元組
print(foo().__closure__)?
"""
(<cell?at?0x000001FD1D3B02B0:?int?object?at?0x00007FFDE559D660>,
?<cell?at?0x000001FD1D42E310:?str?object?at?0x000001FD1D3DA090>)
"""

print(foo().__closure__[0].cell_contents)??#?16
print(foo().__closure__[1].cell_contents)??#?古明地覺

def?foo():
????"""
????hi，歡迎來到我的編程教室
????遇見你真好
????"""
????pass?

print(foo.__doc__)
"""

????hi，歡迎來到我的編程教室
????遇見你真好
????
"""

def?foo(name,?age):
????pass

print(foo.__name__)??#?foo

import?numpy?as?np

print(np.__name__)??#?numpy
print(np.ndarray.__name__)??#?ndarray
print(np.array([1,?2,?3]).transpose.__name__)??#?transpose

def?foo(name,?age):
????pass

print(foo.__dict__)??#?{}

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

code?=?"""
name,?age?=?"古明地覺",?17

def?foo():
????return?"satori"?
"""
exec(code,?foo.__dict__)

print(foo.name)??#?古明地覺
print(foo.age)??#?17
print(foo.foo())??#?satori
print(foo("古明地覺",?17))??#?name:?古明地覺,?age:?17

def?foo(name,?age):
????pass

print(foo.__module__)??#?__main__

import?pandas?as?pd
print(
????pd.read_csv.__module__
)??#?pandas.io.parsers.readers
from?pandas.io.parsers.readers?import?read_csv
print(read_csv?is?pd.read_csv)??#?True

def?foo(name:?str,?age:?int):
????pass

#?Python3.5?新增的語法，但只能用于函數(shù)參數(shù)
#?而在?3.6?的時候，聲明變量也可以使用這種方式
#?特別是當?IDE 無法得知返回值類型時，便可通過類型注解的方式告知?IDE
#?這樣就又能使用?IDE?的智能提示了
print(foo.__annotations__)??
#?{'name':?<class?'str'>,?'age':?<class?'int'>}

def?foo():
????pass
print(foo.__name__,?foo.__qualname__)??#?foo?foo


class?A:

????def?foo(self):
????????pass
print(A.foo.__name__,?A.foo.__qualname__)??#?foo?A.foo

def?foo(name,?age):
????pass

#?<class?'function'>?就是?C?里面的?PyFunction_Type
print(foo.__class__)??#?<class?'function'>

#?虛擬機從上到下順序執(zhí)行字節(jié)碼
name?=?"古明地覺"
age?=?16

#?啪，很快啊，發(fā)現(xiàn)了一個?def?語句
def?foo():
????pass

#?出現(xiàn)?def，虛擬機就知道源代碼進入一個新的作用域了
#?也就是遇到一個新的?PyCodeObject?對象了
#?而通過?def?可以得知這是創(chuàng)建函數(shù)的語句
#?所以會基于?PyCodeObject?創(chuàng)建?PyFunctionObject
#?因此當執(zhí)行完?def?語句之后，一個函數(shù)就創(chuàng)建好了
#?創(chuàng)建完之后，會將函數(shù)名和函數(shù)體組成鍵值對，存放在當前的?local?空間中
print(locals()["foo"])
"""
<function?foo?at?0x7fdc280e6280>
"""

import?dis

s?=?"""
name?=?"satori"
def?foo(a,?b):
????print(a,?b)
????return?123

foo(1,?2)
"""

dis.dis(compile(s,?"<...>",?"exec"))

?????#?加載字符串常量?"satori"，壓入運行時棧
2????0?LOAD_CONST???????????????0?('satori')
?????#?將字符串從運行時棧彈出，并使用變量?name?綁定起來
?????#?也就是將?"name":?"satori"?放到?local?名字空間中
?????2?STORE_NAME???????????????0?(name)
?????
?????#?注意這一步也是?LOAD_CONST，但它加載的是?PyCodeObject?對象
?????#?所以?PyCodeObject?對象本質(zhì)上也是一個常量
3????4?LOAD_CONST???????????????1?(<code?object?foo?at?0x7fb...>)
?????#?加載符號?"foo"
?????6?LOAD_CONST???????????????2?('foo')
?????#?將符號?"foo"?和?PyCodeObject?對象從運行時棧彈出
?????#?然后創(chuàng)建?PyFunctionObject?對象，并壓入運行時棧
?????8?MAKE_FUNCTION????????????0
?????#?將上一步創(chuàng)建的函數(shù)對象從運行時棧彈出，并用變量?foo?與之綁定起來
?????#?后續(xù)通過?foo()?即可發(fā)起函數(shù)調(diào)用
????10?STORE_NAME???????????????1?(foo)

?????#?函數(shù)創(chuàng)建完了，我們調(diào)用函數(shù)
?????#?通過?LOAD_NAME?將?foo?對應(yīng)的函數(shù)對象（指針）壓入運行時棧
6???12?LOAD_NAME????????????????1?(foo)
?????#?將整數(shù)常量（參數(shù)）壓入運行時棧
????14?LOAD_CONST???????????????3?(1)
????16?LOAD_CONST???????????????4?(2)
?????#?將棧里面的參數(shù)和函數(shù)彈出，發(fā)起調(diào)用，并將調(diào)用的結(jié)果（返回值）壓入運行時棧
????18?CALL_FUNCTION????????????2
?????#?從棧頂彈出返回值，然后丟棄，因為我們沒有用變量接收返回值
?????#?如果我們用變量接收了，那么這里的指令就會從?POP_TOP?變成?STORE_NAME
????20?POP_TOP
?????#?return?None
????22?LOAD_CONST???????????????5?(None)
????24?RETURN_VALUE

?????#?以上是模塊對應(yīng)的字節(jié)碼指令，下面是函數(shù)?foo?的字節(jié)碼指令
???Disassembly?of?<code?object?foo?at?0x7fb......>:
?????#?從局部作用域中加載內(nèi)置變量?print
4????0?LOAD_GLOBAL??????????????0?(print)
?????#?從局部作用域中加載局部變量?a
?????2?LOAD_FAST????????????????0?(a)
?????#?從局部作用域中加載局部變量?b
?????4?LOAD_FAST????????????????1?(b)
?????#?從運行時棧中將參數(shù)和函數(shù)依次彈出，發(fā)起調(diào)用，也就是?print(a,?b)
?????6?CALL_FUNCTION????????????2
?????#?從棧頂彈出返回值，然后丟棄，因為我們沒有接收?print?的返回值
?????8?POP_TOP
?????#?return?123
????10?LOAD_CONST???????????????1?(123)
????12?RETURN_VALUE

case?TARGET(MAKE_FUNCTION):?{
????//?彈出壓入運行時棧的函數(shù)名
????PyObject?*qualname?=?POP();?
????//?彈出對應(yīng)的?PyCodeObject?對象
????PyObject?*codeobj?=?POP();??
????//?創(chuàng)建?PyFunctionObject?對象，需要三個參數(shù)
????//?分別是?PyCodeObject?對象、global?名字空間、函數(shù)的全限定名
????//?我們看到創(chuàng)建函數(shù)的時候?qū)?global?名字空間傳遞了進去
????//?所以現(xiàn)在我們應(yīng)該明白為什么函數(shù)可以調(diào)用?__globals__?了
????//?當然也明白為什么函數(shù)在局部變量找不到的時候可以去找全局變量了
????PyFunctionObject?*func?=?(PyFunctionObject?*)
????????PyFunction_NewWithQualName(codeobj,?f->f_globals,?qualname);
????
????//?減少引用計數(shù)
????//?如果函數(shù)創(chuàng)建失敗會返回?NULL，跳轉(zhuǎn)至?error
????Py_DECREF(codeobj);
????Py_DECREF(qualname);
????if?(func?==?NULL)?{
????????goto?error;
????}
????
????//?編譯時能夠靜態(tài)檢測出函數(shù)有沒有設(shè)置閉包、類型注解等屬性
????//?比如設(shè)置了閉包，那么?oparg?&?0x08?為真
????//?設(shè)置了類型注解，那么?oparg?&?0x04?為真
????//?如果條件為真，那么進行相關(guān)屬性設(shè)置
????if?(oparg?&?0x08)?{
????????assert(PyTuple_CheckExact(TOP()));
????????func?->func_closure?=?POP();
????}
????if?(oparg?&?0x04)?{
????????assert(PyDict_CheckExact(TOP()));
????????func->func_annotations?=?POP();
????}
????if?(oparg?&?0x02)?{
????????assert(PyDict_CheckExact(TOP()));
????????func->func_kwdefaults?=?POP();
????}
????if?(oparg?&?0x01)?{
????????assert(PyTuple_CheckExact(TOP()));
????????func->func_defaults?=?POP();
????}

????//?將創(chuàng)建好的函數(shù)對象的指針壓入運行時棧
????//?下一個指令?STORE_NAME?會將它從運行時棧彈出
????//?并用變量?foo?和它綁定起來，放入?local?空間中
????PUSH((PyObject?*)func);
????DISPATCH();
}

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

foo(1,?2)
"""

import?dis
dis.dis(compile(s,?"func",?"exec"))

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

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

def?f():
????pass

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

gender?=?"female"

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

#?得到PyCodeObject對象
code?=?f.__code__
#?根據(jù)類function創(chuàng)建函數(shù)對象
#?接收三個參數(shù):?PyCodeObject對象、名字空間、函數(shù)名
new_f?=?type(f)(code,?globals(),?"根據(jù)?f?創(chuàng)建的?new_f")

#?打印函數(shù)名
print(new_f.__name__)??#?根據(jù)?f?創(chuàng)建的?new_f

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

gender?=?"female"

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

code?=?f.__code__
try:
????new_f?=?type(f)(code,?None,?"根據(jù)?f?創(chuàng)建的?new_f")
except?TypeError?as?e:
????print(e)??
????"""
????function()?argument?'globals'?must?be?dict,?not?None
????"""
#?這里告訴我們?function?的第二個參數(shù)?globals?必須是一個字典
#?我們傳遞一個空字典
new_f1?=?type(f)(code,?{},?"根據(jù)?f?創(chuàng)建的?new_f1")
#?打印函數(shù)名
print(new_f1.__name__)??#?根據(jù)?f?創(chuàng)建的?new_f1

#?調(diào)用函數(shù)
try:
????print(new_f1("古明地覺",?16))
except?NameError?as?e:
????print(e)??
????"""
????name?'gender'?is?not?defined
????"""

#?我們看到提示?gender?沒有定義

gender?=?"female"

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

code?=?f.__code__
new_f?=?type(f)(code,?{"gender":?"少女覺"},?"根據(jù)?f?創(chuàng)建的?new_f")

#?我們可以手動傳遞一個字典進去
#?此時我們傳遞的字典對于函數(shù)來說就是?global?名字空間
#?所以在函數(shù)內(nèi)部找不到某個變量的時候,?就會去我們指定的名字空間中查找
print(new_f("古明地覺",?16))?
"""
name:?古明地覺,?age:?16,?gender:?少女覺
"""
#?所以此時的?gender?不再是外部的?"female"
#?而是我們指定的?"少女覺"

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

#?必須接收一個PyTupleObject對象
f.__defaults__?=?("古明地覺",?16,?"female")
print(f())
"""
name:?古明地覺,?age:?16,?gender:?female
"""

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

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

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

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

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

import?copy

def?f(a,?b):
????return?[a,?b]

#?但是問題來了，這樣能否實現(xiàn)深度拷貝呢？
new_f?=?copy.deepcopy(f)
f.__defaults__?=?(2,?3)
print(new_f())??#?[2,?3]

from?types?import?FunctionType

def?f(a,?b):
????return?"result"

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

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

f.__defaults__?=?(2,?3)
print(f.__defaults__)??#?(2,?3)
print(new_f.__defaults__)??#?None

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

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

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

varnames?=?f.__code__.co_varnames

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

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

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

#?4.?尋找?*args?和?**kwargs
flags?=?f.__code__.co_flags
#?在介紹?PyCodeObject?的時候，我們說里面有一個?co_flags?成員
#?它是函數(shù)的標識，可以對函數(shù)類型和參數(shù)進行檢測
#?如果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
????
#?我們看到此時只有a、b、c
print(f.__code__.co_varnames)??#?('a',?'b',?'c')

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

def?foo():
????pass

print(type(foo))??
print(type(sum))??
"""
<class?'function'>
<class?'builtin_function_or_method'>
"""

s?=?"""
def?foo():
????a,?b?=?1,?2
????return?a?+?b

foo()
"""

if?__name__?==?'__main__':
????import?dis
????dis.dis(compile(s,?"<...>",?"exec"))

?#?遇見?def?表示構(gòu)建函數(shù)
?#?于是加載?PyCodeObject?對象和函數(shù)名?"foo"
?0?LOAD_CONST???????????????0?(<code?object?foo?at?0x7f...>)
?2?LOAD_CONST???????????????1?('foo')
?#?構(gòu)建函數(shù)對象，壓入運行時棧
?4?MAKE_FUNCTION????????????0
?#?從棧中彈出函數(shù)對象，用變量?foo?保存
?6?STORE_NAME???????????????0?(foo)
?#?將變量?foo?壓入運行時棧
?8?LOAD_NAME????????????????0?(foo)
?#?從棧中彈出?foo，執(zhí)行?foo()，也就是函數(shù)調(diào)用，這一會要剖析的重點
10?CALL_FUNCTION????????????0
?#?從棧頂彈出返回值
12?POP_TOP
?#?return?None
14?LOAD_CONST???????????????2?(None)
16?RETURN_VALUE

Disassembly?of?<code?object?foo?at?0x7...>:
?#?函數(shù)的字節(jié)碼，因為模塊和函數(shù)都會對應(yīng)?PyCodeObject
?#?只不過后者在前者的常量池中
?
?#?加載元組常量?(1,?2)
?0?LOAD_CONST???????????????1?((1,?2))
?#?解包，將常量壓入運行時棧
?2?UNPACK_SEQUENCE??????????2
?#?再從棧中彈出，分別賦值給?a?和?b?
?4?STORE_FAST???????????????0?(a)
?6?STORE_FAST???????????????1?(b)
?#?加載?a?和?b
?8?LOAD_FAST????????????????0?(a)
10?LOAD_FAST????????????????1?(b)
?#?執(zhí)行加法運算
12?BINARY_ADD
?#?將相加之和的值返回
14?RETURN_VALUE

case?TARGET(CALL_FUNCTION):?{
????PREDICTED(CALL_FUNCTION);
????PyObject?**sp,?*res;
????// 指向運行時棧的棧頂
????sp?=?stack_pointer;
????// 調(diào)用函數(shù)，將返回值賦值給 res
????// tstate 表示線程狀態(tài)對象
????// &sp 是一個三級指針，oparg 表示指令的操作數(shù)
????res?=?call_function(tstate,?&sp,?oparg,?NULL);
????// 函數(shù)執(zhí)行完畢之后，sp 會指向運行時棧的棧頂
????// 所以再將修改之后的?sp 賦值給 stack_pointer
????stack_pointer?=?sp;
????// 將?res?壓入棧中：*stack_pointer++?=?res
????PUSH(res);
????if?(res?==?NULL)?{
????????goto?error;
????}
????DISPATCH();
}

//Objects/call.c
PyObject?*
_PyFunction_FastCallDict(PyObject?*func,?PyObject?*const?*args,?Py_ssize_t?nargs,
?????????????????????????PyObject?*kwargs)
{???
????//獲取PyCodeObject對象
????PyCodeObject?*co?=?(PyCodeObject?*)PyFunction_GET_CODE(func);?
????//獲取global名字空間
????PyObject?*globals?=?PyFunction_GET_GLOBALS(func);
????//獲取默認值
????PyObject?*argdefs?=?PyFunction_GET_DEFAULTS(func);
????//....
??????
????//我們觀察一下下面的return
????//一個是function_code_fastcall，一個是最后的_PyEval_EvalCodeWithName
????//從名字上能看出來function_code_fastcall是一個快分支
????//但是這個快分支要求函數(shù)調(diào)用時不能傳遞關(guān)鍵字參數(shù)
????if?(co->co_kwonlyargcount?==?0?&&
????????(kwargs?==?NULL?||?PyDict_GET_SIZE(kwargs)?==?0)?&&
????????(co->co_flags?&?~PyCF_MASK)?==?(CO_OPTIMIZED?|?CO_NEWLOCALS?|?CO_NOFREE))
????{
????????/*?Fast?paths?*/
????????if?(argdefs?==?NULL?&&?co->co_argcount?==?nargs)?{
????????????//function_code_fastcall里面邏輯很簡單
????????????//直接抽走當前PyFunctionObject里面PyCodeObject和global名字空間
????????????//根據(jù)PyCodeObject對象直接為其創(chuàng)建一個PyFrameObject對象
????????????//然后PyEval_EvalFrameEx執(zhí)行棧幀
????????????//也就是真正的進入了函數(shù)調(diào)用，執(zhí)行函數(shù)里面的代碼
????????????return?function_code_fastcall(co,?args,?nargs,?globals);
????????}
????????else?if?(nargs?==?0?&&?argdefs?!=?NULL
?????????????????&&?co->co_argcount?==?PyTuple_GET_SIZE(argdefs))?{
????????????/*?function?called?with?no?arguments,?but?all?parameters?have
???????????????a?default?value:?use?default?values?as?arguments?.*/
????????????args?=?_PyTuple_ITEMS(argdefs);
????????????return?function_code_fastcall(co,?args,?PyTuple_GET_SIZE(argdefs),
??????????????????????????????????????????globals);
????????}
????}
??
????//適用于有關(guān)鍵字參數(shù)的情況
????nk?=?(kwargs?!=?NULL)???PyDict_GET_SIZE(kwargs)?:?0;
????//.....
????//調(diào)用_PyEval_EvalCodeWithName
????result?=?_PyEval_EvalCodeWithName((PyObject*)co,?globals,?(PyObject?*)NULL,
??????????????????????????????????????args,?nargs,
??????????????????????????????????????k,?k?!=?NULL???k?+?1?:?NULL,?nk,?2,
??????????????????????????????????????d,?nd,?kwdefs,
??????????????????????????????????????closure,?name,?qualname);
????Py_XDECREF(kwtuple);
????return?result;
}