从零到一：手把手教你用Python模拟一个8位CPU（附二进制运算核心代码）

在计算机科学教育中，理解CPU工作原理常常是道难以跨越的门槛。当教科书用抽象的框图描述指令周期时，当教师用"取指-译码-执行"概括计算机运行机制时，初学者往往陷入似懂非懂的困境。本文提供一种截然不同的学习路径——我们将用Python代码构建一个可运行的8位CPU模拟器，通过约200行直观的代码实现，让ALU运算、总线传输、寄存器操作等概念变得触手可及。

这个项目特别适合具备基础Python语法知识的开发者，或是任何对计算机底层原理充满好奇的技术爱好者。不同于理论教材的叙述方式，我们将采用"代码即文档"的方法，每个CPU组件都将对应具体的Python类和方法，所有抽象概念都能通过执行代码和观察内存状态变化来验证。完成本实验后，您不仅能理解补码运算、时钟脉冲等基础概念，还将获得一个可扩展的CPU模拟框架，用于后续添加中断处理、流水线等高级特性。

1. 环境准备与基础设计

开始编码前，需要明确我们的8位CPU模拟器将包含以下核心组件：8位数据总线、16位地址总线、算术逻辑单元(ALU)、寄存器组(包括累加器A、程序计数器PC等)以及简化的指令集。整个系统将运行在时钟脉冲控制下，每个时钟周期完成特定操作。

首先创建项目目录并初始化Python环境：

mkdir mini_cpu_simulator && cd mini_cpu_simulator
python -m venv venv
source venv/bin/activate  # Linux/Mac
venv\Scripts\activate     # Windows

安装唯一需要的依赖——用于二进制可视化的库：

pip install bitstring

创建主程序文件 cpu.py ，开始构建基础结构：

from bitstring import BitArray

class CPU:
    def __init__(self):
        self.a = BitArray(uint=0, length=8)    # 累加器A
        self.pc = BitArray(uint=0, length=16)  # 程序计数器
        self.ir = BitArray(uint=0, length=8)   # 指令寄存器
        self.flags = {'Z':0, 'C':0}            # 状态标志位
        self.ram = [BitArray(uint=0, length=8) for _ in range(65536)]  # 64KB内存
        self.alu = ALU()
        
    def clock_cycle(self):
        self.fetch()
        self.decode_execute()

2. 实现算术逻辑单元(ALU)

ALU是CPU的数学大脑，我们将实现8位加法、减法、逻辑运算等基础功能。特别注意补码运算的处理，这是理解计算机如何处理负数的关键。

在 cpu.py 中添加ALU类实现：

class ALU:
    def __init__(self):
        self.temp = BitArray(uint=0, length=8)
    
    def add(self, a, b):
        """带进位标志的8位加法"""
        result = a.uint + b.uint
        carry = result > 0xFF
        return BitArray(uint=result & 0xFF, length=8), carry
    
    def sub(self, a, b):
        """利用补码实现减法 a - b"""
        # 计算b的补码：按位取反后加1
        neg_b = BitArray(uint=(~b.uint + 1) & 0xFF, length=8)
        return self.add(a, neg_b)
    
    def logical_and(self, a, b):
        return a & b
    
    def logical_or(self, a, b):
        return a | b
    
    def logical_xor(self, a, b):
        return a ^ b
    
    def shift_left(self, a):
        return a << 1
    
    def shift_right(self, a):
        return a >> 1

补码运算验证示例：

# 测试补码减法 5 - 3
alu = ALU()
a = BitArray(uint=5, length=8)
b = BitArray(uint=3, length=8)
result, carry = alu.sub(a, b)
print(f"5 - 3 = {result.uint} (carry: {carry})")  # 应输出2

3. 设计指令集与总线传输

我们的模拟CPU将实现一个精简指令集，包含数据传输、算术运算和控制流三类指令。每条指令由1字节操作码和可选的操作数组成。

指令集设计示例：

操作码	指令	描述	时钟周期
0x01	LDA addr	加载内存数据到A	3
0x02	STA addr	存储A到内存	3
0x03	ADD addr	A += 内存值	4
0x04	SUB addr	A -= 内存值	4
0x05	JMP addr	跳转到地址	2

实现总线传输和指令执行逻辑：

class CPU:
    # ... 延续之前的初始化代码
    
    def fetch(self):
        """取指阶段：从PC指向的内存位置读取指令"""
        self.ir = self.ram[self.pc.uint]
        self.pc += 1
        
    def decode_execute(self):
        """译码执行阶段"""
        opcode = self.ir.uint
        
        if opcode == 0x01:  # LDA
            addr_high = self.ram[self.pc.uint]
            self.pc += 1
            addr_low = self.ram[self.pc.uint]
            self.pc += 1
            addr = (addr_high.uint << 8) | addr_low.uint
            self.a = self.ram[addr]
            
        elif opcode == 0x03:  # ADD
            addr_high = self.ram[self.pc.uint]
            self.pc += 1
            addr_low = self.ram[self.pc.uint]
            self.pc += 1
            addr = (addr_high.uint << 8) | addr_low.uint
            self.a, self.flags['C'] = self.alu.add(self.a, self.ram[addr])
            self.flags['Z'] = 1 if self.a.uint == 0 else 0
            
        elif opcode == 0x05:  # JMP
            addr_high = self.ram[self.pc.uint]
            self.pc += 1
            addr_low = self.ram[self.pc.uint]
            self.pc = BitArray(uint=(addr_high.uint << 8) | addr_low.uint, length=16)

4. 构建完整执行周期与调试接口

为方便观察CPU内部状态，我们添加状态打印功能和简单的汇编器来编写测试程序。

添加调试支持代码：

class CPU:
    # ... 延续之前的代码
    
    def print_state(self):
        print(f"PC: 0x{self.pc.hex} | A: 0x{self.a.hex} | FLAGS: {self.flags}")
        print(f"IR: 0x{self.ir.hex} (opcode: {self.ir.uint})")
        
    def load_program(self, program, start_addr=0x0000):
        """将机器码程序加载到内存"""
        for i, byte in enumerate(program):
            self.ram[start_addr + i] = BitArray(uint=byte, length=8)
        self.pc = BitArray(uint=start_addr, length=16)

# 示例测试程序：计算5 + 3
test_program = [
    0x01, 0x00, 0x10,  # LDA 0x0010 (加载5到A)
    0x03, 0x00, 0x11,  # ADD 0x0011 (加3)
    0x02, 0x00, 0x12,  # STA 0x0012 (存储结果)
    0x00               # HLT (停机)
]

# 初始化CPU并加载测试程序
cpu = CPU()
cpu.ram[0x0010] = BitArray(uint=5, length=8)  # 地址0x0010存储值5
cpu.ram[0x0011] = BitArray(uint=3, length=8)  # 地址0x0011存储值3
cpu.load_program(test_program, 0x0000)

# 执行程序
for _ in range(6):  # 足够执行完整程序
    cpu.clock_cycle()
    cpu.print_state()

print(f"最终结果存储在0x0012: {cpu.ram[0x0012].uint}")

执行上述代码，您将看到CPU逐步执行指令的过程，最终在内存地址0x0012得到计算结果8。这个简单的模拟器已经具备了真实CPU的核心特征：它按照取指-译码-执行的循环工作，通过总线访问内存，使用ALU进行运算，并能根据程序流程改变执行路径。

5. 扩展与优化方向

基础框架完成后，可以考虑以下增强功能：

性能监控扩展 ：

class CPU:
    def __init__(self):
        # ... 原有初始化
        self.cycles = 0
        self.instructions_executed = 0
        
    def clock_cycle(self):
        self.cycles += 1
        self.fetch()
        self.decode_execute()
        self.instructions_executed += 1

中断处理机制 ：

class CPU:
    def __init__(self):
        # ... 原有初始化
        self.interrupt_enabled = False
        self.interrupt_vector = 0xFF00
        
    def handle_interrupt(self):
        if self.interrupt_enabled:
            # 保存现场
            self.push(self.pc)
            self.push(self.a)
            # 跳转到中断向量
            self.pc = BitArray(uint=self.interrupt_vector, length=16)

流水线初步实现 ：

class PipelinedCPU(CPU):
    def __init__(self):
        super().__init__()
        self.pipeline = [None] * 3  # 三级流水线
        
    def clock_cycle(self):
        # 流水线推进
        self.pipeline[2] = self.pipeline[1]
        self.pipeline[1] = self.pipeline[0]
        
        # 取指阶段
        self.pipeline[0] = ('fetch', self.pc)
        self.ir = self.ram[self.pc.uint]
        self.pc += 1
        
        # 处理其他阶段...

完成这个项目后，您会发现计算机体系结构教材中的各种图示突然变得生动起来——那些箭头和方框在您的代码中都有了具体对应。这种从实践入门的理解方式，往往比纯理论学习更加深刻和持久。