Python面向对象：深入理解继承中父类属性的初始化与传递

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

Python面向对象：深入理解继承中父类属性的初始化与传递

2025-11-19

浏览次数：次

返回列表

Python面向对象：深入理解继承中父类属性的初始化与传递

本文旨在解析python类继承中，子类如何正确初始化和访问父类属性的常见误区。我们将探讨`super().__init__()`的工作机制，以及在子类实例化时如何有效传递参数以定制继承属性。文章还将对比“继承”与“组合”两种设计模式，指导开发者根据实际需求选择最合适的策略，确保父类属性在子类中得到预期管理和使用。

Python类继承中的属性初始化机制

在Python面向对象编程中，当一个类继承自另一个类时，子类可以访问父类的属性和方法。然而，对于实例属性的初始化，存在一些常见的误解，尤其是在涉及到__init__方法和默认参数时。

考虑以下示例代码，它展示了一个常见的困惑场景：

class A():
    def __init__(self, a=12) -> None:
        self.a = a

class B(A):
    def __init__(self) -> None:
        super().__init__() # 调用父类A的__init__方法

# 实例化A和B
instance_a = A(a=16)
instance_b = B()
print(f"instance_a.a: {instance_a.a}") # 期望输出 16
print(f"instance_b.a: {instance_b.a}") # 实际输出 12，为什么不是 16？

问题分析： 上述代码中，instance_a.a的值为16，而instance_b.a的值却是12。这让许多初学者感到困惑，误以为子类B会“继承”父类A的某个特定实例instance_a的属性值。

实际上，super().__init__()的作用是调用父类A的构造函数__init__。在B的__init__方法中，super().__init__()被调用时，并没有传递任何参数。因此，A.__init__会使用其定义中的默认值a=12来初始化instance_b的self.a属性。

instance_a和instance_b是两个完全独立的实例。instance_a的a属性被显式设置为16，而instance_b的a属性则通过其自身的初始化流程（调用无参数的super().__init__()）被设置为12。它们之间没有直接共享属性值的机制，每个实例都有自己独立的属性状态。

解决方案与设计模式

要解决上述问题，并根据实际需求在子类中正确管理父类属性，我们可以采用以下两种主要方法：

方法一：通过参数传递初始化值 (继承关系适用)

如果子类B确实是父类A的一种特殊类型（即“is-a”关系），并且B的实例需要拥有自己独立的、但可定制的父类属性，那么我们应该在子类的__init__方法中接受相应的参数，并将其传递给父类的__init__方法。

示例代码：

小云雀

剪映出品的AI视频和图片创作助手

1949 查看详情小云雀

class A():
    def __init__(self, a=12) -> None:
        self.a = a
        print(f"A.__init__ called, self.a={self.a}")

class B(A):
    def __init__(self, a_val=None) -> None: # 接受一个参数来定制父类的a
        if a_val is not None:
            super().__init__(a=a_val) # 将参数传递给父类
        else:
            super().__init__() # 如果未提供，则使用父类默认值
        print(f"B.__init__ finished, self.a={self.a}")

# 实例化
instance_a = A(a=16)
instance_b_default = B()          # 使用A的默认值12
instance_b_custom = B(a_val=20)   # 传递20给父类a

print(f"\ninstance_a.a: {instance_a.a}")
print(f"instance_b_default.a: {instance_b_default.a}")
print(f"instance_b_custom.a: {instance_b_custom.a}")

输出：

A.__init__ called, self.a=16
A.__init__ called, self.a=12
B.__init__ finished, self.a=12
A.__init__ called, self.a=20
B.__init__ finished, self.a=20

instance_a.a: 16
instance_b_default.a: 12
instance_b_custom.a: 20

通过这种方式，instance_b_custom的a属性被成功设置为20，因为它在实例化时将a_val=20传递给了B的__init__，进而传递给了A的__init__。

方法二：使用组合（Composition）模式 (“has-a”关系适用)

根据原问题中的“真实场景”描述，class A代表调度系统（具有参数），而class B代表解决调度问题的算法环境。B需要“看到”A的参数。这表明B不是A的一种特殊类型，而是B需要使用或包含一个A的实例。这种“has-a”的关系更适合使用组合（Composition）模式。

设计理念： 在这种模式下，B不继承A，而是在其内部持有一个A的实例作为自己的属性。这样，B就可以通过这个内部实例来访问A的所有参数。

示例代码：

class SchedulingSystem(): # 对应原问题中的Class A
    def __init__(self, machines: list, jobs: list, capacities: dict) -> None:
        self.machines = machines
        self.jobs = jobs
        self.capacities = capacities
        print(f"SchedulingSystem initialized with machines: {self.machines}")

class AlgorithmEnvironment(): # 对应原问题中的Class B
    def __init__(self, scheduling_system_instance: SchedulingSystem) -> None:
        # AlgorithmEnvironment不再继承SchedulingSystem，而是持有它的一个实例
        self.scheduling_system = scheduling_system_instance
        print("AlgorithmEnvironment initialized.")

    def solve_problem(self):
        # AlgorithmEnvironment可以通过其持有的scheduling_system实例访问所有参数
        print(f"Algorithm is solving problem using machines: {self.scheduling_system.machines}")
        print(f"And jobs: {self.scheduling_system.jobs}")
        # ... 其他算法逻辑 ...

# 实例化调度系统
my_scheduling_system = SchedulingSystem(
    machines=['M1', 'M2'],
    jobs=['J1', 'J2', 'J3'],
    capacities={'M1': 10, 'M2': 15}
)

# 实例化算法环境，并将调度系统实例传入
my_algorithm_env = AlgorithmEnvironment(scheduling_system_instance=my_scheduling_system)

# 算法环境现在可以访问调度系统的参数
print(f"\nAlgorithm environment sees machines: {my_algorithm_env.scheduling_system.machines}")
my_algorithm_env.solve_problem()

输出：

SchedulingSystem initialized with machines: ['M1', 'M2']
AlgorithmEnvironment initialized.

Algorithm environment sees machines: ['M1', 'M2']
Algorithm is solving problem using machines: ['M1', 'M2']
And jobs: ['J1', 'J2', 'J3']

这种组合模式清晰地表达了AlgorithmEnvironment“拥有”一个SchedulingSystem，并能够通过它来访问所需的参数。这比继承更符合实际的业务逻辑，也使得代码结构更加灵活和解耦。