Python函數的實現原理是什么

本文小編為大家詳細介紹“Python函數的實現原理是什么”，內容詳細，步驟清晰，細節處理妥當，希望這篇“Python函數的實現原理是什么”文章能幫助大家解決疑惑，下面跟著小編的思路慢慢深入，一起來學習新知識吧。

楔子

函數是任何一門編程語言都具備的基本元素，它可以將多個要執行的操作組合起來，一個函數代表了一系列的操作。而且在調用函數時會干什么來著，沒錯，要創建棧幀，用于函數的執行。

PyFunctionObject

Python 一切皆對象，函數也不例外。函數在底層是通過 PyFunctionObject 結構體實現的，定義在 funcobject.h 中。

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

我們來實際獲取一下這些成員，看看它們在 Python 中是如何表現的。

func_code：函數的字節碼

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': '古明地覺'}
# 拿到的其實就是外部的 global名字空間
print(foo.__globals__ is globals())  # True

func_defaults：函數參數的默認值

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

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


def bar():
    pass

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

func_kwdefaults：只能通過關鍵字的方式傳遞的 "參數" 和 "該參數的默認值" 組成的字典

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

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


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

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

在前面加上一個 *，就表示后面的參數必須通過關鍵字的方式傳遞。因為如果不通過關鍵字參數傳遞的話，那么無論多少個位置參數都會被 * 接收，無論如何也不可能傳遞給 name、age。

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

func_closure：閉包對象

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)  # 古明地覺

注意：查看閉包屬性我們使用的是內層函數，不是外層的 foo。

func_doc：函數的 docstring

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

print(foo.__doc__)
"""

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

func_name：函數的名字

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

func_dict：函數的屬性字典

因為函數在底層也是由一個類實例化得到的，所以它可以有自己的屬性字典，只不過這個字典一般為空。

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

所以雖然叫函數，但它也是由某個類型對象實現的。

func_weakreflist：弱引用列表

Python無法獲取這個屬性，底層沒有提供相應的接口，關于弱引用此處就不深入討論了。

func_module：函數所在的模塊

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

類、方法、協程也有 __module__ 屬性。

func_annotations：類型注解

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

# Python3.5 新增的語法，但只能用于函數參數
# 而在 3.6 的時候，聲明變量也可以使用這種方式
# 特別是當 IDE 無法得知返回值類型時，便可通過類型注解的方式告知 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

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

以上就是函數的底層結構，在 Python 里面是由 function 實例化得到的。

def foo(name, age):
    pass

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

但是這個類底層沒有暴露給我們，我們不能直接用，因為函數通過 def 創建即可，不需要通過類型對象來創建。

函數是何時創建的

前面我們說到函數在底層是由 PyFunctionObject 結構體實現的，它里面有一個 func_code 成員，指向一個 PyCodeObject 對象，函數就是根據它創建的。

因為 PyCodeObject 是對一段代碼的靜態表示，Python 編譯器在將源代碼編譯之后，對里面的每一個代碼塊（code block）都會生成一個、并且是唯一一個 PyCodeObject 對象。該對象包含了這個代碼塊的一些靜態信息，也就是可以從源代碼當中看到的信息。

比如某個函數對應的代碼塊里面有一個 a = 1 這樣的表達式，那么符號 a 和整數 1、以及它們之間的聯系就是靜態信息，而這些信息會被靜態存儲起來。

• 符號 a 被存在符號表 co_varnames 中；

• 整數 1 被存在常量池 co_consts 中；

• 這兩者之間是一個賦值語句，因此會有兩條指令：LOAD_CONST 和 STORE_FAST，它們存在字節碼指令序列 co_code 中；

以上這些信息是編譯的時候就可以得到的，因此 PyCodeObject 對象是編譯之后的結果。

但是 PyFunctionObject 對象是何時產生的呢？顯然它是 Python 代碼在運行時動態產生的，更準確的說，是虛擬機在執行一個 def 語句的時候創建的。

當虛擬機在當前棧幀中執行字節碼時發現了 def 語句，那么就代表發現了新的 PyCodeObject 對象，因為它們是可以層層嵌套的。所以虛擬機會根據這個 PyCodeObject 對象創建對應的 PyFunctionObject 對象，然后將函數名和 PyFunctionObject 對象（函數體）組成鍵值對放在當前的 local 空間中。

而在 PyFunctionObject 對象中，也需要拿到相關的靜態信息，因此會有一個 func_code 成員指向 PyCodeObject。

除此之外，PyFunctionObject 對象中還包含了一些函數在執行時所必需的動態信息，即上下文信息。比如 func_globals，就是函數在執行時關聯的 global 空間，說白了就是在局部變量找不到的時候能夠找全局變量，可如果連 global 空間都沒有的話，那即便想找也無從下手呀。

而 global 作用域中的符號和值必須在運行時才能確定，所以這部分必須在運行時動態創建，無法靜態存儲在 PyCodeObject 中，因此要根據 PyCodeObject 對象創建 PyFunctionObject 對象。總之一切的目的，都是為了更好地執行字節碼。

我們舉個例子：

# 虛擬機從上到下順序執行字節碼
name = "古明地覺"
age = 16

# 啪，很快啊，發現了一個 def 語句
def foo():
    pass

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

調用的時候，會從 local 空間中取出符號 foo 對應的 PyFunctionObject 對象。然后根據這個 PyFunctionObject 對象創建 PyFrameObject 對象，也就是為函數創建一個棧幀，隨后將執行權交給新創建的棧幀，并在新創建的棧幀中執行字節碼。

函數是怎么創建的

通過上面的分析，我們知道了函數是虛擬機在遇到 def 語句的時候創建的，并保存在 local 空間中。當我們通過函數名()的方式調用時，會從 local 空間取出和函數名綁定的函數對象，然后執行。

那么問題來了，函數（對象）是怎么創建的呢？或者說虛擬機是如何完成 PyCodeObject 對象到 PyFunctionObject 對象之間的轉變呢？顯然想了解這其中的奧秘，就必須從字節碼入手。

import dis

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

foo(1, 2)
"""

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

源代碼很簡單，定義一個變量 name 和函數 foo，然后調用函數。顯然源代碼在編譯之后會產生兩個 PyCodeObject，一個是模塊的，一個是函數 foo 的，我們來看一下。

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

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

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

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

如果是從 Python 層面的函數調用來理解的話，很容易一句話就解釋了，因為函數只有在調用的時候才會執行，而調用肯定發生在創建之后。但是從字節碼的角度來理解的話，我們發現函數的聲明和實現是分離的，是在不同的 PyCodeObject 對象中。

確實如此，雖然函數名和函數體是一個整體，但是虛擬機在實現的時候，卻在物理上將它們分離開了。

正所謂函數即變量，我們可以把函數當成普通的變量來處理。函數名就是變量名，它位于模塊對應的 PyCodeObject 的符號表中；函數體就是變量指向的值，它是基于一個獨立的 PyCodeObject 構建的。

換句話說，在編譯時，函數體里面的代碼會位于一個新的 PyCodeObject 對象當中，所以函數的聲明和實現是分離的。

至此，函數的結構就已經非常清晰了。

所以函數名和函數體是分離的，它們存儲在不同的 PyCodeObject 對象當中。

分析完結構之后，重點就要落在 MAKE_FUNCTION 指令上了，我們說當遇到 def foo(a, b) 的時候，就知道要創建函數了。在語法上這是函數的聲明語句，但從虛擬機的角度來看這其實是函數對象的創建語句。

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

case TARGET(MAKE_FUNCTION): {
    // 彈出壓入運行時棧的函數名
    PyObject *qualname = POP(); 
    // 彈出對應的 PyCodeObject 對象
    PyObject *codeobj = POP();  
    // 創建 PyFunctionObject 對象，需要三個參數
    // 分別是 PyCodeObject 對象、global 名字空間、函數的全限定名
    // 我們看到創建函數的時候將 global 名字空間傳遞了進去
    // 所以現在我們應該明白為什么函數可以調用 __globals__ 了
    // 當然也明白為什么函數在局部變量找不到的時候可以去找全局變量了
    PyFunctionObject *func = (PyFunctionObject *)
        PyFunction_NewWithQualName(codeobj, f->f_globals, qualname);
    
    // 減少引用計數
    // 如果函數創建失敗會返回 NULL，跳轉至 error
    Py_DECREF(codeobj);
    Py_DECREF(qualname);
    if (func == NULL) {
        goto error;
    }
    
    // 編譯時能夠靜態檢測出函數有沒有設置閉包、類型注解等屬性
    // 比如設置了閉包，那么 oparg & 0x08 為真
    // 設置了類型注解，那么 oparg & 0x04 為真
    // 如果條件為真，那么進行相關屬性設置
    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();
    }

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

整個步驟很好理解，先通過 LOAD_CONST 將 PyCodeObject 對象和符號 foo 壓入棧中。然后執行 MAKE_FUNCTION 的時候，將兩者從棧中彈出，再加上當前棧幀對象中維護的 global 名字空間，三者作為參數傳入 PyFunction_NewWithQualName 函數中，從而構建出相應的函數對象。

上面的函數比較簡單，如果再加上類型注解、以及默認值，會有什么效果呢？

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

這里我們加上了類型注解和默認值，看看它的字節碼指令會有什么變化？

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

不難發現，在構建函數時會先將默認值以元組的形式壓入運行時棧；然后再根據使用了類型注解的參數和類型構建一個字典，并將這個字典壓入運行時棧。

后續創建函數的時候，會將默認值保存在 func_defaults 成員中，類型注解對應的字典會保存在 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'>}

基于類型注解和描述符，我們便可以像靜態語言一樣，實現函數參數的類型約束。介紹完描述符之后，我們會舉例說明。

函數的一些騷操作

我們通過一些騷操作，來更好地理解一下函數。

之前說 <class 'function'> 是函數的類型對象，而這個類底層沒有暴露給我們，但是可以通過曲線救國的方式進行獲取。

def f():
    pass

print(type(f))  # <class 'function'>
# lambda匿名函數的類型也是 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__
# 根據類function創建函數對象
# 接收三個參數: PyCodeObject對象、名字空間、函數名
new_f = type(f)(code, globals(), "根據 f 創建的 new_f")

# 打印函數名
print(new_f.__name__)  # 根據 f 創建的 new_f

# 調用函數
print(
    new_f("古明地覺", 16)
)  # name: 古明地覺, age: 16, gender: female

是不是很神奇呢？另外我們說函數在訪問變量時，顯然先從自身的符號表中查找，如果沒有再去找全局變量。這是因為，我們在創建函數的時候將 global 名字空間傳進去了，如果我們不傳遞呢？

gender = "female"

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

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

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

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

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

gender = "female"

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

code = f.__code__
new_f = type(f)(code, {"gender": "少女覺"}, "根據 f 創建的 new_f")

# 我們可以手動傳遞一個字典進去
# 此時我們傳遞的字典對于函數來說就是 global 名字空間
# 所以在函數內部找不到某個變量的時候, 就會去我們指定的名字空間中查找
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
"""

我們看到函數 f 明明接收三個參數，但是調用時不傳遞居然也不會報錯，原因就在于我們指定了默認值。而默認值可以在定義函數的時候指定，也可以通過 __defaults__ 指定，但很明顯我們應該通過前者來指定。

如果你用的是 pycharm，那么會在 f() 這個位置給你飄黃，提示你參數沒有傳遞。但我們知道，由于使用 __defaults__ 已經設置了默認值，所以這里是不會報錯的。只不過 pycharm 沒有檢測到，當然基本上所有的 IDE 都無法做到這一點，畢竟動態語言。

另外 __defaults__ 接收的元組里面的元素個數和參數個數不匹配怎么辦？

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

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

由于元組里面只有兩個元素，意味著我們在調用時需要至少傳遞一個參數，而這個參數會賦值給 name。原因就是在設置默認值的時候是從后往前設置的，也就是 "female" 會給賦值給 gender，15 會賦值給 age。而 name 沒有得到默認值，那么它就需要調用者顯式傳遞了。

為啥 Python 在設置默認值是從后往前設置呢？如果從前往后設置的話，會出現什么后果呢？顯然此時 15 會賦值給 name，"female" 會賦值給 age，那么函數就等價于如下：

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

這樣的函數能夠通過編譯嗎？顯然是不行的，因為默認參數必須在非默認參數的后面。所以 Python 的這個做法是完全正確的，必須要從后往前進行設置。

另外我們知道默認值的個數是小于等于參數個數的，如果大于會怎么樣呢？

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

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

依舊從后往前進行設置，當所有參數都有默認值了，那么就結束了。當然，如果不使用 __defaults__，是不可能出現默認值個數大于參數個數的。

可要是 __defaults__ 指向的元組先結束，那么沒有得到默認值的參數就必須由我們來傳遞了。

最后再來說一下如何深拷貝一個函數。首先如果是你的話，你會怎么拷貝一個函數呢？不出意外的話，你應該會使用 copy 模塊。

import copy

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

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

修改 f 的 __defaults__，會對 new_f 產生影響，因此我們并沒有實現函數的深度拷貝。事實上，copy 模塊無法對函數、方法、回溯棧、棧幀、模塊、文件、套接字等類型的實例實現深度拷貝。

那我們應該怎么做呢？

from types import FunctionType

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

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

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

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

此時修改 f 不會影響 new_f，當然在拷貝的時候也可以自定義屬性。

其實上面實現的深拷貝，本質上就是定義了一個新的函數。由于是兩個不同的函數，那么自然就沒有聯系了。

判斷函數都有哪些參數

再來看看如何檢測一個函數有哪些參數，首先函數的局部變量(包括參數)在編譯時就已經確定，會存在符號表 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')
"""

注意：在定義函數的時候，* 和 ** 最多只能出現一次。

顯然 a 和 b 必須通過位置參數傳遞，c 和 d 可以通過位置參數和關鍵字參數傳遞，e 和 f 必須通過關鍵字參數傳遞。

而從打印的符號表來看，里面的符號是有順序的。參數永遠處于函數內部定義的局部變量的前面，比如 g 和 h 就是函數內部定義的局部變量，所以它在所有參數的后面。

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

那么接下來我們就可以進行檢測了。

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

varnames = f.__code__.co_varnames

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

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

# 3. 尋找必須通過關鍵字參數傳遞的參數
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 成員
# 它是函數的標識，可以對函數類型和參數進行檢測
# 如果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

以上我們檢測出了函數都有哪些參數，你也可以將其封裝成一個函數，實現代碼的復用。

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

但如果我們定義的時候不是 *args，只是一個 *，那么它就不是參數了。

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
# 顯然此時也都為假

單獨的一個 * 只是為了強制要求后面的參數必須通過關鍵字參數的方式傳遞。

以上就是如何通過 PyCodeObject 對象來檢索函數的參數，以及相關種類，標準庫中的 inspect 模塊也是這么做的。準確的說，是我們模仿人家的思路做的。

函數是怎么調用的

到目前為止，我們聊了聊 Python 函數的底層實現，并且還演示了如何通過函數的類型對象自定義一個函數，以及如何獲取函數的參數。雖然這在工作中沒有太大意義，但是可以讓我們深刻理解函數的行為。

下面我來探討一下函數在底層是怎么調用的，但是在介紹調用之前，我們需要補充一個知識點。

def foo():
    pass

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

函數實際上分為兩種：

• 如果是 Python 實現的函數，底層會對應 PyFunctionObject。其類型在 Python 里面是 <class 'function'>，在底層是 PyFunction_Type；

• 如果是 C 實現的函數，底層會對應 PyCFunctionObject。其類型在 Python 里面是 <class 'builtin_function_or_method'>，在底層是 PyCFunction_Type；

像內置函數、使用 C 擴展編寫的函數，它們都是 PyCFunctionObject。

另外從名字上可以看出 PyCFunctionObject 不僅用于 C 實現的函數，還用于方法。關于方法，我們后續在介紹類的時候細說，這里暫時不做深入討論。

總之對于 Python 函數和 C 函數，底層在實現的時候將兩者分開了，因為 C 函數可以有更快的執行方式。

注意這里說的 C 函數，指的是 C 實現的 Python 函數。像內置函數就是 C 實現的，比如 sum、getattr 等等。

好了，下面來看函數調用的具體細節。

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

foo()
"""

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

還是以一個簡單的函數為例，看看它的字節碼：

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

Disassembly of <code object foo at 0x7...>:
 # 函數的字節碼，因為模塊和函數都會對應 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)
 # 執行加法運算
12 BINARY_ADD
 # 將相加之和的值返回
14 RETURN_VALUE

相信現在看字節碼已經不是什么問題了，然后我們看到調用函數用的是 CALL_FUNCTION 指令，那么這個指令都做了哪些事情呢？

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

CALL_FUNCTION 這個指令之前提到過，但是函數的核心執行流程是在 call_function 里面，它位于 ceval.c 中，我們來看一下。

因此接下來重點就在 _PyObject_Vectorcall 函數上面，在該函數內部又會調用其它函數，最終會走到 _PyFunction_FastCallDict 這里。

//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是一個快分支
    //但是這個快分支要求函數調用時不能傳遞關鍵字參數
    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名字空間
            //根據PyCodeObject對象直接為其創建一個PyFrameObject對象
            //然后PyEval_EvalFrameEx執行棧幀
            //也就是真正的進入了函數調用，執行函數里面的代碼
            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);
        }
    }
  
    //適用于有關鍵字參數的情況
    nk = (kwargs != NULL) ? PyDict_GET_SIZE(kwargs) : 0;
    //.....
    //調用_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;
}

所以函數調用時會有兩種方式：

因此我們看到，總共有兩條途徑，分別針對有無關鍵字參數。但是最終殊途同歸，都會走到 PyEval_EvalFrameEx 那里，然后虛擬機在新的棧幀中執行新的 PyCodeObject。

不過可能有人會好奇，我們之前說過：

• PyFrameObject 是根據 PyCodeObject 創建的

• PyFunctionObject 也是根據 PyCodeObject 創建的

那么 PyFrameObject 和 PyFunctionObject 之間有啥關系呢？

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

其實在棧幀中執行指令時候，PyFunctionObject 的影響就已經消失了，真正對棧幀產生影響的是PyFunctionObject 里面的 PyCodeObject 對象和 global 名字空間。

也就是說，最終是 PyFrameObject 和 PyCodeObject 兩者如膠似漆，跟 PyFunctionObject 之間沒有關系，所以 PyFunctionObject 辛苦一場，實際上是為別人做了嫁衣。PyFunctionObject 主要是對 PyCodeObject 和 global 名字空間的一種打包和運輸方式。

讀到這里，這篇“Python函數的實現原理是什么”文章已經介紹完畢，想要掌握這篇文章的知識點還需要大家自己動手實踐使用過才能領會，如果想了解更多相關內容的文章，歡迎關注億速云行業資訊頻道。