Python:函数对象

def greet(name):    return f"Hello, {name}"

在模块加载或类体执行阶段，解释器会先将函数体编译为一个字节码的代码对象（code object）。

代码对象是不可变的，它描述了函数的指令序列、局部变量布局、编译阶段嵌入的字面量值对象等信息，但并不包含执行环境。

需要注意的是，代码对象并不是函数本身，而只是函数“可执行逻辑”的静态表示。

（2）创建函数对象

当 def 语句被执行时，解释器会基于：

• 代码对象

• 当前作用域中的全局命名空间

• 默认参数

• 闭包信息（如有）

创建一个新的函数对象。

该函数对象持有：

• 对代码对象的引用

• 对全局命名空间的引用

• 对默认参数与闭包变量等的引用

（3）名称绑定

最终生成的函数对象被绑定到当前作用域中的名字 greet：

greet → <function greet at 0x...>

至此，函数对象的创建过程完成。

由此可见，函数并非定义时即存在的静态实体，而是 def 语句执行的运行时结果。

二、函数对象内部的核心绑定关系

在对象模型中，函数对象承担的是一种执行协议封装者的角色，其核心职责包括：

• 关联一段代码对象（__code__）

• 绑定全局命名空间（__globals__）

• 绑定默认参数（__defaults__ / __kwdefaults__）

• 绑定闭包变量（__closure__，如有）

函数对象本身不保存执行期状态，也不承载指令执行过程。它的职责在于规定一次函数调用应当如何创建相应的执行上下文。

1、执行结构来源

__code__ 指向一个代码对象，用于描述函数体的执行结构。

f.__code__

函数对象并不修改代码对象，也无法改变其结构，它只是引用这一结构。

2、名称解析的外部环境

函数对象会绑定其定义时所在的全局命名空间__globals__：

f.__globals__

这决定了：

• 函数体中全局变量的解析位置

• 内置名称的查找路径

这一绑定在函数创建时完成，而不是在调用时动态决定。

3、默认参数的早绑定特性

默认参数在函数对象创建时即被绑定：

def f(x, y=[]):    y.append(x)    return y

这里的 y 并不是“每次调用重新生成”，而是函数对象持有的一个默认值引用。

这再次说明，函数对象并不是语法层面的声明，而是调用行为得以成立的对象化前提。

4、闭包的入口

当函数引用了外层作用域中的变量时，函数对象会持有一个 __closure__：

• 每个元素是一个 cell 对象

• cell 对象中保存的是跨帧共享的绑定

函数对象并不保存变量值本身，而是保存对 cell 的引用。

三、函数对象的对象模型定位

1、一致的基本定位

从对象模型的角度看，函数对象与其他对象并无本质差异。

函数对象同样具备对象的三要素：

身份（identity）：运行期间唯一的对象标识

类型（type）：function

值（value）：由代码对象、全局命名空间、默认参数、闭包引用等内部绑定状态共同构成

def f():    passprint(isinstance(f, object))   # Trueprint(type(f))                 # <class 'function'>

这意味着：

• 函数可以被绑定到名称

• 函数可以作为参数传递

• 函数可以作为返回值

• 函数可以在运行时被修改或包装

2、与相关对象的关系

在 Python 中，一次函数调用至少涉及三类对象：

• 代码对象：描述“执行结构”，被函数对象持有

• 函数对象：提供“可调用语义”，触发帧对象创建

• 帧对象：承载“运行期状态”，引用代码对象执行

函数对象并不是代码对象的别名，而是对某段代码在特定执行环境下可被调用这一语义的对象化表达。

同一个代码对象，理论上可以被多个函数对象持有：

import typesdef f(x):    return x * 2g = types.FunctionType(    f.__code__,    globals())

这里的 f 与 g，拥有同一个代码对象，但可以绑定不同的全局命名空间、默认参数或闭包。这说明：

函数对象并不等同于“那段代码”，而是一次“可调用声明”。

当我们调用一个函数时：

f(10)

函数对象本身并不会执行任何字节码。它所做的，仅是：

（1）根据自身绑定的信息，创建一个新的帧对象

（2）将代码对象与执行环境交给帧对象

（3）将控制权交给解释器的执行循环

也就是说，函数对象是调用的触发者，而不是执行的承载者。

真正执行字节码的，是帧对象。

3、为什么会如此设计

如果函数对象本身保存执行状态，将直接破坏以下基本能力：

• 多次调用的独立性

• 递归调用的正确性

• 高阶函数的可组合性

通过将职责拆分为：

• 函数对象：声明调用规则

• 帧对象：承载运行状态

Python 才能保证：

• 同一个函数对象可以被安全地反复调用

• 每一次调用都有独立的执行上下文

四、函数对象的应用场景

Python 中的函数是典型的一等对象，这一特性是许多高级机制的基础。

1、作为参数传递

def apply(func, value):    return func(value)def square(x):    return x * xprint(apply(square, 5))  # 25

此处，square 并未被调用，而是作为普通对象传递。

2、作为返回值

def make_adder(n):    def adder(x):        return x + n    return adderadd10 = make_adder(10)print(add10(5))  # 15

这里返回的并非“代码片段”，而是一个完整的函数对象。

3、存储于数据结构中

operations = [abs, str, hex]print(operations[0](-10))  # 10

函数对象可以与其他对象并列存在于容器中，完全遵循对象的一般使用规则。

4、函数对象在闭包机制中的角色

考虑如下示例：

def outer(x):    def inner(y):        return x + y    return inner

在这一结构中：

• outer 的代码对象声明 x 为 cellvar

• inner 的代码对象声明 x 为 freevar

函数对象在其中承担的职责是：在创建 inner 时，将 outer 帧中的 cell 对象绑定到 inner.__closure__。

也就是说，函数对象是闭包结构在对象模型中的“连接器”。

它并不捕获变量值，也不维护生命周期，只是将词法结构声明与运行期对象进行连接。

📘 小结

在 Python 的对象模型中，函数对象是可调用语义的封装者，而非执行本身。它将代码对象所描述的执行结构，与全局环境、默认参数及闭包引用稳定绑定，并在调用时触发帧对象的创建。通过将执行结构、执行入口与运行状态严格分层，Python 实现了函数调用、闭包与递归语义的一致性与可组合性。