<!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>Python 的类中有三种方法——<strong>实例方法</strong>、<strong>类方法</strong>（<code>@classmethod</code>）和<strong>静态方法</strong>（<code>@staticmethod</code>）。实例方法第一个参数是 <code>self</code>，操作具体对象的数据；类方法第一个参数是 <code>cls</code>，操作类本身的数据（如类属性）；静态方法没有自动传入的参数，和普通函数几乎一样，只是&quot;碰巧&quot;放在类里。在 AI 开发中，类方法常用于创建模型的工厂方法（如 <code>from_pretrained</code>），静态方法常用于工具函数（如激活函数、损失计算）。</p>
<blockquote class="highlight-box"><strong>💡 核心要点：</strong>①实例方法（<code>def method(self):</code>）操作实例数据，是最常见的方法类型 ②类方法用 <code>@classmethod</code> 装饰，第一个参数是 <code>cls</code>（代表类本身），常用来创建&quot;替代构造器&quot; ③静态方法用 <code>@staticmethod</code> 装饰，没有 <code>self</code> 或 <code>cls</code> 参数，本质上是&quot;放在类里的普通函数&quot; ④类方法和静态方法都可以通过 <code>类名.方法()</code> 或 <code>实例.方法()</code> 调用 ⑤判断标准：需要访问实例属性→实例方法，需要访问类属性或创建实例→类方法，都不需要→静态方法</blockquote>


<h2>教学与演示</h2>
<h3>一、实例方法回顾——最常见的方法类型</h3>
<p><strong>是什么</strong>：实例方法（Instance Method）是定义在类中的&quot;标准方法&quot;，第一个参数是 <code>self</code>（代表调用该方法的对象实例）。实例方法可以自由访问和修改实例属性（通过 <code>self.xxx</code>）和类属性（通过 <code>self.xxx</code> 或 <code>类名.xxx</code>）。调用时必须通过实例：<code>obj.method()</code>，Python 自动把 <code>obj</code> 传给 <code>self</code>。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 实例方法就像私人教练——每个学员（对象）有自己的教练，教练了解这个学员的所有情况（实例属性）。教练说&quot;做 10 个俯卧撑&quot;——他知道你（self）能承受的运动量是多少（因为了解你的属性），给的是个性化指导。但如果学员没来（没有实例），教练就不知道该指导谁——实例方法必须通过实例调用。</blockquote>


<p><strong>为什么</strong>：实例方法是 OOP 中使用频率最高的方法类型——90% 的方法都是实例方法。因为 OOP 的核心就是&quot;对象带着自己的数据和行为&quot;——实例方法操作对象自己的数据，这是最自然的组合。如果方法不需要访问实例属性，那也许它应该是类方法或静态方法（下一节会讲判断标准）。</p>
<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-1"><code class="language-python">import numpy as np

# ====== 1. 标准实例方法 ======

class BankAccount:
    &quot;&quot;&quot;银行账户——演示实例方法&quot;&quot;&quot;
    
    interest_rate = 0.03                        # 类属性：利率（所有账户相同）
    
    def __init__(self, owner, balance=0):
        self.owner = owner                      # 实例属性
        self.balance = balance                  # 实例属性
        self.transaction_count = 0              # 实例属性：交易次数
    
    # 实例方法——操作实例数据
    def deposit(self, amount):
        &quot;&quot;&quot;存款——修改自己的余额&quot;&quot;&quot;
        if amount &lt;= 0:
            return False
        self.balance += amount
        self.transaction_count += 1
        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:
            return False
        if amount &gt; self.balance:
            print(f&quot;{self.owner} 余额不足！&quot;)
            return False
        self.balance -= amount
        self.transaction_count += 1
        print(f&quot;{self.owner} 取出 {amount} 元，余额 {self.balance} 元&quot;)
        return True
    
    def apply_interest(self):
        &quot;&quot;&quot;计算利息——读取类属性 + 修改实例属性&quot;&quot;&quot;
        interest = self.balance * self.interest_rate
        self.balance += interest
        print(f&quot;{self.owner} 获得利息 {interest:.2f} 元，余额 {self.balance:.2f} 元&quot;)
    
    def get_info(self):
        &quot;&quot;&quot;查看信息——只读实例属性&quot;&quot;&quot;
        return f&quot;账户: {self.owner}，余额: {self.balance}，交易: {self.transaction_count} 次&quot;

# 实例方法通过实例调用
acc = BankAccount(&quot;张三&quot;, 5000)
acc.deposit(2000)                                # 张三 存入 2000 元，余额 7000 元
acc.withdraw(1000)                               # 张三 取出 1000 元，余额 6000 元
acc.apply_interest()                             # 张三 获得利息 180.00 元
print(acc.get_info())                            # 账户: 张三，余额: 6180.0，交易: 3 次

# ====== 2. 实例方法 VS 类名调用 ======

class Demo:
    def instance_method(self):
        print(f&quot;这是实例方法，self = {self}&quot;)

d = Demo()
# 常规调用：实例.方法()
d.instance_method()                              # 这是实例方法，self = &lt;__main__.Demo object at 0x...&gt;

# 底层调用：类名.方法(实例) —— 原理是一样的
Demo.instance_method(d)                          # 同样的输出！

# ====== 3. AI 场景：模型训练中的实例方法 ======

class MiniModel:
    &quot;&quot;&quot;迷你神经网络模型&quot;&quot;&quot;
    
    def __init__(self, layer_sizes):
        &quot;&quot;&quot;layer_sizes 如 [4, 8, 2] 表示 4→8→2&quot;&quot;&quot;
        self.layer_sizes = layer_sizes
        self.weights = []
        self.biases = []
        self._init_params()
    
    def _init_params(self):
        &quot;&quot;&quot;内部实例方法——初始化参数（仅 __init__ 中调用）&quot;&quot;&quot;
        for i in range(len(self.layer_sizes) - 1):
            fan_in = self.layer_sizes[i]
            fan_out = self.layer_sizes[i + 1]
            self.weights.append(np.random.randn(fan_out, fan_in) * 0.1)
            self.biases.append(np.zeros(fan_out))
    
    def forward(self, x):
        &quot;&quot;&quot;前向传播——实例方法，操作 self.weights/self.biases&quot;&quot;&quot;
        for W, b in zip(self.weights, self.biases):
            x = np.dot(x, W.T) + b
            x = np.maximum(0, x)                # ReLU
        return x
    
    def count_params(self):
        &quot;&quot;&quot;统计总参数量——只读实例方法&quot;&quot;&quot;
        return sum(W.size for W in self.weights) + sum(b.size for b in self.biases)
    
    def summary(self):
        &quot;&quot;&quot;打印模型结构——只读实例方法&quot;&quot;&quot;
        print(f&quot;\n模型结构: {' → '.join(str(s) for s in self.layer_sizes)}&quot;)
        print(f&quot;总参数量: {self.count_params()}&quot;)
        for i, (W, b) in enumerate(zip(self.weights, self.biases)):
            print(f&quot;  层 {i+1}: W{W.shape} + b{b.shape}&quot;)

model = MiniModel([4, 8, 2])
model.summary()
x = np.array([0.5, -0.3, 0.8, 1.2])
pred = model.forward(x)
print(f&quot;预测输出: {pred.round(3)}&quot;)</code></pre><p><strong>什么用</strong>：实例方法是 AI 开发中最常用的方法类型。模型的 <code>forward()</code>、<code>predict()</code>、<code>train()</code> 都是实例方法——它们操作模型自身的参数（实例属性）。优化器的 <code>step()</code>、<code>zero_grad()</code> 操作优化器自身的状态。数据集的 <code>__getitem__</code> 操作数据集实例的数据。可以说，掌握了实例方法就掌握了 90% 的 AI 代码编写。</p>
<h3>二、类方法——操作类本身的方法</h3>
<p><strong>是什么</strong>：类方法（Class Method）用 <code>@classmethod</code> 装饰器标记，第一个参数是 <code>cls</code>（代表类本身，类似 <code>self</code> 代表实例）。类方法不能直接访问实例属性（因为没有 <code>self</code>），但可以访问和修改类属性（通过 <code>cls.xxx</code>）。类方法最经典的用途是写&quot;替代构造器&quot;（Alternative Constructor）——提供除 <code>__init__</code> 之外的其他创建对象的方式。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 类方法就像公司的 HR 部门。HR 不直接生产产品（不操作实例属性），但 HR 负责招人（创建实例）、制定公司政策（修改类属性）。<code>cls</code> 就是 HR 手中的&quot;公司名册&quot;——通过公司名册可以查看公司规定（类属性）、办理入职手续（创建新员工实例）。HR 说&quot;招一个 Python 工程师&quot;——不用知道具体哪个产品小组（不需要 self），只需要按招聘流程（类方法）创建员工对象。</blockquote>


<p><strong>为什么</strong>：类方法最核心的价值是&quot;替代构造器&quot;。<code>__init__</code> 只能有一种创建对象的方式——比如 <code>Student(name, age)</code>。但如果想支持 <code>Student.from_csv(&quot;data.csv&quot;)</code>、<code>Student.from_dict({&quot;name&quot;:&quot;张三&quot;,&quot;age&quot;:20})</code>、<code>Student.random()</code> 等多种创建方式呢？这些都可以写成类方法——每个类方法提供一种创建逻辑，返回创建好的实例。Python 标准库中 <code>datetime.now()</code>、<code>dict.fromkeys()</code> 都是类方法。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 你去餐厅点菜。<code>__init__</code> 是标准菜单——&quot;宫保鸡丁，大份，28 元&quot;。但你可能想要：&quot;按套餐点&quot;（<code>Order.from_combo(&quot;双人套餐&quot;)</code>）、&quot;从外卖 App 导入&quot;（<code>Order.from_app(app_data)</code>）、&quot;按昨天的订单复制一份&quot;（<code>Order.from_yesterday()</code>）。类方法就是这些&quot;特殊点餐方式&quot;——最终都创建了订单对象，但创建逻辑各不相同。</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;
    
    school = &quot;AI 学院&quot;                          # 类属性
    
    def __init__(self, name, age, score=0):
        self.name = name
        self.age = age
        self.score = score
    
    def __repr__(self):
        return f&quot;Student({self.name}, {self.age}岁, {self.score}分)&quot;
    
    # 标准构造器：Student(&quot;张三&quot;, 20, 85)
    
    @classmethod
    def from_string(cls, info_str):
        &quot;&quot;&quot;替代构造器：从字符串创建 '张三,20,85'&quot;&quot;&quot;
        name, age, score = info_str.split(&quot;,&quot;)
        return cls(name.strip(), int(age), float(score))  # cls(...) = Student(...)
    
    @classmethod
    def from_dict(cls, data):
        &quot;&quot;&quot;替代构造器：从字典创建&quot;&quot;&quot;
        return cls(data[&quot;name&quot;], data[&quot;age&quot;], data.get(&quot;score&quot;, 0))
    
    @classmethod
    def random(cls):
        &quot;&quot;&quot;替代构造器：创建一个随机的学生&quot;&quot;&quot;
        import random
        names = [&quot;张三&quot;, &quot;李四&quot;, &quot;王五&quot;, &quot;赵六&quot;, &quot;孙七&quot;]
        return cls(
            random.choice(names),
            random.randint(18, 25),
            random.randint(50, 100)
        )
    
    @classmethod
    def change_school(cls, new_name):
        &quot;&quot;&quot;类方法修改类属性&quot;&quot;&quot;
        old = cls.school
        cls.school = new_name
        print(f&quot;学校名称更新: {old} → {new_name}&quot;)

# 多种创建方式——同一个类，不同的入口
stu1 = Student(&quot;张三&quot;, 20, 85)                  # 标准构造器
stu2 = Student.from_string(&quot;李四,21,92&quot;)        # 从字符串创建
stu3 = Student.from_dict({&quot;name&quot;: &quot;王五&quot;, &quot;age&quot;: 22, &quot;score&quot;: 78})
stu4 = Student.random()                          # 随机创建
stu5 = Student.random()

print(&quot;标准构造:&quot;, stu1)
print(&quot;字符串创建:&quot;, stu2)
print(&quot;字典创建:&quot;, stu3)
print(&quot;随机创建1:&quot;, stu4)
print(&quot;随机创建2:&quot;, stu5)

# 修改类属性
Student.change_school(&quot;AI 科技大学&quot;)             # 学校名称更新: AI 学院 → AI 科技大学
print(f&quot;\n当前学校: {Student.school}&quot;)          # AI 科技大学

# ====== 2. 类方法访问和修改类属性 ======

class Counter:
    &quot;&quot;&quot;带计数的类——用类方法管理类属性&quot;&quot;&quot;
    
    _instance_count = 0                         # 私有类属性
    
    def __init__(self):
        Counter._instance_count += 1
        self.id = Counter._instance_count
    
    @classmethod
    def get_count(cls):
        &quot;&quot;&quot;类方法：获取已创建的实例数量&quot;&quot;&quot;
        return cls._instance_count              # cls 就是 Counter
    
    @classmethod
    def reset_count(cls):
        &quot;&quot;&quot;类方法：重置计数器&quot;&quot;&quot;
        cls._instance_count = 0
        print(&quot;计数器已归零&quot;)
    
    def __repr__(self):
        return f&quot;Object(id={self.id})&quot;

c1 = Counter()
c2 = Counter()
c3 = Counter()
print(f&quot;\n已创建 {Counter.get_count()} 个对象&quot;)  # 3

Counter.reset_count()
c4 = Counter()
print(f&quot;重置后创建: {Counter.get_count()} 个&quot;)   # 1

# ====== 3. 类方法的继承——cls 指向调用时的实际类 ======

class Animal:
    species_name = &quot;动物&quot;                       # 类属性
    
    def __init__(self, name):
        self.name = name
    
    @classmethod
    def create_anonymous(cls):
        &quot;&quot;&quot;匿名创建——cls 是调用这个方法的实际类&quot;&quot;&quot;
        print(f&quot;cls = {cls.__name__}&quot;)
        return cls(f&quot;无名{cls.species_name}&quot;)   # 使用 cls 而不是硬编码 Animal
    
    @classmethod
    def get_species(cls):
        return cls.species_name

class Dog(Animal):
    species_name = &quot;狗&quot;                         # 重写类属性

class Cat(Animal):
    species_name = &quot;猫&quot;

# cls 的多态——根据调用类不同，行为也不同
anonymous_dog = Dog.create_anonymous()
# cls = Dog, 返回 Dog(&quot;无名狗&quot;)
anonymous_cat = Cat.create_anonymous()
# cls = Cat, 返回 Cat(&quot;无名猫&quot;)

print(f&quot;\n匿名狗: {anonymous_dog.name}, 种类: {Dog.get_species()}&quot;)
print(f&quot;匿名猫: {anonymous_cat.name}, 种类: {Cat.get_species()}&quot;)

# ====== 4. AI 场景：模型工厂方法 ======

class ConvNet:
    &quot;&quot;&quot;卷积神经网络——演示类方法在 AI 中的使用&quot;&quot;&quot;
    
    # 类属性：预定义的经典架构配置
    architectures = {
        &quot;tiny&quot;:   [3, 8, 16, 10],              # 输入3→8→16→输出10
        &quot;small&quot;:  [3, 16, 32, 64, 10],
        &quot;medium&quot;: [3, 32, 64, 128, 256, 10],
    }
    
    def __init__(self, channel_list):
        &quot;&quot;&quot;channel_list: 每层的通道数，如 [3, 8, 16, 10]&quot;&quot;&quot;
        self.channels = channel_list
        self.weights = self._build_weights()
    
    def _build_weights(self):
        &quot;&quot;&quot;根据通道列表构建权重&quot;&quot;&quot;
        w = []
        for i in range(len(self.channels) - 1):
            fan_out, fan_in = self.channels[i+1], self.channels[i]
            w.append(np.random.randn(fan_out, fan_in, 3, 3) * 0.01)
        return w
    
    def count_params(self):
        return int(sum(w.size for w in self.weights))
    
    def __repr__(self):
        return f&quot;ConvNet({'→'.join(str(c) for c in self.channels)}, {self.count_params():,} 参数)&quot;
    
    @classmethod
    def from_preset(cls, preset_name):
        &quot;&quot;&quot;工厂方法：按预设名称创建模型&quot;&quot;&quot;
        if preset_name not in cls.architectures:
            available = &quot;, &quot;.join(cls.architectures.keys())
            raise ValueError(f&quot;未知预设 '{preset_name}'。可选: {available}&quot;)
        return cls(cls.architectures[preset_name])
    
    @classmethod
    def from_config(cls, config_dict):
        &quot;&quot;&quot;工厂方法：从配置字典创建&quot;&quot;&quot;
        return cls(config_dict[&quot;channels&quot;])
    
    @classmethod
    def list_presets(cls):
        &quot;&quot;&quot;类方法：列出所有预设模型&quot;&quot;&quot;
        print(&quot;可用的预设模型:&quot;)
        for name, channels in cls.architectures.items():
            temp = cls(channels)
            print(f&quot;  {name:8s} — {'→'.join(str(c) for c in channels)} ({temp.count_params():,} 参数)&quot;)

# 列出所有可用预设
ConvNet.list_presets()

# 按预设创建模型——不必记住具体通道数
print(f&quot;\n创建模型:&quot;)
tiny_cnn = ConvNet.from_preset(&quot;tiny&quot;)
small_cnn = ConvNet.from_preset(&quot;small&quot;)
medium_cnn = ConvNet.from_preset(&quot;medium&quot;)

print(f&quot;  {tiny_cnn}&quot;)
print(f&quot;  {small_cnn}&quot;)
print(f&quot;  {medium_cnn}&quot;)</code></pre><p><strong>什么用</strong>：在 AI 中，类方法的&quot;替代构造器&quot;模式大量使用。PyTorch 的 <code>torch.nn.Module</code> 有 <code>load_state_dict</code>（类方法变体）、HuggingFace 的 <code>Model.from_pretrained(&quot;bert-base&quot;)</code> 是最经典的类方法——它从远程下载预训练权重、解析配置、构建模型对象，一行代码完成。PyTorch 的 <code>Dataset</code> 子类也常用类方法提供多种数据加载方式。类方法还是实现单例模式（Singleton）的标准手段。</p>
<h3>三、静态方法——放在类里的普通函数</h3>
<p><strong>是什么</strong>：静态方法（Static Method）用 <code>@staticmethod</code> 装饰器标记，它<strong>没有</strong> <code>self</code> 参数，也<strong>没有</strong> <code>cls</code> 参数——和类外的普通函数几乎一模一样。唯一的区别是：它在类的命名空间内，调用时需要用 <code>类名.方法()</code> 或 <code>实例.方法()</code>。静态方法不能直接访问实例属性或类属性（除非通过类名显式引用）。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 静态方法就像放在工具箱里的独立工具——扳手、螺丝刀、卷尺。这些工具放在工具箱（类）里只是因为&quot;和工具箱主人的工作相关&quot;（逻辑上的归属），但它们本身不依赖工具箱里的任何东西。你用扳手时不关心工具箱是谁的、里面还有什么——扳手是独立的。静态方法就是这样的&quot;独立工具函数&quot;。</blockquote>


<p><strong>为什么</strong>：为什么要把一个看起来像普通函数的代码放在类里面？三个原因：①<strong>逻辑归组</strong>——<code>MathUtils.power(x, n)</code> 比 <code>power(x, n)</code> 更能表明&quot;这是数学工具函数&quot;；②<strong>避免命名空间污染</strong>——如果把所有工具函数都放在全局，很快就会出现命名冲突；③<strong>方便导入</strong>——<code>from math_utils import MathUtils</code> 一次导入一个工具箱的所有工具。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 厨房里的盐罐放在&quot;调料区&quot;——盐是独立的（静态方法），你可以单独用它。但把它放在调料区而不是客厅或卧室，是因为&quot;做菜时你自然去调料区找&quot;。同样，激活函数 <code>relu(x)</code> 放在神经网络类里是静态方法——relu 自己不依赖模型数据，但&quot;和神经网络强相关&quot;，放在一起方便查找和使用。</blockquote>


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

# ====== 1. 基本静态方法 ======

class MathUtils:
    &quot;&quot;&quot;数学工具集合——用静态方法组织&quot;&quot;&quot;
    
    @staticmethod
    def add(a, b):
        &quot;&quot;&quot;加法——不需要 self 或 cls&quot;&quot;&quot;
        return a + b
    
    @staticmethod
    def factorial(n):
        &quot;&quot;&quot;阶乘——纯函数，不依赖任何实例/类数据&quot;&quot;&quot;
        if n &lt; 0:
            raise ValueError(&quot;阶乘不支持负数&quot;)
        result = 1
        for i in range(2, n + 1):
            result *= i
        return result
    
    @staticmethod
    def is_prime(n):
        &quot;&quot;&quot;判断是否为质数&quot;&quot;&quot;
        if n &lt; 2:
            return False
        for i in range(2, int(n ** 0.5) + 1):
            if n % i == 0:
                return False
        return True

# 通过类名调用（推荐）
print(f&quot;3 + 5 = {MathUtils.add(3, 5)}&quot;)         # 8
print(f&quot;5! = {MathUtils.factorial(5)}&quot;)         # 120
print(f&quot;17 是质数吗？{MathUtils.is_prime(17)}&quot;) # True

# 也可以通过实例调用（不推荐，但仍然有效）
utils = MathUtils()
print(f&quot;通过实例: {utils.add(1, 2)}&quot;)           # 3 —— 也能用但没意义

# ====== 2. 静态方法 vs 类方法 vs 实例方法——三者对比 ======

class MethodDemo:
    &quot;&quot;&quot;演示三种方法的区别&quot;&quot;&quot;
    
    class_attr = &quot;类属性&quot;
    
    def __init__(self, value):
        self.instance_attr = value              # 实例属性
    
    def instance_method(self):
        &quot;&quot;&quot;实例方法——有 self，可访问一切&quot;&quot;&quot;
        return f&quot;实例方法: 实例属性={self.instance_attr}, 类属性={self.class_attr}&quot;
    
    @classmethod
    def class_method(cls):
        &quot;&quot;&quot;类方法——有 cls，可访问类属性但不能访问实例属性&quot;&quot;&quot;
        return f&quot;类方法: cls={cls.__name__}, 类属性={cls.class_attr}&quot;
    
    @staticmethod
    def static_method(x, y):
        &quot;&quot;&quot;静态方法——没有 self 和 cls，不能直接访问任何属性&quot;&quot;&quot;
        return f&quot;静态方法: 不依赖任何实例或类，只是 {x} + {y} = {x + y}&quot;

obj = MethodDemo(&quot;实例数据&quot;)
print(obj.instance_method())
print(MethodDemo.class_method())                 # 可以通过类名调用
print(MethodDemo.static_method(3, 5))

# ====== 3. 静态方法的组织价值 ======

class DataValidator:
    &quot;&quot;&quot;数据验证工具——用静态方法组织验证函数&quot;&quot;&quot;
    
    @staticmethod
    def is_valid_score(score):
        &quot;&quot;&quot;验证成绩是否在有效范围&quot;&quot;&quot;
        return isinstance(score, (int, float)) and 0 &lt;= score &lt;= 100
    
    @staticmethod
    def is_valid_email(email):
        &quot;&quot;&quot;验证邮箱格式（简化版）&quot;&quot;&quot;
        return isinstance(email, str) and &quot;@&quot; in email and &quot;.&quot; in email
    
    @staticmethod
    def is_valid_age(age):
        &quot;&quot;&quot;验证年龄是否合理&quot;&quot;&quot;
        return isinstance(age, int) and 0 &lt; age &lt; 150

# 逻辑归组——所有数据验证函数集中管理
print(f&quot;\n验证工具:&quot;)
print(f&quot;  成绩 85 有效？{DataValidator.is_valid_score(85)}&quot;)    # True
print(f&quot;  成绩 -5 有效？{DataValidator.is_valid_score(-5)}&quot;)    # False
print(f&quot;  邮箱有效？{DataValidator.is_valid_email('a@b.com')}&quot;) # True
print(f&quot;  邮箱有效？{DataValidator.is_valid_email('invalid')}&quot;) # False

# ====== 4. AI 场景：激活函数和损失函数作为静态方法 ======

class NeuralUtils:
    &quot;&quot;&quot;神经网络工具函数集合——用静态方法组织&quot;&quot;&quot;
    
    @staticmethod
    def relu(x):
        &quot;&quot;&quot;ReLU 激活函数——纯数学运算&quot;&quot;&quot;
        return np.maximum(0, x)
    
    @staticmethod
    def sigmoid(x):
        &quot;&quot;&quot;Sigmoid 激活函数&quot;&quot;&quot;
        return 1 / (1 + np.exp(-np.clip(x, -500, 500)))
    
    @staticmethod
    def softmax(x):
        &quot;&quot;&quot;Softmax 函数——返回概率分布&quot;&quot;&quot;
        exp_x = np.exp(x - np.max(x))           # 减去最大值防止溢出
        return exp_x / exp_x.sum()
    
    @staticmethod
    def cross_entropy(predictions, targets):
        &quot;&quot;&quot;交叉熵损失——简化版&quot;&quot;&quot;
        epsilon = 1e-8
        pred = np.clip(predictions, epsilon, 1 - epsilon)
        return -np.sum(targets * np.log(pred))
    
    @staticmethod
    def accuracy(predictions, targets):
        &quot;&quot;&quot;计算准确率&quot;&quot;&quot;
        pred_labels = np.argmax(predictions, axis=1)
        true_labels = np.argmax(targets, axis=1)
        return np.mean(pred_labels == true_labels)

# 使用静态方法——不需要实例，直接调用
x = np.array([-2.0, -1.0, 0.0, 1.0, 2.0])
print(f&quot;\nReLU: {NeuralUtils.relu(x)}&quot;)          # [0. 0. 0. 1. 2.]
print(f&quot;Sigmoid: {NeuralUtils.sigmoid(x).round(3)}&quot;)

logits = np.array([2.0, 1.0, 0.1])              # 3 个类别的 logits
probs = NeuralUtils.softmax(logits)
print(f&quot;Softmax: {probs.round(3)}&quot;)              # [0.659 0.242 0.099]</code></pre><p><strong>什么用</strong>：在 AI 中，静态方法常用于组织工具函数。PyTorch 的 <code>torch.nn.functional</code> 模块中就是大量静态函数——<code>F.relu(x)</code>、<code>F.softmax(x)</code>、<code>F.cross_entropy(pred, target)</code>。虽然它们在模块级别（不是类内），但本质上就是静态方法的概念。在你的自定义项目中，可以把数据预处理、评估指标、可视化函数等作为静态方法组织在一个工具类中——避免全局命名空间污染，方便跨模块导入。</p>
<h3>四、如何选择——三种方法的决策树</h3>
<p><strong>是什么</strong>：面对&quot;这个方法应该写成实例方法、类方法还是静态方法&quot;的选择时，遍历一个简单的决策树即可：①需要访问或修改实例属性（<code>self.xxx</code>）？→ <strong>实例方法</strong>。②不需要实例属性，但需要访问类属性或创建本类的实例？→ <strong>类方法</strong>。③都不需要，只是一个和类主题相关的工具函数？→ <strong>静态方法</strong>。④都不需要，且和类主题无关？→ <strong>普通函数</strong>（放在类外面）。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 就像给一个工具箱分配工具：这把工具需要使用工具箱主人的私人材料（实例属性）→ 实例方法；这把工具需要使用工具箱的公共物资（类属性）或给工具箱添加新工具（创建实例）→ 类方法；这把工具是独立的，但因为&quot;做木工活&quot;所以放在木工工具箱里 → 静态方法；这把工具是个菜刀，和木工没关系 → 别放进来，放厨房去。</blockquote>


<p><strong>为什么</strong>：选择正确的方法类型直接影响代码的可读性和可维护性。错误的选择会导致：①实例方法写成静态方法 → 传参变多，调用变啰嗦；②静态方法写成实例方法 → 方法签名有没用的 <code>self</code> 参数，让读者困惑；③类方法写成实例方法 → 无法通过类名调用，逼着用户先创建实例（本末倒置）。掌握决策树，让你的 API 设计更专业。</p>
<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-4"><code class="language-python">import numpy as np

# ====== 决策树实战演练 ======

class ImageProcessor:
    &quot;&quot;&quot;图片处理器——演示三种方法的正确使用&quot;&quot;&quot;
    
    # 类属性：默认配置
    default_size = (224, 224)
    default_mean = np.array([0.485, 0.456, 0.406])
    default_std  = np.array([0.229, 0.224, 0.225])
    
    def __init__(self, image_data):
        &quot;&quot;&quot;image_data: 模拟图片的 numpy 数组 (H, W, C)&quot;&quot;&quot;
        self.data = np.array(image_data)        # 实例属性：图片数据
        self.processed = False                  # 实例属性：处理状态
    
    # ✅ 实例方法——操作 self.data
    def resize(self, size=None):
        &quot;&quot;&quot;缩放图片——修改实例属性 self.data&quot;&quot;&quot;
        target = size if size else self.default_size
        # 模拟缩放
        h, w = self.data.shape[:2]
        if h &gt; target[0] or w &gt; target[1]:
            self.data = self.data[:target[0], :target[1]]
        self.processed = True
        print(f&quot;图片已缩放到 {self.data.shape}&quot;)
        return self                              # 返回 self 支持链式调用
    
    def get_mean(self):
        &quot;&quot;&quot;计算图片均值——只读实例属性&quot;&quot;&quot;
        return self.data.mean(axis=(0, 1))
    
    # ✅ 类方法——创建实例 + 访问类属性
    @classmethod
    def from_random(cls, height=256, width=256, channels=3):
        &quot;&quot;&quot;从随机噪声创建图片——替代构造器&quot;&quot;&quot;
        random_data = np.random.rand(height, width, channels) * 255
        return cls(random_data.astype(np.uint8))  # cls(...) 创建实例
    
    @classmethod
    def get_default_transform(cls):
        &quot;&quot;&quot;获取默认的变换参数——只读类属性&quot;&quot;&quot;
        return {
            &quot;size&quot;: cls.default_size,
            &quot;mean&quot;: cls.default_mean.tolist(),
            &quot;std&quot;: cls.default_std.tolist(),
        }
    
    # ✅ 静态方法——纯工具函数
    @staticmethod
    def normalize(data, mean, std):
        &quot;&quot;&quot;标准化图片——纯计算，不依赖任何实例或类状态&quot;&quot;&quot;
        return (data - mean) / (std + 1e-8)
    
    @staticmethod
    def rgb_to_grayscale(data):
        &quot;&quot;&quot;RGB 转灰度——纯算法&quot;&quot;&quot;
        weights = np.array([0.299, 0.587, 0.114])
        return np.dot(data, weights)
    
    @staticmethod
    def is_valid_image(data):
        &quot;&quot;&quot;验证是否为有效图片数据——纯校验&quot;&quot;&quot;
        return (isinstance(data, np.ndarray) and
                data.ndim in [2, 3] and
                data.dtype in [np.uint8, np.float32, np.float64])

# === 使用演示 ===

# 标准构造
img = ImageProcessor(np.random.rand(300, 300, 3) * 255)
# 实例方法
img.resize((200, 200))
print(f&quot;图片均值: {img.get_mean().round(2)}&quot;)

# 类方法——替代构造器
random_img = ImageProcessor.from_random(128, 128)
print(f&quot;\n随机图片 size: {random_img.data.shape}&quot;)
default_config = ImageProcessor.get_default_transform()
print(f&quot;默认变换配置: {default_config}&quot;)

# 静态方法——纯工具函数
data = np.random.rand(100, 100, 3) * 255
normalized = ImageProcessor.normalize(data, 
                                       ImageProcessor.default_mean,
                                       ImageProcessor.default_std)
gray = ImageProcessor.rgb_to_grayscale(data)
print(f&quot;\n标准化后范围: [{normalized.min():.2f}, {normalized.max():.2f}]&quot;)
print(f&quot;灰度图 shape: {gray.shape}&quot;)
print(f&quot;验证有效数据: {ImageProcessor.is_valid_image(data)}&quot;)  # True

# ====== 决策树总结：一张图看清怎么选 ======

print(&quot;&quot;&quot;
=== 方法类型选择决策树 ===

需要访问/修改 self.xxx？
  ├── YES → 实例方法 (def method(self):)
  └── NO → 需要访问类属性/创建实例？
            ├── YES → 类方法 (@classmethod)
            └── NO → 和类主题相关？
                      ├── YES → 静态方法 (@staticmethod)
                      └── NO → 普通函数（放在类外面）
&quot;&quot;&quot;)</code></pre><p><strong>什么用</strong>：在 AI 项目中，方法类型的正确选择直接影响 API 的易用性。PyTorch 的设计就是决策树的完美示范：<code>model.forward(x)</code> 是实例方法（需要 self 的网络参数），<code>Dataset.from_files(path)</code> 可以是类方法（创建数据集实例），<code>F.relu(x)</code> 是静态方法（纯数学运算）。HuggingFace 的 <code>AutoModel.from_pretrained(&quot;bert-base&quot;)</code> 是最出名的类方法之一——它读取远程配置、下载权重、创建模型实例，如果不写成类方法，用户就需要手动完成这三步。</p>
<div class="demo-embed" data-demo-src="/demos/methods-class-demo1.html"><a href="/demos/methods-class-demo1.html">方法三剑客——实例方法 vs 类方法 vs 静态方法对比演示（动画演示）</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>操作实例属性，第一个参数 self</td><td>model.forward(x)、optimizer.step()</td><td>self、实例属性</td></tr><tr><td>类方法</td><td>操作类属性/创建实例，第一个参数 cls</td><td>Model.from_pretrained()</td><td>cls、替代构造器</td></tr><tr><td>静态方法</td><td>独立工具函数，无 self/cls</td><td>F.relu(x)、工具函数集合</td><td>纯函数、工具类</td></tr><tr><td>@classmethod</td><td>标记类方法的装饰器</td><td>加载预训练模型的工厂方法</td><td>@staticmethod</td></tr><tr><td>@staticmethod</td><td>标记静态方法的装饰器</td><td>激活函数、损失函数等纯计算</td><td>@classmethod</td></tr><tr><td>cls</td><td>类方法的第一个参数，代表类本身</td><td>在继承体系中指向实际调用的子类</td><td>self、类型引用</td></tr><tr><td>替代构造器</td><td>通过类方法提供除 <strong>init</strong> 外的创建方式</td><td>from_config()、from_random()</td><td>工厂方法</td></tr><tr><td>命名空间</td><td>静态方法避免全局函数名冲突</td><td>组织项目中的工具函数</td><td>模块、import</td></tr></tbody></table></div>
<h2>重点答疑</h2>
<h3>Q1: 静态方法和普通函数到底有什么区别？为什么不直接把函数写在类外面？</h3>
<p>三个区别：①<strong>命名空间</strong>——静态方法在类的命名空间内，调用时写成 <code>Utils.func()</code> 而不是 <code>func()</code>，更清晰地表达了函数归属；②<strong>导入便利</strong>——<code>from utils import Utils</code> 一次导入一组相关工具函数；③<strong>语义关联</strong>——静态方法告诉阅读代码的人&quot;这个函数和这个类强相关&quot;。但如果函数和类毫无关系——比如一个发邮件的函数放在 ImageProcessor 类里——那就应该放在类外面。判断标准是：函数是否在逻辑上属于这个类。</p>
<h3>Q2: 类方法中 <code>cls</code> 和直接写类名（如 <code>MyClass</code>）有什么区别？</h3>
<p>在单继承的简单场景下，<code>cls()</code> 和 <code>MyClass()</code> 结果一样。但在继承场景下，<code>cls</code> 才是正确的做法——<code>cls</code> 始终指向&quot;调用该方法的实际类&quot;，如果子类继承了类方法，<code>cls</code> 就是子类。举例：<code>Dog.create_anonymous()</code> 中 <code>cls = Dog</code>，而硬编码 <code>Animal(&quot;无名动物&quot;)</code> 会丢失子类信息。这就是前面 Dog 和 Cat 例子的原理——<code>cls</code> 实现了类方法的多态。</p>
<h3>Q3: 类方法和静态方法可以通过实例调用吗？</h3>
<p>都可以，但不推荐。<code>obj.class_method()</code> 和 <code>obj.static_method()</code> 在语法上完全合法——Python 会忽略实例，通过 <code>type(obj)</code> 找到类来调用。但通过实例调用会让人困惑——读代码的人会想&quot;这个方法是操作这个实例的吗？&quot;通过类名调用（<code>MyClass.method()</code>）能一目了然地传达&quot;这是类级别的方法，不操作特定实例&quot;。</p>
<h3>Q4: 在 AI 中，什么时候把方法写成 <code>@classmethod</code> 而不是 <code>@staticmethod</code>？</h3>
<p>关键看是否需要创建本类的实例或访问类属性。典型场景：①需要返回本类实例 → 类方法（如 <code>from_pretrained()</code> 返回模型实例）。②需要读取/修改类级别的配置 → 类方法。③只需要数学计算、和类实例无关 → 静态方法（如激活函数、损失函数）。如果你不确定，先从实例方法开始——如果发现方法体里完全没用到 <code>self</code>，再考虑改为类方法或静态方法。</p>
<h3>Q5: 类方法可以被继承和重写吗？</h3>
<p>可以。类方法和实例方法一样，遵循正常的继承和重写规则。子类可以继承父类的类方法，也可以重写它。当子类重写类方法时，<code>cls</code> 会指向调用时的实际子类——这就是类方法多态的基础。一个有趣的现象是：子类重写 <code>@classmethod</code> 后，它的替代构造器会自然地创建子类实例（因为 <code>cls</code> 是子类），这正是 HuggingFace 的 <code>AutoModel</code> 体系的工作原理。</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>instance method</td><td>/ˈɪnstəns ˈmeθəd/</td><td>实例方法；第一个参数为 self 的标准方法</td></tr><tr><td>classmethod</td><td>/klæs ˈmeθəd/</td><td>类方法；用 @classmethod 装饰，第一个参数为 cls</td></tr><tr><td>staticmethod</td><td>/ˈstætɪk ˈmeθəd/</td><td>静态方法；用 @staticmethod 装饰，无 self/cls</td></tr><tr><td>decorator</td><td>/ˈdekəreɪtər/</td><td>装饰器；用 @ 语法修改函数/方法的行为</td></tr><tr><td>cls</td><td>/siː el es/</td><td>类方法的第一个参数，代表类本身</td></tr><tr><td>factory method</td><td>/ˈfæktəri ˈmeθəd/</td><td>工厂方法；用于创建对象的方法（常为类方法）</td></tr><tr><td>alternative constructor</td><td>/ɔːlˈtɜːrnətɪv kənˈstrʌktər/</td><td>替代构造器；除 <strong>init</strong> 外的对象创建方式</td></tr><tr><td>namespace</td><td>/ˈneɪmspeɪs/</td><td>命名空间；静态方法避免全局名称冲突的机制</td></tr></tbody></table></div>
<div class="quiz-raw"><h2>面试练习</h2>
<h3>Q1 [单选] <code>@classmethod</code> 装饰的方法，第一个参数叫什么？</h3>
<ul>
<li>A. self</li><li>B. cls</li><li>C. this</li><li>D. obj</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。类方法的第一个参数约定命名为 <code>cls</code>（class 的缩写），代表类本身。就像实例方法的第一个参数约定命名为 <code>self</code>。</blockquote>


<h3>Q2 [多选] 关于 <code>@staticmethod</code>，以下说法正确的是？</h3>
<ul>
<li>A. 静态方法没有 self 参数</li><li>B. 静态方法没有 cls 参数</li><li>C. 可以通过类名直接调用静态方法</li><li>D. 静态方法可以访问实例属性</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 正确。D 错误——静态方法不能直接访问实例属性（因为没有 self），也不能直接访问类属性（除非通过类名显式引用）。</blockquote>


<h3>Q3 [单选] 以下哪个最适合写成类方法？</h3>
<ul>
<li>A. 计算两个数的和</li><li>B. 修改对象的名字属性</li><li>C. 从 JSON 文件加载数据并创建对象</li><li>D. 判断一个数是否为偶数</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。&quot;从 JSON 文件加载数据并创建对象&quot;是替代构造器的经典场景，最适合写成类方法（<code>MyClass.from_json(&quot;data.json&quot;)</code>）。A 和 D 是纯工具函数，适合静态方法或普通函数。B 操作实例属性，适合实例方法。</blockquote>


<h3>Q4 [单选] <code>class A: @classmethod def f(cls): return cls.__name__; class B(A): pass; print(B.f())</code> 输出什么？</h3>
<ul>
<li>A. B</li><li>B. A</li><li>C. 报错</li><li>D. None</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。类方法中 <code>cls</code> 指向&quot;调用时实际使用的类&quot;。<code>B.f()</code> 中 <code>cls = B</code>，所以 <code>cls.__name__</code> 是 <code>&#39;B&#39;</code>。继承的类方法中 cls 会指向子类——这就是类方法的多态。</blockquote>


<h3>Q5 [多选] 以下哪些场景适合使用 <code>@staticmethod</code>？</h3>
<ul>
<li>A. 一个和类主题相关的数学工具函数（如激活函数）</li><li>B. 数据验证函数（如 is_valid_email）</li><li>C. 需要读取实例属性的配置解析函数</li><li>D. 一组不依赖类状态的辅助计算函数</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 都适合静态方法。C 错误——需要读取实例属性就必须用实例方法，静态方法无法访问实例属性。</blockquote>


<h3>Q6 [单选] 以下关于三种方法的调用方式，正确的是？</h3>
<ul>
<li>A. 实例方法可以通过类名直接调用</li><li>B. 类方法必须通过实例调用</li><li>C. 静态方法不能通过实例调用</li><li>D. 三种方法都可以通过实例调用（实例方法只能通过实例）</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>D 正确。实例方法只能通过实例调用（<code>obj.method()</code>）；类方法和静态方法既可以通过类名（<code>Cls.method()</code>）也可以通过实例（<code>obj.method()</code>）调用。A 错误——实例方法通过类名调用需要手动传实例。</blockquote>


<h3>Q7 [多选] 类方法 <code>@classmethod</code> 可以做什么？</h3>
<ul>
<li>A. 访问和修改类属性</li><li>B. 创建本类的实例</li><li>C. 被子类继承和重写</li><li>D. 直接访问实例属性（self.xxx）</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 都正确。D 错误——类方法没有 self 参数，不能直接访问实例属性。但可以通过 cls 创建实例后再访问实例属性。</blockquote>


<h3>Q8 [单选] HuggingFace 的 <code>AutoModel.from_pretrained(&quot;bert-base&quot;)</code> 是什么类型的方法？</h3>
<ul>
<li>A. 实例方法</li><li>B. 类方法</li><li>C. 静态方法</li><li>D. 普通函数</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>from_pretrained</code> 是典型的类方法——它读取预训练配置、下载权重、创建并返回新的模型实例。不需要先有实例才能调用（因为没有 self），返回的是本类的实例。</blockquote>


<h3>Q9 [单选] 以下代码中 <code>method2</code> 是什么类型？<code>class A: @staticmethod def method1(): pass; @classmethod def method2(cls): pass</code></h3>
<ul>
<li>A. 实例方法</li><li>B. 类方法</li><li>C. 静态方法</li><li>D. 普通函数</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>@classmethod</code> 装饰器将 <code>method2</code> 标记为类方法，第一个参数 <code>cls</code> 代表类本身。</blockquote>


<h3>Q10 [多选] 关于装饰器在方法类型中的作用，以下说法正确的是？</h3>
<ul>
<li>A. <code>@classmethod</code> 让 Python 自动把类（而不是实例）作为第一个参数传入</li><li>B. <code>@staticmethod</code> 告诉 Python &quot;不要自动传入任何东西&quot;</li><li>C. 没有装饰器的普通方法默认是静态方法</li><li>D. 装饰器的语法糖 <code>@decorator</code> 等价于 <code>method = decorator(method)</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 都正确。C 错误——没有装饰器的普通方法默认是实例方法（Python 会自动传入 self）。<code>@staticmethod</code> 正是用来&quot;阻止&quot;这种自动传入行为的。</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": 1,
    "explanation": "B 正确。类方法的第一个参数约定命名为 `cls`（class 的缩写），代表类本身。就像实例方法的第一个参数约定命名为 `self`。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 正确。D 错误——静态方法不能直接访问实例属性（因为没有 self），也不能直接访问类属性（除非通过类名显式引用）。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 正确。\"从 JSON 文件加载数据并创建对象\"是替代构造器的经典场景，最适合写成类方法（`MyClass.from_json(\"data.json\")`）。A 和 D 是纯工具函数，适合静态方法或普通函数。B 操作实例属性，适合实例方法。"
  },
  {
    "type": "single",
    "answer": 0,
    "explanation": "A 正确。类方法中 `cls` 指向\"调用时实际使用的类\"。`B.f()` 中 `cls = B`，所以 `cls.__name__` 是 `'B'`。继承的类方法中 cls 会指向子类——这就是类方法的多态。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 都适合静态方法。C 错误——需要读取实例属性就必须用实例方法，静态方法无法访问实例属性。"
  },
  {
    "type": "single",
    "answer": 3,
    "explanation": "D 正确。实例方法只能通过实例调用（`obj.method()`）；类方法和静态方法既可以通过类名（`Cls.method()`）也可以通过实例（`obj.method()`）调用。A 错误——实例方法通过类名调用需要手动传实例。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 都正确。D 错误——类方法没有 self 参数，不能直接访问实例属性。但可以通过 cls 创建实例后再访问实例属性。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`from_pretrained` 是典型的类方法——它读取预训练配置、下载权重、创建并返回新的模型实例。不需要先有实例才能调用（因为没有 self），返回的是本类的实例。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`@classmethod` 装饰器将 `method2` 标记为类方法，第一个参数 `cls` 代表类本身。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 都正确。C 错误——没有装饰器的普通方法默认是实例方法（Python 会自动传入 self）。`@staticmethod` 正是用来\"阻止\"这种自动传入行为的。"
  }
]</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>