<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="description" content="深入讲解三大特性封装继承多态的核心内容与关键技术，属于Python编程基础的面向对象编程（OOP）方向">
<title>三大特性：封装、继承、多态 面向对象编程（OOP） Python编程基础-AI全栈-AIQZ.CC</title>
<link rel="icon" type="image/svg+xml" href="/favicon.svg">
<link rel="stylesheet" href="/css/chapter.css?v=20260612e">
<link rel="stylesheet" href="/vendor/katex/katex.min.css">
<script src="/vendor/katex/katex.min.js"></script>
<script src="/vendor/katex/auto-render.min.js"></script>
</head>
<body>
<div class="app-container">
  <aside class="left-sidebar" id="leftSidebar">
    <div class="sidebar-content">
      <nav class="nav-section">
        <div class="nav-header">课程目录</div>
        <!--#include virtual="/ssi/nav/course-nav.html" -->
      </nav>
    </div>
  </aside>
  <main class="main-content">
    <article class="content-area">
      <h1>三大特性：封装、继承、多态</h1><div class="divider"></div>

<h2>一句话概述</h2>
<p>面向对象编程有三大基石——<strong>封装</strong>隐藏内部细节、提供安全接口；<strong>继承</strong>让子类复用父类的代码、实现&quot;是一种&quot;的关系；<strong>多态</strong>让不同类的对象用相同的接口表现出各自的行为。这三个特性合在一起，让你能写出灵活、可扩展、易维护的代码。在 AI 开发中，继承 <code>nn.Module</code> 创建自定义模型、多态统一调用 <code>model.forward()</code>、封装保护内部参数——三大特性贯穿始终。</p>
<blockquote class="highlight-box"><strong>💡 核心要点：</strong>①封装通过私有属性（<code>_</code> 和 <code>__</code> 前缀）和公开方法控制对数据的访问，保护对象状态不被随意篡改 ②继承用 <code>class 子类(父类):</code> 语法实现，子类自动获得父类的所有属性和方法，并能重写（override）它们 ③多态指同一个方法名在不同类中表现出不同行为，Python 的&quot;鸭子类型&quot;天然支持多态 ④<code>super().__init__()</code> 是子类调用父类 <code>__init__</code> 的标准方式，确保父类属性被正确初始化</blockquote>


<h2>教学与演示</h2>
<h3>一、封装——隐藏细节，暴露接口</h3>
<p><strong>是什么</strong>：封装（Encapsulation）是把数据（属性）和操作数据的方法捆绑在一个类中，并控制外部对这些数据的访问权限。在 Python 中，通过命名约定实现封装：<code>self.name</code> 是公开的，<code>self._name</code>（单下划线）表示&quot;受保护的——请别碰&quot;，<code>self.__name</code>（双下划线）触发名称改编（name mangling），让外部更难直接访问。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 封装就像一个黑盒子。比如你的手机——你只知道按开机键能开机、按音量键能调音量，至于主板上的电路怎么工作的，你不需要知道，厂家也不让你乱碰（碰坏了还不保修）。类也一样——把复杂的内部逻辑藏起来，只暴露几个简单的方法给外部用，这就是封装。</blockquote>


<p><strong>为什么</strong>：封装最大的价值是<strong>解耦</strong>——让使用代码的人不需要了解实现细节。你可以随时修改类的内部实现（比如把列表改成字典存储数据），只要对外的方法签名不变，所有使用这个类的代码都不用改。封装还能防止数据被意外篡改——如果没有封装，任何人都能 <code>obj.balance = -1000</code> 把余额改成负数，这显然不合理。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 银行的 ATM 机就是封装的绝佳例子。你能做的操作只有：插卡、输入密码、查询余额、取钱、存钱。你不能直接伸手进去拿钞票，也不能手动修改数据库把余额改成 100 万。银行把危险操作封起来了，只给你安全的按钮。写类的封装就是自己做一台&quot;代码 ATM 机&quot;。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-1"><code class="language-python">import numpy as np

# ====== 1. 没有封装的类——数据裸奔，谁都能改 ======

class BadBankAccount:
    &quot;&quot;&quot;糟糕的设计：属性公开，毫无保护&quot;&quot;&quot;
    def __init__(self, owner, balance):
        self.owner = owner                      # 谁都能看，谁都能改
        self.balance = balance
    
    def deposit(self, amount):
        self.balance += amount

# 数据裸奔的后果
bad = BadBankAccount(&quot;张三&quot;, 1000)
bad.balance = -5000                             # 直接改成负数！不合理！
bad.balance = &quot;一百万&quot;                          # 改成字符串！类型都乱了！
print(f&quot;裸奔账户: {bad.owner}, 余额: {bad.balance}&quot;)  # 余额居然是一百万？！

# ====== 2. 封装后的类——用方法控制访问 ======

class SafeBankAccount:
    &quot;&quot;&quot;好的设计：封装数据，通过方法操作&quot;&quot;&quot;
    
    def __init__(self, owner, initial_balance=0):
        self.owner = owner                      # 公开属性（所有者的名字可以随意看）
        self._balance = None                    # 受保护属性（约定：不要直接访问）
        self._set_balance(initial_balance)      # 通过内部方法设置，有验证逻辑
    
    def _set_balance(self, amount):
        &quot;&quot;&quot;内部方法（单下划线前缀）——验证并设置余额&quot;&quot;&quot;
        if not isinstance(amount, (int, float)):
            raise TypeError(f&quot;余额必须是数字，而你传了 {type(amount)}&quot;)
        if amount &lt; 0:
            raise ValueError(&quot;余额不能为负数！&quot;)
        self._balance = amount
    
    def get_balance(self):
        &quot;&quot;&quot;获取余额——唯一的读取途径&quot;&quot;&quot;
        return self._balance
    
    def deposit(self, amount):
        &quot;&quot;&quot;存款——唯一的修改途径&quot;&quot;&quot;
        if amount &lt;= 0:
            print(f&quot;错误：存款金额必须大于 0&quot;)
            return False
        self._balance += amount
        print(f&quot;{self.owner} 存入 {amount} 元，余额 {self._balance} 元&quot;)
        return True
    
    def withdraw(self, amount):
        &quot;&quot;&quot;取款——带余额验证&quot;&quot;&quot;
        if amount &lt;= 0:
            print(f&quot;错误：取款金额必须大于 0&quot;)
            return False
        if amount &gt; self._balance:
            print(f&quot;错误：余额不足！（余额 {self._balance}，想要取 {amount}）&quot;)
            return False
        self._balance -= amount
        print(f&quot;{self.owner} 取出 {amount} 元，余额 {self._balance} 元&quot;)
        return True

# 安全的账户
safe = SafeBankAccount(&quot;李四&quot;, 2000)
print(f&quot;\n安全账户: {safe.owner}, 余额: {safe.get_balance()}&quot;)

safe.deposit(500)                                # 李四 存入 500 元，余额 2500 元
safe.withdraw(300)                               # 李四 取出 300 元，余额 2200 元
safe.withdraw(10000)                             # 错误：余额不足！（余额 2200，想要取 10000）
# safe._balance = -5000                          # 虽然技术上还能改，但 IDE 会警告你

# ====== 3. 双下划线——名称改编（Name Mangling） ======

class Secret:
    &quot;&quot;&quot;演示名称改编机制&quot;&quot;&quot;
    def __init__(self):
        self.public = &quot;公开的——随便看&quot;          # 公开属性
        self._internal = &quot;受保护的——请尊重约定&quot;  # 单下划线：约定
        self.__private = &quot;私密的——改编了名字&quot;    # 双下划线：名称改编
    
    def reveal(self):
        &quot;&quot;&quot;类内部可以正常访问&quot;&quot;&quot;
        print(f&quot;内部访问: {self.__private}&quot;)

s = Secret()
print(f&quot;\n公开: {s.public}&quot;)
print(f&quot;受保护: {s._internal}&quot;)
# print(s.__private)                             # 报 AttributeError！找不到 __private

# 但是！Python 的私有不是真正的私有——它只是改了个名字而已
# __private 被改编成了 _Secret__private
print(f&quot;名称改编后: {s._Secret__private}&quot;)      # 私密的——改编了名字
s.reveal()                                       # 内部访问: 私密的——改编了名字

# ⚠️ Python 哲学：我们都是成年人——封装靠约定和信任，而不是强制

# ====== 4. AI 场景：封装模型配置 ======

class ModelConfig:
    &quot;&quot;&quot;封装 AI 模型的配置参数&quot;&quot;&quot;
    
    def __init__(self, input_dim, hidden_dim, output_dim):
        self._input_dim = None
        self._hidden_dim = None
        self._output_dim = None
        # 通过 setter 方法验证参数
        self.set_dims(input_dim, hidden_dim, output_dim)
    
    def set_dims(self, input_dim, hidden_dim, output_dim):
        &quot;&quot;&quot;设置维度参数——必须都是正整数&quot;&quot;&quot;
        for name, val in [(&quot;输入维度&quot;, input_dim), (&quot;隐藏维度&quot;, hidden_dim),
                          (&quot;输出维度&quot;, output_dim)]:
            if not isinstance(val, int) or val &lt;= 0:
                raise ValueError(f&quot;{name} 必须为正整数，得到 {val}&quot;)
        self._input_dim = input_dim
        self._hidden_dim = hidden_dim
        self._output_dim = output_dim
    
    def get_total_params(self):
        &quot;&quot;&quot;计算模型总参数量&quot;&quot;&quot;
        # 输入层 → 隐藏层 + 隐藏层偏置 + 隐藏层 → 输出层 + 输出层偏置
        w1 = self._input_dim * self._hidden_dim
        b1 = self._hidden_dim
        w2 = self._hidden_dim * self._output_dim
        b2 = self._output_dim
        return w1 + b1 + w2 + b2

# 使用封装好的配置类
config = ModelConfig(784, 128, 10)               # 类似 MNIST 分类模型
print(f&quot;\n模型总参数量: {config.get_total_params():,}&quot;)  # 101,770</code></pre><p><strong>什么用</strong>：在 AI 框架中，封装无处不在。PyTorch 的 <code>nn.Linear(10, 5)</code> 内部封装了权重矩阵和偏置向量，你不需要（也不应该）手动修改 <code>layer.weight</code> 中的某个值——应该通过优化器来更新。scikit-learn 的模型有 <code>fit()</code> 和 <code>predict()</code> 两个公开方法，内部复杂的矩阵运算全部封装，用户只需要调这两个方法。封装让复杂的 AI 算法变得像黑盒一样易用。</p>
<h3>二、继承——站在巨人的肩膀上</h3>
<p><strong>是什么</strong>：继承（Inheritance）是子类获得父类所有属性和方法的机制。语法是 <code>class 子类名(父类名):</code>。子类可以：①直接用父类的属性和方法（继承）；②定义自己独有的属性和方法（扩展）；③重写父类的方法（覆盖/override）。继承体现了&quot;is-a&quot;（是一种）关系——&quot;猫是一种动物&quot;，所以 <code>Cat</code> 继承自 <code>Animal</code>。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 继承就像家族基因遗传。你从父母那里继承了很多特征——眼睛颜色、身高、血型（父类的属性），还有一些行为习惯——怎么握筷子、说话口音（父类的方法）。但你不是父母的复制品——你有自己的名字、自己的爱好（子类扩展），你可能比爸爸更会打篮球（重写行为）。继承让你&quot;免费&quot;获得了一大堆能力，然后在此基础上发展自己的特色。</blockquote>


<p><strong>为什么</strong>：继承是代码复用的终极武器。假设你需要写 <code>Dog</code>、<code>Cat</code>、<code>Bird</code> 三个类——它们都有 <code>name</code>、<code>age</code> 属性和 <code>eat()</code>、<code>sleep()</code> 方法。如果不继承，每个类都要重复写这些代码。有了继承，你定义一个 <code>Animal</code> 父类放共性，然后 <code>Dog</code>、<code>Cat</code>、<code>Bird</code> 继承它——只需写各自差异的部分。在 AI 中，继承 <code>nn.Module</code> 让你免费获得 <code>parameters()</code>、<code>to()</code>、<code>train()</code>、<code>eval()</code> 等所有方法。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 就像你写论文——导师给了你一个论文模板（父类），里面标题格式、目录结构、参考文献规范都弄好了。你只需要填充你研究的具体内容（重写核心方法），不用从空白页开始。这就是 PyTorch 的哲学——继承 <code>nn.Module</code>，你只需要写 <code>__init__</code> 和 <code>forward</code>，剩下的反向传播、参数管理、GPU 迁移全交给父类。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-2"><code class="language-python">import numpy as np

# ====== 1. 基本继承——父类定义共性，子类定义个性 ======

class Animal:
    &quot;&quot;&quot;动物父类——定义所有动物共有的东西&quot;&quot;&quot;
    
    kingdom = &quot;动物界&quot;                          # 类属性——所有动物共有的
    
    def __init__(self, name, age):
        &quot;&quot;&quot;所有动物都有名字和年龄&quot;&quot;&quot;
        self.name = name
        self.age = age
        print(f&quot;[Animal] 一只动物诞生了：{name}，{age} 岁&quot;)
    
    def eat(self):
        &quot;&quot;&quot;所有动物都要吃东西&quot;&quot;&quot;
        print(f&quot;{self.name} 正在吃东西～&quot;)
    
    def sleep(self):
        &quot;&quot;&quot;所有动物都要睡觉&quot;&quot;&quot;
        print(f&quot;{self.name} 在睡觉……zzZ&quot;)
    
    def introduce(self):
        &quot;&quot;&quot;自我介绍——子类可以重写&quot;&quot;&quot;
        return f&quot;我是 {self.name}，{self.age} 岁&quot;

class Dog(Animal):                              # Dog 继承 Animal
    &quot;&quot;&quot;狗类——继承动物，并添加自己的特色&quot;&quot;&quot;
    
    def __init__(self, name, age, breed):
        &quot;&quot;&quot;子类的 __init__&quot;&quot;&quot;
        super().__init__(name, age)             # 必须调用父类的 __init__！
        self.breed = breed                      # 子类独有的属性：品种
        print(f&quot;[Dog] 具体品种：{breed}&quot;)
    
    def bark(self):
        &quot;&quot;&quot;子类独有的方法——狗叫&quot;&quot;&quot;
        print(f&quot;{self.name}：汪汪汪！🐶&quot;)
    
    def introduce(self):
        &quot;&quot;&quot;重写父类方法——多态的基础&quot;&quot;&quot;
        base = super().introduce()              # 可以先调用父类的方法
        return f&quot;{base}，品种是 {self.breed}&quot;

class Cat(Animal):                              # Cat 也继承 Animal
    &quot;&quot;&quot;猫类——和 Dog 共享 Animal 的代码&quot;&quot;&quot;
    
    def __init__(self, name, age, color):
        super().__init__(name, age)
        self.color = color
        print(f&quot;[Cat] 毛色：{color}&quot;)
    
    def meow(self):
        &quot;&quot;&quot;猫独有的方法&quot;&quot;&quot;
        print(f&quot;{self.name}：喵喵喵～🐱&quot;)

# 创建子类实例
dog = Dog(&quot;旺财&quot;, 3, &quot;金毛&quot;)
cat = Cat(&quot;咪咪&quot;, 2, &quot;白色&quot;)

print(f&quot;\n{dog.introduce()}&quot;)                   # 我是 旺财，3 岁，品种是 金毛
print(f&quot;{cat.introduce()}&quot;)                     # 我是 咪咪，2 岁（没有额外信息）

# 继承的方法可以自由使用
dog.eat()                                       # 旺财 正在吃东西～
cat.sleep()                                     # 咪咪 在睡觉……zzZ

# 各自独有的方法
dog.bark()                                      # 旺财：汪汪汪！🐶
cat.meow()                                      # 咪咪：喵喵喵～🐱

# 类属性也被继承了
print(f&quot;\n{cat.name} 属于 {cat.kingdom}&quot;)       # 咪咪 属于 动物界

# ====== 2. super()——调用父类方法的桥梁 ======

class A:
    def __init__(self):
        self.value_a = &quot;来自 A&quot;
        print(&quot;A.__init__ 被调用&quot;)

class B(A):
    def __init__(self):
        super().__init__()                      # 调用 A 的 __init__
        self.value_b = &quot;来自 B&quot;
        print(&quot;B.__init__ 被调用&quot;)

class C(B):
    def __init__(self):
        super().__init__()                      # 调用 B 的 __init__（链式向上）
        self.value_c = &quot;来自 C&quot;
        print(&quot;C.__init__ 被调用&quot;)

print(f&quot;\n=== super() 链式调用演示 ===&quot;)
c = C()
print(f&quot;属性: {c.value_a}, {c.value_b}, {c.value_c}&quot;)
# print(C.__mro__)                              # 查看方法解析顺序: C -&gt; B -&gt; A -&gt; object

# ====== 3. 多重继承——Python 支持但需谨慎 ======

class Flyer:
    &quot;&quot;&quot;会飞的生物&quot;&quot;&quot;
    def fly(self):
        print(f&quot;{getattr(self, 'name', '未知')} 在飞翔！&quot;)

class Swimmer:
    &quot;&quot;&quot;会游泳的生物&quot;&quot;&quot;
    def swim(self):
        print(f&quot;{getattr(self, 'name', '未知')} 在游泳！&quot;)

class Duck(Animal, Flyer, Swimmer):
    &quot;&quot;&quot;鸭子——继承 Animal + 飞翔能力 + 游泳能力&quot;&quot;&quot;
    def __init__(self, name, age):
        super().__init__(name, age)             # 只会调用 Animal.__init__
    
    def quack(self):
        print(f&quot;{self.name}：嘎嘎嘎！🦆&quot;)

print(f&quot;\n=== 多重继承演示 ===&quot;)
duck = Duck(&quot;唐老鸭&quot;, 5)
duck.eat()                                      # 继承自 Animal
duck.fly()                                      # 继承自 Flyer
duck.swim()                                     # 继承自 Swimmer
duck.quack()                                    # Duck 自己的方法

# ====== 4. AI 场景：继承 nn.Module 创建自定义模型 ======

class BaseModel:
    &quot;&quot;&quot;模拟 PyTorch nn.Module 的简化版本&quot;&quot;&quot;
    
    def __init__(self):
        self._parameters = {}                   # 存储模型参数
        self._training = True                   # 训练模式
    
    def register_parameter(self, name, value):
        &quot;&quot;&quot;注册一个可训练的参数&quot;&quot;&quot;
        self._parameters[name] = value
    
    def parameters(self):
        &quot;&quot;&quot;返回所有可训练参数&quot;&quot;&quot;
        return self._parameters
    
    def train(self):
        &quot;&quot;&quot;切换为训练模式&quot;&quot;&quot;
        self._training = True
        print(&quot;&gt;&gt;&gt; 模型切换到训练模式&quot;)
    
    def eval(self):
        &quot;&quot;&quot;切换为评估模式&quot;&quot;&quot;
        self._training = False
        print(&quot;&gt;&gt;&gt; 模型切换到评估模式&quot;)
    
    def compute_loss(self, pred, target):
        &quot;&quot;&quot;计算损失——子类会重写&quot;&quot;&quot;
        raise NotImplementedError(&quot;子类必须实现 compute_loss 方法&quot;)

class MyClassifier(BaseModel):
    &quot;&quot;&quot;自定义分类器——继承 BaseModel&quot;&quot;&quot;
    
    def __init__(self, input_dim, num_classes):
        super().__init__()                      # 必须调用父类 __init__
        # 注册模型参数（模拟 nn.Linear）
        self.register_parameter(
            &quot;weight&quot;,
            np.random.randn(num_classes, input_dim) * 0.01
        )
        self.register_parameter(&quot;bias&quot;, np.zeros(num_classes))
        self.num_classes = num_classes
    
    def forward(self, x):
        &quot;&quot;&quot;前向传播&quot;&quot;&quot;
        W = self._parameters[&quot;weight&quot;]
        b = self._parameters[&quot;bias&quot;]
        return np.dot(x, W.T) + b               # 线性变换
    
    def compute_loss(self, pred, target):
        &quot;&quot;&quot;重写父类方法——交叉熵损失的简化版&quot;&quot;&quot;
        # Softmax + 交叉熵的简化实现
        exp_pred = np.exp(pred - pred.max())    # 减去最大值防溢出
        softmax = exp_pred / exp_pred.sum()
        loss = -np.log(softmax[target] + 1e-8)  # 负对数似然
        return loss

model = MyClassifier(4, 3)                       # 4 维输入 → 3 分类
model.train()
x = np.array([0.5, -0.3, 0.8, 1.2])
pred = model.forward(x)
loss = model.compute_loss(pred, target=1)
print(f&quot;预测 logits: {pred.round(3)}&quot;)
print(f&quot;损失: {loss:.4f}&quot;)</code></pre><p><strong>什么用</strong>：继承在 AI 开发中是刚需。PyTorch 中的所有模型都继承自 <code>nn.Module</code>——你写 <code>class MyNet(nn.Module):</code> 时，自动获得了 <code>parameters()</code>、<code>to(device)</code>、<code>train()</code>、<code>eval()</code>、<code>state_dict()</code>、<code>load_state_dict()</code> 等十几个方法。scikit-learn 中所有模型继承自 <code>BaseEstimator</code>，自动获得 <code>get_params()</code> 和 <code>set_params()</code> 用于超参数网格搜索。继承让你专注于模型架构本身，而不是基础设施。</p>
<h3>三、多态——同一个接口，不同的行为</h3>
<p><strong>是什么</strong>：多态（Polymorphism）的字面意思是&quot;多种形态&quot;。在编程中，多态指不同的类可以定义同名方法，调用方不需要知道对象具体是哪个类，只需要知道&quot;它有这个方法&quot;。Python 的&quot;鸭子类型&quot;（Duck Typing）是多态的极致体现——如果它走路像鸭子、叫起来像鸭子，那它就是鸭子（管它实际是什么类型）。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 多态就像遥控器上的&quot;播放&quot;按钮。不管你是 DVD 播放器、CD 播放器还是手机音乐 App，按下&quot;播放&quot;按钮，它们都会开始播放——但各自播放的方式完全不同：DVD 读光盘、CD 转碟片、手机解码 MP3。你作为用户不在乎设备内部怎么工作，你只需要知道&quot;按播放就能听歌&quot;。多态就是这个道理——不同类有同名的 <code>play()</code> 方法，调用方只需写 <code>device.play()</code>，具体的执行逻辑由每个类自己决定。</blockquote>


<p><strong>为什么</strong>：多态是面向对象设计的灵魂——它让你能写出&quot;开闭原则&quot;的代码：对扩展开放（加新子类很容易），对修改关闭（现有代码不用改）。假设你写了一个 <code>train_all(models)</code> 函数，遍历所有模型调用 <code>model.forward(x)</code>。有了多态，你不需要关心 models 列表里是 ResNet、Transformer 还是你自定义的模型——只要它们都有 <code>forward()</code> 方法就行。加新模型也不需要修改 <code>train_all</code>。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 动物园的饲养员喂食——她有 100 种动物：狮子、熊猫、企鹅、蛇……每种动物吃的东西不同：狮子吃肉、熊猫吃竹子、企鹅吃鱼。如果饲养员要根据动物种类写 100 个 if-else 判断，那她要疯了。多态的解法：所有动物都有 <code>eat()</code> 方法，饲养员只需要循环 <code>for animal in animals: animal.eat()</code>——具体吃什么，由每个动物的 <code>eat()</code> 方法自己决定。饲养员完全不用关心&quot;这只动物到底什么品种&quot;。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-3"><code class="language-python">import numpy as np

# ====== 1. 多态的基本演示——统一接口，各自实现 ======

class Rectangle:
    &quot;&quot;&quot;矩形&quot;&quot;&quot;
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        &quot;&quot;&quot;计算面积——矩形的面积公式&quot;&quot;&quot;
        return self.width * self.height
    
    def describe(self):
        return f&quot;矩形(宽={self.width}, 高={self.height})&quot;

class Circle:
    &quot;&quot;&quot;圆形&quot;&quot;&quot;
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        &quot;&quot;&quot;计算面积——圆形的面积公式&quot;&quot;&quot;
        return np.pi * self.radius ** 2
    
    def describe(self):
        return f&quot;圆形(半径={self.radius})&quot;

class Triangle:
    &quot;&quot;&quot;三角形&quot;&quot;&quot;
    def __init__(self, base, height):
        self.base = base
        self.height = height
    
    def area(self):
        &quot;&quot;&quot;计算面积——三角形的面积公式&quot;&quot;&quot;
        return 0.5 * self.base * self.height
    
    def describe(self):
        return f&quot;三角形(底={self.base}, 高={self.height})&quot;

# 多态的核心：统一处理不同类型的对象
def print_all_areas(shapes):
    &quot;&quot;&quot;这个函数不关心 shapes 里是什么类型——只要它们都有 area() 方法就行&quot;&quot;&quot;
    total = 0.0
    for shape in shapes:
        a = shape.area()                        # 多态调用——实际调用哪个 area()？
        total += a
        print(f&quot;  {shape.describe()} → 面积 = {a:.2f}&quot;)
    print(f&quot;  总面积 = {total:.2f}&quot;)

shapes = [
    Rectangle(3, 4),
    Circle(5),
    Triangle(6, 4),
    Rectangle(2, 7),
    Circle(3)
]
print_all_areas(shapes)
# 注意：这里没有用 if isinstance(shape, Rectangle) 这种判断！
# 这就是多态的力量——代码更简洁，扩展性更强

# ====== 2. 鸭子类型——Python 的多态哲学 ======

class Duck:
    def quack(self):
        print(&quot;🦆 嘎嘎嘎！这是真鸭子&quot;)

class Person:
    def quack(self):
        print(&quot;👤 嘎嘎嘎！人也可以学鸭子叫！&quot;)

class Toy:
    def quack(self):
        print(&quot;🧸 嘎嘎嘎！玩具鸭子也能叫！&quot;)

def let_it_quack(thing):
    &quot;&quot;&quot;只要会嘎嘎叫，我就当你是鸭子！&quot;&quot;&quot;
    thing.quack()                               # 完全不检查 thing 的类型

print(f&quot;\n=== 鸭子类型演示 ===&quot;)
let_it_quack(Duck())                            # 🦆 嘎嘎嘎！这是真鸭子
let_it_quack(Person())                          # 👤 嘎嘎嘎！人也可以学鸭子叫！
let_it_quack(Toy())                             # 🧸 嘎嘎嘎！玩具鸭子也能叫！
# 三个完全不同的类——没有继承关系——但因为都有 quack() 方法
# let_it_quack 就能处理它们。这就是鸭子类型！

# ====== 3. 继承 + 多态 = 终极组合 ======

class DataLoader:
    &quot;&quot;&quot;基础数据加载器&quot;&quot;&quot;
    def __init__(self):
        self.data = []
    
    def load(self):
        &quot;&quot;&quot;加载数据——子类各自实现&quot;&quot;&quot;
        raise NotImplementedError(&quot;子类必须实现 load 方法&quot;)
    
    def process(self):
        &quot;&quot;&quot;处理数据——子类各自实现&quot;&quot;&quot;
        raise NotImplementedError(&quot;子类必须实现 process 方法&quot;)
    
    def get_batch(self, batch_size):
        &quot;&quot;&quot;多态方法——子类可以重写，也可以直接用&quot;&quot;&quot;
        if not self.data:
            self.load()
            self.process()
        indices = np.random.choice(len(self.data),
                                    min(batch_size, len(self.data)),
                                    replace=False)
        return [self.data[i] for i in indices]

class ImageLoader(DataLoader):
    &quot;&quot;&quot;图片数据加载器&quot;&quot;&quot;
    def load(self):
        print(&quot;[ImageLoader] 从文件夹加载图片……&quot;)
        self.data = [f&quot;img_{i}&quot; for i in range(100)]
    
    def process(self):
        print(&quot;[ImageLoader] 图片预处理：resize + normalize&quot;)

class TextLoader(DataLoader):
    &quot;&quot;&quot;文本数据加载器&quot;&quot;&quot;
    def load(self):
        print(&quot;[TextLoader] 从文本文件加载语料……&quot;)
        self.data = [f&quot;sent_{i}&quot; for i in range(80)]
    
    def process(self):
        print(&quot;[TextLoader] 文本预处理：tokenize + padding&quot;)

# 多态：统一处理不同的数据加载器
print(f&quot;\n=== AI 数据加载器的多态 ===&quot;)
loaders = [ImageLoader(), TextLoader()]
for loader in loaders:
    batch = loader.get_batch(3)                 # 相同的调用，不同的行为！
    print(f&quot;  获取 batch: {batch}\n&quot;)

# ====== 4. 多态 + numpy——AI 中的通用处理 ======

def process_data(data, processor):
    &quot;&quot;&quot;通用的数据处理函数——多态的体现&quot;&quot;&quot;
    return processor(data)

class Normalizer:
    &quot;&quot;&quot;标准化处理器&quot;&quot;&quot;
    def __call__(self, data):
        mean = data.mean()
        std = data.std()
        if std &gt; 0:
            return (data - mean) / std
        return data - mean

class MinMaxScaler:
    &quot;&quot;&quot;MinMax 缩放器&quot;&quot;&quot;
    def __call__(self, data):
        d_min = data.min()
        d_max = data.max()
        if d_max &gt; d_min:
            return (data - d_min) / (d_max - d_min)
        return data - d_min

class LogTransformer:
    &quot;&quot;&quot;对数变换器&quot;&quot;&quot;
    def __call__(self, data):
        return np.log1p(data)                   # log(1+x)，避免 log(0)

# 相同的接口，不同的行为
raw = np.array([1, 5, 10, 50, 100], dtype=float)
print(f&quot;\n原始数据: {raw}&quot;)
print(f&quot;标准化:   {process_data(raw, Normalizer()).round(3)}&quot;)
print(f&quot;MinMax:   {process_data(raw, MinMaxScaler()).round(3)}&quot;)
print(f&quot;对数变换: {process_data(raw, LogTransformer()).round(3)}&quot;)</code></pre><p><strong>什么用</strong>：多态是 AI 框架设计的基石。PyTorch 的优化器接口——<code>SGD</code>、<code>Adam</code>、<code>AdamW</code>——都实现了 <code>step()</code> 和 <code>zero_grad()</code> 方法。你在训练循环中写 <code>optimizer.step()</code> 时，完全不需要关心 optimizer 的具体类型。损失函数也一样——<code>MSELoss</code>、<code>CrossEntropyLoss</code>、<code>BCELoss</code> 都实现了 <code>forward(pred, target)</code>，可以随时替换。数据增强的 <code>Compose</code> 就是多态的经典应用——<code>transforms.Compose([Resize(224), ToTensor(), Normalize(...)])</code> 把不同的图像变换统一成一个多态管道。</p>
<h3>四、<code>super()</code> 与 MRO——继承的正确姿势</h3>
<p><strong>是什么</strong>：<code>super()</code> 是一个内置函数，返回父类的代理对象，让你能调用父类的方法。最常见的用途是在子类的 <code>__init__</code> 中调用 <code>super().__init__()</code>，确保父类的初始化逻辑被执行。MRO（Method Resolution Order，方法解析顺序）是 Python 在多重继承场景下决定&quot;先找哪个父类&quot;的规则——使用 C3 线性化算法，可以通过 <code>类名.__mro__</code> 查看。</p>
<blockquote class="plain-explain"><strong>大白话</strong> super() 就像一个&quot;向上级请示&quot;的通道。你（子类）在做一个决定前，先问问你的上级（父类）：&quot;您觉得这件事该怎么处理？&quot;父类可能说&quot;我来处理&quot;，也可能说&quot;你按自己的方式处理&quot;。super() 确保你不会跳过该走的流程——就像子类 <code>__init__</code> 中不调 <code>super().__init__()</code>，父类的初始化代码就不会运行，可能导致一些关键属性缺失。</blockquote>


<p><strong>为什么</strong>：在多继承场景中，不使用 <code>super()</code> 直接写 <code>ParentA.__init__(self)</code> 会导致&quot;钻石问题&quot;——同一个祖先类的 <code>__init__</code> 被调用多次。<code>super()</code> 配合 MRO 能保证每个父类的方法最多被调用一次，而且调用顺序是确定的。在实际 AI 开发中，每次继承 <code>nn.Module</code> 都必须写 <code>super().__init__()</code>——这是 PyTorch 的硬性要求，否则模型无法正确注册参数。</p>
<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-4"><code class="language-python">import numpy as np

# ====== 1. super() 的基本用法 ======

class Parent:
    def __init__(self, name):
        self.name = name
        print(f&quot;Parent.__init__: {name}&quot;)
    
    def greet(self):
        return f&quot;你好，我是 {self.name}&quot;

class Child(Parent):
    def __init__(self, name, toy):
        super().__init__(name)                  # 调用父类 __init__ 设置 name
        self.toy = toy                          # 子类自己的属性
        print(f&quot;Child.__init__: 玩具={toy}&quot;)
    
    def greet(self):
        parent_greeting = super().greet()       # 先拿到父类的问候语
        return f&quot;{parent_greeting}，我有 {self.toy}&quot;

child = Child(&quot;小明&quot;, &quot;乐高&quot;)
print(f&quot;\n{child.greet()}&quot;)                     # 你好，我是 小明，我有 乐高

# ====== 2. super() 的两种写法 ======

class NewStyle(Parent):
    def __init__(self, name, hobby):
        # 写法1：Python 3 推荐写法（自动推断当前类和实例）
        super().__init__(name)
        
        # 写法2：显式传参（兼容 Python 2 的写法）
        # super(NewStyle, self).__init__(name)
        
        self.hobby = hobby

ns = NewStyle(&quot;小红&quot;, &quot;画画&quot;)
print(f&quot;爱好: {ns.hobby}&quot;)

# ====== 3. 不调 super() 会怎样？——一个典型错误 ======

class WrongChild(Parent):
    def __init__(self, name, extra):
        # 忘了调 super().__init__(name) ！！
        self.extra = extra
        # self.name 没有被设置！父类初始化被跳过了！

# wrong = WrongChild(&quot;错误例子&quot;, &quot;测试&quot;)
# wrong.greet()                                 # 报 AttributeError: 'WrongChild' object has no attribute 'name'

# ====== 4. AI 场景：继承基类，重写核心方法 ======

class BaseClassifier:
    &quot;&quot;&quot;所有分类器的基类——定义接口&quot;&quot;&quot;
    
    def __init__(self, num_classes):
        self.num_classes = num_classes
        self.trained = False
    
    def fit(self, X, y):
        &quot;&quot;&quot;训练模型——子类必须实现&quot;&quot;&quot;
        raise NotImplementedError
    
    def predict(self, X):
        &quot;&quot;&quot;预测——子类必须实现&quot;&quot;&quot;
        raise NotImplementedError
    
    def evaluate(self, X, y):
        &quot;&quot;&quot;评估准确率——基类提供通用实现&quot;&quot;&quot;
        if not self.trained:
            raise RuntimeError(&quot;模型尚未训练！&quot;)
        preds = self.predict(X)                 # 多态调用子类的 predict
        # 假设 preds 和 y 是标签索引
        accuracy = np.mean(np.array(preds) == np.array(y))
        return accuracy

class LogisticRegression(BaseClassifier):
    &quot;&quot;&quot;逻辑回归——用 numpy 实现&quot;&quot;&quot;
    
    def __init__(self, num_classes=2, learning_rate=0.01, epochs=100):
        super().__init__(num_classes)           # 调用基类 __init__
        self.lr = learning_rate
        self.epochs = epochs
        self.W = None                           # 权重矩阵
        self.b = None                           # 偏置
    
    def fit(self, X, y):
        &quot;&quot;&quot;训练逻辑回归&quot;&quot;&quot;
        n_samples, n_features = X.shape
        self.W = np.random.randn(self.num_classes, n_features) * 0.01
        self.b = np.zeros(self.num_classes)
        
        for epoch in range(self.epochs):
            # 前向传播
            logits = np.dot(X, self.W.T) + self.b
            # Softmax
            exp_logits = np.exp(logits - logits.max(axis=1, keepdims=True))
            probs = exp_logits / exp_logits.sum(axis=1, keepdims=True)
            # 梯度计算（简化）
            probs[np.arange(n_samples), y] -= 1
            dW = np.dot(probs.T, X) / n_samples
            db = probs.sum(axis=0) / n_samples
            # 参数更新
            self.W -= self.lr * dW
            self.b -= self.lr * db
        
        self.trained = True
        print(f&quot;逻辑回归训练完成（{self.epochs} 轮）&quot;)
        return self
    
    def predict(self, X):
        &quot;&quot;&quot;预测类别&quot;&quot;&quot;
        logits = np.dot(X, self.W.T) + self.b
        return np.argmax(logits, axis=1)

# 训练和评估
X = np.random.randn(50, 4)
y = np.random.randint(0, 2, 50)
clf = LogisticRegression(num_classes=2, learning_rate=0.1, epochs=200)
clf.fit(X, y)
acc = clf.evaluate(X, y)                       # 调用基类的 evaluate → 多态调用子类的 predict
print(f&quot;训练集准确率: {acc:.2%}&quot;)</code></pre><p><strong>什么用</strong>：在 PyTorch 中，每个模型类内部 <code>super().__init__()</code> 的调用链最终会到达 <code>nn.Module.__init__()</code>——这个方法负责注册模型的所有基础能力（参数追踪、设备迁移、序列化等）。如果忘了调用，你的模型看起来能跑，但 <code>model.parameters()</code> 会是空的，<code>model.to(cuda)</code> 不会生效，<code>model.state_dict()</code> 也保存不了任何东西。牢记：<code>class MyModel(nn.Module): def __init__(self): super().__init__()</code>——这是每个 AI 模型的第一行代码。</p>
<div class="demo-embed" data-demo-src="/demos/encapsulation-inheritance-demo1.html"><a href="/demos/encapsulation-inheritance-demo1.html">OOP 三大特性——封装、继承、多态互动演示（动画演示）</a></div>


<h2>概念关系图谱</h2>
<div class="table-wrapper"><table class="concept-map-table"><thead><tr><th>概念</th><th>核心含义</th><th>与AI的关系</th><th>关联概念</th></tr></thead><tbody><tr><td>封装</td><td>隐藏内部数据，通过方法控制访问</td><td>模型参数受保护，通过优化器更新</td><td>私有属性、getter/setter</td></tr><tr><td>继承</td><td>子类复用父类的属性和方法</td><td>class MyNet(nn.Module)</td><td>父类、子类、is-a</td></tr><tr><td>多态</td><td>同一接口，不同类有不同实现</td><td>optimizer.step() 统一接口</td><td>鸭子类型、方法重写</td></tr><tr><td>super()</td><td>调用父类方法的桥梁</td><td>super().<strong>init</strong>() 注册模型</td><td>MRO、<strong>mro</strong></td></tr><tr><td>私有属性</td><td><code>_name</code> 和 <code>__name</code> 命名约定</td><td>不应直接修改 weight.data</td><td>名称改编、受保护</td></tr><tr><td>方法重写</td><td>子类重新定义父类的方法</td><td>重写 forward() 定义模型逻辑</td><td>override、覆盖</td></tr><tr><td>鸭子类型</td><td>不检查类型，只检查是否有某方法</td><td>任何有 forward() 的对象都可当模型用</td><td>动态类型、协议</td></tr><tr><td>MRO</td><td>多继承时的方法查找顺序</td><td>混合使用多个 Mixin 时的查找规则</td><td>C3 线性化、super()</td></tr></tbody></table></div>
<h2>重点答疑</h2>
<h3>Q1: Python 真的有&quot;私有&quot;属性吗？<code>__name</code> 和 <code>_name</code> 有什么区别？</h3>
<p>Python 没有真正的私有属性——只是约定和障眼法。<code>_name</code>（单下划线）是 PEP 8 约定：意思是&quot;这是内部实现细节，请不要从外部访问&quot;。违反约定不会报错，但你的 IDE 和代码检查工具会提醒你。<code>__name</code>（双下划线）触发了&quot;名称改编&quot;——Python 在后台把 <code>__name</code> 改成了 <code>_类名__name</code>，让外部访问变麻烦（但并非不可能：<code>obj._类名__name</code> 仍然可以访问）。Python 哲学：大家都是成年人，相信你不会乱来。</p>
<h3>Q2: 什么时候应该用继承，什么时候应该用组合（一个类包含另一个类的对象）？</h3>
<p>记住一个简单的判断标准——如果是&quot;是一种&quot;（is-a）关系，用继承：狗是一种动物，所以 <code>Dog</code> 继承 <code>Animal</code>。如果是&quot;有一个&quot;（has-a）关系，用组合：人有地址，所以 <code>Person</code> 包含 <code>Address</code> 对象。实际开发中的建议是&quot;优先使用组合而非继承&quot;——因为继承是强耦合（父类一变，子类跟着变），组合更灵活。在 AI 中，继承主要用在继承框架基类（<code>nn.Module</code>），而功能扩展多用组合（模型包含多个层对象）。</p>
<h3>Q3: 什么是鸭子类型？它和传统的多态有什么不同？</h3>
<p>鸭子类型是 Python 独特的类型哲学——&quot;如果它走路像鸭子、叫起来像鸭子，那它就是鸭子&quot;。传统语言（如 Java）的多态需要显式声明接口或继承关系：<code>Animal animal = new Dog()</code>。而 Python 根本不检查类型——只要你传进来的对象有对应方法就行。好处是极其灵活（不需要继承树），坏处是可能导致运行时错误（传了有 <code>forward()</code> 但不是模型的对象）。AI 中 PyTorch 的 <code>nn.Sequential</code> 就是鸭子类型的完美应用——你放进去的模块只要有 <code>forward()</code> 方法就行，不管它们具体是什么类型。</p>
<h3>Q4: <code>super().__init__()</code> 不调用会怎样？</h3>
<p>轻则缺少属性导致后续代码报 <code>AttributeError</code>，重则程序偷偷出错——父类的一些关键初始化（如注册参数、设置训练状态）被跳过。在 PyTorch 中，如果你忘了写 <code>super().__init__()</code>，<code>model.parameters()</code> 返回空列表，<code>model.to(device)</code> 不生效（模型还在 CPU 上）。更隐蔽的是——如果不报错，你可能训练了好几个小时才发现保存不了模型参数。所以写 PyTorch 模型的第一条规矩就是：<code>def __init__(self): super().__init__()</code>，这是铁律。</p>
<h3>Q5: 多重继承在 Python 中怎么用？什么是 MRO？</h3>
<p>多重继承指一个类同时继承多个父类。Python 的 <code>class C(A, B):</code> 让 C 同时获得 A 和 B 的属性和方法。MRO（Method Resolution Order）决定了当多个父类有同名方法时，Python 按什么顺序查找。Python 使用 C3 线性化算法，简单规则是从左到右、从下到上。查看 MRO 用 <code>C.__mro__</code> 或 <code>C.mro()</code>。在实际 AI 开发中，多重继承很少直接使用——更多是用 Mixin 模式（把独立功能包装成&quot;混入类&quot;）。PyTorch 内部有少量多继承，但作为开发者你几乎不需要自己写。</p>

<h2>章节单词汇总</h2>
<div class="vocab-table-wrapper"><table class="vocab-table"><thead><tr><th>英文</th><th>音标</th><th>术语/释义</th></tr></thead><tbody><tr><td>encapsulation</td><td>/ɪnˌkæpsjuˈleɪʃən/</td><td>封装；隐藏内部实现，只暴露接口</td></tr><tr><td>inheritance</td><td>/ɪnˈherɪtəns/</td><td>继承；子类获得父类的属性和方法</td></tr><tr><td>polymorphism</td><td>/ˌpɑːliˈmɔːrfɪzəm/</td><td>多态；同一接口在不同类中有不同表现</td></tr><tr><td>override</td><td>/ˌoʊvərˈraɪd/</td><td>重写；子类重新定义父类的方法</td></tr><tr><td>super()</td><td>/ˈsuːpər/</td><td>调用父类方法的函数</td></tr><tr><td>private</td><td>/ˈpraɪvət/</td><td>私有的；通过 <code>__</code> 名称改编隐藏</td></tr><tr><td>duck typing</td><td>/dʌk ˈtaɪpɪŋ/</td><td>鸭子类型；Python 的类型判断哲学</td></tr><tr><td>MRO</td><td>/ˌem ɑːr ˈoʊ/</td><td>方法解析顺序；多继承时的方法查找顺序</td></tr></tbody></table></div>
<div class="quiz-raw"><h2>面试练习</h2>
<h3>Q1 [单选] 以下哪个是 Python 中表示&quot;受保护的&quot;属性的命名约定？</h3>
<ul>
<li>A. <code>public</code></li><li>B. <code>__private</code></li><li>C. <code>_internal</code></li><li>D. <code>protected_</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。PEP 8 约定单下划线前缀（<code>_name</code>）表示&quot;受保护的/内部使用的&quot;。B 是双下划线，触发名称改编。A 不是 Python 约定。D 不存在这种写法。</blockquote>


<h3>Q2 [单选] 以下代码中，<code>c.bar()</code> 输出什么？<code>class A: def foo(self): return &quot;A&quot;; class B: def bar(self): return self.foo(); class C(A, B): def foo(self): return &quot;C&quot;</code></h3>
<ul>
<li>A. &quot;C&quot;</li><li>B. &quot;A&quot;</li><li>C. 报错，因为 foo 在 A 和 C 中都有定义</li><li>D. 报错，因为 C 没有 bar 方法</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。C 继承了 B 的 <code>bar()</code> 方法，但重写了 A 的 <code>foo()</code> 方法。当 <code>c.bar()</code> 调用 <code>self.foo()</code> 时，self 是 C 的实例，所以会调用 C 中重写的 <code>foo()</code>，返回 &quot;C&quot;。这就是多态——<code>self.foo()</code> 根据实际对象类型分发。</blockquote>


<h3>Q3 [多选] 关于 Python 的封装，以下说法正确的是？</h3>
<ul>
<li>A. <code>_name</code> 是约定，表示不应从外部访问</li><li>B. <code>__name</code> 会触发名称改编，变成 <code>_类名__name</code></li><li>C. <code>__name</code> 是真正私有的，无论如何外部都访问不到</li><li>D. Python 的封装依赖程序员的自觉和约定</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确。C 错误——<code>__name</code> 仍然可以通过 <code>obj._类名__name</code> 访问，Python 没有真正的私有属性。</blockquote>


<h3>Q4 [单选] <code>class Dog(Animal):</code> 中，Dog 和 Animal 的关系是？</h3>
<ul>
<li>A. Dog 包含 Animal</li><li>B. Dog 是一种 Animal</li><li>C. Dog 和 Animal 是并列关系</li><li>D. Animal 是 Dog 的实例</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。继承表达的是&quot;is-a&quot;关系：狗是一种动物。组合才表达&quot;has-a&quot;关系（如人有地址）。</blockquote>


<h3>Q5 [多选] 关于 <code>super()</code>，以下说法正确的是？</h3>
<ul>
<li>A. <code>super().__init__()</code> 调用父类的初始化方法</li><li>B. <code>super()</code> 在多重继承中按 MRO 顺序调用父类方法</li><li>C. 子类的 <code>__init__</code> 中通常需要调用 <code>super().__init__()</code></li><li>D. <code>super()</code> 只能用于 <code>__init__</code> 方法</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 都正确。D 错误——<code>super()</code> 可以用于任何方法。比如子类重写 <code>forward()</code> 时也可以用 <code>super().forward(x)</code> 调用父类的实现。</blockquote>


<h3>Q6 [单选] 下列关于多态的描述，哪个最准确？</h3>
<ul>
<li>A. 多态就是同一个函数名可以接收不同类型的参数</li><li>B. 多态就是父类的方法被子类重写</li><li>C. 多态是不同类的对象响应相同的方法调用，但表现出不同的行为</li><li>D. 多态就是函数重载（overloading）</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 最准确。多态的核心是&quot;同一接口，不同行为&quot;。A 描述了泛型或鸭子类型的一个侧面但不够完整。B 只描述了&quot;重写&quot;（多态的前提条件之一）。D 是错误理解——Python 不支持传统的函数重载。</blockquote>


<h3>Q7 [多选] 以下哪些是使用继承的优势？</h3>
<ul>
<li>A. 代码复用——子类自动获得父类的属性方法</li><li>B. 层次清晰——用类层级表达&quot;is-a&quot;关系</li><li>C. 扩展方便——添加新子类不影响现有代码</li><li>D. 继承越多越好，类层级越深越优秀</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 都正确。D 是反面观点——过深的继承层级反而不利于维护。经验法则：继承深度不超过 3-4 层，优先考虑组合。</blockquote>


<h3>Q8 [单选] 鸭子类型的核心思想是？</h3>
<ul>
<li>A. 对象必须声明它属于哪个类型</li><li>B. 关注对象能做什么，而不是它是什么类型</li><li>C. 所有对象都必须是鸭子类的子类</li><li>D. 只有继承关系才能实现多态</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。鸭子类型的核心是&quot;行为决定类型&quot;——对象能不能用取决于它有没有对应的方法，而不是它的类型标签。</blockquote>


<h3>Q9 [单选] 在 PyTorch 中，<code>class MyModel(nn.Module):</code> 体现了什么 OOP 特性？</h3>
<ul>
<li>A. 封装</li><li>B. 继承</li><li>C. 多态</li><li>D. 抽象</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>MyModel(nn.Module)</code> 是用继承语法，MyModel 继承自 nn.Module。当然实际使用时三种特性都会涉及（训练循环中调用 <code>model.forward(x)</code> 体现了多态，nn.Module 内部封装了参数管理）。</blockquote>


<h3>Q10 [多选] 关于方法重写（override），以下说法正确的是？</h3>
<ul>
<li>A. 子类可以重写父类的方法</li><li>B. 重写时方法名和参数列表应该保持一致</li><li>C. 重写后无法再调用父类的原方法</li><li>D. 在 Python 中，所有方法默认都是&quot;虚方法&quot;（可被重写）</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确。C 错误——可以通过 <code>super().方法名()</code> 显式调用父类的原方法。D 正确——Python 不像 Java/C++ 那样需要 <code>virtual</code> 关键字，所有方法默认都可以被重写。</blockquote>


</div>

      <div class="content-actions">
        <button class="action-btn" onclick="sharePage()" title="分享">
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8"/><polyline points="16 6 12 2 8 6"/><line x1="12" y1="2" x2="12" y2="15"/></svg><span>分享</span>
        </button>
        <button class="action-btn" onclick="printPage()" title="打印">
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><polyline points="6 9 6 2 18 2 18 9"/><path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"/><rect x="6" y="14" width="12" height="8"/></svg><span>打印</span>
        </button>
        <button class="action-btn" onclick="showFeedback()" title="反馈">
          <svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"/></svg><span>反馈</span>
        </button>
      </div>
    </article>
  </main>
</div>

<script type="application/json" id="formula-data">{}</script>
<script type="application/json" id="quiz-data">[
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 正确。PEP 8 约定单下划线前缀（`_name`）表示\"受保护的/内部使用的\"。B 是双下划线，触发名称改编。A 不是 Python 约定。D 不存在这种写法。"
  },
  {
    "type": "single",
    "answer": 0,
    "explanation": "A 正确。C 继承了 B 的 `bar()` 方法，但重写了 A 的 `foo()` 方法。当 `c.bar()` 调用 `self.foo()` 时，self 是 C 的实例，所以会调用 C 中重写的 `foo()`，返回 \"C\"。这就是多态——`self.foo()` 根据实际对象类型分发。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确。C 错误——`__name` 仍然可以通过 `obj._类名__name` 访问，Python 没有真正的私有属性。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。继承表达的是\"is-a\"关系：狗是一种动物。组合才表达\"has-a\"关系（如人有地址）。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 都正确。D 错误——`super()` 可以用于任何方法。比如子类重写 `forward()` 时也可以用 `super().forward(x)` 调用父类的实现。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 最准确。多态的核心是\"同一接口，不同行为\"。A 描述了泛型或鸭子类型的一个侧面但不够完整。B 只描述了\"重写\"（多态的前提条件之一）。D 是错误理解——Python 不支持传统的函数重载。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 都正确。D 是反面观点——过深的继承层级反而不利于维护。经验法则：继承深度不超过 3-4 层，优先考虑组合。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。鸭子类型的核心是\"行为决定类型\"——对象能不能用取决于它有没有对应的方法，而不是它的类型标签。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`MyModel(nn.Module)` 是用继承语法，MyModel 继承自 nn.Module。当然实际使用时三种特性都会涉及（训练循环中调用 `model.forward(x)` 体现了多态，nn.Module 内部封装了参数管理）。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确。C 错误——可以通过 `super().方法名()` 显式调用父类的原方法。D 正确——Python 不像 Java/C++ 那样需要 `virtual` 关键字，所有方法默认都可以被重写。"
  }
]</script>

<script src="/js/chapter-enhance.js"></script>
<script src="/js/pay-modal.js?v=20260606e"></script>
<script src="/js/chapter-common.js"></script>
<script src="/js/chapter-learn.js"></script>
<script src="/js/chapter-nav.js"></script>
<script src="/js/chapter-voice.js"></script>
<script src="/js/chapter-quiz.js"></script>
<script src="/js/chapter-presence.js"></script>
<script src="/js/chapter-auth.js"></script>
<script src="/js/chapter-code.js"></script>
<script src="/js/chapter-annotation.js"></script>
<script src="/js/chapter-comments.js"></script>
<script src="/js/chapter-social.js"></script>
<script src="/js/chapter-ui.js?v=20260612c"></script>
<script src="/js/chapter-init.js?v=20260612b"></script>
</body>
</html>