Python代码内联性能考量及动态函数合并方案咨询

问题描述 #

我正在构建一套数据转换系统，通过转换构建块修改已反序列化为常规Python对象的XML。因需处理海量对象，必须兼顾内存与CPU性能，所有操作需在反序列化后的特定对象类型上完成：

• 多数转换为标准操作，适用于所有数据集；
• 部分数据集的部分对象需设置自定义属性，希望以用户自定义函数形式提供该能力，且这些函数会在内部处理循环中执行，支持对流入数据使用partial(f, ..)操作。

已放弃动态函数并行执行方案，子类化扩展方式因面向可视化构建块（5GL领域）的用户而不可行。

基准测试结果 #

• 在i7-8700处理器上，Python 3.12.3的性能逊于Python 3.10.12；
• forloop3性能优于any(map(lambda))方案；
• forloop2通过单函数执行实现最优性能。

核心问题 #

是否存在优雅的方式（例如使用ast）将a、b、c的代码全部内联，动态生成类似abc的函数？是否有更优替代方案？

可行方案 #

1. AST动态生成内联函数 #

AST是实现代码完全内联的直接方案，可遍历目标函数的AST节点，将它们的执行逻辑合并为一个新函数的代码体，同时处理变量作用域避免冲突。

示例实现：

import ast
import inspect
import copy

def extract_func_body_ast(func):
    # 获取函数源码并解析为AST
    source = inspect.getsource(func)
    tree = ast.parse(source)
    return tree.body[0].body  # 提取函数内部执行语句的AST节点

def merge_functions(*funcs):
    # 构建新函数的AST结构
    merged_func_ast = ast.FunctionDef(
        name='merged',
        args=ast.arguments(
            args=[ast.arg(arg='obj', annotation=None)],
            vararg=None,
            kwonlyargs=[],
            kw_defaults=[],
            kwarg=None,
            defaults=[]
        ),
        body=[],
        decorator_list=[],
        returns=None
    )
    
    # 合并所有函数的执行逻辑
    for func in funcs:
        func_body = extract_func_body_ast(func)
        merged_func_ast.body.extend(copy.deepcopy(func_body))
    
    # 修复AST节点位置信息，确保编译正常
    ast.fix_missing_locations(merged_func_ast)
    # 编译并生成可调用函数
    module = ast.Module(body=[merged_func_ast], type_ignores=[])
    compiled = compile(module, filename='<dynamic_merge>', mode='exec')
    ns = {}
    exec(compiled, ns)
    return ns['merged']

# 示例转换函数
def a(obj):
    obj.attr_a = "val_a"

def b(obj):
    obj.attr_b = "val_b"

def c(obj):
    obj.attr_c = "val_c"

# 生成合并后的内联函数
abc = merge_functions(a, b, c)
# 使用方式：abc(target_obj)

注意：如果转换函数存在返回值或依赖外部变量，需额外处理作用域捕获与return语句的合并逻辑（若为纯对象修改操作，直接合并代码体即可）。

2. 函数组合（轻量高性能替代） #

若无需完全内联代码，仅追求接近单函数的性能，可通过函数组合将多个转换逻辑打包为一个调用链，实现简单且性能损耗极低：

from functools import reduce

def compose(*funcs):
    def composed(obj):
        for func in funcs:
            func(obj)
        return obj
    return composed

# 合并a、b、c为单函数调用
abc = compose(a, b, c)

这种方式的性能接近手写单函数abc，因为本质是在一个函数内依次执行所有转换逻辑，避免了多次函数调用的额外开销，且维护成本远低于AST方案。

3. 源码字符串拼接（快速验证方案） #

如果AST学习成本较高，可直接拼接函数源码字符串并编译执行，实现直观但对函数格式有一定要求：

import inspect

def merge_via_source(*funcs):
    body_lines = []
    for func in funcs:
        # 提取函数内部代码（去除def定义行与缩进）
        lines = inspect.getsource(func).splitlines()
        func_body = [line[4:] for line in lines[1:]]  # 假设使用4空格缩进
        body_lines.extend(func_body)
    
    # 生成合并后的函数源码
    merged_source = f"""
def merged(obj):
    {'\n    '.join(body_lines)}
    return obj
"""
    ns = {}
    exec(merged_source, ns)
    return ns['merged']

该方案的缺点是依赖函数的格式一致性（如缩进规则），但实现简单，适合快速验证功能。

性能选择建议 #

• 追求极致性能：AST生成的内联函数与手写单函数性能几乎一致；
• 平衡性能与维护成本：函数组合compose方案足够满足绝大多数场景，性能接近内联函数且实现简单；
• 快速验证需求：源码拼接方案开发速度快，但需注意格式兼容性。

内容的提问来源于stack exchange，提问作者Skinkie