函数是任何一门编程语言都具备的基本元素,它可以将多个动作组合起来,一个函数代表了一系列的动作。而且在调用函数时会干什么来着,没错,要创建栈帧,用于函数的执行。 那么下面就来看看函数在 C 中是如何实现的,生得一副什么模样。 Python 一切皆对象,函数也不例外,函数这种抽象机制在底层是通过 PyFunctionObject 结构体实现的。 // Include/cpython/funcobject.h #define COMMON_FIELDS(PREFIX) \ PyObject *PREFIX ## globals; \ PyObject *PREFIX ## builtins; \ PyObject *PREFIX ## name; \ PyObject *PREFIX ## qualname; \ PyObject *PREFIX ## code; \ PyObject *PREFIX ## defaults; \ PyObject *PREFIX ## kwdefaults; \ PyObject *PREFIX ## closure;
typedef struct { PyObject_HEAD COMMON_FIELDS(func_) PyObject *func_doc; PyObject *func_dict; PyObject *func_weakreflist; PyObject *func_module; PyObject *func_annotations; PyObject *func_typeparams; vectorcallfunc vectorcall; uint32_t func_version; } PyFunctionObject;
如果将宏展开的话,结构体就是下面这个样子。 typedef struct { PyObject_HEAD PyObject *func_globals; PyObject *func_builtins; PyObject *func_name; PyObject *func_qualname; PyObject *func_code; PyObject *func_defaults; PyObject *func_kwdefaults; PyObject *func_closure; PyObject *func_doc; PyObject *func_dict; PyObject *func_weakreflist; PyObject *func_module; PyObject *func_annotations; PyObject *func_typeparams; vectorcallfunc vectorcall; uint32_t func_version; } PyFunctionObject;
我们来解释一下这些字段,并实际获取一下,看看它们在 Python 中是如何表现的。 func_globals:global 名字空间 def foo(a, b, c): pass
name = "古明地觉" print(foo.__globals__) # {..., 'name': '古明地觉'} # 拿到的其实就是外部的 global名字空间 print(foo.__globals__ is globals()) # True
函数内部之所以可以访问全局变量,就是因为它保存了全局名字空间。 func_builtins:builtin 名字空间 def foo(a, b, c): pass
print(foo.__builtins__ is __builtins__.__dict__) # True
注意:在之前的版本中,函数内部是没有这个字段的。
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_name 之外,函数还有一个 func_qualname 字段。 func_qualname:函数的全限定名 print(str.join.__name__) # join print(str.join.__qualname__) # str.join
函数如果定义在类里面,那么它就叫类的成员函数,但它本质上依旧是个函数,和普通函数并无区别。只是在获取全限定名的时候,会带上类名。
func_code:函数对应的 PyCodeObject 对象 def foo(a, b, c): pass
code = foo.__code__ print(code) # <code object foo at ......> print(code.co_varnames) # ('a', 'b', 'c')
函数便是基于 PyCodeObject 构建的。 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__) # {'age': 16}
加上一个 * 表示后面的参数必须通过关键字的方式传递。 func_closure:一个元组,包含了内层函数使用的外层作用域的变量,即 cell 变量。 def foo(): name = "古明地觉" age = 17
def bar(): print(name, age)
return bar
# 内层函数 bar 使用了外层作用域中的 name、age 变量 print(foo().__closure__) """ (<cell at 0x000001FD1D3B02B0: int object at 0x7efe79d4a1c8>, <cell at 0x000001FD1D42E310: str object at 0x7efe7921bc30>) """
print(foo().__closure__[0].cell_contents) # 17 print(foo().__closure__[1].cell_contents) # 古明地觉
注意:查看闭包属性我们使用的是内层函数。 func_doc:函数的 docstring def foo(): """ hi,欢迎来到我的小屋 遇见你真好 """ pass
print(foo.__doc__) """ hi,欢迎来到我的小屋 遇见你真好 """
当我们在写 Python 扩展的时候,由于编译之后是一个 pyd,那么就会通过 docstring 来描述函数的相关信息。 func_dict:函数的属性字典 def foo(name, age): pass
print(foo.__dict__) # {}
函数在底层也是由一个类实例化得到的,所以它也可以有自己的属性字典,只不过这个字典一般为空。 func_module:函数所在的模块 import numpy as np
print(np.array.__module__) # numpy
除了函数,类、方法、协程也有 __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'>}
像 FastAPI、Pydantic 等框架,都大量应用了类型注解。
func_typeparams:类型参数 from typing import TypeVar
T = TypeVar('T') S = TypeVar('S')
def foo[T, S](x: T, y: S) -> list[S, T]: return (y, x)
print(foo.__type_params__) # (T, S)
class A[T, S]: def __init__(self, x: T, y: S): self.x: T = x self.y: S = y
a1 = A[int, float](3, 2.71) a2 = A[str, dict]("hello", {}) print(A.__type_params__) # (T, S) print(a1.__type_params__) # (T, S) print(a2.__type_params__) # (T, S)
关于类型参数的更具体用法,可以查阅相关文档,说实话如果是在 Python 里面,这种语法我估计一辈子都不会用。
vectorcallfunc vectorcall:矢量调用协议 函数本质上也是一个实例对象,在调用时会执行类型对象的 tp_call,对应 Python 里的 __call__。但 tp_call 属于通用逻辑,而通用往往也意味着平庸,tp_call 在执行时需要创建临时元组和临时字典来存储位置参数、关键字参数,这些临时对象增加了内存分配和垃圾回收的开销。 如果只是一般的实例对象倒也没什么,但函数不同,它作为实例对象注定是要被调用的。所以底层对它进行了优化,引入了速度更快的 vectorcall,即矢量调用。 关于普通调用(tp_call)和矢量调用(vectorcall)的具体细节,后续会详细说明。总之一个实例对象如果支持矢量调用,那么它也必须支持普通调用,并且两者的结果是一致的,当对象不支持矢量调用时,会退化成普通调用。
uint32_t func_version:版本号,用于函数特化 函数特化是指根据函数的调用模式,生成更高效的特定版本代码,特别是针对那些频繁调用的函数。但函数特化有一个前提,就是函数本身不能够发生改变,于是引入了 func_version 字段。 当函数的某些字段的值发生改变时,func_version 会重置为 0,而当底层看到 func_version 为 0 时,就知道函数发生改变了,特化失效。 def foo(x, y=10): return x + y
# 以下操作会将 func_version 重置为 0
# 1. 修改默认参数 foo.__defaults__ = (20,)
# 2. 修改关键字默认参数 # 注:必须是指向一个新的字典,版本号才会重置 foo.__kwdefaults__ = {"z": 30}
# 3. 修改代码对象 # (几乎不可能直接修改,但可以通过某些高级技巧)
# 4. 修改注解 foo.__annotations__["return"] = int
# 5. 修改 vectorcall 函数指针 # (这是 C 级别的操作,Python 代码通常无法直接触及)
所以只要函数保持不变,Python 就会用特化版本来优化执行,而我们在工作中基本也不会修改上面这几个字段。 以上就是函数的底层结构,在 Python 里面是由 <class 'function'> 实例化得到的。 def foo(name, age): pass
# <class 'function'> 就是 C 里面的 PyFunction_Type print(foo.__class__) # <class 'function'>
但这个类底层没有暴露给我们,我们不能直接用,因为函数通过 def 创建即可,不需要通过类型对象来创建。
后续会介绍更多关于函数相关的知识。
|