如何在Python中实现类实例的原地Apply（生效）行为？

你需要的是让参数化对象在调用方法后原地转换为目标类型，无需重新赋值变量。Python中变量本质是对象的引用，直接改变变量指向的对象通常需要重新赋值，但可以通过以下几种方式模拟你要的行为：

方案1：修改实例的__class__属性（适用于兼容类） #

如果目标类型和原参数化类属于同一继承体系、内存布局兼容，直接修改实例的__class__属性是最简洁的方式。比如你的3D场景示例：

class 3D_Object:
    def __init__(self, height, width, subdivision):
        self.height = height
        self.width = width
        self.subdivision = subdivision
        # 这里添加3D对象的实际初始化逻辑（比如生成网格数据）

class ParametricCube:
    def __init__(self):
        # 默认参数
        self.height = 1
        self.width = 1
        self.subdivision = 1

    def make_real(self):
        # 切换实例的类为3D_Object
        self.__class__ = 3D_Object
        # 调用目标类的初始化方法，复用已有参数
        3D_Object.__init__(self, self.height, self.width, self.subdivision)

# 测试
my_cube = ParametricCube()
my_cube.height = 2
my_cube.width = 1
my_cube.subdivision = 3
print(type(my_cube))  # <class '__main__.ParametricCube'>

my_cube.make_real()
print(type(my_cube))  # <class '__main__.3D_Object'>

注意：这种方法仅适用于类结构兼容的场景，不能直接将自定义类实例转为float、int等内置类型（内置类型的内存结构和自定义类完全不同）。

方案2：代理类模拟类型转换（适用于任意目标类型） #

如果要转换成内置类型或不兼容的类，可以用代理类包装参数化状态和实例化后的对象，通过重写特殊方法让代理类“伪装”成目标类型。比如你的Expression示例：

class Expression:
    def __init__(self):
        self._parametric = True
        self.a = 1
        self.b = 2
        self.c = 3
        self._realized = None

    def __str__(self):
        if self._parametric:
            return f"<Expression '{self.a}+{self.b}+{self.c}'={self.a + self.b + self.c}>"
        return str(self._realized)

    def __repr__(self):
        if self._parametric:
            return super().__repr__()
        return repr(self._realized)

    # 伪装类型
    @property
    def __class__(self):
        if self._parametric:
            return Expression
        return type(self._realized)

    def realize(self):
        if self._parametric:
            # 计算并生成目标对象
            self._realized = float(self.a + self.b + self.c)
            self._parametric = False
            # 清理参数化属性
            del self.a, self.b, self.c

    # 转发所有未定义的属性/方法给实例化后的对象
    def __getattr__(self, name):
        if not self._parametric:
            return getattr(self._realized, name)
        raise AttributeError(f"'Expression' object has no attribute '{name}'")

    # 按需实现操作符转发，比如加法
    def __add__(self, other):
        if self._parametric:
            raise TypeError("无法对参数化Expression执行操作")
        return self._realized + other

# 测试
x = Expression()
x.a = 1
x.b = 1
x.c = 1
print(x)  # <Expression '1+1+1'=3>
print(type(x))  # <class '__main__.Expression'>

x.realize()
print(x)  # 3.0
print(type(x))  # <class 'float'>
# 支持float的操作
print(x + 2)  # 5.0

这种方法的优势是可以模拟转换为任意类型，但需要手动实现所需的特殊方法（如__add__、__mul__等）来覆盖所有操作场景。

方案3：修改全局变量引用（不推荐） #

通过sys.modules修改当前模块的全局变量字典，可以直接改变变量的引用，但这种方法依赖变量名、可读性差，且无法处理局部变量，仅作了解：

import sys

class Expression:
    def __init__(self):
        self.a = 1
        self.b = 2
        self.c = 3

    def __str__(self):
        return f"<Expression '{self.a}+{self.b}+{self.c}'={self.a + self.b + self.c}>"

    def realize(self):
        # 遍历全局变量，找到指向当前实例的变量
        global_vars = sys.modules[__name__].__dict__
        for var_name, obj in global_vars.items():
            if obj is self:
                global_vars[var_name] = float(self.a + self.b + self.c)
                break

# 测试
x = Expression()
x.a = 1
x.b = 1
x.c = 1
print(x)  # <Expression '1+1+1'=3>
print(type(x))  # <class '__main__.Expression'>

x.realize()
print(x)  # 3.0
print(type(x))  # <class 'float'>

总结 #

• 优先使用**修改__class__**的方案（兼容类场景），简单高效。
• 需要转换为内置类型或不兼容类时，用代理类方案，灵活性强。
• 全局变量修改方案尽量避免，维护成本极高。

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