从零实现 Python 虚拟机（一）：PVM 基本原理介绍

从这段代码中可以看出，闭包机制并不是依靠某一条孤立指令完成的，而是由多条字节码指令配合形成一条完整链路。

首先，在外层函数 outer 中，MAKE_CELL 字节码指令会在变量 x 所对应的局部变量槽位中新创建一个单元对象（Cell Object）；随后，STORE_DEREF 字节码指令并不是把常量 10 直接写入 x 对应的槽位，而是写入该槽位的单元对象当中。这意味着从这一时刻开始，x 在运行时就已经不再以“普通局部变量值”的形态存在，而是变成了一个可被多个函数共享的间接引用单元。这部分字节码指令表明，Python 代码中普通局部变量和自由变量是在编译阶段完成区分的，这就首先回答了问题（1）。

接下来，在内部函数 inner 被创建之前，LOAD_CLOSURE 指令会把 x 对应的单元对象压入操作数栈。随后，BUILD_TUPLE 指令会将操作数栈顶的全体单元对象打包成一个 Python 元组。最后，被编译器前端添加特殊参数标记的 MAKE_FUNCTION 指令会在创建函数对象时，把这个装有单元对象的元组绑定进内部函数。如下图所示，内部函数拿到的并不是 x 当前变量值的一份副本，而是对同一个单元对象的引用；因此，当外层函数 outer 后续返回时，只要这个函数对象仍然存活，它就能够继续持有该单元对象，从而解决了问题（2）。

当内部函数 inner 真正被调用时，COPY_FREE_VARS 指令又会把函数对象里保存的这些单元对象重新注入新建立的 inner 对应的栈帧中，使该栈帧的局部变量槽位区持有同一个单元对象。随后，LOAD_DEREF 指令才真正执行对自由变量的读取操作。也就是说，内部函数运行时读取到的，并不是当初创建函数对象时复制下来的一份静态值，而是通过单元对象间接解析出来的“当前值”。

因此，无论是外层函数还是内部函数，只要它们操作的是同一个单元对象，就都能够观察到对该变量所做的更新。这就解释了 PVM 是如何解决问题（3）与（4）的。

总结一下，Python 语言中的闭包是一套需要由编译器前端、单元对象间接层和专用字节码指令共同协作完成的完整机制。

8. 内建函数也要被建模为“可调用对象”

除了用户自己定义的函数，Python 还提供了很多内建函数，比如 print()、len()、isinstance()。这些函数通常不是用 Python 实现的，而是由虚拟机内部的本地代码实现，并提前注册到内建命名空间中。

但从语言层面看，用户调用它们的方式和调用普通函数没有本质区别：

print("hello")
len([1, 2, 3])

因此，PVM 需要把内建函数和 Python 函数统一建模为“可调用对象”。编译器只需要生成通用的调用指令，真正执行时由虚拟机判断目标对象到底是 Python 函数对象、内建函数对象、绑定方法、类型对象构造调用，还是其他可调用对象。这种统一的调用模型，是实现 Python 动态语言语义的重要基础。

9. Python 的对象系统：万物皆对象

Python 是一门面向对象的动态语言。不仅普通实例是对象，数字、字符串、列表、字典、函数、模块也都是对象。更进一步，类本身也是对象——也就是类型对象。这意味着 PVM 必须建立一套统一的对象表示机制，解释器执行过程中操作的所有值，最终都应该落到统一的对象模型上。

一个最小可用的 Python 虚拟机，通常至少需要支持这些基础内建类型：object、int、float、str、tuple、list、dict、函数对象、模块对象、类型对象。这些类型不只是为了让用户代码能创建数据，它们本身也支撑着虚拟机内部机制。例如，函数默认参数可能要用 tuple 保存；模块命名空间需要用 dict 保存；属性查找依赖对象和类型对象的字典；函数调用、闭包、模块导入都离不开对象系统。所以，对象系统不是虚拟机的附属功能，而是整个 PVM 的核心基础设施之一。

10. 属性查找不只是字典查询

Python 的封装机制和 C++、Ja va 这类静态语言不太一样。一个对象可以在运行时动态添加属性：

obj.name = "Alice"

类也可以在运行时修改属性和方法：

MyClass.new_method = some_function

因此，Python 虚拟机不能简单采用“字段偏移固定、方法入口固定”的静态对象模型。通常来说，对象实例会有自己的属性字典，类对象也会有自己的属性字典。读取属性时，虚拟机需要按一定规则查找：先查实例自己的属性，再查类对象，再沿继承链继续查找，必要时触发描述符、补救查找等机制。

另外，方法绑定也是关键点。例如：

class MyClass:
    def foo(self):
        print("hello")

instance = MyClass()
instance.foo()

当虚拟机查找 instance.foo 时，foo 实际上定义在类中，而不是实例自己的属性字典里。此时虚拟机会把函数对象和当前实例组合成一个绑定方法。调用这个绑定方法时，虚拟机会自动把 instance 作为 self 参数传入。

但如果这样写：

def bar():
    print("bar")

instance.bar = bar
instance.bar()

这里的 bar 是直接放在实例属性字典里的普通函数对象，不会自动绑定 self。所以，Python 的属性访问不是简单的哈希表查询，而是包含实例属性、类属性、继承链和方法绑定等多种语义的动态解析过程。

11. 继承与 MRO

Python 支持继承，也支持多继承。多继承带来的一个问题是：如果多个父类中存在同名方法，应该先调用哪一个？Python 使用 MRO（Method Resolution Order，方法解析顺序）来解决这个问题。对于多继承场景，Python 使用 C3 线性化算法计算 MRO。

从虚拟机实现角度看，这意味着类型对象创建时不只是简单分配一个对象，还需要计算并保存该类的 MRO 序列。后续属性查找时，虚拟机必须按照 MRO 顺序查找对应属性或方法。因此，在一个支持 Python 面向对象机制的 PVM 中，类型系统、继承关系、MRO 和属性查找是紧密绑定在一起的。

12. Python 的多态来自运行时动态解析

在 C++ 或 Ja va 中，多态通常和接口、虚函数表、静态类型系统等机制有关。但 Python 的多态更接近鸭子类型：

def do_say(animal):
    animal.say()

class Cat:
    def say(self):
        print("meow")

class Dog:
    def say(self):
        print("woof")

do_say(Cat())
do_say(Dog())

do_say 并不关心传进来的对象到底是 Cat 还是 Dog，只关心它有没有一个可以调用的 say 方法。从虚拟机角度看，这种多态依赖运行时属性查找与方法绑定。调用点在编译阶段不需要绑定到某个确定实现，而是在运行时根据对象实际类型动态解析。

不过，对于虚拟机内部来说，如果所有行为都退化为动态字典查找，性能会非常差。比如整数加法 1 + 2，如果每次都要完整查找 int.__add__ 再调用，开销会很高。因此，一个实际可用的 PVM 通常需要区分两层多态：第一层是语言语义层面的动态多态，也就是用户在 Python 代码中观察到的属性查找和方法绑定；第二层是虚拟机内部的高效行为分派，例如对加法、比较、迭代等核心操作建立更直接的调度路径。S.A.A.U.S.O 在后续实现对象系统时，也采用了类似的分层思路：既保留 Python 语言层面的动态性，又为虚拟机内部核心行为设计更高效的分派机制。

13. 异常是一种特殊控制流

Python 的异常机制从用户角度看很直观：

try:
    risky()
except RuntimeError:
    handle()

但从 PVM 的角度看，异常其实是一种特殊控制流。普通控制流通过顺序执行和跳转指令改变程序计数器，而异常会打断当前执行流程，并尝试把控制权转移到最近的异常处理器。

当异常发生时，虚拟机需要做几件事：创建或记录异常对象；保存异常状态；在当前函数中查找匹配的异常处理器；如果当前函数处理不了，就弹出当前栈帧；继续向上一层调用者查找；直到找到处理器，或者调用栈被完全展开。这个过程通常称为栈展开（Stack Unwinding）。

在 CPython 3.12 的执行模型中，异常处理器的查找依赖函数级别的异常表。异常表会记录某段字节码范围对应的异常处理入口，以及恢复操作数栈所需的信息。这种设计的好处是：正常执行路径不需要频繁维护额外异常状态，只有真正发生异常时，虚拟机才根据异常表查找处理逻辑。所以，实现异常机制并不是简单支持 raise 和 except 语法，而是要把异常状态、异常表查询、操作数栈恢复和调用栈展开整合进解释器主循环中。

14. import 背后是一套模块加载系统

最后再看模块机制。对用户来说，导入模块只是一行代码：

import math

或者：

from package import module

但对 PVM 来说，模块导入是一套系统级流程，涉及：模块名称解析、搜索路径查找、模块对象创建、模块代码加载、模块体执行、模块命名空间初始化、导入缓存、父子模块绑定。

一次典型的模块导入大致可以理解为：先检查模块是否已经在缓存中；如果已经存在，直接复用；如果不存在，根据搜索路径查找模块文件；创建模块对象；执行模块代码，初始化模块命名空间；把模块登记到缓存；返回模块对象或导入其中的名称。也就是说，import 并不是简单的文件包含，而是在运行时创建和初始化模块对象，并维护模块缓存。对于一个可用的 Python 虚拟机来说，模块系统是非常重要的一环。没有模块机制，代码组织、复用和多文件项目支持都会受到很大限制。

15. 小结：实现 PVM 前，必须先理解这些核心机制

本文主要介绍了实现一个轻量级 Python 虚拟机后端之前，需要掌握的一组关键机制：

• PVM 通过解释字节码执行 Python 程序；
• PVM 本质上是一台围绕操作数栈运行的栈机；
• Python 变量是名称到对象的绑定；
• 控制流最终会变成条件跳转和无条件跳转；
• 函数是运行时创建的对象；
• 函数调用依赖栈帧保存执行现场；
• 闭包依赖 Cell Object 实现自由变量共享；
• 内建函数需要和普通函数统一建模为可调用对象；
• Python 对象系统需要支持动态属性、方法绑定、继承和 MRO；
• Python 多态依赖运行时动态解析；
• 异常是一种特殊控制流，需要异常状态和栈展开机制；
• 模块导入背后是一套完整的模块加载与缓存系统。

这些机制共同构成了 S.A.A.U.S.O 这个轻量级 Python 虚拟机后端的理论基础。后续文章中，我会继续介绍这个系统的总体架构设计，包括运行时容器、虚拟机堆、句柄机制、对象系统、执行层和嵌入接口层是如何组织起来的。