<!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>面向对象编程（OOP）的核心就是&quot;类&quot;和&quot;对象&quot;——<strong>类</strong>是蓝图（模板），<strong>对象</strong>是按蓝图制造出来的具体实例。用 <code>class</code> 关键字定义类，通过 <code>类名()</code> 实例化创建对象。类里面可以定义<strong>属性</strong>（数据）和<strong>方法</strong>（行为），对象拥有类赋予的一切能力。在 AI 开发中，PyTorch 的 <code>nn.Module</code> 就是一个类——你定义自己的模型就是继承这个类并实例化它。</p>
<blockquote class="highlight-box"><strong>💡 核心要点：</strong>①<code>class 类名:</code> 定义类，类名通常用大驼峰命名法（每个单词首字母大写）②<code>__init__(self)</code> 是初始化方法，定义对象创建时需要的属性，self 代表对象自身 ③<code>对象 = 类名()</code> 是实例化——把一个类&quot;变成&quot;一个活的对象 ④方法就是在类内部定义的函数，第一个参数必须是 <code>self</code>，通过 <code>对象.方法()</code> 调用 ⑤类和对象的关系就像&quot;饼干模具&quot;和&quot;饼干&quot;——一个模具可以做出无数块饼干</blockquote>


<h2>教学与演示</h2>
<h3>一、类的定义——绘制蓝图</h3>
<p><strong>是什么</strong>：<code>class</code> 是 Python 定义类的关键字。一个类本质上是把相关的数据（属性）和操作这些数据的函数（方法）打包在一起的&quot;容器&quot;。基本语法：<code>class 类名:</code>，下面缩进编写属性和方法。类定义了对象应该有什么（属性）和能做什么（方法），但它本身不存储具体数据——就像一个空白的表格模板。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 想象你要开一家宠物店，需要管理很多只猫。你不可能为每只猫都写一套全新的代码——太蠢了！所以你设计一个&quot;猫的通用模板&quot;（类）：每只猫都有名字、年龄、颜色（属性），都会喵喵叫、吃东西（方法）。之后每来一只猫，你只需要&quot;套用模板&quot;填写具体信息就行了。这个模板就是&quot;类&quot;，按模板填出来的具体猫就是&quot;对象&quot;。</blockquote>


<p><strong>为什么</strong>：没有 OOP 之前，我们只能用散落的变量和函数来管理数据——比如 <code>cat1_name</code>、<code>cat1_age</code>、<code>cat2_name</code>、<code>cat2_age</code>……这会导致变量名爆炸、代码重复、数据和行为分离。类的出现把&quot;数据&quot;和&quot;操作数据的方法&quot;捆绑在一起，解决了三个核心问题：①<strong>封装</strong>——相关数据和函数组织在一起，逻辑清晰；②<strong>复用</strong>——模板写好，无限实例化；③<strong>可维护</strong>——修改模板，所有对象同步更新。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 就像管理 100 个学生的信息。不用类：你得维护 <code>stu1_name</code>、<code>stu1_score</code>、<code>stu2_name</code>、<code>stu2_score</code>……100 个学生就是 200 个变量，而且计算平均分时你得一锅乱炖。用类：定义 <code>Student</code> 模板，然后 <code>s1 = Student(&quot;张三&quot;, 85)</code>，<code>s2 = Student(&quot;李四&quot;, 92)</code>……每个学生都是独立对象，风格清爽，一目了然。</blockquote>


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

# ====== 1. 最简单的类——就像一张空白的登记表 ======

class Dog:                                      # class 关键字 + 首字母大写的类名 + 冒号
    &quot;&quot;&quot;狗类：定义狗应该有的属性和行为&quot;&quot;&quot;          # 文档字符串
    pass                                        # pass 是占位符，表示&quot;目前什么都不做&quot;

# 类定义完毕，但它只是一个&quot;概念&quot;，还不能直接使用
print(&quot;Dog 类的类型:&quot;, type(Dog))               # &lt;class 'type'&gt; — 类本身也是对象！
print(&quot;Dog 类的说明:&quot;, Dog.__doc__)             # '狗类：定义狗应该有的属性和行为'

# ====== 2. 定义带属性和方法的类 ======

class Cat:
    &quot;&quot;&quot;猫类——定义了猫是什么，猫能做什么&quot;&quot;&quot;
    
    def __init__(self, name, age, color):       # __init__ 是初始化方法（双下划线 = &quot;魔术方法&quot;）
        &quot;&quot;&quot;初始化一只新猫——给猫赋予具体的属性值&quot;&quot;&quot;
        self.name = name                        # self.name 是对象的属性，name 是传入的参数
        self.age = age                          # self.age 把参数值存到对象身上
        self.color = color                      # self.color 同理——self 就是&quot;这只猫自己&quot;
    
    def meow(self):                             # 定义方法——第一个参数必须是 self
        &quot;&quot;&quot;猫叫&quot;&quot;&quot;
        print(f&quot;{self.name}：喵喵喵！(我 {self.age} 岁了)&quot;)  # self.name 获取当前对象的 name 属性
    
    def eat(self, food):
        &quot;&quot;&quot;猫吃东西&quot;&quot;&quot;
        print(f&quot;{self.name} 正在吃 {food}，吧唧吧唧~&quot;)
    
    def introduce(self):
        &quot;&quot;&quot;自我介绍&quot;&quot;&quot;
        return f&quot;我叫 {self.name}，是一只 {self.color} 色的猫，今年 {self.age} 岁。&quot;

# ====== 3. 实例化——用模板创建具体的猫 ======

cat1 = Cat(&quot;小花&quot;, 3, &quot;白&quot;)                      # Cat() 调用 __init__，self 自动传入
cat2 = Cat(&quot;大橘&quot;, 2, &quot;橘&quot;)                      # 每一次 Cat() 都创建一个全新的对象

print(f&quot;\ncat1 的类型: {type(cat1)}&quot;)           # &lt;class '__main__.Cat'&gt;
print(f&quot;cat2 的类型: {type(cat2)}&quot;)             # &lt;class '__main__.Cat'&gt;

# cat1 和 cat2 是两个独立的对象，互不影响
print(f&quot;\n{cat1.introduce()}&quot;)                  # 我叫 小花，是一只 白 色的猫，今年 3 岁。
print(f&quot;{cat2.introduce()}&quot;)                    # 我叫 大橘，是一只 橘 色的猫，今年 2 岁。

# 调用方法：对象名.方法名()
cat1.meow()                                     # 小花：喵喵喵！(我 3 岁了)
cat2.eat(&quot;小鱼干&quot;)                              # 大橘 正在吃 小鱼干，吧唧吧唧~

# ====== 4. self 到底是什么？——self 就是对象本身 ======

class Demo:
    def __init__(self, value):
        self.value = value                      # self.value 存储在对象上
        print(f&quot;__init__ 中的 self is: {self}&quot;)
    
    def show_self(self):
        print(f&quot;show_self 中的 self is: {self}&quot;)

d = Demo(42)                                    # __init__ 中的 self is: &lt;__main__.Demo object at 0x...&gt;
d.show_self()                                   # show_self 中的 self is: &lt;__main__.Demo object at 0x...&gt;
# 两个 self 指向同一个对象——self 就是 d 的另一个名字

# ====== 5. AI 场景：模拟一个简化的神经网络神经元 ======

class Neuron:
    &quot;&quot;&quot;单个神经元——简化版（OOP 思维在 AI 中的体现）&quot;&quot;&quot;
    
    def __init__(self, num_inputs):
        &quot;&quot;&quot;初始化神经元：随机初始化权重和偏置&quot;&quot;&quot;
        self.weights = np.random.randn(num_inputs)  # 权重向量（正态分布随机初始化）
        self.bias = np.random.randn(1)[0]           # 偏置（单个标量）
        print(f&quot;神经元初始化：权重={self.weights.round(3)}, 偏置={self.bias:.3f}&quot;)
    
    def forward(self, inputs):
        &quot;&quot;&quot;前向传播：加权求和 + ReLU 激活&quot;&quot;&quot;
        # 点积运算：inputs · weights + bias
        z = np.dot(inputs, self.weights) + self.bias
        # ReLU 激活：负数变 0，正数原样输出
        return max(0.0, z)

# 创建神经元（3 个输入）
neuron = Neuron(3)
# 模拟一组输入数据
x = np.array([0.5, -0.3, 0.8])                  # 三个输入特征
output = neuron.forward(x)
print(f&quot;输入: {x}&quot;)
print(f&quot;输出（ReLU 后）: {output:.4f}&quot;)</code></pre><p><strong>什么用</strong>：在 AI 开发中，类是最核心的代码组织方式。PyTorch 中所有模型都继承自 <code>nn.Module</code> 类——定义模型就是定义类。<code>nn.Linear(10, 5)</code> 是一个类实例，它内部封装了权重矩阵和偏置向量。scikit-learn 的 <code>LinearRegression()</code>、<code>RandomForestClassifier()</code> 都是类。理解类和对象的关系，是你从&quot;脚本程序员&quot;进阶到&quot;AI 工程师&quot;的第一步。</p>
<h3>二、属性——对象的数据</h3>
<p><strong>是什么</strong>：属性是绑定在对象上的变量，用于存储对象的状态信息。属性通常在 <code>__init__</code> 方法中通过 <code>self.属性名 = 值</code> 创建。每个对象拥有自己独立的属性副本——修改一只猫的名字不会影响另一只猫。属性的值可以是任何 Python 类型：数字、字符串、列表、字典，甚至是另一个对象。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 属性和对象的关系就像&quot;个人信息表&quot;上的各个栏目。你的身份证上有姓名、性别、出生日期、住址——这些就是人的&quot;属性&quot;。张三和李四共用同一张表格模板（类），但填上去的内容（属性值）各不相同。同样，每只猫的 name、age、color 各不相同，但它们都是用同一个 Cat 模板创建的。</blockquote>


<p><strong>为什么</strong>：属性让每个对象拥有了自己的&quot;个性&quot;。没有属性，所有对象千篇一律——每只猫都叫&quot;咪咪&quot;毫无意义。属性是对象之间区分彼此的唯一方式。更重要的是，属性可以动态变化——一只猫的 age 可以从 2 变成 3（过生日），worSt 可以从 3kg 变成 5kg（吃胖了）。属性让对象&quot;活&quot;了起来。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 游戏中——每个玩家角色都是同一个 <code>Player</code> 类的实例，但 hp（血量）、level（等级）、inventory（背包）各不相同。这就是属性的价值：同样的代码，不同的数据，产生不同的游戏体验。如果所有角色属性都一模一样，游戏还有什么意思？</blockquote>


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

# ====== 1. 属性的定义、读取和修改 ======

class Student:
    &quot;&quot;&quot;学生类——展示属性的完整用法&quot;&quot;&quot;
    
    def __init__(self, name, score):
        &quot;&quot;&quot;创建学生时设置初始属性&quot;&quot;&quot;
        self.name = name                        # 字符串属性
        self.score = score                      # 数字属性
        self.subjects = []                      # 列表属性——初始为空
    
    def add_subject(self, subject):
        &quot;&quot;&quot;添加一门课程&quot;&quot;&quot;
        self.subjects.append(subject)           # 修改列表属性
    
    def update_score(self, new_score):
        &quot;&quot;&quot;更新成绩&quot;&quot;&quot;
        self.score = new_score                  # 直接赋值修改属性

# 创建学生对象
stu = Student(&quot;张三&quot;, 85)
print(f&quot;姓名: {stu.name}, 成绩: {stu.score}&quot;)   # 姓名: 张三, 成绩: 85
print(f&quot;课程: {stu.subjects}&quot;)                  # [] — 空列表

# 读取属性：对象.属性名
print(f&quot;\n初始成绩: {stu.score}&quot;)

# 修改属性：直接赋值
stu.score = 92                                  # 修改成绩
stu.name = &quot;张三丰&quot;                             # 修改名字（你也可以这么干……）
print(f&quot;修改后: {stu.name}, 成绩: {stu.score}&quot;)

# 通过方法修改属性（推荐——有逻辑校验）
stu.update_score(88)
stu.add_subject(&quot;数学&quot;)
stu.add_subject(&quot;Python&quot;)
print(f&quot;课程列表: {stu.subjects}&quot;)             # ['数学', 'Python']

# ====== 2. 动态添加属性——Python 的灵活性 ======

class Empty:
    &quot;&quot;&quot;一个空类——什么属性都没有&quot;&quot;&quot;
    pass

e = Empty()
# Python 允许在任何时候给对象添加新属性（但强烈不建议！）
e.name = &quot;临时属性&quot;
e.value = 42
print(f&quot;\n动态添加的属性: {e.name}, {e.value}&quot;) # 临时属性, 42

# ⚠️ 警告：这种&quot;突发奇想&quot;添加属性容易导致代码混乱，应在 __init__ 中统一定义！

# ====== 3. 属性可以是其他对象——组合模式 ======

class Address:
    &quot;&quot;&quot;地址类——用于描述一个地址&quot;&quot;&quot;
    def __init__(self, city, street):
        self.city = city
        self.street = street
    def __str__(self):
        return f&quot;{self.city}市{self.street}&quot;

class Person:
    &quot;&quot;&quot;人类——属性包含另一个对象&quot;&quot;&quot;
    def __init__(self, name, city, street):
        self.name = name
        self.address = Address(city, street)    # 属性是另一个对象！这叫&quot;组合&quot;
    
    def info(self):
        return f&quot;{self.name} 住在 {self.address}&quot;

p = Person(&quot;李雷&quot;, &quot;北京&quot;, &quot;长安街&quot;)
print(f&quot;\n{p.info()}&quot;)                          # 李雷 住在 北京市长安街

# ====== 4. AI 场景：数据样本对象 ======

class DataSample:
    &quot;&quot;&quot;AI 训练数据中的一个样本——组合特征和标签&quot;&quot;&quot;
    
    def __init__(self, features, label):
        &quot;&quot;&quot;一个样本由特征向量和标签组成&quot;&quot;&quot;
        self.features = np.array(features)      # 特征：numpy 数组
        self.label = label                      # 标签：整数或字符串
        self.processed = False                  # 是否已预处理
    
    def normalize(self):
        &quot;&quot;&quot;Min-Max 标准化特征&quot;&quot;&quot;
        f_min = self.features.min()
        f_max = self.features.max()
        if f_max &gt; f_min:
            self.features = (self.features - f_min) / (f_max - f_min)
        self.processed = True
        return self.features                    # 返回标准化后的特征

# 创建训练样本
sample = DataSample([2.0, 8.0, 5.0], label=&quot;猫&quot;)
print(f&quot;\n原始特征: {sample.features}&quot;)
print(f&quot;标签: {sample.label}&quot;)
print(f&quot;预处理前: processed={sample.processed}&quot;)

normalized = sample.normalize()
print(f&quot;标准化后: {normalized.round(3)}&quot;)
print(f&quot;预处理后: processed={sample.processed}&quot;)  # True — 状态被更新了</code></pre><p><strong>什么用</strong>：在 AI 开发中，属性用于存储模型的状态和配置。PyTorch 的 <code>model.parameters()</code> 返回的就是模型的属性——所有权重和偏置。<code>nn.Linear</code> 对象有 <code>weight</code> 和 <code>bias</code> 两个核心属性，训练就是不断修改这些属性的值。scikit-learn 模型有 <code>coef_</code>（系数）和 <code>intercept_</code>（截距）属性，训练后它们自动填充。理解属性是你理解&quot;模型训练的本质就是修改属性值&quot;的第一步。</p>
<h3>三、方法——对象的行为</h3>
<p><strong>是什么</strong>：方法是定义在类内部的函数。和普通函数唯一的区别是——方法的第一个参数必须是 <code>self</code>，指向调用该方法的对象。方法通过 <code>self</code> 可以访问和修改对象的属性。方法的调用方式和函数完全相同：<code>对象.方法名(参数)</code>，调用时 Python 自动把对象传给 <code>self</code>，你不需要手动传。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 类 = 汽车的设计图纸。属性 = 汽车的颜色、品牌、当前油量。方法 = 汽车能做什么——启动引擎（<code>.start()</code>）、加速（<code>.accelerate()</code>）、刹车（<code>.brake()</code>）。你不能让图纸发动——你得先把图纸变成真车（实例化），然后开车的人按按钮（调用方法），车才会动。方法就是对象的行为能力。</blockquote>


<p><strong>为什么</strong>：方法是 OOP 的灵魂——光有数据没有行为，对象就像一具僵尸。方法让对象拥有了&quot;能动性&quot;。更关键的是，方法通过 <code>self</code> 自动拿到对象的上下文（所有属性），不需要像普通函数那样把数据传来传去。这大大减少了函数参数的数量——本来需要传 5 个参数的函数，变成方法后只需要传 2 个（剩下 3 个从 self 拿）。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 不用 OOP：<code>calculate_gpa(student_name, student_subjects, student_scores)</code>——你得记住传参的顺序和数量，稍微搞错就出 bug。用 OOP：<code>student.calculate_gpa()</code>——不需要任何参数，因为学生的所有信息都在 <code>self</code> 里了。代码更短、更清晰、更难出错。</blockquote>


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

# ====== 1. 方法的基本定义和调用 ======

class Calculator:
    &quot;&quot;&quot;计算器类——演示各种方法&quot;&quot;&quot;
    
    def __init__(self, brand=&quot;默认品牌&quot;):
        self.brand = brand                      # 品牌属性
        self.history = []                       # 计算历史记录
    
    def add(self, a, b):
        &quot;&quot;&quot;加法&quot;&quot;&quot;
        result = a + b
        self.history.append(f&quot;{a} + {b} = {result}&quot;)  # 通过 self 修改历史记录
        return result
    
    def multiply(self, a, b):
        &quot;&quot;&quot;乘法&quot;&quot;&quot;
        result = a * b
        self.history.append(f&quot;{a} × {b} = {result}&quot;)
        return result
    
    def show_history(self):
        &quot;&quot;&quot;展示计算历史——不需要额外参数，从 self 拿数据&quot;&quot;&quot;
        if not self.history:
            print(&quot;尚无计算记录&quot;)
            return
        print(f&quot;\n=== {self.brand} 计算器 使用记录 ===&quot;)
        for i, record in enumerate(self.history, 1):
            print(f&quot;  {i}. {record}&quot;)

calc = Calculator(&quot;AI 牌&quot;)
print(f&quot;3 + 5 = {calc.add(3, 5)}&quot;)              # 3 + 5 = 8
print(f&quot;4 × 7 = {calc.multiply(4, 7)}&quot;)         # 4 × 7 = 28
print(f&quot;2 + 9 = {calc.add(2, 9)}&quot;)              # 2 + 9 = 11
calc.show_history()                              # 展示三次计算记录

# ====== 2. 方法调用方法——self 的链式能力 ======

class Student:
    &quot;&quot;&quot;学生成绩管理系统&quot;&quot;&quot;
    
    def __init__(self, name):
        self.name = name
        self.scores = {}                        # 字典：科目 -&gt; 分数
    
    def add_score(self, subject, score):
        &quot;&quot;&quot;添加一门课的成绩&quot;&quot;&quot;
        self.scores[subject] = score
        print(f&quot;{self.name} 的 {subject} 成绩已录入: {score}&quot;)
        return self                             # 返回 self 支持链式调用！
    
    def get_average(self):
        &quot;&quot;&quot;计算平均分——方法内部调用其他属性&quot;&quot;&quot;
        if not self.scores:
            return 0.0
        return sum(self.scores.values()) / len(self.scores)
    
    def get_report(self):
        &quot;&quot;&quot;生成成绩报告——方法调用另一个方法&quot;&quot;&quot;
        avg = self.get_average()                # 调用自己的另一个方法
        print(f&quot;\n=== {self.name} 的成绩报告 ===&quot;)
        for subj, score in self.scores.items():
            status = &quot;优秀&quot; if score &gt;= 90 else (&quot;良好&quot; if score &gt;= 75 else &quot;需努力&quot;)
            print(f&quot;  {subj}: {score} 分 ({status})&quot;)
        print(f&quot;  平均分: {avg:.1f}&quot;)
        return avg

stu = Student(&quot;王五&quot;)
# 链式调用——因为 add_score 返回了 self
stu.add_score(&quot;Python&quot;, 92).add_score(&quot;数学&quot;, 85).add_score(&quot;英语&quot;, 78)
stu.get_report()

# ====== 3. self 不是关键字——只是约定俗成的名字 ======

class Weird:
    &quot;&quot;&quot;演示：第一个参数叫什么都可以（但千万别这样写）&quot;&quot;&quot;
    def __init__(myself, x):                    # myself 而不是 self
        myself.x = x
    
    def show(me):                               # me 而不是 self
        print(f&quot;x = {me.x}&quot;)

w = Weird(42)
w.show()                                        # x = 42 —— 正常工作，但请不要学！
# ✅ 真正写代码时，永远用 self——这是全世界 Python 程序员的共同约定

# ====== 4. AI 场景：模型训练循环 ======

class SimpleModel:
    &quot;&quot;&quot;一个带训练的简单模型（模拟 AI 训练过程）&quot;&quot;&quot;
    
    def __init__(self, learning_rate=0.01):
        self.w = np.random.randn()              # 权重（随机初始化）
        self.b = np.random.randn()              # 偏置
        self.lr = learning_rate                 # 学习率
        self.loss_history = []                  # 记录损失变化
    
    def predict(self, x):
        &quot;&quot;&quot;前向传播：y = w*x + b&quot;&quot;&quot;
        return self.w * x + self.b
    
    def compute_loss(self, x, y_true):
        &quot;&quot;&quot;计算均方误差损失&quot;&quot;&quot;
        y_pred = self.predict(x)
        return (y_pred - y_true) ** 2           # (预测值 - 真实值)^2
    
    def train_step(self, x, y_true):
        &quot;&quot;&quot;一步训练：计算梯度（手动求导）并更新参数&quot;&quot;&quot;
        y_pred = self.predict(x)
        # 手动计算梯度（MSE 对 w 和 b 的偏导数）
        grad_w = 2 * (y_pred - y_true) * x      # ∂loss/∂w = 2(y_pred - y_true) * x
        grad_b = 2 * (y_pred - y_true)          # ∂loss/∂b = 2(y_pred - y_true)
        # 梯度下降：参数往梯度的反方向更新
        self.w -= self.lr * grad_w
        self.b -= self.lr * grad_b
        loss = (y_pred - y_true) ** 2
        self.loss_history.append(loss)
        return loss

# 训练数据：y = 2x + 1（我们要让模型学会这条直线）
model = SimpleModel(learning_rate=0.01)
print(f&quot;\n初始参数: w={model.w:.3f}, b={model.b:.3f}&quot;)

# 训练 200 轮
for epoch in range(200):
    # 用固定数据反复训练（实际场景中会遍历数据集）
    loss = model.train_step(x=3.0, y_true=7.0)  # 3*2+1=7，所以正确答案是 7

print(f&quot;训练后参数: w={model.w:.3f}, b={model.b:.3f}&quot;)  # w≈2, b≈1
print(f&quot;预测 f(3) = {model.predict(3):.2f}&quot;)    # ≈ 7.0
print(f&quot;最终损失: {model.loss_history[-1]:.6f}&quot;)</code></pre><p><strong>什么用</strong>：方法在 AI 框架中无处不在。PyTorch 的 <code>model.forward(x)</code> 是对外接口，内部调用 <code>self.linear(x)</code> 等方法层层传递。<code>model.train()</code> 和 <code>model.eval()</code> 通过方法切换训练/推理模式。<code>optimizer.step()</code> 和 <code>optimizer.zero_grad()</code> 封装了复杂的参数更新和梯度清零逻辑——你只需要调用这两个方法，完全不用关心底层实现。这就是好方法的价值：把复杂的事情变简单。</p>
<h3>四、<code>__init__</code> 与 self——对象诞生的魔法</h3>
<p><strong>是什么</strong>：<code>__init__</code>（读作 &quot;dunder init&quot;，dunder = double underscore 双下划线）是 Python 的<strong>初始化方法</strong>。当你执行 <code>对象 = 类名()</code> 时，Python 自动做两件事：①调用 <code>__new__</code> 创建一个空对象；②调用 <code>__init__</code> 初始化这个对象。<code>self</code> 就是那个刚创建好的空对象——<code>__init__</code> 的任务是往这个空壳子里填充属性。你不需要 return self——Python 自动帮你返回。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 想象你在网上订制一件 T 恤。选款式（选择类）、选尺码颜色（传参数）、提交订单（实例化）→ 工厂拿到你的订单后：先裁剪出一件空白 T 恤（<code>__new__</code> 创建对象）、再根据你的要求印上图案和尺码标签（<code>__init__</code> 初始化属性）、最后寄给你（返回对象）。你拿到手的就是一件按你要求定制的 T 恤——每个订单参数不同，T 恤就不同。</blockquote>


<p><strong>为什么</strong>：<code>__init__</code> 是类的&quot;入口关卡&quot;——它保证了每个对象在诞生时就拥有了必要的初始状态。如果允许对象创建后再手动设置属性，很容易忘记设置某个属性，导致后续代码出错。<code>__init__</code> 强制你在创建对象时就提供必要信息，杜绝了&quot;半成品对象&quot;。在 AI 模型中，<code>__init__</code> 负责定义网络层结构——没有它，模型就是一团空气。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 银行的账户开户流程。你去柜台说&quot;我要开户&quot;——柜员不会给你一个什么都没有的空账户，而是必须先让你填姓名、身份证号、初始存款等信息，然后才能把账户给你。<code>__init__</code> 就是开户流程中的&quot;信息采集表&quot;——必须填完了才能把账户对象给你。</blockquote>


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

# ====== 1. __init__ 的自动调用——你不需要手动调 ======

class Product:
    &quot;&quot;&quot;商品类&quot;&quot;&quot;
    def __init__(self, name, price):
        print(f&quot;&gt;&gt;&gt; __init__ 被自动调用了！正在创建商品: {name}&quot;)
        self.name = name
        self.price = price

# 实例化时，Python 自动调用 __init__
p = Product(&quot;笔记本电脑&quot;, 5999)                  # 自动打印：&gt;&gt;&gt; __init__ 被自动调用了！
# 你不需要写 p.__init__(&quot;笔记本&quot;, 5999) —— Python 帮你做了

# ====== 2. __init__ 的参数控制——哪些信息必须在创建时提供 ======

class BankAccount:
    &quot;&quot;&quot;银行账户——开户时必须提供姓名和初始存款&quot;&quot;&quot;
    
    def __init__(self, owner, initial_balance=0):
        &quot;&quot;&quot;owner 必填，initial_balance 可选（默认 0）&quot;&quot;&quot;
        self.owner = owner                      # 账户持有人（必填）
        self.balance = initial_balance          # 余额（默认为 0）
        self.transactions = []                  # 交易记录（自动初始化为空列表）
        print(f&quot;开户成功：{owner}，余额 {initial_balance} 元&quot;)
    
    def deposit(self, amount):
        &quot;&quot;&quot;存款&quot;&quot;&quot;
        self.balance += amount
        self.transactions.append(f&quot;+{amount}&quot;)
        print(f&quot;{self.owner} 存入 {amount} 元，余额 {self.balance} 元&quot;)

# 开户——必须提供姓名
acc1 = BankAccount(&quot;张三&quot;, 1000)                # 开户成功：张三，余额 1000 元
acc2 = BankAccount(&quot;李四&quot;)                      # 开户成功：李四，余额 0 元（用默认值）

acc1.deposit(500)                               # 张三 存入 500 元，余额 1500 元

# ====== 3. self 的生命周期——从创建到销毁 ======

class LifecycleDemo:
    &quot;&quot;&quot;演示一个对象的完整生命周期&quot;&quot;&quot;
    
    def __init__(self, name):
        self.name = name
        print(f&quot;[生] {self.name} 诞生了！id={id(self)}&quot;)  # id() 是内存地址
    
    def work(self):
        print(f&quot;[活] {self.name} 正在工作……&quot;)
    
    def __del__(self):
        &quot;&quot;&quot;析构方法——对象被销毁时调用（不常用，Python 有垃圾回收）&quot;&quot;&quot;
        print(f&quot;[灭] {self.name} 被销毁了。&quot;)

print(&quot;\n=== 对象生命周期演示 ===&quot;)
d1 = LifecycleDemo(&quot;对象A&quot;)                     # [生] 对象A 诞生了！
d1.work()                                       # [活] 对象A 正在工作……
d2 = LifecycleDemo(&quot;对象B&quot;)                     # [生] 对象B 诞生了！
d2.work()                                       # [活] 对象B 正在工作……

# ====== 4. AI 场景：nn.Module 的 __init__ 模拟 ======

class MyLinearLayer:
    &quot;&quot;&quot;模拟 PyTorch 的 nn.Linear——理解 __init__ 在 AI 中的作用&quot;&quot;&quot;
    
    def __init__(self, in_features, out_features):
        &quot;&quot;&quot;定义层的结构——输入维度 → 输出维度&quot;&quot;&quot;
        self.in_features = in_features
        self.out_features = out_features
        # 权重矩阵 shape: (out_features, in_features)——He 初始化
        self.weight = np.random.randn(out_features, in_features) * 0.01
        # 偏置向量 shape: (out_features,)
        self.bias = np.zeros(out_features)
        print(f&quot;Linear 层: {in_features} → {out_features}, &quot;
              f&quot;weight shape={self.weight.shape}&quot;)
    
    def forward(self, x):
        &quot;&quot;&quot;前向传播：y = x @ W^T + b&quot;&quot;&quot;
        return np.dot(x, self.weight.T) + self.bias

# 创建一个将 4 维输入映射到 3 维输出的全连接层
layer = MyLinearLayer(4, 3)
# 模拟输入：batch_size=2, 特征维度=4
x = np.array([[1.0, 2.0, 3.0, 4.0],
              [5.0, 6.0, 7.0, 8.0]])
y = layer.forward(x)
print(f&quot;输入 shape: {x.shape}&quot;)
print(f&quot;输出 shape: {y.shape}&quot;)                 # (2, 3)
print(f&quot;输出:\n{y.round(3)}&quot;)</code></pre><p><strong>什么用</strong>：在 PyTorch 中，每个模型类都必须重写 <code>__init__</code> 来定义层结构。<code>super().__init__()</code> 调用父类 <code>nn.Module</code> 的 <code>__init__</code>，注册模型基础设施。<code>self.conv1 = nn.Conv2d(...)</code> 和 <code>self.fc = nn.Linear(...)</code> 都是在 <code>__init__</code> 中完成的。没有 <code>__init__</code>，模型就是一张白纸——连层都没有，根本无法训练和推理。</p>
<div class="demo-embed" data-demo-src="/demos/class-definition-demo1.html"><a href="/demos/class-definition-demo1.html">蓝图工厂——类与对象的可视化之旅（动画演示）</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>class</td><td>定义类的关键字，创建对象模板</td><td>PyTorch 模型都是 class</td><td>类型、蓝图、模板</td></tr><tr><td>对象（实例）</td><td>类实例化后的具体实体，拥有独立属性</td><td>model = ResNet() 创建模型实例</td><td>实例化、new</td></tr><tr><td><code>__init__</code></td><td>初始化方法，对象创建时自动调用</td><td>定义模型的层结构</td><td>self、构造函数</td></tr><tr><td>self</td><td>指向当前对象的引用，方法的第一个参数</td><td>方法内访问模型层和参数</td><td>实例方法、this</td></tr><tr><td>属性</td><td>对象上存储的数据变量</td><td>模型权重、偏置、超参数</td><td>实例变量、字段</td></tr><tr><td>方法</td><td>定义在类中的函数，操作对象属性</td><td>forward()、train()、eval()</td><td>成员函数、行为</td></tr><tr><td>实例化</td><td>从类创建对象的过程：<code>类名()</code></td><td>model = ModelClass(config)</td><td>构造、创建</td></tr><tr><td>组合</td><td>一个对象包含另一个对象作为属性</td><td>模型包含多个子层</td><td>聚合、has-a</td></tr></tbody></table></div>
<h2>重点答疑</h2>
<h3>Q1: <code>__init__</code> 和普通方法有什么区别？为什么它叫&quot;魔术方法&quot;？</h3>
<p><code>__init__</code> 和其他方法的本质区别在于<strong>调用时机</strong>。普通方法需要你显式调用——<code>obj.method()</code>；而 <code>__init__</code> 是 Python 在对象创建时自动调用的，你写 <code>Cat(&quot;小花&quot;, 3, &quot;白&quot;)</code> 时 Python 就自动帮你调了 <code>Cat.__init__(新对象, &quot;小花&quot;, 3, &quot;白&quot;)</code>。它被称为&quot;魔术方法&quot;（magic method / dunder method）是因为它名字两边有双下划线——Python 内部会在特定时机&quot;魔法般地&quot;调用它们。你不需要手动调用，但可以重写它们来自定义对象的行为。</p>
<h3>Q2: self 到底是形参还是实参？为什么调用方法时不需要传 self？</h3>
<p>self 在方法<strong>定义</strong>时是形参（形式参数）——它是一个占位符，表示&quot;调用该方法的那个对象&quot;。在方法<strong>调用</strong>时，你不需要传 self——Python 会自动把点号前面的对象传给 self。比如 <code>cat1.meow()</code>，Python 内部等价于 <code>Cat.meow(cat1)</code>——cat1 被当作第一个参数传给了 meow 方法。这就是为什么你在定义方法时写 <code>def meow(self):</code>，但调用时只写 <code>cat1.meow()</code>。</p>
<h3>Q3: 类的属性和普通变量有什么不同？</h3>
<p>三个关键区别：①<strong>归属不同</strong>——属性是&quot;长在对象身上&quot;的，普通变量是&quot;飘在代码里&quot;的。②<strong>生命周期不同</strong>——属性随对象存在而存在，对象不销毁属性就不消失；普通变量出了作用域就被回收。③<strong>访问方式不同</strong>——属性通过 <code>对象.属性名</code> 访问，普通变量直接用变量名。最重要的是：属性让数据有了&quot;主人&quot;，你能清楚地知道某个数据属于谁，全局变量那种谁都能改的混乱局面就消失了。</p>
<h3>Q4: 可以在 <code>__init__</code> 之外定义属性吗？</h3>
<p>技术上可以——Python 允许在任何时候给对象添加新属性（如 <code>obj.new_attr = 42</code>），但<strong>强烈不建议</strong>！在 <code>__init__</code> 之外定义属性会导致：①代码可读性极差——看 <code>__init__</code> 不知道完整的属性列表；②容易出错——某些方法可能在使用属性时它还不存在；③IDE 无法自动补全。好习惯是：所有实例属性都在 <code>__init__</code> 中声明（即使赋值为 None），保证阅读代码的人一眼看清对象有哪些属性。</p>
<h3>Q5: 一个 Python 文件可以定义多个类吗？类之间能互相引用吗？</h3>
<p>完全可以。一个 .py 文件可以定义任意多个类——这是 Python 的常见做法。比如 <code>models.py</code> 里可能同时定义 <code>Encoder</code>、<code>Decoder</code>、<code>AutoEncoder</code> 三个类。类之间也可以互相引用：一个类的方法可以接收另一个类的对象作为参数，或者用一个类创建另一个类的属性。但要注意<strong>定义顺序</strong>——如果类 A 的 <code>__init__</code> 中创建类 B 的实例，类 B 必须在前面定义。大型项目中通常每个文件只放一个核心类，保持模块化。</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>class</td><td>/klæs/</td><td>类；对象的模板/蓝图</td></tr><tr><td>object</td><td>/ˈɑːbdʒekt/</td><td>对象；类的具体实例</td></tr><tr><td>instance</td><td>/ˈɪnstəns/</td><td>实例；对象也可称作&quot;实例&quot;</td></tr><tr><td>attribute</td><td>/ˈætrɪbjuːt/</td><td>属性；对象上存储的数据变量</td></tr><tr><td>method</td><td>/ˈmeθəd/</td><td>方法；定义在类中的函数</td></tr><tr><td><strong>init</strong></td><td>/ˈdʌndər ɪˈnɪt/</td><td>初始化方法；对象创建时自动调用</td></tr><tr><td>self</td><td>/self/</td><td>指向当前对象自身的引用</td></tr><tr><td>instantiate</td><td>/ɪnˈstænʃieɪt/</td><td>实例化；从类创建对象的过程</td></tr></tbody></table></div>
<div class="quiz-raw"><h2>面试练习</h2>
<h3>Q1 [单选] 以下哪个是正确的类定义语法？</h3>
<ul>
<li>A. <code>class Dog: pass</code></li><li>B. <code>class Dog(): pass</code></li><li>C. <code>class Dog pass</code></li><li>D. <code>def Dog: pass</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。Python 用 <code>class 类名:</code> 定义类，冒号不能省略。B 中的括号是可选的（只有在继承时才需要），不是语法错误但没必要。C 和 D 语法错误——C 缺少冒号，D 用了 <code>def</code>。</blockquote>


<h3>Q2 [单选] 关于 <code>self</code>，以下说法错误的是？</h3>
<ul>
<li>A. self 必须是方法的第一个参数</li><li>B. 调用方法时不需要手动传 self</li><li>C. self 是 Python 关键字，不能用其他名字</li><li>D. self 指向调用该方法的对象本身</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 错误。self 不是 Python 关键字——它只是一个约定俗成的名字。你可以用 <code>this</code>、<code>myself</code> 等其他名字（虽然强烈不建议）。A、B、D 都是正确的。</blockquote>


<h3>Q3 [多选] 以下关于 <code>__init__</code> 的说法正确的是？</h3>
<ul>
<li>A. <code>__init__</code> 在对象创建时自动调用</li><li>B. <code>__init__</code> 可以有多个参数</li><li>C. <code>__init__</code> 中必须写 <code>self</code></li><li>D. <code>__init__</code> 必须用 return 返回 self</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 都正确。D 错误——<code>__init__</code> 不应该写 return 语句（如果写了 return 非 None 值会报 TypeError）。Python 自动返回创建好的对象，你不需要手动 return。</blockquote>


<h3>Q4 [单选] <code>class Cat: def __init__(self, name): self.name = name</code> 执行 <code>c = Cat()</code> 会怎样？</h3>
<ul>
<li>A. 创建一个名字为空的猫</li><li>B. 创建一个名字为 None 的猫</li><li>C. 报 TypeError</li><li>D. 创建一个 name 属性为 None 的猫</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。<code>__init__</code> 定义中 <code>name</code> 是必填参数（没有默认值），调用 <code>Cat()</code> 时不传参数会报 <code>TypeError: Cat.__init__() missing 1 required positional argument: &#39;name&#39;</code>。如果写成 <code>def __init__(self, name=None)</code> 则 A 正确。</blockquote>


<h3>Q5 [多选] 以下哪些是面向对象编程的优点？</h3>
<ul>
<li>A. 代码复用——一个类可以创建无数个对象</li><li>B. 逻辑清晰——数据和行为绑定在一起</li><li>C. 易于维护——修改类定义即可影响所有对象</li><li>D. 执行速度一定比面向过程快</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 是正确的 OOP 优点。D 错误——OOP 有时比面向过程慢（因为多了一层对象查找的开销），不能简单断言&quot;一定更快&quot;。但 OOP 在大型项目中的组织优势远超这点微小的性能差异。</blockquote>


<h3>Q6 [单选] 以下代码输出什么？<code>class A: x=1; a=A(); a.x=2; print(A.x)</code></h3>
<ul>
<li>A. 2</li><li>B. 1</li><li>C. 报错</li><li>D. None</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>A.x = 1</code> 设置的是类属性。<code>a.x = 2</code> 是在实例 a 上创建了同名的实例属性，不会影响类属性 <code>A.x</code>。所以 <code>A.x</code> 仍然是 1。这是类属性与实例属性的核心区别。</blockquote>


<h3>Q7 [多选] 关于对象方法，以下说法正确的是？</h3>
<ul>
<li>A. 方法的第一个参数必须是 self</li><li>B. 方法内通过 self 可以访问对象的属性</li><li>C. 方法不能调用同类中的其他方法</li><li>D. 方法调用格式为 <code>对象.方法名(参数)</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确。C 错误——方法完全可以通过 <code>self.其他方法名()</code> 调用同类中的其他方法（这是常见做法，见 <code>get_report()</code> 调用 <code>get_average()</code> 的示例）。D 正确——对象通过点号调用方法。</blockquote>


<h3>Q8 [单选] <code>__init__</code> 的名字为什么有两条下划线？</h3>
<ul>
<li>A. 只是为了看起来酷</li><li>B. 表示这是私有方法</li><li>C. 表示这是 Python 的&quot;魔术方法&quot;，有特殊含义</li><li>D. 是历史遗留问题，没有特殊原因</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。双下划线前后包围的名字（<code>__xxx__</code>）是 Python 的&quot;魔术方法&quot;命名约定——它们有特殊含意，Python 解释器会在特定时机自动调用它们。单下划线前缀（<code>_x</code>）表示&quot;受保护的&quot;，双下划线前缀（<code>__x</code>）触发名称改编机制——但前后双下划线是另一回事。</blockquote>


<h3>Q9 [多选] 关于类的实例化，以下说法正确的是？</h3>
<ul>
<li>A. <code>obj = MyClass()</code> 创建了一个 MyClass 的实例</li><li>B. 每次调用 <code>MyClass()</code> 都创建一个全新的对象</li><li>C. 可以创建多个同一类的实例</li><li>D. 一个类最多只能创建 100 个实例</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 都正确。D 错误——类没有实例数量限制（除非你自己写逻辑限制）。一个类可以创建任意多个实例——就像模具可以做出无数块饼干。</blockquote>


<h3>Q10 [单选] 在 PyTorch 中，<code>model = ResNet()</code> 执行时发生了什么？</h3>
<ul>
<li>A. 只创建了一个空对象</li><li>B. 下载预训练权重</li><li>C. 调用 ResNet 类的 <code>__init__</code> 初始化模型结构</li><li>D. 自动开始训练模型</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。<code>ResNet()</code> 是类的实例化——它调用 <code>__init__</code> 方法构建网络的所有层（卷积层、批归一化、全连接等）。A 不完全对（对象不是空的，内部结构已经建好）。B 需要额外调用 <code>pretrained=True</code> 参数。D 还需要额外的训练代码。</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": 0,
    "explanation": "A 正确。Python 用 `class 类名:` 定义类，冒号不能省略。B 中的括号是可选的（只有在继承时才需要），不是语法错误但没必要。C 和 D 语法错误——C 缺少冒号，D 用了 `def`。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 错误。self 不是 Python 关键字——它只是一个约定俗成的名字。你可以用 `this`、`myself` 等其他名字（虽然强烈不建议）。A、B、D 都是正确的。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 都正确。D 错误——`__init__` 不应该写 return 语句（如果写了 return 非 None 值会报 TypeError）。Python 自动返回创建好的对象，你不需要手动 return。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 正确。`__init__` 定义中 `name` 是必填参数（没有默认值），调用 `Cat()` 时不传参数会报 `TypeError: Cat.__init__() missing 1 required positional argument: 'name'`。如果写成 `def __init__(self, name=None)` 则 A 正确。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 是正确的 OOP 优点。D 错误——OOP 有时比面向过程慢（因为多了一层对象查找的开销），不能简单断言\"一定更快\"。但 OOP 在大型项目中的组织优势远超这点微小的性能差异。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`A.x = 1` 设置的是类属性。`a.x = 2` 是在实例 a 上创建了同名的实例属性，不会影响类属性 `A.x`。所以 `A.x` 仍然是 1。这是类属性与实例属性的核心区别。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确。C 错误——方法完全可以通过 `self.其他方法名()` 调用同类中的其他方法（这是常见做法，见 `get_report()` 调用 `get_average()` 的示例）。D 正确——对象通过点号调用方法。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 正确。双下划线前后包围的名字（`__xxx__`）是 Python 的\"魔术方法\"命名约定——它们有特殊含意，Python 解释器会在特定时机自动调用它们。单下划线前缀（`_x`）表示\"受保护的\"，双下划线前缀（`__x`）触发名称改编机制——但前后双下划线是另一回事。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 都正确。D 错误——类没有实例数量限制（除非你自己写逻辑限制）。一个类可以创建任意多个实例——就像模具可以做出无数块饼干。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 正确。`ResNet()` 是类的实例化——它调用 `__init__` 方法构建网络的所有层（卷积层、批归一化、全连接等）。A 不完全对（对象不是空的，内部结构已经建好）。B 需要额外调用 `pretrained=True` 参数。D 还需要额外的训练代码。"
  }
]</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>