优化基于方法列表动态生成Python类方法的实现方案

你当前的实现虽然可以跑通，但存在几个非常典型的反模式问题：

• 拼接代码字符串+exec的方式可维护性极差，模板字符串里的缩进、语法错误很难排查，IDE无法做静态检查、补全
• 存在任意代码执行风险：如果_prop里的键名来自外部不可信输入，exec可以执行任何传入的代码
• 逻辑冗余：每次实例化Base都会重复给类绑定方法，还依赖全局变量临时传递生成的函数，容易出现命名污染
• 隐含bug：原代码里自定义异常ValueNot未定义、方法名拼写错误（dinamic_method应为dynamic_method）

完全不需要用exec做这种动态方法生成，Python里闭包+setattr就可以安全、清晰地实现完全一样的功能，甚至性能更好。

优化实现方案 #

核心思路是写一组方法工厂函数，传入配置项名称，通过闭包绑定对应的存储属性名，返回生成好的方法，再统一绑定到类上。推荐把方法绑定逻辑放到类创建阶段执行，避免每次实例化重复操作。

第一步：定义通用方法工厂和自定义异常 #

class ValueNotExist(KeyError):
    """替代原代码未定义的ValueNot异常，继承KeyError更符合语义"""
    pass

def _make_add(attr: str):
    storage = f"_{attr}"
    cap = attr.capitalize()
    def add(self, v, rule=True):
        getattr(self, storage)[v._name] = (v, rule)
        self.markChanged()
    add.__name__ = f"add{cap}"
    return add

def _make_get_names(attr: str):
    storage = f"_{attr}"
    cap = attr.capitalize()
    def get_names(self):
        return list(getattr(self, storage).keys())
    get_names.__name__ = f"get{cap}Names"
    return get_names

def _make_remove(attr: str):
    storage = f"_{attr}"
    cap = attr.capitalize()
    get_names = f"get{cap}Names"
    def remove(self, name):
        if name in getattr(self, get_names)():
            del getattr(self, storage)[name]
            self.markChanged()
    remove.__name__ = f"remove{cap}"
    return remove

def _make_get(attr: str):
    storage = f"_{attr}"
    cap = attr.capitalize()
    def get(self, name):
        s = getattr(self, storage)
        if name in s:
            return s[name]
        raise ValueNotExist(f"{attr} {name} not in object")
    get.__name__ = f"get{cap}"
    return get

def _make_update_rule(attr: str):
    storage = f"_{attr}"
    cap = attr.capitalize()
    def update_rule(self, name, rule):
        s = getattr(self, storage)
        if name in s:
            obj, _ = s[name]
            s[name] = (obj, rule)
            self.markChanged()
    update_rule.__name__ = f"update{cap}Rule"
    return update_rule

def _make_prop(attr: str):
    storage = f"_{attr}"
    def getter(self):
        return getattr(self, storage)
    return property(getter)

第二步：改造Base类，自动绑定动态方法 #

用__init_subclass__钩子在类定义阶段就完成方法绑定，不需要在实例化时重复执行：

class Parameter:
    def __init__(self, name):
        self._name = name

class Base:
    # 类级配置，可在子类中覆盖扩展
    _prop_config = {
        'parameters': 'entity_type_parameter',
        'functions': 'entity_type_function'
    }

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        for attr_name in cls._prop_config:
            cap = attr_name.capitalize()
            setattr(cls, f"_{attr_name}", {})
            setattr(cls, f"add{cap}", _make_add(attr_name))
            setattr(cls, f"get{cap}Names", _make_get_names(attr_name))
            setattr(cls, f"remove{cap}", _make_remove(attr_name))
            setattr(cls, f"get{cap}", _make_get(attr_name))
            setattr(cls, f"update{cap}Rule", _make_update_rule(attr_name))
            setattr(cls, cap, _make_prop(attr_name))

    def __init__(self):
        # 每个实例初始化独立的存储字典，避免实例间数据共享
        for attr_name in self._prop_config:
            setattr(self, f"_{attr_name}", {})

    def markChanged(self):
        print("Changed")

测试调用（和原逻辑完全兼容） #

if __name__ == "__main__":
    b = Base()
    p = Parameter("test_p")
    b.addParameters(p)
    print(b.Parameters)
    print(b.getParametersNames())
    print(b.getParameters("test_p"))
    b.updateParametersRule("test_p", False)
    print(b.getParameters("test_p"))
    b.removeParameters("test_p")
    print(b.getParametersNames())

方案优势 #

• 更安全：完全抛弃exec，不存在代码注入风险，所有逻辑可静态检查
• 易维护：每个方法的逻辑独立，修改时不需要调整复杂的字符串模板，IDE可以正常补全、调试，报错栈可以准确定位到行号
• 性能更好：方法只在类加载时绑定一次，原实现每次创建实例都会重新执行代码生成方法、重复绑定，存在不必要的开销
• 无副作用：不需要依赖全局变量传递生成的函数，不会出现命名污染问题，每个动态生成的方法都有正确的函数名，调试时更容易识别
• 扩展性强：后续新增配置项只需要在_prop_config里加键值对即可，新增方法类型只需要加一个对应的工厂函数，不需要改动原有逻辑

如果后续动态属性的访问逻辑更复杂，还可以进一步用Python描述符（Descriptor）封装存储逻辑，代码复用性会更高；对于当前的需求场景，上面的闭包方案已经足够简洁，完全符合Python的常规编码范式。

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