一文解密Python函數(shù)的實(shí)現(xiàn)原理

更新時(shí)間：2023年03月23日 09:50:08 作者：古明地覺(jué)

函數(shù)是任何一門(mén)編程語(yǔ)言都具備的基本元素，它可以將多個(gè)要執(zhí)行的操作組合起來(lái)，一個(gè)函數(shù)代表了一系列的操作。那就來(lái)看看Python函數(shù)的實(shí)現(xiàn)原理吧

楔子

函數(shù)是任何一門(mén)編程語(yǔ)言都具備的基本元素，它可以將多個(gè)要執(zhí)行的操作組合起來(lái)，一個(gè)函數(shù)代表了一系列的操作。而且在調(diào)用函數(shù)時(shí)會(huì)干什么來(lái)著，沒(méi)錯(cuò)，要?jiǎng)?chuàng)建棧幀，用于函數(shù)的執(zhí)行。

那么下面就來(lái)看看函數(shù)在 C 中是如何實(shí)現(xiàn)的，生得一副什么模樣。

PyFunctionObject

Python 一切皆對(duì)象，函數(shù)也不例外。函數(shù)在底層是通過(guò) PyFunctionObject 結(jié)構(gòu)體實(shí)現(xiàn)的，定義在 funcobject.h 中。

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

我們來(lái)實(shí)際獲取一下這些成員，看看它們?cè)?Python 中是如何表現(xiàn)的。

func_code：函數(shù)的字節(jié)碼

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

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

func_globals：global 名字空間

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

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

func_defaults：函數(shù)參數(shù)的默認(rèn)值

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

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


def?bar():
????pass

#?沒(méi)有默認(rèn)值的話，__defaults__?為?None
print(bar.__defaults__)??#?None

func_kwdefaults：只能通過(guò)關(guān)鍵字的方式傳遞的 "參數(shù)" 和 "該參數(shù)的默認(rèn)值" 組成的字典

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

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


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

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

在前面加上一個(gè) *，就表示后面的參數(shù)必須通過(guò)關(guān)鍵字的方式傳遞。因?yàn)槿绻煌ㄟ^(guò)關(guān)鍵字參數(shù)傳遞的話，那么無(wú)論多少個(gè)位置參數(shù)都會(huì)被 * 接收，無(wú)論如何也不可能傳遞給 name、age。

我們知道如果定義了 *args，那么函數(shù)可以接收任意個(gè)位置參數(shù)，然后這些參數(shù)以元組的形式保存在 args 里面。但這里我們不需要，我們只是希望后面的參數(shù)必須通過(guò)關(guān)鍵字參數(shù)傳遞，因此前面寫(xiě)一個(gè) * 即可，當(dāng)然寫(xiě) *args 也是可以的。

func_closure：閉包對(duì)象

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

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

????return?bar

#?查看的是閉包里面使用的外層作用域的變量
#?所以 foo().__closure__?是一個(gè)包含兩個(gè)元素的元組
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)??#?古明地覺(jué)

注意：查看閉包屬性我們使用的是內(nèi)層函數(shù)，不是外層的 foo。

func_doc：函數(shù)的 docstring

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

print(foo.__doc__)
"""

????hi，歡迎來(lái)到我的編程教室
????遇見(jiàn)你真好
????
"""

func_name：函數(shù)的名字

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

print(foo.__name__)??#?foo

當(dāng)然不光是函數(shù)，方法、類(lèi)、模塊都有自己的名字。

import?numpy?as?np

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

func_dict：函數(shù)的屬性字典

因?yàn)楹瘮?shù)在底層也是由一個(gè)類(lèi)實(shí)例化得到的，所以它可以有自己的屬性字典，只不過(guò)這個(gè)字典一般為空。

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

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

當(dāng)然啦，我們也可以整點(diǎn)騷操作：

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

code?=?"""
name,?age?=?"古明地覺(jué)",?17

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

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

所以雖然叫函數(shù)，但它也是由某個(gè)類(lèi)型對(duì)象實(shí)現(xiàn)的。

func_weakreflist：弱引用列表

Python無(wú)法獲取這個(gè)屬性，底層沒(méi)有提供相應(yīng)的接口，關(guān)于弱引用此處就不深入討論了。

func_module：函數(shù)所在的模塊

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

類(lèi)、方法、協(xié)程也有 __module__ 屬性。

func_annotations：類(lèi)型注解

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

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

func_qualname：全限定名

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

全限定名要更加地完整一些。

以上就是函數(shù)的底層結(jié)構(gòu)，在 Python 里面是由 function 實(shí)例化得到的。

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

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

但是這個(gè)類(lèi)底層沒(méi)有暴露給我們，我們不能直接用，因?yàn)楹瘮?shù)通過(guò) def 創(chuàng)建即可，不需要通過(guò)類(lèi)型對(duì)象來(lái)創(chuàng)建。

函數(shù)是何時(shí)創(chuàng)建的

前面我們說(shuō)到函數(shù)在底層是由 PyFunctionObject 結(jié)構(gòu)體實(shí)現(xiàn)的，它里面有一個(gè) func_code 成員，指向一個(gè) PyCodeObject 對(duì)象，函數(shù)就是根據(jù)它創(chuàng)建的。

因?yàn)?PyCodeObject 是對(duì)一段代碼的靜態(tài)表示，Python 編譯器在將源代碼編譯之后，對(duì)里面的每一個(gè)代碼塊（code block）都會(huì)生成一個(gè)、并且是唯一一個(gè) PyCodeObject 對(duì)象。該對(duì)象包含了這個(gè)代碼塊的一些靜態(tài)信息，也就是可以從源代碼當(dāng)中看到的信息。

比如某個(gè)函數(shù)對(duì)應(yīng)的代碼塊里面有一個(gè) a = 1 這樣的表達(dá)式，那么符號(hào) a 和整數(shù) 1、以及它們之間的聯(lián)系就是靜態(tài)信息，而這些信息會(huì)被靜態(tài)存儲(chǔ)起來(lái)。

符號(hào) a 被存在符號(hào)表 co_varnames 中；
整數(shù) 1 被存在常量池 co_consts 中；
這兩者之間是一個(gè)賦值語(yǔ)句，因此會(huì)有兩條指令：LOAD_CONST 和 STORE_FAST，它們存在字節(jié)碼指令序列 co_code 中；

以上這些信息是編譯的時(shí)候就可以得到的，因此 PyCodeObject 對(duì)象是編譯之后的結(jié)果。

但是 PyFunctionObject 對(duì)象是何時(shí)產(chǎn)生的呢？顯然它是 Python 代碼在運(yùn)行時(shí)動(dòng)態(tài)產(chǎn)生的，更準(zhǔn)確的說(shuō)，是虛擬機(jī)在執(zhí)行一個(gè) def 語(yǔ)句的時(shí)候創(chuàng)建的。

當(dāng)虛擬機(jī)在當(dāng)前棧幀中執(zhí)行字節(jié)碼時(shí)發(fā)現(xiàn)了 def 語(yǔ)句，那么就代表發(fā)現(xiàn)了新的 PyCodeObject 對(duì)象，因?yàn)樗鼈兪强梢詫訉忧短椎?。所以虛擬機(jī)會(huì)根據(jù)這個(gè) PyCodeObject 對(duì)象創(chuàng)建對(duì)應(yīng)的 PyFunctionObject 對(duì)象，然后將函數(shù)名和 PyFunctionObject 對(duì)象（函數(shù)體）組成鍵值對(duì)放在當(dāng)前的 local 空間中。

而在 PyFunctionObject 對(duì)象中，也需要拿到相關(guān)的靜態(tài)信息，因此會(huì)有一個(gè) func_code 成員指向 PyCodeObject。

除此之外，PyFunctionObject 對(duì)象中還包含了一些函數(shù)在執(zhí)行時(shí)所必需的動(dòng)態(tài)信息，即上下文信息。比如 func_globals，就是函數(shù)在執(zhí)行時(shí)關(guān)聯(lián)的 global 空間，說(shuō)白了就是在局部變量找不到的時(shí)候能夠找全局變量，可如果連 global 空間都沒(méi)有的話，那即便想找也無(wú)從下手呀。

而 global 作用域中的符號(hào)和值必須在運(yùn)行時(shí)才能確定，所以這部分必須在運(yùn)行時(shí)動(dòng)態(tài)創(chuàng)建，無(wú)法靜態(tài)存儲(chǔ)在 PyCodeObject 中，因此要根據(jù) PyCodeObject 對(duì)象創(chuàng)建 PyFunctionObject 對(duì)象?？傊磺械哪康?，都是為了更好地執(zhí)行字節(jié)碼。

我們舉個(gè)例子：

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

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

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

調(diào)用的時(shí)候，會(huì)從 local 空間中取出符號(hào) foo 對(duì)應(yīng)的 PyFunctionObject 對(duì)象。然后根據(jù)這個(gè) PyFunctionObject 對(duì)象創(chuàng)建 PyFrameObject 對(duì)象，也就是為函數(shù)創(chuàng)建一個(gè)棧幀，隨后將執(zhí)行權(quán)交給新創(chuàng)建的棧幀，并在新創(chuàng)建的棧幀中執(zhí)行字節(jié)碼。

函數(shù)是怎么創(chuàng)建的

通過(guò)上面的分析，我們知道了函數(shù)是虛擬機(jī)在遇到 def 語(yǔ)句的時(shí)候創(chuàng)建的，并保存在 local 空間中。當(dāng)我們通過(guò)函數(shù)名()的方式調(diào)用時(shí)，會(huì)從 local 空間取出和函數(shù)名綁定的函數(shù)對(duì)象，然后執(zhí)行。

那么問(wèn)題來(lái)了，函數(shù)（對(duì)象）是怎么創(chuàng)建的呢？或者說(shuō)虛擬機(jī)是如何完成 PyCodeObject 對(duì)象到 PyFunctionObject 對(duì)象之間的轉(zhuǎn)變呢？顯然想了解這其中的奧秘，就必須從字節(jié)碼入手。

import?dis

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

foo(1,?2)
"""

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

源代碼很簡(jiǎn)單，定義一個(gè)變量 name 和函數(shù) foo，然后調(diào)用函數(shù)。顯然源代碼在編譯之后會(huì)產(chǎn)生兩個(gè) PyCodeObject，一個(gè)是模塊的，一個(gè)是函數(shù) foo 的，我們來(lái)看一下。

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

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

?????#?以上是模塊對(duì)應(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)
?????#?從運(yùn)行時(shí)棧中將參數(shù)和函數(shù)依次彈出，發(fā)起調(diào)用，也就是?print(a,?b)
?????6?CALL_FUNCTION????????????2
?????#?從棧頂彈出返回值，然后丟棄，因?yàn)槲覀儧](méi)有接收?print?的返回值
?????8?POP_TOP
?????#?return?123
????10?LOAD_CONST???????????????1?(123)
????12?RETURN_VALUE

上面有一個(gè)有趣的現(xiàn)象，就是源代碼的行號(hào)。之前看到源代碼的行號(hào)都是從上往下、依次增大的，這很好理解，畢竟一條一條解釋嘛。但是這里卻發(fā)生了變化，先執(zhí)行了第 6 行，之后再執(zhí)行第 4 行。

如果是從 Python 層面的函數(shù)調(diào)用來(lái)理解的話，很容易一句話就解釋了，因?yàn)楹瘮?shù)只有在調(diào)用的時(shí)候才會(huì)執(zhí)行，而調(diào)用肯定發(fā)生在創(chuàng)建之后。但是從字節(jié)碼的角度來(lái)理解的話，我們發(fā)現(xiàn)函數(shù)的聲明和實(shí)現(xiàn)是分離的，是在不同的 PyCodeObject 對(duì)象中。

確實(shí)如此，雖然函數(shù)名和函數(shù)體是一個(gè)整體，但是虛擬機(jī)在實(shí)現(xiàn)的時(shí)候，卻在物理上將它們分離開(kāi)了。

正所謂函數(shù)即變量，我們可以把函數(shù)當(dāng)成普通的變量來(lái)處理。函數(shù)名就是變量名，它位于模塊對(duì)應(yīng)的 PyCodeObject 的符號(hào)表中；函數(shù)體就是變量指向的值，它是基于一個(gè)獨(dú)立的 PyCodeObject 構(gòu)建的。

換句話說(shuō)，在編譯時(shí)，函數(shù)體里面的代碼會(huì)位于一個(gè)新的 PyCodeObject 對(duì)象當(dāng)中，所以函數(shù)的聲明和實(shí)現(xiàn)是分離的。

至此，函數(shù)的結(jié)構(gòu)就已經(jīng)非常清晰了。

所以函數(shù)名和函數(shù)體是分離的，它們存儲(chǔ)在不同的 PyCodeObject 對(duì)象當(dāng)中。

分析完結(jié)構(gòu)之后，重點(diǎn)就要落在 MAKE_FUNCTION 指令上了，我們說(shuō)當(dāng)遇到 def foo(a, b) 的時(shí)候，就知道要?jiǎng)?chuàng)建函數(shù)了。在語(yǔ)法上這是函數(shù)的聲明語(yǔ)句，但從虛擬機(jī)的角度來(lái)看這其實(shí)是函數(shù)對(duì)象的創(chuàng)建語(yǔ)句。

所以下面我們就要分析一下這個(gè)指令，看看它到底是怎么將一個(gè) PyCodeObject 對(duì)象變成一個(gè) PyFunctionObject 對(duì)象的。

case?TARGET(MAKE_FUNCTION):?{
????//?彈出壓入運(yùn)行時(shí)棧的函數(shù)名
????PyObject?*qualname?=?POP();?
????//?彈出對(duì)應(yīng)的?PyCodeObject?對(duì)象
????PyObject?*codeobj?=?POP();??
????//?創(chuàng)建?PyFunctionObject?對(duì)象，需要三個(gè)參數(shù)
????//?分別是?PyCodeObject?對(duì)象、global?名字空間、函數(shù)的全限定名
????//?我們看到創(chuàng)建函數(shù)的時(shí)候?qū)?global?名字空間傳遞了進(jìn)去
????//?所以現(xiàn)在我們應(yīng)該明白為什么函數(shù)可以調(diào)用?__globals__?了
????//?當(dāng)然也明白為什么函數(shù)在局部變量找不到的時(shí)候可以去找全局變量了
????PyFunctionObject?*func?=?(PyFunctionObject?*)
????????PyFunction_NewWithQualName(codeobj,?f->f_globals,?qualname);
????
????//?減少引用計(jì)數(shù)
????//?如果函數(shù)創(chuàng)建失敗會(huì)返回?NULL，跳轉(zhuǎn)至?error
????Py_DECREF(codeobj);
????Py_DECREF(qualname);
????if?(func?==?NULL)?{
????????goto?error;
????}
????
????//?編譯時(shí)能夠靜態(tài)檢測(cè)出函數(shù)有沒(méi)有設(shè)置閉包、類(lèi)型注解等屬性
????//?比如設(shè)置了閉包，那么?oparg?&?0x08?為真
????//?設(shè)置了類(lèi)型注解，那么?oparg?&?0x04?為真
????//?如果條件為真，那么進(jìn)行相關(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ù)對(duì)象的指針壓入運(yùn)行時(shí)棧
????//?下一個(gè)指令?STORE_NAME?會(huì)將它從運(yùn)行時(shí)棧彈出
????//?并用變量?foo?和它綁定起來(lái)，放入?local?空間中
????PUSH((PyObject?*)func);
????DISPATCH();
}

整個(gè)步驟很好理解，先通過(guò) LOAD_CONST 將 PyCodeObject 對(duì)象和符號(hào) foo 壓入棧中。然后執(zhí)行 MAKE_FUNCTION 的時(shí)候，將兩者從棧中彈出，再加上當(dāng)前棧幀對(duì)象中維護(hù)的 global 名字空間，三者作為參數(shù)傳入 PyFunction_NewWithQualName 函數(shù)中，從而構(gòu)建出相應(yīng)的函數(shù)對(duì)象。

上面的函數(shù)比較簡(jiǎn)單，如果再加上類(lèi)型注解、以及默認(rèn)值，會(huì)有什么效果呢？

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"))

這里我們加上了類(lèi)型注解和默認(rèn)值，看看它的字節(jié)碼指令會(huì)有什么變化？

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

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

不難發(fā)現(xiàn)，在構(gòu)建函數(shù)時(shí)會(huì)先將默認(rèn)值以元組的形式壓入運(yùn)行時(shí)棧；然后再根據(jù)使用了類(lèi)型注解的參數(shù)和類(lèi)型構(gòu)建一個(gè)字典，并將這個(gè)字典壓入運(yùn)行時(shí)棧。

后續(xù)創(chuàng)建函數(shù)的時(shí)候，會(huì)將默認(rèn)值保存在 func_defaults 成員中，類(lèi)型注解對(duì)應(yīng)的字典會(huì)保存在 func_annotations 成員中。

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'>}

基于類(lèi)型注解和描述符，我們便可以像靜態(tài)語(yǔ)言一樣，實(shí)現(xiàn)函數(shù)參數(shù)的類(lèi)型約束。介紹完描述符之后，我們會(huì)舉例說(shuō)明。

函數(shù)的一些騷操作

我們通過(guò)一些騷操作，來(lái)更好地理解一下函數(shù)。

之前說(shuō) <class 'function'> 是函數(shù)的類(lèi)型對(duì)象，而這個(gè)類(lèi)底層沒(méi)有暴露給我們，但是可以通過(guò)曲線救國(guó)的方式進(jìn)行獲取。

def?f():
????pass

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

那么下面就來(lái)創(chuàng)建函數(shù)：

gender?=?"female"

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

#?得到PyCodeObject對(duì)象
code?=?f.__code__
#?根據(jù)類(lèi)function創(chuàng)建函數(shù)對(duì)象
#?接收三個(gè)參數(shù):?PyCodeObject對(duì)象、名字空間、函數(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("古明地覺(jué)",?16)
)??#?name:?古明地覺(jué),?age:?16,?gender:?female

是不是很神奇呢？另外我們說(shuō)函數(shù)在訪問(wèn)變量時(shí)，顯然先從自身的符號(hào)表中查找，如果沒(méi)有再去找全局變量。這是因?yàn)?，我們?cè)趧?chuàng)建函數(shù)的時(shí)候?qū)?global 名字空間傳進(jìn)去了，如果我們不傳遞呢？

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?的第二個(gè)參數(shù)?globals?必須是一個(gè)字典
#?我們傳遞一個(gè)空字典
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("古明地覺(jué)",?16))
except?NameError?as?e:
????print(e)??
????"""
????name?'gender'?is?not?defined
????"""

#?我們看到提示?gender?沒(méi)有定義

因此現(xiàn)在我們又從 Python 的角度理解了一遍，為什么函數(shù)能夠在局部變量找不到的時(shí)候，去找全局變量。原因就在于構(gòu)建函數(shù)的時(shí)候，將 global 名字空間交給了函數(shù)，使得函數(shù)可以在 global 空間進(jìn)行變量查找，所以它才能夠找到全局變量。而我們這里給了一個(gè)空字典，那么顯然就找不到 gender 這個(gè)變量了。

gender?=?"female"

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

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

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

此外我們還可以為函數(shù)指定默認(rèn)值：

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

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

我們看到函數(shù) f 明明接收三個(gè)參數(shù)，但是調(diào)用時(shí)不傳遞居然也不會(huì)報(bào)錯(cuò)，原因就在于我們指定了默認(rèn)值。而默認(rèn)值可以在定義函數(shù)的時(shí)候指定，也可以通過(guò) __defaults__ 指定，但很明顯我們應(yīng)該通過(guò)前者來(lái)指定。

如果你用的是 pycharm，那么會(huì)在 f() 這個(gè)位置給你飄黃，提示你參數(shù)沒(méi)有傳遞。但我們知道，由于使用 __defaults__ 已經(jīng)設(shè)置了默認(rèn)值，所以這里是不會(huì)報(bào)錯(cuò)的。只不過(guò) pycharm 沒(méi)有檢測(cè)到，當(dāng)然基本上所有的 IDE 都無(wú)法做到這一點(diǎn)，畢竟動(dòng)態(tài)語(yǔ)言。

另外 __defaults__ 接收的元組里面的元素個(gè)數(shù)和參數(shù)個(gè)數(shù)不匹配怎么辦？

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

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

由于元組里面只有兩個(gè)元素，意味著我們?cè)谡{(diào)用時(shí)需要至少傳遞一個(gè)參數(shù)，而這個(gè)參數(shù)會(huì)賦值給 name。原因就是在設(shè)置默認(rèn)值的時(shí)候是從后往前設(shè)置的，也就是 "female" 會(huì)給賦值給 gender，15 會(huì)賦值給 age。而 name 沒(méi)有得到默認(rèn)值，那么它就需要調(diào)用者顯式傳遞了。

為啥 Python 在設(shè)置默認(rèn)值是從后往前設(shè)置呢？如果從前往后設(shè)置的話，會(huì)出現(xiàn)什么后果呢？顯然此時(shí) 15 會(huì)賦值給 name，"female" 會(huì)賦值給 age，那么函數(shù)就等價(jià)于如下：

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

這樣的函數(shù)能夠通過(guò)編譯嗎？顯然是不行的，因?yàn)槟J(rèn)參數(shù)必須在非默認(rèn)參數(shù)的后面。所以 Python 的這個(gè)做法是完全正確的，必須要從后往前進(jìn)行設(shè)置。

另外我們知道默認(rèn)值的個(gè)數(shù)是小于等于參數(shù)個(gè)數(shù)的，如果大于會(huì)怎么樣呢？

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

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

依舊從后往前進(jìn)行設(shè)置，當(dāng)所有參數(shù)都有默認(rèn)值了，那么就結(jié)束了。當(dāng)然，如果不使用 __defaults__，是不可能出現(xiàn)默認(rèn)值個(gè)數(shù)大于參數(shù)個(gè)數(shù)的。

可要是 __defaults__ 指向的元組先結(jié)束，那么沒(méi)有得到默認(rèn)值的參數(shù)就必須由我們來(lái)傳遞了。

最后再來(lái)說(shuō)一下如何深拷貝一個(gè)函數(shù)。首先如果是你的話，你會(huì)怎么拷貝一個(gè)函數(shù)呢？不出意外的話，你應(yīng)該會(huì)使用 copy 模塊。

import?copy

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

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

修改 f 的 __defaults__，會(huì)對(duì) new_f 產(chǎn)生影響，因此我們并沒(méi)有實(shí)現(xiàn)函數(shù)的深度拷貝。事實(shí)上，copy 模塊無(wú)法對(duì)函數(shù)、方法、回溯棧、棧幀、模塊、文件、套接字等類(lèi)型的實(shí)例實(shí)現(xiàn)深度拷貝。

那我們應(yīng)該怎么做呢？

from?types?import?FunctionType

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

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

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

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

此時(shí)修改 f 不會(huì)影響 new_f，當(dāng)然在拷貝的時(shí)候也可以自定義屬性。

其實(shí)上面實(shí)現(xiàn)的深拷貝，本質(zhì)上就是定義了一個(gè)新的函數(shù)。由于是兩個(gè)不同的函數(shù)，那么自然就沒(méi)有聯(lián)系了。

判斷函數(shù)都有哪些參數(shù)

再來(lái)看看如何檢測(cè)一個(gè)函數(shù)有哪些參數(shù)，首先函數(shù)的局部變量(包括參數(shù))在編譯時(shí)就已經(jīng)確定，會(huì)存在符號(hào)表 co_varnames 中。

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')
"""

注意：在定義函數(shù)的時(shí)候，* 和 ** 最多只能出現(xiàn)一次。

顯然 a 和 b 必須通過(guò)位置參數(shù)傳遞，c 和 d 可以通過(guò)位置參數(shù)和關(guān)鍵字參數(shù)傳遞，e 和 f 必須通過(guò)關(guān)鍵字參數(shù)傳遞。

而從打印的符號(hào)表來(lái)看，里面的符號(hào)是有順序的。參數(shù)永遠(yuǎn)處于函數(shù)內(nèi)部定義的局部變量的前面，比如 g 和 h 就是函數(shù)內(nèi)部定義的局部變量，所以它在所有參數(shù)的后面。

而對(duì)于參數(shù)，* 和 ** 會(huì)位于最后面，其它參數(shù)位置不變。所以除了 g 和 h，最后面的就是 args 和 kwargs。

那么接下來(lái)我們就可以進(jìn)行檢測(cè)了。

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

varnames?=?f.__code__.co_varnames

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

#?2.?尋找既可以通過(guò)位置參數(shù)傳遞、又可以通過(guò)關(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ò)關(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?的時(shí)候，我們說(shuō)里面有一個(gè)?co_flags?成員
#?它是函數(shù)的標(biāo)識(shí)，可以對(duì)函數(shù)類(lèi)型和參數(shù)進(jìn)行檢測(cè)
#?如果co_flags和?4?進(jìn)行按位與之后為真，那么就代表有* args,?否則沒(méi)有
#?如果co_flags和?8?進(jìn)行按位與之后為真，那么就代表有 **kwargs,?否則沒(méi)有
step?=?argcount?+?kwonlyargcount
if?flags?&?0x04:
????print(varnames[step])??#?args
????step?+=?1

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

以上我們檢測(cè)出了函數(shù)都有哪些參數(shù)，你也可以將其封裝成一個(gè)函數(shù)，實(shí)現(xiàn)代碼的復(fù)用。

然后需要注意一下 args 和 kwargs，打印的內(nèi)容主要取決定義時(shí)使用的名字。如果定義的時(shí)候是 *ARGS 和 **KWARGS，那么這里就會(huì)打印 ARGS 和 KWARGS，只不過(guò)一般我們都叫做 *args 和 **kwargs。

但如果我們定義的時(shí)候不是 *args，只是一個(gè) *，那么它就不是參數(shù)了。

def?f(a,?b,?*,?c):
????pass
????
#?我們看到此時(shí)只有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
#?顯然此時(shí)也都為假

單獨(dú)的一個(gè) * 只是為了強(qiáng)制要求后面的參數(shù)必須通過(guò)關(guān)鍵字參數(shù)的方式傳遞。

以上就是如何通過(guò) PyCodeObject 對(duì)象來(lái)檢索函數(shù)的參數(shù)，以及相關(guān)種類(lèi)，標(biāo)準(zhǔn)庫(kù)中的 inspect 模塊也是這么做的。準(zhǔn)確的說(shuō)，是我們模仿人家的思路做的。

函數(shù)是怎么調(diào)用的

到目前為止，我們聊了聊 Python 函數(shù)的底層實(shí)現(xiàn)，并且還演示了如何通過(guò)函數(shù)的類(lèi)型對(duì)象自定義一個(gè)函數(shù)，以及如何獲取函數(shù)的參數(shù)。雖然這在工作中沒(méi)有太大意義，但是可以讓我們深刻理解函數(shù)的行為。

下面我來(lái)探討一下函數(shù)在底層是怎么調(diào)用的，但是在介紹調(diào)用之前，我們需要補(bǔ)充一個(gè)知識(shí)點(diǎn)。

def?foo():
????pass

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

函數(shù)實(shí)際上分為兩種：

如果是 Python 實(shí)現(xiàn)的函數(shù)，底層會(huì)對(duì)應(yīng) PyFunctionObject。其類(lèi)型在 Python 里面是 <class 'function'>，在底層是 PyFunction_Type；
如果是 C 實(shí)現(xiàn)的函數(shù)，底層會(huì)對(duì)應(yīng) PyCFunctionObject。其類(lèi)型在 Python 里面是 <class 'builtin_function_or_method'>，在底層是 PyCFunction_Type；

像內(nèi)置函數(shù)、使用 C 擴(kuò)展編寫(xiě)的函數(shù)，它們都是 PyCFunctionObject。

另外從名字上可以看出 PyCFunctionObject 不僅用于 C 實(shí)現(xiàn)的函數(shù)，還用于方法。關(guān)于方法，我們后續(xù)在介紹類(lèi)的時(shí)候細(xì)說(shuō)，這里暫時(shí)不做深入討論。

總之對(duì)于 Python 函數(shù)和 C 函數(shù)，底層在實(shí)現(xiàn)的時(shí)候?qū)烧叻珠_(kāi)了，因?yàn)?C 函數(shù)可以有更快的執(zhí)行方式。

注意這里說(shuō)的 C 函數(shù)，指的是 C 實(shí)現(xiàn)的 Python 函數(shù)。像內(nèi)置函數(shù)就是 C 實(shí)現(xiàn)的，比如 sum、getattr 等等。

好了，下面來(lái)看函數(shù)調(diào)用的具體細(xì)節(jié)。

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

foo()
"""

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

還是以一個(gè)簡(jiǎn)單的函數(shù)為例，看看它的字節(jié)碼：

?#?遇見(jiàn)?def?表示構(gòu)建函數(shù)
?#?于是加載?PyCodeObject?對(duì)象和函數(shù)名?"foo"
?0?LOAD_CONST???????????????0?(<code?object?foo?at?0x7f...>)
?2?LOAD_CONST???????????????1?('foo')
?#?構(gòu)建函數(shù)對(duì)象，壓入運(yùn)行時(shí)棧
?4?MAKE_FUNCTION????????????0
?#?從棧中彈出函數(shù)對(duì)象，用變量?foo?保存
?6?STORE_NAME???????????????0?(foo)
?#?將變量?foo?壓入運(yùn)行時(shí)棧
?8?LOAD_NAME????????????????0?(foo)
?#?從棧中彈出?foo，執(zhí)行?foo()，也就是函數(shù)調(diào)用，這一會(huì)要剖析的重點(diǎn)
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é)碼，因?yàn)槟K和函數(shù)都會(huì)對(duì)應(yīng)?PyCodeObject
?#?只不過(guò)后者在前者的常量池中
?
?#?加載元組常量?(1,?2)
?0?LOAD_CONST???????????????1?((1,?2))
?#?解包，將常量壓入運(yùn)行時(shí)棧
?2?UNPACK_SEQUENCE??????????2
?#?再?gòu)臈Ｖ袕棾?，分別賦值給?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í)行加法運(yùn)算
12?BINARY_ADD
?#?將相加之和的值返回
14?RETURN_VALUE

相信現(xiàn)在看字節(jié)碼已經(jīng)不是什么問(wèn)題了，然后我們看到調(diào)用函數(shù)用的是 CALL_FUNCTION 指令，那么這個(gè)指令都做了哪些事情呢？

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

CALL_FUNCTION 這個(gè)指令之前提到過(guò)，但是函數(shù)的核心執(zhí)行流程是在 call_function 里面，它位于 ceval.c 中，我們來(lái)看一下。

因此接下來(lái)重點(diǎn)就在 _PyObject_Vectorcall 函數(shù)上面，在該函數(shù)內(nèi)部又會(huì)調(diào)用其它函數(shù)，最終會(huì)走到 _PyFunction_FastCallDict 這里。

//Objects/call.c
PyObject?*
_PyFunction_FastCallDict(PyObject?*func,?PyObject?*const?*args,?Py_ssize_t?nargs,
?????????????????????????PyObject?*kwargs)
{???
????//獲取PyCodeObject對(duì)象
????PyCodeObject?*co?=?(PyCodeObject?*)PyFunction_GET_CODE(func);?
????//獲取global名字空間
????PyObject?*globals?=?PyFunction_GET_GLOBALS(func);
????//獲取默認(rèn)值
????PyObject?*argdefs?=?PyFunction_GET_DEFAULTS(func);
????//....
??????
????//我們觀察一下下面的return
????//一個(gè)是function_code_fastcall，一個(gè)是最后的_PyEval_EvalCodeWithName
????//從名字上能看出來(lái)function_code_fastcall是一個(gè)快分支
????//但是這個(gè)快分支要求函數(shù)調(diào)用時(shí)不能傳遞關(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里面邏輯很簡(jiǎn)單
????????????//直接抽走當(dāng)前PyFunctionObject里面PyCodeObject和global名字空間
????????????//根據(jù)PyCodeObject對(duì)象直接為其創(chuàng)建一個(gè)PyFrameObject對(duì)象
????????????//然后PyEval_EvalFrameEx執(zhí)行棧幀
????????????//也就是真正的進(jìn)入了函數(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;
}

所以函數(shù)調(diào)用時(shí)會(huì)有兩種方式：

因此我們看到，總共有兩條途徑，分別針對(duì)有無(wú)關(guān)鍵字參數(shù)。但是最終殊途同歸，都會(huì)走到 PyEval_EvalFrameEx 那里，然后虛擬機(jī)在新的棧幀中執(zhí)行新的 PyCodeObject。

不過(guò)可能有人會(huì)好奇，我們之前說(shuō)過(guò)：

PyFrameObject 是根據(jù) PyCodeObject 創(chuàng)建的
PyFunctionObject 也是根據(jù) PyCodeObject 創(chuàng)建的

那么 PyFrameObject 和 PyFunctionObject 之間有啥關(guān)系呢？

如果把 PyCodeObject 比喻成妹子，那么 PyFunctionObject 就是妹子的備胎，PyFrameObject 就是妹子的心上人。

其實(shí)在棧幀中執(zhí)行指令時(shí)候，PyFunctionObject 的影響就已經(jīng)消失了，真正對(duì)棧幀產(chǎn)生影響的是PyFunctionObject 里面的 PyCodeObject 對(duì)象和 global 名字空間。

也就是說(shuō)，最終是 PyFrameObject 和 PyCodeObject 兩者如膠似漆，跟 PyFunctionObject 之間沒(méi)有關(guān)系，所以 PyFunctionObject 辛苦一場(chǎng)，實(shí)際上是為別人做了嫁衣。PyFunctionObject 主要是對(duì) PyCodeObject 和 global 名字空間的一種打包和運(yùn)輸方式。

以上我們就聊了聊 Python 函數(shù)的底層實(shí)現(xiàn)，總的來(lái)說(shuō) Python 函數(shù)的開(kāi)銷(xiāo)還是蠻大的。但從 3.11 開(kāi)始，這個(gè)開(kāi)銷(xiāo)變小了很多，至于背后細(xì)節(jié)我們以后再聊。

到此這篇關(guān)于一文解密Python函數(shù)的實(shí)現(xiàn)原理的文章就介紹到這了,更多相關(guān)Python函數(shù)內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: