Tweet:

1. Preliminary Concepts

2. Optimization Methods

2.1 Basic Concepts

2.2 Install the SD card

2.3 Using the frozen Module and Frozen Bytecode

2.3.1 Python Bytecode

2.3.2 Steps for Generating Freeze Module and Bytecode

2.3.3 Main Features of MicroPython Frozen Modules

2.4 Using. mpy Files

2.5 Using const Constants

2.5.1 MicroPython Namespaces and Scopes

import sys

# sys.modules显示当前已导入 (加载) 的所有模块名和模块对象
print("Initial modules:")
print(list(sys.modules.keys()))

# 定义全局变量
global_var = "I am a global variable"

# enclosing_var 闭包外层变量
# local_var 函数inner_function内部局部变量
# len 是内置函数
# 尝试修改全局变量global_var （不使用global会创建局部变量）
# 闭包外层无法访问内部局部变量
def scope_demo():
    enclosing_var = "I am an enclosing variable (outer of closure)"
    
    def inner_function():
        local_var = "I am a local variable"
        
        print("Local variable:", local_var)
        print("Enclosing variable:", enclosing_var)
        print("Global variable:", global_var)
        print("Built-in function example:", len("test"))
        
        try:
            global_var = "Trying to modify"
        except:
            pass
    
    inner_function()
    
    try:
        print(local_var)
    except:
        print("Cannot access local variable")

# 使用global修改全局变量
def modify_global():
    global global_var
    global_var = "Modified global variable"
    print("Inside function:", global_var)

# 多层嵌套中的nonlocal使用
# 内部middle()函数和inner()函数中修改嵌套作用域中的变量outer_var
def nonlocal_demo():
    outer_var = "Outer layer"
    
    def middle():
        nonlocal outer_var
        outer_var = "Modified by middle layer"
        
        def inner():
            nonlocal outer_var
            outer_var = "Modified by inner layer"
        
        inner()
        print("In middle:", outer_var)
    
    middle()
    print("In nonlocal_demo:", outer_var)

# 作用域演示
print("\n=== Scope Demonstration ===")
scope_demo()
print("Access in global scope:", global_var)

# 修改全局变量
print("\n=== Modify Global Variable ===")
modify_global()
print("In global scope:", global_var)

# nonlocal演示
print("\n=== nonlocal Demonstration ===")
nonlocal_demo()

# 尝试访问内置作用域
import builtins
print("Built-in module:", builtins)

2.5.2 Definition and Optimization Principles of const Constants

from micropython import const
# 垃圾回收模块，用于查看内存使用情况
import gc

# 第一步：查看初始内存使用情况
# 强制垃圾回收，释放无用内存
gc.collect()
initial_free = gc.mem_free()
print(f"Initial free RAM: {initial_free} bytes")

# 第二步：定义const常量
# 公开常量（模块外能访问，仅占极少量RAM）
CONST_X = const(123)
CONST_Y = const(2 * 123 + 1)
# 私有常量（以下划线开头，模块外不能访问，完全不占用RAM）
_COLS = const(0x10)
ROWS = const(33)

# 第三步：使用常量
a = ROWS
b = _COLS
print(f"CONST_X: {CONST_X}, CONST_Y: {CONST_Y}")
print(f"a: {a}, b: {b}")

# 第四步：查看定义常量后的内存使用情况
gc.collect()
after_free = gc.mem_free()
print(f"Free RAM after defining constants: {after_free} bytes")
print(f"RAM change: {after_free - initial_free} bytes (positive means memory freed)")

# 补充：对比普通变量与const常量的区别
# 普通变量，存储在RAM中
normal_var = 123  
gc.collect()
after_normal = gc.mem_free()
print(f"Free RAM after defining normal variable: {after_normal} bytes")
print(f"Normal variable uses {after_free - after_normal} more bytes than const")

from micropython import const

ROWS = const(33)
# 下面用法报错
COLS = const(0x10+ROWS)
# 正确用法
COLS = const(0x10+33)

2.6 Reduce unnecessary object creation

2.6.1 String Operation Optimization (Avoiding Temporary String Objects)

# 静态字符串拼接（编译时合并，无临时对象）
static_str = "MicroPython" "Memory" "Opt"
print("Static string:", static_str)

# 动态字符串（推荐format，减少临时对象）
temp = 25.5
press = 101325
dynamic_str = "Temp: {:.2f}, Press: {:d}".format(temp, press)
print("Dynamic string:", dynamic_str)

2.6.2 Buffer to reuse in hardware operations (UART/SPI/I2C scenarios)

from machine import UART, Pin

# 初始化UART
uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))
# 预分配缓冲区（仅创建1次）
uart_buf = bytearray(16)

# 循环接收（复用缓冲区）
for _ in range(5):
    uart.readinto(uart_buf)
    print("UART data:", uart_buf)

from machine import SPI, Pin

# 初始化SPI
spi = SPI(0, baudrate=1000000, sck=Pin(2), mosi=Pin(3), miso=Pin(4))
# 预分配缓冲区
spi_buf = bytearray(8)

# 循环读写（复用缓冲区）
for _ in range(5):
    spi.readinto(spi_buf)
    print("SPI data:", spi_buf)

2.6.3 Numerical Storage Optimization (Replace Lists with struct/bytearray)

# 1. str vs bytes（内存占用一致，ASCII场景）
# String (ASCII)
s = 'the quick brown fox'  
# Bytes (1 byte per char)
b = b'the quick brown fox' 
print("String:", s)
print("Bytes:", b)

# 2. 字符串与字节的转换（注意：转换会创建新对象）
# str -> bytes
s_to_b = s.encode()  
# bytes -> str
b_to_s = b.decode()  
print("Str->Bytes:", s_to_b)
print("Bytes->Str:", b_to_s)

# 3. bytes支持字符串方法（如lstrip）
foo = b'  empty whitespace'
foo_stripped = foo.lstrip()
print("Stripped bytes:", foo_stripped)

2.6.4 Avoid Creating Temporary Containers in Loops

import gc
import struct

# 初始化垃圾回收，建立测试基线
gc.collect()
ram_init = gc.mem_free()

# 定义循环次数（模拟多次迭代场景）
loop_times = 100

# ---------------------- 低效实现：循环内创建临时列表 ----------------------
# 循环内每次创建新的列表容器，产生大量临时对象
gc.collect()
ram_slow_before = gc.mem_free()
total_slow = 0

# 每次循环创建新列表[1,2,3,4,5]
# struct测试列表数据的字节大小（打包为5个整数，用'i'格式）
for _ in range(loop_times):
    temp_list = [1, 2, 3, 4, 5]
    total_slow += sum(temp_list)
    
    size_slow = len(struct.pack("5i", *temp_list))
# 记录低效实现后的RAM
ram_slow_after = gc.mem_free()

# ---------------------- 高效实现1：循环外创建列表，复用容器 ----------------------
# 列表仅创建一次，循环内复用
gc.collect()
ram_fast1_before = gc.mem_free()
total_fast1 = 0

# 临时列表移到循环外（仅创建1次）
# struct测试复用列表的字节大小（与低效实现一致）
temp_list_reuse = [1, 2, 3, 4, 5]
for _ in range(loop_times):
    total_fast1 += sum(temp_list_reuse)
    
    size_fast1 = len(struct.pack("5i", *temp_list_reuse))
# 记录高效实现1后的RAM
ram_fast1_after = gc.mem_free()

# ---------------------- 高效实现2：使用生成器，替代临时列表 ----------------------
# 定义生成器函数（仅创建一次，循环内复用迭代器）
# 直接yield元素，避免元组创建
def num_generator():
    yield 1
    yield 2
    yield 3
    yield 4
    yield 5
    
# 生成器不创建完整列表，仅迭代生成元素，内存开销最低
gc.collect()
ram_fast2_before = gc.mem_free()
total_fast2 = 0

# 生成器表达式（无临时列表对象）
# struct测试生成器数据的字节大小（打包为5个整数）
for _ in range(loop_times):
    total_fast2 += sum(num_generator())
    size_fast2 = len(struct.pack("5i", 1, 2, 3, 4, 5))
# 记录高效实现2后的RAM
ram_fast2_after = gc.mem_free()

# 输出测试结果（无中文）
print("Slow total:", total_slow)
print("Slow RAM change:", ram_slow_before - ram_slow_after)
print("Slow data size:", size_slow)

print("Fast1 total:", total_fast1)
print("Fast1 RAM change:", ram_fast1_before - ram_fast1_after)
print("Fast1 data size:", size_fast1)

print("Fast2 total:", total_fast2)
print("Fast2 RAM change:", ram_fast2_before - ram_fast2_after)
print("Fast2 data size:", size_fast2)

2.6.5 Avoid runtime compiler execution (eval / exec)

import gc
import struct
import json

# ---------------------- 低效：使用eval ----------------------
gc.collect()
ram_eval_before = gc.mem_free()
# 避免使用eval，此处仅作对比
res_eval = eval("1 + 2 * 3 + 4 / 2")
ram_eval_after = gc.mem_free()

# ---------------------- 高效：直接计算 ----------------------
gc.collect()
ram_calc_before = gc.mem_free()
res_calc = 1 + 2 * 3 + 4 / 2
ram_calc_after = gc.mem_free()

# ---------------------- 高效：ujson序列化 ----------------------
gc.collect()
ram_json_before = gc.mem_free()
# 序列化
data = {"temp": 25.5, "press": 101325}
json_data = json.dumps(data)
# 反序列化
size_json = len(struct.pack(f"{len(json_data.encode())}s", json_data.encode()))
data_loaded = json.loads(json_data)
ram_json_after = gc.mem_free()

# 输出测试结果
print("Eval RAM change:", ram_eval_before - ram_eval_after)
print("Calc RAM change:", ram_calc_before - ram_calc_after)
print("JSON size:", size_json)
print("JSON RAM change:", ram_json_before - ram_json_after)

The terminal output is as follows:

2.6.6 Storing Strings in Flash (qstr Mechanism)

import gc
import struct
import micropython

# 初始化垃圾回收
gc.collect()
ram_init = gc.mem_free()

# 定义测试字符串（会被qstr机制处理）
s1 = "MicroPython"
# 重复字符串，复用闪存中的qstr
s2 = "MicroPython"  

# struct测试字符串字节大小
size_s = len(struct.pack(f"{len(s1.encode())}s", s1.encode()))

# 打印qstr信息（1表示详细输出）
micropython.qstr_info(1)

# 记录RAM
ram_after = gc.mem_free()

# 输出测试结果
print("String size:", size_s)
print("RAM free:", ram_after)

>>> micropython.qstr_info(1)
qstr pool: n_pool=1, n_qstr=5, n_str_data_bytes=26, n_total_bytes=170
Q(ram_init)
Q(s1)
Q(s2)
Q(size_s)
Q({}s)

2.7 Heap and Garbage Collection Mechanism

# 导入gc模块，用于操作垃圾回收（mpy版）
import gc

# 1. 查看自动GC是否开启（部分mpy版本支持）
print(gc.isenabled())

# 2. 禁用自动GC，方便手动控制测试过程
gc.disable()
print(gc.isenabled())

# 3. 查看初始的空闲堆内存和已分配堆内存（mpy专属方法）
print(f"Free heap: {gc.mem_free()} bytes")
print(f"Allocated heap: {gc.mem_alloc()} bytes")

# 4. 演示gc.threshold()方法：设置并查询GC分配阈值（mpy专属方法）
# 设置阈值为1024字节，累计分配1024字节后触发GC（提前回收减少碎片）
gc.threshold(1024)
# 无参数时查询当前阈值
current_threshold = gc.threshold()  
print(f"Current GC threshold: {current_threshold} bytes")

# 5. 创建普通对象，占用堆内存（变量是栈中的引用，指向堆对象）
# 创建更大的列表，内存变化更明显
obj1 = [1, 2, 3, 4, 5]  
obj2 = {"name": "test", "age": 18}
print("Objects created")

# 6. 查看创建对象后的内存变化
print(f"Free heap after create: {gc.mem_free()} bytes")
print(f"Allocated heap after create: {gc.mem_alloc()} bytes")

# 7. 切断引用，让对象成为垃圾（堆中对象无引用指向）
obj1 = None
obj2 = None
print("References cut, objects become garbage")

# 8. 查看切断引用后的内存（未GC，内存未释放）
print(f"Free heap before collect: {gc.mem_free()} bytes")
print(f"Allocated heap before collect: {gc.mem_alloc()} bytes")

# 9. 手动触发GC，清理垃圾对象
# mpy中部分版本无返回值，故移除接收变量
gc.collect()  
print("Garbage collection executed")

# 10. 查看GC后的内存变化（垃圾被清理，空闲内存增加）
print(f"Free heap after collect: {gc.mem_free()} bytes")
print(f"Allocated heap after collect: {gc.mem_alloc()} bytes")

# 11. 演示循环引用的垃圾回收（引用计数法无法处理，需gc.collect()）
a = []
b = []
# a引用b, b引用a，形成循环引用
a.append(b)  
b.append(a) 
print("Circular reference objects created")

# 12. 查看创建循环引用对象后的内存
print(f"Free heap after circular ref: {gc.mem_free()} bytes")
print(f"Allocated heap after circular ref: {gc.mem_alloc()} bytes")

# 13. 切断外部引用，此时a和b互相引用，引用计数不为0
a = None
b = None
print("External references cut (circular ref remains)")

# 14. 手动触发GC，清理循环引用的垃圾
gc.collect()
print("Garbage collection for circular ref executed")

# 15. 查看清理循环引用后的内存
print(f"Free heap after circular collect: {gc.mem_free()} bytes")
print(f"Allocated heap after circular collect: {gc.mem_alloc()} bytes")

# 16. 恢复自动GC，并重置阈值为默认（-1表示禁用阈值）
gc.threshold(-1)
print(f"Reset GC threshold: {gc.threshold()}")
gc.enable()
print(gc.isenabled())

stack: 516 out of 7936
GC: total: 233024, used: 7168, free: 225856
 No. of 1-blocks: 96, 2-blocks: 26, max blk sz: 64, max free sz: 14075
...（内存布局省略）

References