如何优化子类默认参数继承逻辑？解决None值冲突与冗余代码问题

需求与现有问题 #

需要实现一个System类，支持创建子类系统，规则为：子类未传入的参数继承父类对应值，传入参数则覆盖父类值。现有代码可实现基础功能，但存在两个核心问题：

• 参数数量较多时，会产生大量重复的if判断冗余代码；
• 业务场景中None具有实际业务含义，无法用它作为「参数未传入」的判断标识，导致逻辑失效。

优化方案 #

方案1：自定义哨兵值区分「未传入」与「传入None」 #

定义一个独一无二的哨兵对象（Python中object()生成的实例具有唯一性），用它作为方法参数的默认值，以此区分用户是未传入参数还是主动传入了None。通过循环处理参数，避免冗余代码。

class System:
    # 定义专属哨兵，标记参数未传入
    _UNSET = object()

    def __init__(self, a=0, b=0, c=0):
        self.a, self.b, self.c = a, b, c
        self.sub_systems = []

    def create_sub_sys(self, a=_UNSET, b=_UNSET, c=_UNSET):
        params = {}
        # 循环处理所有参数，统一判断逻辑
        for attr in ['a', 'b', 'c']:
            param_val = locals()[attr]
            if param_val is not self._UNSET:
                params[attr] = param_val
            else:
                params[attr] = getattr(self, attr)
        
        ss = System(**params)
        self.sub_systems.append(ss)
        return ss

# 测试用例
s = System(a=10, b=100, c=-19)
s1 = s.create_sub_sys()  # 继承父类所有参数：10, 100, -19
s2 = s.create_sub_sys(b=3)  # a继承10，b=3，c继承-19
s21 = s2.create_sub_sys(a=3, c=3)  # a=3，b继承s2的3，c=3
s3 = s.create_sub_sys(c=None)  # 主动传入None作为c的业务值

print(s1.a, s1.b, s1.c)  # 输出：10 100 -19
print(s2.a, s2.b, s2.c)  # 输出：10 3 -19
print(s21.a, s21.b, s21.c)  # 输出：3 3 3
print(s3.a, s3.b, s3.c)  # 输出：10 100 None

方案2：利用inspect模块获取实际传入参数 #

通过inspect模块解析方法签名与实际传入参数，精准识别用户主动传入的参数（排除默认值），再与父类属性合并。无需自定义哨兵，适合参数较多的场景。

import inspect

class System:
    def __init__(self, a=0, b=0, c=0):
        self.a, self.b, self.c = a, b, c
        self.sub_systems = []

    def create_sub_sys(self, a=0, b=0, c=0):
        # 获取方法签名与实际绑定的参数
        sig = inspect.signature(self.create_sub_sys)
        frame = inspect.currentframe()
        args = inspect.getargvalues(frame).args[1:]
        bound_args = sig.bind(*args)
        bound_args.apply_defaults()
        
        # 筛选出用户主动传入的参数（与默认值不同的项）
        passed_params = {}
        param_names = ['a', 'b', 'c']
        for name in param_names:
            if bound_args.arguments[name] != sig.parameters[name].default:
                passed_params[name] = bound_args.arguments[name]
        
        # 合并父类属性与传入参数
        params = {attr: getattr(self, attr) for attr in param_names}
        params.update(passed_params)
        
        ss = System(**params)
        self.sub_systems.append(ss)
        return ss

# 测试效果与方案1完全一致

方案3：使用**kwargs动态接收参数 #

通过**kwargs动态接收所有传入参数，配合预设的支持参数列表，过滤无效参数后与父类属性合并。此方案扩展性最强，新增参数仅需修改支持列表，无需调整方法签名。

class System:
    # 定义支持的参数列表，后续扩展仅需修改此处
    SUPPORTED_PARAMS = ['a', 'b', 'c']

    def __init__(self, a=0, b=0, c=0):
        self.a, self.b, self.c = a, b, c
        self.sub_systems = []

    def create_sub_sys(self, **kwargs):
        # 过滤出合法参数
        valid_params = {k: v for k, v in kwargs.items() if k in self.SUPPORTED_PARAMS}
        # 合并父类属性与传入参数
        params = {attr: getattr(self, attr) for attr in self.SUPPORTED_PARAMS}
        params.update(valid_params)
        
        ss = System(**params)
        self.sub_systems.append(ss)
        return ss

# 测试用例
s = System(a=10, b=100, c=-19)
s1 = s.create_sub_sys()  # 10 100 -19
s2 = s.create_sub_sys(b=3)  #10 3 -19
s21 = s2.create_sub_sys(a=3, c=3) #3 3 3
s3 = s.create_sub_sys(c=None) #10 100 None

print(s1.a, s1.b, s1.c)
print(s2.a, s2.b, s2.c)
print(s21.a, s21.b, s21.c)
print(s3.a, s3.b, s3.c)

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