您好,登錄后才能下訂單哦!
這篇文章主要介紹“Python函數(shù)的實(shí)現(xiàn)原理源碼分析”,在日常操作中,相信很多人在Python函數(shù)的實(shí)現(xiàn)原理源碼分析問題上存在疑惑,小編查閱了各式資料,整理出簡單好用的操作方法,希望對(duì)大家解答”Python函數(shù)的實(shí)現(xiàn)原理源碼分析”的疑惑有所幫助!接下來,請(qǐng)跟著小編一起來學(xué)習(xí)吧!
函數(shù)是任何一門編程語言都具備的基本元素,它可以將多個(gè)要執(zhí)行的操作組合起來,一個(gè)函數(shù)代表了一系列的操作。而且在調(diào)用函數(shù)時(shí)會(huì)干什么來著,沒錯(cuò),要?jiǎng)?chuàng)建棧幀,用于函數(shù)的執(zhí)行。
Python 一切皆對(duì)象,函數(shù)也不例外。函數(shù)在底層是通過 PyFunctionObject 結(jié)構(gòu)體實(shí)現(xiàn)的,定義在 funcobject.h 中。
typedef struct { /* 頭部信息,無需多說 */ 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ā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ù)的類型注解 */ PyObject *func_annotations; /* 函數(shù)的全限定名 */ PyObject *func_qualname; /* Python 函數(shù)在底層也是某個(gè)類(PyFunction_Type)的實(shí)例對(duì)象 調(diào)用時(shí)會(huì)執(zhí)行類型對(duì)象的 tp_call,在 Python 里面就是 __call__ 但函數(shù)比較特殊,它創(chuàng)建出來就是為了調(diào)用的,所以不能走通用的 tp_call 為了優(yōu)化調(diào)用效率,引入了 vectorcall */ vectorcallfunc vectorcall; } PyFunctionObject;
我們來實(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 = "古明地覺" print(foo.__globals__) # {......, 'name': '古明地覺'} # 拿到的其實(shí)就是外部的 global名字空間 print(foo.__globals__ is globals()) # True
func_defaults:函數(shù)參數(shù)的默認(rèn)值
def foo(name="古明地覺", age=16): pass # 打印的是默認(rèn)值 print(foo.__defaults__) # ('古明地覺', 16) def bar(): pass # 沒有默認(rèn)值的話,__defaults__ 為 None print(bar.__defaults__) # None
func_kwdefaults:只能通過關(guān)鍵字的方式傳遞的 "參數(shù)" 和 "該參數(shù)的默認(rèn)值" 組成的字典
def foo(name="古明地覺", age=16): pass # 打印為 None,這是因?yàn)殡m然有默認(rèn)值 # 但并不要求必須通過關(guān)鍵字參數(shù)的方式傳遞 print(foo.__kwdefaults__) # None def bar(*, name="古明地覺", age=16): pass print( bar.__kwdefaults__ ) # {'name': '古明地覺', 'age': 16}
在前面加上一個(gè) *,就表示后面的參數(shù)必須通過關(guān)鍵字的方式傳遞。因?yàn)槿绻煌ㄟ^關(guān)鍵字參數(shù)傳遞的話,那么無論多少個(gè)位置參數(shù)都會(huì)被 * 接收,無論如何也不可能傳遞給 name、age。
我們知道如果定義了 *args,那么函數(shù)可以接收任意個(gè)位置參數(shù),然后這些參數(shù)以元組的形式保存在 args 里面。但這里我們不需要,我們只是希望后面的參數(shù)必須通過關(guān)鍵字參數(shù)傳遞,因此前面寫一個(gè) * 即可,當(dāng)然寫 *args 也是可以的。
func_closure:閉包對(duì)象
def foo(): name = "古明地覺" 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) # 古明地覺
注意:查看閉包屬性我們使用的是內(nèi)層函數(shù),不是外層的 foo。
func_doc:函數(shù)的 docstring
def foo(): """ hi,歡迎來到我的編程教室 遇見你真好 """ pass print(foo.__doc__) """ hi,歡迎來到我的編程教室 遇見你真好 """
func_name:函數(shù)的名字
def foo(name, age): pass print(foo.__name__) # foo
當(dāng)然不光是函數(shù),方法、類、模塊都有自己的名字。
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è)類實(shí)例化得到的,所以它可以有自己的屬性字典,只不過這個(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 = "古明地覺", 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
所以雖然叫函數(shù),但它也是由某個(gè)類型對(duì)象實(shí)現(xiàn)的。
func_weakreflist:弱引用列表
Python無法獲取這個(gè)屬性,底層沒有提供相應(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
類、方法、協(xié)程也有 __module__ 屬性。
func_annotations:類型注解
def foo(name: str, age: int): pass # Python3.5 新增的語法,但只能用于函數(shù)參數(shù) # 而在 3.6 的時(shí)候,聲明變量也可以使用這種方式 # 特別是當(dāng) IDE 無法得知返回值類型時(shí),便可通過類型注解的方式告知 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
全限定名要更加地完整一些。
def foo(name, age): pass # <class 'function'> 就是 C 里面的 PyFunction_Type print(foo.__class__) # <class 'function'>
但是這個(gè)類底層沒有暴露給我們,我們不能直接用,因?yàn)楹瘮?shù)通過 def 創(chuàng)建即可,不需要通過類型對(duì)象來創(chuàng)建。
前面我們說到函數(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ǔ)起來。
符號(hào) a 被存在符號(hào)表 co_varnames 中;
整數(shù) 1 被存在常量池 co_consts 中;
這兩者之間是一個(gè)賦值語句,因此會(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)確的說,是虛擬機(jī)在執(zhí)行一個(gè) def 語句的時(shí)候創(chuàng)建的。
當(dāng)虛擬機(jī)在當(dāng)前棧幀中執(zhí)行字節(jié)碼時(shí)發(fā)現(xiàn)了 def 語句,那么就代表發(fā)現(xiàn)了新的 PyCodeObject 對(duì)象,因?yàn)樗鼈兪强梢詫訉忧短椎摹K蕴摂M機(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 空間,說白了就是在局部變量找不到的時(shí)候能夠找全局變量,可如果連 global 空間都沒有的話,那即便想找也無從下手呀。
而 global 作用域中的符號(hào)和值必須在運(yùn)行時(shí)才能確定,所以這部分必須在運(yùn)行時(shí)動(dòng)態(tài)創(chuàng)建,無法靜態(tài)存儲(chǔ)在 PyCodeObject 中,因此要根據(jù) PyCodeObject 對(duì)象創(chuàng)建 PyFunctionObject 對(duì)象??傊磺械哪康?,都是為了更好地執(zhí)行字節(jié)碼。
我們舉個(gè)例子:
# 虛擬機(jī)從上到下順序執(zhí)行字節(jié)碼 name = "古明地覺" age = 16 # 啪,很快啊,發(fā)現(xiàn)了一個(gè) def 語句 def foo(): pass # 出現(xiàn) def,虛擬機(jī)就知道源代碼進(jìn)入一個(gè)新的作用域了 # 也就是遇到一個(gè)新的 PyCodeObject 對(duì)象了 # 而通過 def 可以得知這是創(chuàng)建函數(shù)的語句 # 所以會(huì)基于 PyCodeObject 創(chuàng)建 PyFunctionObject # 因此當(dāng)執(zhí)行完 def 語句之后,一個(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ù)是虛擬機(jī)在遇到 def 語句的時(shí)候創(chuàng)建的,并保存在 local 空間中。當(dāng)我們通過函數(shù)名()的方式調(diào)用時(shí),會(huì)從 local 空間取出和函數(shù)名綁定的函數(shù)對(duì)象,然后執(zhí)行。
那么問題來了,函數(shù)(對(duì)象)是怎么創(chuàng)建的呢?或者說虛擬機(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"))
源代碼很簡單,定義一個(gè)變量 name 和函數(shù) foo,然后調(diào)用函數(shù)。顯然源代碼在編譯之后會(huì)產(chǎn)生兩個(gè) PyCodeObject,一個(gè)是模塊的,一個(gè)是函數(shù) foo 的,我們來看一下。
# 加載字符串常量 "satori",壓入運(yùn)行時(shí)棧 2 0 LOAD_CONST 0 ('satori') # 將字符串從運(yùn)行時(shí)棧彈出,并使用變量 name 綁定起來 # 也就是將 "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 與之綁定起來 # 后續(xù)通過 foo() 即可發(fā)起函數(shù)調(diào)用 10 STORE_NAME 1 (foo) # 函數(shù)創(chuàng)建完了,我們調(diào)用函數(shù) # 通過 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)槲覀儧]有用變量接收返回值 # 如果我們用變量接收了,那么這里的指令就會(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)槲覀儧]有接收 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)用來理解的話,很容易一句話就解釋了,因?yàn)楹瘮?shù)只有在調(diào)用的時(shí)候才會(huì)執(zhí)行,而調(diào)用肯定發(fā)生在創(chuàng)建之后。但是從字節(jié)碼的角度來理解的話,我們發(fā)現(xiàn)函數(shù)的聲明和實(shí)現(xiàn)是分離的,是在不同的 PyCodeObject 對(duì)象中。
確實(shí)如此,雖然函數(shù)名和函數(shù)體是一個(gè)整體,但是虛擬機(jī)在實(shí)現(xiàn)的時(shí)候,卻在物理上將它們分離開了。
正所謂函數(shù)即變量,我們可以把函數(shù)當(dāng)成普通的變量來處理。函數(shù)名就是變量名,它位于模塊對(duì)應(yīng)的 PyCodeObject 的符號(hào)表中;函數(shù)體就是變量指向的值,它是基于一個(gè)獨(dú)立的 PyCodeObject 構(gòu)建的。
換句話說,在編譯時(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 指令上了,我們說當(dāng)遇到 def foo(a, b) 的時(shí)候,就知道要?jiǎng)?chuàng)建函數(shù)了。在語法上這是函數(shù)的聲明語句,但從虛擬機(jī)的角度來看這其實(shí)是函數(shù)對(duì)象的創(chuàng)建語句。
所以下面我們就要分析一下這個(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ū)?nbsp;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ù)有沒有設(shè)置閉包、類型注解等屬性 // 比如設(shè)置了閉包,那么 oparg & 0x08 為真 // 設(shè)置了類型注解,那么 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 和它綁定起來,放入 local 空間中 PUSH((PyObject *)func); DISPATCH(); }
整個(gè)步驟很好理解,先通過 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ù)比較簡單,如果再加上類型注解、以及默認(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"))
這里我們加上了類型注解和默認(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ù)使用了類型注解的參數(shù)和類型構(gòu)建一個(gè)字典,并將這個(gè)字典壓入運(yùn)行時(shí)棧。
后續(xù)創(chuàng)建函數(shù)的時(shí)候,會(huì)將默認(rèn)值保存在 func_defaults 成員中,類型注解對(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'>}
基于類型注解和描述符,我們便可以像靜態(tài)語言一樣,實(shí)現(xiàn)函數(shù)參數(shù)的類型約束。介紹完描述符之后,我們會(huì)舉例說明。
我們通過一些騷操作,來更好地理解一下函數(shù)。
之前說 <class 'function'> 是函數(shù)的類型對(duì)象,而這個(gè)類底層沒有暴露給我們,但是可以通過曲線救國的方式進(jìn)行獲取。
def f(): pass print(type(f)) # <class 'function'> # lambda匿名函數(shù)的類型也是 function print(type(lambda: None)) # <class 'function'>
那么下面就來創(chuàng)建函數(shù):
gender = "female" def f(name, age): return f"name: {name}, age: {age}, gender: {gender}" # 得到PyCodeObject對(duì)象 code = f.__code__ # 根據(jù)類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("古明地覺", 16) ) # name: 古明地覺, age: 16, gender: female
是不是很神奇呢?另外我們說函數(shù)在訪問變量時(shí),顯然先從自身的符號(hào)表中查找,如果沒有再去找全局變量。這是因?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("古明地覺", 16)) except NameError as e: print(e) """ name 'gender' is not defined """ # 我們看到提示 gender 沒有定義
因此現(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": "少女覺"}, "根據(jù) f 創(chuàng)建的 new_f") # 我們可以手動(dòng)傳遞一個(gè)字典進(jìn)去 # 此時(shí)我們傳遞的字典對(duì)于函數(shù)來說就是 global 名字空間 # 所以在函數(shù)內(nèi)部找不到某個(gè)變量的時(shí)候, 就會(huì)去我們指定的名字空間中查找 print(new_f("古明地覺", 16)) """ name: 古明地覺, age: 16, gender: 少女覺 """ # 所以此時(shí)的 gender 不再是外部的 "female" # 而是我們指定的 "少女覺"
此外我們還可以為函數(shù)指定默認(rèn)值:
def f(name, age, gender): return f"name: {name}, age: {age}, gender: {gender}" # 必須接收一個(gè)PyTupleObject對(duì)象 f.__defaults__ = ("古明地覺", 16, "female") print(f()) """ name: 古明地覺, age: 16, gender: female """
我們看到函數(shù) f 明明接收三個(gè)參數(shù),但是調(diào)用時(shí)不傳遞居然也不會(huì)報(bào)錯(cuò),原因就在于我們指定了默認(rèn)值。而默認(rèn)值可以在定義函數(shù)的時(shí)候指定,也可以通過 __defaults__ 指定,但很明顯我們應(yīng)該通過前者來指定。
如果你用的是 pycharm,那么會(huì)在 f() 這個(gè)位置給你飄黃,提示你參數(shù)沒有傳遞。但我們知道,由于使用 __defaults__ 已經(jīng)設(shè)置了默認(rèn)值,所以這里是不會(huì)報(bào)錯(cuò)的。只不過 pycharm 沒有檢測(cè)到,當(dāng)然基本上所有的 IDE 都無法做到這一點(diǎn),畢竟動(dòng)態(tài)語言。
另外 __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 沒有得到默認(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ù)能夠通過編譯嗎?顯然是不行的,因?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__ = ("古明地覺", "古明地戀", 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é)束,那么沒有得到默認(rèn)值的參數(shù)就必須由我們來傳遞了。
最后再來說一下如何深拷貝一個(gè)函數(shù)。首先如果是你的話,你會(huì)怎么拷貝一個(gè)函數(shù)呢?不出意外的話,你應(yīng)該會(huì)使用 copy 模塊。
import copy def f(a, b): return [a, b] # 但是問題來了,這樣能否實(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)生影響,因此我們并沒有實(shí)現(xiàn)函數(shù)的深度拷貝。事實(shí)上,copy 模塊無法對(duì)函數(shù)、方法、回溯棧、棧幀、模塊、文件、套接字等類型的實(shí)例實(shí)現(xiàn)深度拷貝。
那我們應(yīng)該怎么做呢?
from types import FunctionType def f(a, b): return "result" # FunctionType 就是函數(shù)的類型對(duì)象 # 它也是通過 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ù),那么自然就沒有聯(lián)系了。
再來看看如何檢測(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 必須通過位置參數(shù)傳遞,c 和 d 可以通過位置參數(shù)和關(guān)鍵字參數(shù)傳遞,e 和 f 必須通過關(guān)鍵字參數(shù)傳遞。
而從打印的符號(hào)表來看,里面的符號(hào)是有順序的。參數(shù)永遠(yuǎn)處于函數(shù)內(nèi)部定義的局部變量的前面,比如 g 和 h 就是函數(shù)內(nèi)部定義的局部變量,所以它在所有參數(shù)的后面。
而對(duì)于參數(shù),* 和 ** 會(huì)位于最后面,其它參數(shù)位置不變。所以除了 g 和 h,最后面的就是 args 和 kwargs。
那么接下來我們就可以進(jìn)行檢測(cè)了。
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 的時(shí)候,我們說里面有一個(gè) co_flags 成員 # 它是函數(shù)的標(biāo)識(shí),可以對(duì)函數(shù)類型和參數(shù)進(jìn)行檢測(cè) # 如果co_flags和 4 進(jìn)行按位與之后為真,那么就代表有* args, 否則沒有 # 如果co_flags和 8 進(jìn)行按位與之后為真,那么就代表有 **kwargs, 否則沒有 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,只不過一般我們都叫做 *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ān)鍵字參數(shù)的方式傳遞。
到目前為止,我們聊了聊 Python 函數(shù)的底層實(shí)現(xiàn),并且還演示了如何通過函數(shù)的類型對(duì)象自定義一個(gè)函數(shù),以及如何獲取函數(shù)的參數(shù)。雖然這在工作中沒有太大意義,但是可以讓我們深刻理解函數(shù)的行為。
下面我來探討一下函數(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。其類型在 Python 里面是 <class 'function'>,在底層是 PyFunction_Type;
如果是 C 實(shí)現(xiàn)的函數(shù),底層會(huì)對(duì)應(yīng) PyCFunctionObject。其類型在 Python 里面是 <class 'builtin_function_or_method'>,在底層是 PyCFunction_Type;
像內(nèi)置函數(shù)、使用 C 擴(kuò)展編寫的函數(shù),它們都是 PyCFunctionObject。
另外從名字上可以看出 PyCFunctionObject 不僅用于 C 實(shí)現(xiàn)的函數(shù),還用于方法。關(guān)于方法,我們后續(xù)在介紹類的時(shí)候細(xì)說,這里暫時(shí)不做深入討論。
總之對(duì)于 Python 函數(shù)和 C 函數(shù),底層在實(shí)現(xiàn)的時(shí)候?qū)烧叻珠_了,因?yàn)?C 函數(shù)可以有更快的執(zhí)行方式。
注意這里說的 C 函數(shù),指的是 C 實(shí)現(xiàn)的 Python 函數(shù)。像內(nèi)置函數(shù)就是 C 實(shí)現(xiàn)的,比如 sum、getattr 等等。
好了,下面來看函數(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è)簡單的函數(shù)為例,看看它的字節(jié)碼:
# 遇見 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 # 只不過后者在前者的常量池中 # 加載元組常量 (1, 2) 0 LOAD_CONST 1 ((1, 2)) # 解包,將常量壓入運(yùn)行時(shí)棧 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í)行加法運(yùn)算 12 BINARY_ADD # 將相加之和的值返回 14 RETURN_VALUE
相信現(xiàn)在看字節(jié)碼已經(jīng)不是什么問題了,然后我們看到調(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è)指令之前提到過,但是函數(shù)的核心執(zhí)行流程是在 call_function 里面,它位于 ceval.c 中,我們來看一下。
因此接下來重點(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 //從名字上能看出來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里面邏輯很簡單 //直接抽走當(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ì)有無關(guān)鍵字參數(shù)。但是最終殊途同歸,都會(huì)走到 PyEval_EvalFrameEx 那里,然后虛擬機(jī)在新的棧幀中執(zhí)行新的 PyCodeObject。
不過可能有人會(huì)好奇,我們之前說過:
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 名字空間。
也就是說,最終是 PyFrameObject 和 PyCodeObject 兩者如膠似漆,跟 PyFunctionObject 之間沒有關(guān)系,所以 PyFunctionObject 辛苦一場(chǎng),實(shí)際上是為別人做了嫁衣。PyFunctionObject 主要是對(duì) PyCodeObject 和 global 名字空間的一種打包和運(yùn)輸方式。
到此,關(guān)于“Python函數(shù)的實(shí)現(xiàn)原理源碼分析”的學(xué)習(xí)就結(jié)束了,希望能夠解決大家的疑惑。理論與實(shí)踐的搭配能更好的幫助大家學(xué)習(xí),快去試試吧!若想繼續(xù)學(xué)習(xí)更多相關(guān)知識(shí),請(qǐng)繼續(xù)關(guān)注億速云網(wǎng)站,小編會(huì)繼續(xù)努力為大家?guī)砀鄬?shí)用的文章!
免責(zé)聲明:本站發(fā)布的內(nèi)容(圖片、視頻和文字)以原創(chuàng)、轉(zhuǎn)載和分享為主,文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng),如果涉及侵權(quán)請(qǐng)聯(lián)系站長郵箱:is@yisu.com進(jìn)行舉報(bào),并提供相關(guān)證據(jù),一經(jīng)查實(shí),將立刻刪除涉嫌侵權(quán)內(nèi)容。