如何在动态创建的Python类中实现正确的名称修饰（name mangling）？

这个问题其实戳中了Python名称修饰（name mangling）的一个关键特性——它是在类定义的编译阶段完成的，而不是运行时动态调整的。我们先来拆解下你的初始代码为什么失效，再聊聊更靠谱的实现方式。

你的make_class函数里，定义的Ret类在编译时，self.__x已经被自动转换成了_Ret__x。哪怕你后来把Ret.__name__改成了'A'，这个已经生成的属性名不会跟着变化，所以a._A__x自然找不到，assert也就失败了。

下面是几种更可行的解决方案，各有优劣，可以根据你的场景选择：

方案1：安全版exec（可控场景首选） #

如果你的类名是可信的（比如来自内部定义，不是用户输入），那改进后的exec写法其实是最直观的——让类在定义时就使用你传入的名称，这样Python会自动帮你做正确的名称修饰：

def make_class(name: str) -> type:
    # 创建独立的命名空间，避免污染全局变量
    class_namespace = {}
    # 用exec动态生成类，类名直接用传入的name
    exec(f'''
class {name}:
    def __init__(self):
        self.__x = 0
''', globals(), class_namespace)
    # 从独立命名空间中取出生成的类
    return class_namespace[name]

# 测试验证
A = make_class('A')
a = A()
assert a._A__x == 0  # 现在能正常通过了

这个方案的优点是完全遵循Python的类定义逻辑，多个私有属性也能自动处理，缺点是如果类名来自不可信输入，存在代码注入风险——但如果是可控场景，这是最省心的选择。

方案2：手动构建初始化方法（无exec，更安全） #

如果不想用exec，也可以手动生成__init__函数，直接设置修饰后的属性名。结合types.new_class可以让代码更规整：

import types

def make_class(name: str) -> type:
    # 定义初始化逻辑，手动处理名称修饰
    def __init__(self):
        mangled_attr = f'_{name}__x'
        setattr(self, mangled_attr, 0)
    
    # 动态创建类，指定类名、基类和类属性
    return types.new_class(
        name,
        bases=(),
        dict={'__init__': __init__}
    )

# 测试验证
A = make_class('A')
a = A()
assert a._A__x == 0  # 正常工作

这个方案完全避免了exec，安全性更高，但缺点是每个私有属性都需要手动处理名称修饰，如果类里有多个私有变量，写起来会比较繁琐。

方案3：元类实现（高级场景） #

如果需要处理更复杂的类结构（比如多个方法里都有私有属性），可以用元类来自动修正私有属性的名称。不过这个实现复杂度较高，适合特殊场景：

import inspect
import types

class MangleMeta(type):
    def __new__(cls, class_name, bases, namespace):
        # 遍历类中的可调用方法，修正其中的私有属性引用
        for attr_name, attr in namespace.items():
            if callable(attr) and hasattr(attr, '__code__'):
                # 获取方法源码，替换__x为_{class_name}__x
                try:
                    source = inspect.getsource(attr)
                    modified_source = source.replace('self.__x', f'self._{class_name}__x')
                    # 编译替换后的代码，更新方法
                    local_vars = {}
                    exec(modified_source, globals(), local_vars)
                    namespace[attr_name] = local_vars[attr_name]
                except OSError:
                    # 处理无法获取源码的情况（比如内置函数）
                    pass
        return super().__new__(cls, class_name, bases, namespace)

def make_class(name: str) -> type:
    # 用元类创建类，保留原始的__x写法
    return MangleMeta(name, (), {
        '__init__': lambda self: setattr(self, '__x', 0)
    })

# 测试验证
A = make_class('A')
a = A()
assert a._A__x == 0

这个方案可以自动修正多个方法里的私有属性，但缺点是依赖源码获取，对于动态生成的方法可能失效，而且实现起来比较绕，一般场景下用前两个方案就足够了。

总的来说，如果是可控场景，方案1最省心；如果需要绝对安全，方案2更稳妥；方案3则留给复杂的高级需求。

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