python

关注公众号 jb51net

关闭
首页 > 脚本专栏 > python > Python继承__init__覆盖super()

理解Python继承之从__init__覆盖到super()的妙用方法

作者：雨夜的星光

这篇文章主要介绍了理解Python继承之从__init__覆盖到super()的相关资料,解决了初学者对为何子类的__init__必须手动调用父类__init__的困惑,需要的朋友可以参考下

Python的面向对象编程（OOP）中，继承是一个强大的工具，但它也常常是初学者（甚至有经验的开发者）的困惑之源。核心的困惑点通常围绕：

  1. 为什么子类的 __init__ 必须手动调用父类的 __init__？

  2. super() 到底是什么，它和直接用父类名调用有何区别？

本文将通过“造房子”的类比和“钻石问题”的深度解析，彻底澄清这些概念。

第1部分：核心问题——__init__的“覆盖”机制

要理解为何需要 super()，首先必须理解Python的方法搜索规则。

当在子类实例上调用一个方法时（如 __init__），Python的搜索顺序是：

  1. 先在子类中寻找该方法。

  2. 如果找到了，立即停止搜索并执行。

  3. 如果没找到，才去父类中寻找。

这个规则会导致一个常见问题：子类 __init__ 会覆盖父类 __init__。

类比：造房子（StandardHousevsDeluxeHouse）

假设我们有一个“标准房子”的设计图（父类）：

class StandardHouse:
    def __init__(self, foundation_type):
        # 建造房子的第一步：打地基
        self.foundation = foundation_type
        print(f"地基已打好，类型是: {self.foundation}")

    def get_info(self):
        print(f"这是一座标准房子，地基是 {self.foundation}")

现在，我们想设计一个“豪华房子”（子类），它在“标准房子”的基础上，还想额外添加一个“游泳池”。为此，我们必须定义它自己的 __init__：

错误的继承（“覆盖”导致的问题）

class DeluxeHouse(StandardHouse):
    # 子类定义了自己的 __init__
    def __init__(self, pool_size):
        # 建造房子的第一步：建游泳池
        self.pool = pool_size
        print(f"游泳池已建好，大小是: {self.pool} 平米")

# --- 尝试建造 ---
print("--- 准备建造豪华房子 ---")
my_deluxe_house = DeluxeHouse(50)

# --- 尝试获取信息 ---
try:
    my_deluxe_house.get_info()  # 调用继承来的方法
except AttributeError as e:
    print(f"\n!!! 出错了: {e}")

执行结果：

--- 准备建造豪华房子 ---
游泳池已建好，大小是: 50 平米

!!! 出错了: 'DeluxeHouse' object has no attribute 'foundation'

错误分析：

  1. 创建 DeluxeHouse(50) 时，Python 在 DeluxeHouse 中找到了 __init__。

  2. 它立刻停止搜索，并执行了子类的 __init__。

  3. 父类 StandardHouse 的 __init__ 从未被调用。

  4. 因此，self.foundation（地基）这个属性根本没有被创建。

  5. 当 get_info() 试图访问 self.foundation 时，程序崩溃。

第2部分：解决方案——super()与self的真相

DeluxeHouse 的建造者在建游泳池之前，必须显式地（手动地）先去执行“标准房子”的建造流程（打地基）。super() 就是这个“手动调用父类”的命令。

1.super()的含义

2.self的真相

从始至终，只有一个 self 对象。self 就是那个“正在被建造的实例”。

正确的代码：

class DeluxeHouse(StandardHouse):
    # 子类 __init__ 必须接收 *所有* 参数（父类的 + 自己的）
    def __init__(self, foundation_type, pool_size):
        print("--- [子类] DeluxeHouse.__init__ 开始 ---")
        
        # 关键步骤：呼叫父类团队，先把地基打好
        # 把属于父类的参数 (foundation_type) 传递过去
        super().__init__(foundation_type)
        
        print("--- [子类] 父类工作已完成，现在我来添加新功能 ---")
        # 2. 子类现在可以安全地设置自己的属性
        self.pool = pool_size
        print(f"    [子类] 游泳池已建好: {self.pool}")
        print("--- [子类] DeluxeHouse.__init__ 结束 ---")

# --- 尝试建造 ---
my_deluxe_house = DeluxeHouse("钢筋混凝土", 50)
my_deluxe_house.get_info()

执行流程分析：

  1. 调用 DeluxeHouse(...)，进入 DeluxeHouse.__init__。

  2. 执行 super().__init__(...)，暂停子类 __init__，跳转到父类 StandardHouse.__init__。

  3. 父类 __init__ 在同一个 self 上设置了 self.foundation。

  4. 父类 __init__ 结束，返回到子类 __init__。

  5. 子类 __init__ 继续执行，在同一个 self 上设置 self.pool。

  6. self 对象现在同时拥有了 .foundation 和 .pool。

第3部分：super()vsParentClass.__init__(新旧对比)

既然必须手动调用父类，有两种方法可以做到：

  1. 现代方式 (推荐): super().__init__(...)

  2. 老式方式 (不推荐): ParentClass.__init__(self, ...)

在简单的“单继承”场景下，两者似乎都能工作：

class Vehicle:
    def __init__(self, brand):
        print(f"[Vehicle] 设置品牌为: {brand}")
        self.brand = brand

# 1. 现代方式 (super)
class Car_Modern(Vehicle):
    def __init__(self, brand, model):
        # 语法：
        # 1. 不需要写父类名
        # 2. 不需要传递 self
        super().__init__(brand)
        self.model = model

# 2. 老式方式 (父类名)
class Car_Old(Vehicle):
    def __init__(self, brand, model):
        # 语法：
        # 1. 必须 明确写出父类名 (Vehicle)
        # 2. 必须 手动传递 self
        Vehicle.__init__(self, brand)
        self.model = model

为什么 super() 完胜？

特性super().__init__(...) (现代)ParentClass.__init__(self, ...) (老式)
self 参数隐式传递。Python自动处理，代码更简洁。必须手动传递。容易忘记，导致错误。
可维护性高 (灵活)低 (死板 / 易碎)
原因如果父类改名 (如 Vehicle -> BaseVehicle)，子类代码无需任何改动。如果父类改名，你必须在所有子类中搜索并替换 Vehicle.__init__。
多重继承唯一正确的方案。完全失效或导致灾难性bug。

第4部分：决定性因素——多重继承与“钻石问题”

super() 存在的真正理由是：它能智能地处理复杂的多重继承，而“父类名”调用则会彻底失败。

经典的“钻石问题”：D 继承自 B 和 C，而 B 和 C 都继承自 A。

     A
   /   \
  B     C
   \   /
     D

1.super()的正确演示

super() 会智能地遵循“方法解析顺序”（MRO），确保继承链中的每个 __init__ 都被调用一次，且仅被调用一次。

class A:
    def __init__(self):
        print("A 初始化 (只应被调用一次)")

class B(A):
    def __init__(self):
        print("B 初始化开始...")
        super().__init__()
        print("B 初始化结束。")

class C(A):
    def __init__(self):
        print("C 初始化开始...")
        super().__init__()
        print("C 初始化结束。")

class D_Super(B, C): # 孙子 (使用 super)
    def __init__(self):
        print("D_Super 初始化开始...")
        super().__init__()
        print("D_Super 初始化结束。")

print("--- 测试 super() 的多重继承 ---")
d1 = D_Super()

super() 的正确执行结果 (A只调用一次)：

--- 测试 super() 的多重继承 ---
D_Super 初始化开始...
B 初始化开始...
C 初始化开始...
A 初始化 (只应被调用一次)
C 初始化结束。
B 初始化结束。
D_Super 初始化结束。

2. “老式”方法的错误演示

如果 B 和 C 使用“父类名”的方式调用 A：

class B_Old(A):
    def __init__(self):
        print("B_Old 初始化开始...")
        A.__init__(self) # 明确调用 A
        print("B_Old 初始化结束。")

class C_Old(A):
    def __init__(self):
        print("C_Old 初始化开始...")
        A.__init__(self) # 明确调用 A
        print("C_Old 初始化结束。")

class D_Old(B_Old, C_Old):
    def __init__(self):
        print("D_Old 初始化开始...")
        B_Old.__init__(self) # 明确调用 B
        C_Old.__init__(self) # 明确调用 C
        print("D_Old 初始化结束。")

print("\n--- 测试 '父类名' 的多重继承 (错误演示) ---")
d2 = D_Old()

“老式”方法的错误执行结果 (A被调用两次！)：

--- 测试 '父类名' 的多重继承 (错误演示) ---
D_Old 初始化开始...
B_Old 初始化开始...
A 初始化 (只应被调用一次)  <-- A 被调用了第1次
B_Old 初始化结束。
C_Old 初始化开始...
A 初始化 (只应被调用一次)  <-- A 被调用了第2次 (!! BUG !!)
C_Old 初始化结束。
D_Old 初始化结束。

分析：A (顶层父类) 的 __init__ 被调用了两次！如果 A 的 __init__ 是在打开一个文件或建立一个数据库连接，这种重复调用很可能会导致资源冲突或数据损坏。

结论与建议

对比项super() (推荐)ParentClass.__init__(self, ...) (不推荐)
简单继承可用可用（但不推荐）
多重继承完美工作导致Bug（如重复调用）
可维护性高 (父类改名不影响子类)低 (父类改名必须重构所有子类)
语法简洁 (自动处理self)繁琐 (必须手动传递self)
适用范围现代Python (3.x) 的标准历史遗留 (Python 2 旧代码)

最终建议：

始终使用 super()。 它更简洁、更灵活，是唯一能正确处理复杂继承（多重继承）的工具。ParentClass.__init__ 是一种需要被理解（以便能看懂旧代码）但不再需要被使用的历史写法。

到此这篇关于理解Python继承之从__init__覆盖到super()的妙用方法的文章就介绍到这了,更多相关Python继承__init__覆盖super()内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文