Python可堆叠Trait实现咨询：混合类属性自定义合并需求

我正在Python中实现一套类层级结构：

• 通用基类BaseEntity作为接口暴露若干属性方法；
• 存在多个不可直接实例化的抽象类（如AbstractEntity1、AbstractEntity2）；
• 具体子类（如FinalEntity）可混入这些抽象类以扩展行为。

示例代码如下：

from abc import ABC, abstractmethod
from typing import List

class BaseEntity(ABC):
    @property
    @abstractmethod
    def f(self) -> List[str]:
        pass

    @property
    @abstractmethod
    def g(self) -> int:
        pass


class AbstractEntity1(BaseEntity, ABC):  # 不可直接实例化
    @property
    @abstractmethod
    def f(self) -> List[str]:
        return ["a", "b"]

    @property
    @abstractmethod
    def g(self) -> int:
        return 10


class AbstractEntity2(BaseEntity, ABC):  # 不可直接实例化
    @property
    @abstractmethod
    def f(self) -> List[str]:
        return ["x"]

    @property
    @abstractmethod
    def g(self) -> int:
        return 3


class FinalEntity(AbstractEntity1, AbstractEntity2, BaseEntity):
    @property
    def f(self) -> List[str]:
        return ["C"]

    @property
    def g(self) -> int:
        return 10

需求：

• 调用final_entity.f时返回["a", "b", "x", "C"]（所有混入类与自身的f属性执行列表相加）；
• 调用final_entity.g时返回10+3+10=23（所有混入类与自身的g属性执行数值求和）；
• 实际场景中合并逻辑不限于相加，需为每个属性自定义逻辑。

请问实现该需求最符合Python风格的方式是什么？

核心思路：利用MRO遍历+属性合并器分离逻辑 #

借助Python的方法解析顺序（MRO）遍历所有混入的抽象类，结合属性专属合并器的设计，既能实现自定义合并逻辑，又保持代码的可扩展性与可读性。

具体实现步骤 #

1. 重构基类，加入合并逻辑基础支持
   修改BaseEntity，添加属性收集工具方法和合并器注册机制，让合并逻辑与属性值提供分离：

   from abc import ABC, abstractmethod
   from typing import List, Callable, Any
   
   class BaseEntity(ABC):
       # 存储属性名到对应合并逻辑的映射
       _merge_handlers: dict[str, Callable[[List[Any]], Any]] = {}
   
       @classmethod
       def register_merge_handler(cls, attr_name: str, handler: Callable[[List[Any]], Any]):
           """注册指定属性的合并逻辑"""
           cls._merge_handlers[attr_name] = handler
   
       def _collect_attr_values(self, attr_name: str) -> List[Any]:
           """遍历MRO中的所有父类，收集对应属性的值"""
           values = []
           # 跳过自身和最顶层的object类，遍历所有混入的抽象类
           for base in self.__class__.mro()[1:-1]:
               if hasattr(base, attr_name):
                   # 绑定当前实例调用父类的属性方法
                   value = getattr(base, attr_name).__get__(self, base)
                   values.append(value)
           # 最后加入自身的属性值
           values.append(getattr(self.__class__, attr_name).__get__(self, self.__class__))
           return values
   
       @property
       @abstractmethod
       def f(self) -> List[str]:
           pass
   
       @property
       @abstractmethod
       def g(self) -> int:
           pass
   
   # 为默认属性注册合并逻辑
   BaseEntity.register_merge_handler("f", lambda vals: sum(vals, []))
   BaseEntity.register_merge_handler("g", lambda vals: sum(vals))
   

2. 调整抽象类，移除冗余的抽象标记
   抽象类中的属性已有具体实现，无需再标记@abstractmethod（否则会导致类无法通过ABC的实例化检查）：

   class AbstractEntity1(BaseEntity, ABC):
       @property
       def f(self) -> List[str]:
           return ["a", "b"]
   
       @property
       def g(self) -> int:
           return 10
   
   
   class AbstractEntity2(BaseEntity, ABC):
       @property
       def f(self) -> List[str]:
           return ["x"]
   
       @property
       def g(self) -> int:
           return 3
   

3. 具体子类复用合并逻辑，支持自定义
   子类只需调用基类的工具方法，即可实现属性值的合并；若需要自定义合并逻辑，直接覆盖注册即可：

   class FinalEntity(AbstractEntity1, AbstractEntity2):
       @property
       def f(self) -> List[str]:
           vals = self._collect_attr_values("f")
           return self._merge_handlers["f"](vals)
   
       @property
       def g(self) -> int:
           vals = self._collect_attr_values("g")
           return self._merge_handlers["g"](vals)
   
       # 子类自定义合并逻辑示例：给f属性添加去重逻辑
       @classmethod
       def __init_subclass__(cls):
           cls.register_merge_handler("f", lambda vals: list({item for sublist in vals for item in sublist}))
   

验证效果 #

fe = FinalEntity()
print(fe.f)  # 若子类未自定义f的合并器，输出["a", "b", "x", "C"]；自定义后输出去重后的列表
print(fe.g)  # 输出23

方案优势 #

• 符合Python风格：利用MRO特性实现父类遍历，用注册器模式实现逻辑解耦，契合Python的鸭子类型与模块化思想；
• 扩展性强：新增属性或合并逻辑时，只需注册新的合并器，无需修改核心遍历逻辑；
• 职责清晰：抽象类专注提供基础属性值，子类专注选择或自定义合并方式，代码维护成本低。

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