Python中如何转移类资源给新类并禁用原类实例？

假设我有一个Python对象A，它包含字段field。A.field是一个深度嵌套的字典，生成或复制它的成本极高。在完成对A实例的所有必要操作后，我调用A.getB()来获取一个新对象B。getB函数会修改field，使其不再满足A的预期格式，但符合B的需求。由于field成本过高，无法使用deepcopy来复制一份给B，请问如何让A实例无法被复用？在Rust中可以通过所有权机制让原对象无法再被使用，但Python没有这类保障，最符合Python风格的处理方式是什么？

Python没有Rust那样的所有权强制机制，核心思路是主动标记实例状态+阻止无效访问，让误用快速暴露，避免静默错误。以下是几种符合Python风格的实现方式：

1. 标记失效状态，访问属性时校验 #

给A添加一个内部状态标记，调用getB()后标记为失效，并重写属性访问方法，一旦检测到失效就抛出明确异常。

class A:
    def __init__(self):
        self.field = {"deep": {"nested": {"data": "expensive"}}}
        self._is_valid = True

    def getB(self):
        # 修改field适配B的需求
        self.field = self.field["deep"]["nested"]
        self._is_valid = False
        return B(self.field)

    def __getattribute__(self, name):
        # 避免访问_is_valid时触发递归检查
        if name == "_is_valid":
            return super().__getattribute__(name)
        if not self._is_valid:
            raise RuntimeError("A实例已在调用getB()后失效，无法再使用")
        return super().__getattribute__(name)

class B:
    def __init__(self, data):
        self.data = data

调用a.getB()后，再访问a的任何属性都会直接抛出异常，从根源上阻止误用。

2. 转移核心数据引用，清空原实例字段 #

在getB()中将field的引用直接转给B，然后把A的field设为None，同时标记实例已被使用，避免重复调用getB()。

class A:
    def __init__(self):
        self.field = {"deep": {"nested": {"data": "expensive"}}}
        self._has_been_used = False

    def getB(self):
        if self._has_been_used:
            raise RuntimeError("该A实例已经转换为B，无法重复操作")
        # 把field的引用交给B
        b_instance = B(self.field)
        # 清空原实例的核心字段
        self.field = None
        self._has_been_used = True
        return b_instance

class B:
    def __init__(self, data):
        self.data = data

这种方式让A失去核心数据，后续访问a.field会得到None，结合状态标记也能防止重复转换。

3. 用上下文管理器限定实例生命周期 #

如果A的使用场景有明确的代码块范围，可以把A实现为上下文管理器，强制实例只能在with块内有效，离开块后自动失效。

class A:
    def __init__(self):
        self.field = {"deep": {"nested": {"data": "expensive"}}}
        self._in_context = True

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        # 退出上下文时标记失效并清空数据
        self._in_context = False
        self.field = None

    def getB(self):
        if not self._in_context:
            raise RuntimeError("只能在with代码块内将A转换为B")
        b_instance = B(self.field)
        self.field = None
        self._in_context = False
        return b_instance

class B:
    def __init__(self, data):
        self.data = data

# 使用方式
with A() as a:
    # 执行对a的必要操作
    b = a.getB()

# 此时a已失效，访问a.field会得到None，调用getB()会报错

这种方式利用Python原生的上下文语法，让实例生命周期更清晰，符合Python的惯用写法。

最通用的方案是第一种（标记失效+访问校验），能覆盖大多数场景；如果有明确的生命周期范围，上下文管理器的写法更地道。核心都是让误用快速抛出明确异常，而不是产生难以排查的错误结果。

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