Python类继承基础：子类定义、父类方法调用与super()用法

一、子类定义与基础属性继承

继承是面向对象三大特性之一。当一个新类需要具备已有类的全部功能，并在此基础上增加特定功能或修改部分逻辑时，便可以通过继承创建“子类”（Derived/Sub Class），被继承的类则称为“父类”或“基类”（Base/Super Class）。

1. 子类声明语法

在 Python 中，声明子类只需在类名后面的圆括号内指明父类名称即可。若未显式指定父类，在 Python 3 中所有类均默认隐式继承自顶层根类 object。

# 父类（基类）定义
class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self):
        return f"{self.name} 正在进食"

# 子类（派生类）定义：在圆括号内填入父类 Animal
class Dog(Animal):
    def bark(self):
        return f"{self.name} 汪汪叫"

2. 属性与方法的继承效果

子类定义完成后，会自动继承父类的所有公开属性与方法。在创建 Dog 实例时，由于 Dog 没有显式定义自己的 __init__ 构造方法，解释器会自动回溯调用父类 Animal 的 __init__ 完成实例化初始化。

# 实例化子类并执行调用
d = Dog("Snoopy")
print(d.eat())   # 调用继承自 Animal 的方法
print(d.bark())  # 调用子类自身的特有方法

如上图所示，当访问 d.eat() 时，Python 解释器的解析顺序是严格且可预测的：首先在实例自身的字典 d.__dict__ 中查找是否存在该名字；若不存在，则进入其类对象 Dog.__dict__；若仍不存在，则沿着继承链向上检索 Animal.__dict__，命中后完成方法绑定并执行；如果一直检索到根类 object 依然找不到，解释器才会抛出 AttributeError。

二、方法重写与父类方法调用

子类继承父类后，并不局限于被动接收父类的既有功能。当父类的默认行为不满足业务需求时，子类可以重新定义同名方法，这种操作称为“方法重写”（Method Overriding）。在方法重写中，主要存在两种开发诉求：完全替换原有逻辑，或在父类逻辑的基础上进行功能扩展。

1. 完全重写（覆盖）

如果子类只需提供一套完全不同的逻辑，直接在子类中编写同名函数即可。此时只要子类实例调用该方法，就会立即在子类命名空间命中并返回，父类的同名方法被彻底屏蔽：

class Cat(Animal):
    # 完全重写 eat 方法，不使用父类逻辑
    def eat(self):
        return f"{self.name} 正在细嚼慢咽地吃猫粮"

c = Cat("Kitty")
print(c.eat())

2. 扩展式重写与直接通过父类名调用

在大多数工业级代码中，我们并不希望丢弃父类既有的逻辑（例如复杂的资源校验、核心状态初始化等），而是希望在父类执行前后增加子类特有的逻辑。在没有引入高级机制前，最直观的写法是通过“父类名.方法名”进行直接调用。

请注意：通过类名直接调用未绑定方法时，必须显式将当前实例 self 作为第一个参数传入，因为此时属于非绑定函数的直接执行：

class ServiceAnimal(Animal):
    def __init__(self, name, job):
        # 方式一：直接显式通过父类名调用构造函数，必须传 self
        Animal.__init__(self, name)
        self.job = job

    def eat(self):
        # 先获取父类基础行为
        parent_action = Animal.eat(self)
        # 附加子类特定状态
        return f"{parent_action}，吃完后准备去执行 [{self.job}] 工作"

sa = ServiceAnimal("Max", "导盲")
print(sa.eat())

三、深入掌握 super() 的工作机制与 MRO

super() 是 Python 提供的用于动态委派方法调用的内置代理对象。初学者常常将 super() 简单理解为“指向父类的指针”，但这种理解是不完整的。准确地说，super() 是沿着该对象所属类的方法解析顺序（Method Resolution Order，简称 MRO）寻找下一个匹配类的代理。

1. super() 的现代推荐用法（Python 3 零参语法）

在 Python 2 中，调用父类需要写成冗长的 super(SubClass, self).method()；而在 Python 3 中，编译器在编译类方法时会自动填充当前类和实例信息，开发者只需书写 super().method() 即可，既简洁又安全。

class PoliceDog(Dog):
    def __init__(self, name, rank):
        # 无参 super()：自动委托给 MRO 链中的下一个类并绑定 self
        super().__init__(name)
        self.rank = rank

    def bark(self):
        # 调用父类 bark() 并在其后扩充警犬专属逻辑
        base_bark = super().bark()
        return f"{base_bark}，正在警戒巡逻（职级：{self.rank}）"

pd = PoliceDog("Rex", "一级警犬")
print(pd.bark())

2. MRO 与 C3 线性化算法

为什么 super() 能够保证多重继承时的安全？关键在于 Python 采用的 C3 线性化算法（C3 Linearization）。该算法确保了任何类层次结构都会被摊分成一条确定、单调且无环的线性列表。

可以通过类的 __mro__ 属性或 mro() 方法查看具体解析顺序：

print(PoliceDog.__mro__)

3. 菱形继承场景下的 super() 协同运作

考虑经典的菱形继承：类 A 为基类，B 与 C 均继承自 A，而 D 同时继承 B 和 C。如果使用显式类名调用，A 的逻辑会被执行两次；而如果统一使用 super()，整条链条将被优雅地协作串联，且 A 仅执行一次。

class BaseA:
    def action(self):
        print("-> 进入 BaseA")
        print("<- 离开 BaseA")

class BranchB(BaseA):
    def action(self):
        print("-> 进入 BranchB")
        super().action()
        print("<- 离开 BranchB")

class BranchC(BaseA):
    def action(self):
        print("-> 进入 BranchC")
        super().action()
        print("<- 离开 BranchC")

class DiamondD(BranchB, BranchC):
    def action(self):
        print("-> 进入 DiamondD")
        super().action()
        print("<- 离开 DiamondD")

obj = DiamondD()
obj.action()

核心洞见：仔细观察上述输出顺序。在 BranchB 的代码中，它的定义语句明明只写了 class BranchB(BaseA):，但在 DiamondD 实例运行期间，BranchB 中的 super().action() 调用的居然是 BranchC.action()！这就是 super() 的威力所在——它不是简单找父类，而是在查找当前上下文对象所对应的 MRO 序列中的后继节点。

四、常见开发陷阱与最佳实践

在实际工程开发中，类的继承和 super() 如果使用不当，往往会导致隐蔽的 Bug。以下梳理了三种最常见的问题及其规避方案。

1. 遗漏调用父类构造函数引发 AttributeError

当子类定义了自己的 __init__ 方法时，父类的 __init__ 就被自动覆盖。如果子类忘记在初始化时调用 super().__init__(...)，父类中本应创建的实例属性将根本不存在，后续调用父类方法时便会抛出 AttributeError。

class BrokenChild(Animal):
    def __init__(self, breed):
        # 错误做法：忘记写 super().__init__(name)
        self.breed = breed

bad = BrokenChild("Golden")
# bad.eat() -> 抛出 AttributeError: 'BrokenChild' object has no attribute 'name'

2. 混用类名调用与 super() 造成连锁崩塌

在同一个继承体系中，所有类必须保持一致的调用风格。如果在部分类中使用 Base.method(self)，另一些类中使用 super().method()，多重继承的 MRO 链就会被硬编码短路，导致某些类被重复执行，或者部分中间类的方法被直接跳过。

3. 多重继承中的参数解构（*args, **kwargs）

在协作式多继承中，由于一个类的 super() 可能会调用到任意同辈类，不同类的初始化参数可能各不相同。为了使参数能够沿 MRO 链顺畅传递，最佳模式是使用通配关键字参数：

class ConfigurableNode:
    def __init__(self, *args, **kwargs):
        # object.__init__ 不接受多余参数，最终由链路末端消费完毕
        super().__init__()

class LoggingMixin:
    def __init__(self, *args, log_level="INFO", **kwargs):
        super().__init__(*args, **kwargs)
        self.log_level = log_level

class Worker(LoggingMixin, ConfigurableNode):
    def __init__(self, worker_id, **kwargs):
        super().__init__(**kwargs)
        self.worker_id = worker_id

4. 常用内置内省函数速查

总结

Python 的类继承模型既灵活又强大。在单继承场景下，通过 class Sub(Base) 定义子类，并在需要增强方法时使用零参数的 super().method()，可以编写出结构清晰、耦合度低的扩展代码；而在多继承场景下，牢记 super() 是基于 MRO 动态线性序列向后查找，并始终保持方法签名兼容与协作，是避免复杂继承体系失控的关键法则。在日常系统设计中，建议优先遵循“组合优于继承”的软件设计原则，仅在存在明确“是一个（is-a）”的层次关系时才构建继承结构。