如何让子类B调用父类A的方法时返回B实例而非A实例？

不需要逐个重写所有方法，根据是否能修改类A的代码，有两种通用方案：

一、可以修改类A的代码（最优解） #

如果有权限改动A的实现，只需要把A中所有创建实例的地方，从直接调用A(...)改成调用self.__class__(...)。这样不管是A本身还是它的子类调用这些方法，都会返回当前调用者所属类的实例。

示例代码：

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

    def filter(self, condition):
        filtered_data = [x for x in self.data if condition(x)]
        # 用self.__class__替代A，自动适配子类
        return self.__class__(filtered_data)

    def sort(self):
        sorted_data = sorted(self.data)
        return self.__class__(sorted_data)

class B(A):
    def __init__(self, data):
        super().__init__(data)

    def double_data(self):
        return [x*2 for x in self.data]

# 测试：B调用A的方法会返回B实例
b = B([3,1,2])
sorted_b = b.sort()
print(type(sorted_b))  # 输出 <class '__main__.B'>
print(sorted_b.double_data())  # 输出 [2,4,6]

二、无法修改类A的代码（比如A是第三方库类） #

如果不能改动A的代码，可以通过装饰器批量包装方法或者元类自动处理，把A方法返回的实例转换成B的实例。

方法1：批量装饰继承的方法 #

先写一个装饰器，负责将方法返回的A实例转换为当前类的实例，再批量给B中继承自A的方法加上这个装饰器：

import inspect

def convert_to_current_class(func):
    def wrapper(self, *args, **kwargs):
        result = func(self, *args, **kwargs)
        # 仅当返回A实例且不是当前类实例时转换
        if isinstance(result, A) and not isinstance(result, self.__class__):
            # 这里根据A的实际初始化参数调整，比如从A实例中提取必要数据
            return self.__class__(result.data)
        return result
    return wrapper

class A:
    # 假设这是无法修改的第三方类
    def __init__(self, data):
        self.data = data
    def filter(self, condition):
        return A([x for x in self.data if condition(x)])
    def sort(self):
        return A(sorted(self.data))

class B(A):
    def __init__(self, data):
        super().__init__(data)
    def double_data(self):
        return [x*2 for x in self.data]

# 批量给B中未重写的A方法添加装饰器
for method_name, _ in inspect.getmembers(A, inspect.isfunction):
    if method_name not in B.__dict__:
        original_method = getattr(B, method_name)
        setattr(B, method_name, convert_to_current_class(original_method))

# 测试
b = B([3,1,2])
filtered_b = b.filter(lambda x: x>1)
print(type(filtered_b))  # 输出 <class '__main__.B'>
print(filtered_b.double_data())  # 输出 [6,4]

方法2：用元类自动处理 #

元类可以在B类创建时，自动包装所有继承自A的方法，无需手动批量处理：

import inspect

class ConvertReturnMeta(type):
    def __new__(cls, name, bases, attrs):
        new_class = super().__new__(cls, name, bases, attrs)
        # 遍历基类（A）的所有方法
        for base in bases:
            for method_name, method in inspect.getmembers(base, inspect.isfunction):
                if method_name not in attrs:
                    # 包装方法，转换返回实例
                    def wrapper(self, *args, **kwargs):
                        result = getattr(super(new_class, self), method_name)(*args, **kwargs)
                        if isinstance(result, base) and not isinstance(result, new_class):
                            return new_class(result.data)
                        return result
                    setattr(new_class, method_name, wrapper)
        return new_class

class A:
    # 无法修改的第三方类
    def __init__(self, data):
        self.data = data
    def filter(self, condition):
        return A([x for x in self.data if condition(x)])
    def sort(self):
        return A(sorted(self.data))

class B(A, metaclass=ConvertReturnMeta):
    def __init__(self, data):
        super().__init__(data)
    def double_data(self):
        return [x*2 for x in self.data]

# 测试
b = B([3,1,2])
sorted_b = b.sort()
print(type(sorted_b))  # 输出 <class '__main__.B'>
print(sorted_b.double_data())  # 输出 [2,4,6]

注意事项 #

• 转换实例时，要确保你能从A实例中获取创建B实例所需的全部数据（比如示例中的data属性），如果A的初始化逻辑复杂，可能需要调整转换逻辑。
• 如果A的某些方法不需要转换（比如返回非A实例的方法），可以在批量处理时排除这些方法名。

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