如何实现适配子类的基类copy/deepcopy，无需子类重写__copy__/__deepcopy__

这绝对是Python继承场景下实现通用复制逻辑的典型痛点——既要让基类牢牢把控哪些字段不能被复制（比如计算值、外部引用），又要让子类不用每次都重写__copy__/__deepcopy__就能自动带上自己新增属性的复制能力。下面我给你一套通用的设计方案，完美解决你给出的两个场景：

一、解决浅复制（copy.copy）问题 #

核心思路是：基类不要硬编码返回自身实例，而是动态创建当前子类的实例，同时跳过不需要复制的字段（比如计算字段），并把计算逻辑抽离到单独方法以便复制后重新生成。

基类实现 #

import copy

class A(object):
    # 基类定义：不需要复制的字段（比如计算字段）
    _copy_exclude = {'b'}

    def __init__(self, a):
        self.a = a
        # 把计算字段的逻辑抽离到单独方法
        self._compute_derived_fields()

    def _compute_derived_fields(self):
        """生成所有计算/派生字段，复制后会重新调用此方法"""
        self.b = self.a + 1

    def __copy__(self):
        # 动态创建当前类（子类）的未初始化实例
        new_instance = self.__class__.__new__(self.__class__)
        
        # 复制__dict__中不在排除列表的所有属性（包括子类新增的属性）
        for key, value in self.__dict__.items():
            if key not in self._copy_exclude:
                setattr(new_instance, key, value)
        
        # 重新生成计算字段，避免直接复制旧的计算值
        new_instance._compute_derived_fields()
        
        return new_instance

子类测试（无需重写__copy__） #

class B(A):
    def __init__(self, c):
        # 子类构造函数签名和基类不同也没关系
        super().__init__(c + 100)
        self.c = c  # 子类新增属性

# 测试浅复制
b = B(5)
b_copy = copy.copy(b)

print(isinstance(b_copy, B))  # 输出 True：返回的是子类实例
print(b_copy.c)               # 输出 5：子类属性被正确复制
print(b_copy.a)               # 输出 105：基类属性正常复制
print(b_copy.b)               # 输出 106：计算字段重新生成，正确

二、解决深复制（copy.deepcopy）问题 #

核心思路是：基类明确标记需要深复制的字段、直接引用的字段，剩下的子类新增属性默认自动深复制，同时处理循环引用问题。

基类实现 #

from copy import deepcopy

class A:
    # 基类定义：需要深复制的字段
    _deepcopy_include = {'content'}
    # 基类定义：直接引用、不需要深复制的字段（比如外部引用）
    _deepcopy_skip = {'container'}

    def __init__(self, content, container):
        self.content = content
        self.container = container

    def __deepcopy__(self, memo):
        # 1. 创建当前类（子类）的未初始化实例
        new_instance = self.__class__.__new__(self.__class__)
        # 2. 记录到memo字典，避免循环引用
        memo[id(self)] = new_instance

        # 3. 深复制指定字段
        for key in self._deepcopy_include:
            if hasattr(self, key):
                setattr(new_instance, key, deepcopy(getattr(self, key), memo))

        # 4. 直接引用指定字段（不深复制）
        for key in self._deepcopy_skip:
            if hasattr(self, key):
                setattr(new_instance, key, getattr(self, key))

        # 5. 自动处理子类新增的其他属性：默认深复制
        for key, value in self.__dict__.items():
            if key not in self._deepcopy_include and key not in self._deepcopy_skip:
                setattr(new_instance, key, deepcopy(value, memo))

        # 6. 特殊处理：如果原实例的container指向自身，修正为新实例
        if self.container is self:
            new_instance.container = new_instance

        return new_instance

子类测试（无需重写__deepcopy__） #

class B(A):
    def __init__(self, attr):
        # 这里container传入self，测试循环引用的深复制
        super().__init__([1,2,3], self)
        self.attr = attr  # 子类新增属性

# 测试深复制
b = B(123)
b.content.append(4)  # 修改原实例的content
b1 = deepcopy(b)

print(isinstance(b1, B))        # 输出 True：返回子类实例
print(b1.content == b.content)  # 输出 True：content被深复制
print(b1.content is b.content)  # 输出 False：确认是深复制，不是引用
print(b1.attr == b.attr)        # 输出 True：子类属性被深复制
print(b1.container is b1)       # 输出 True：循环引用被正确修正

三、通用设计思路总结 #

1. 动态实例化：用self.__class__.__new__(self.__class__)创建实例，确保返回的是子类对象，而非硬编码的基类。
2. 元数据控制：通过类变量（_copy_exclude、_deepcopy_include等）明确标记字段的复制规则，基类统一处理，子类可按需扩展这些变量。
3. 分离计算逻辑：把计算/派生字段的生成逻辑抽离到单独方法，复制后重新调用，避免复制过时的计算值。
4. 自动适配子类：直接操作实例的__dict__复制属性，不依赖构造函数签名，子类新增属性自动被处理。
5. 循环引用处理：在__deepcopy__中用memo字典记录已复制的实例，避免无限递归。

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