<!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="深入讲解魔术方法__init____str____repr__等的核心内容与关键技术，属于Python编程基础的面向对象编程（OOP）方向">
<title>魔术方法：__init__、__str__、__repr__等 面向对象编程（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>魔术方法：__init__、__str__、__repr__等</h1><div class="divider"></div>

<h2>一句话概述</h2>
<p>魔术方法（Magic Methods / Dunder Methods）是 Python 中以双下划线开头和结尾的特殊方法——它们不直接调用，而是在特定时机被 Python 解释器&quot;魔法般地&quot;自动触发。<code>__init__</code> 在对象创建时调用，<code>__str__</code> 在 <code>print()</code> 时调用，<code>__repr__</code> 在交互式环境中显示对象时调用，<code>__len__</code> 在 <code>len()</code> 时调用，<code>__getitem__</code> 在 <code>[]</code> 索引时调用，<code>__call__</code> 让实例能像函数一样被调用。掌握魔术方法，你就掌握了 Python 面向对象编程的终极武器。</p>
<blockquote class="highlight-box"><strong>💡 核心要点：</strong>①魔术方法以双下划线开头和结尾（如 <code>__init__</code>），由 Python 解释器在特定时机自动调用，不要手动调用它们 ②<code>__init__(self, ...)</code> 是初始化方法，<code>__new__(cls, ...)</code> 是构造方法（更底层） ③<code>__str__</code> 给用户看（<code>print()</code>、<code>str()</code>），<code>__repr__</code> 给开发者看（交互式环境、调试），优先实现 <code>__repr__</code> ④<code>__len__</code> 和 <code>__getitem__</code> 让你的对象支持 <code>len()</code> 和 <code>[]</code> 索引，像内置容器一样使用 ⑤<code>__call__</code> 让实例变成&quot;可调用对象&quot;，在 AI 中 <code>model(x)</code> 就是靠它实现的</blockquote>


<h2>教学与演示</h2>
<h3>一、<code>__str__</code> 与 <code>__repr__</code>——让对象会说话</h3>
<p><strong>是什么</strong>：<code>__str__</code> 和 <code>__repr__</code> 是控制对象&quot;字符串表示&quot;的两个魔术方法。<code>__str__</code> 面向用户，追求可读性——<code>print(obj)</code> 和 <code>str(obj)</code> 调用它，返回的信息应该是友好的、人类易读的。<code>__repr__</code> 面向开发者，追求明确性——在交互式环境中直接输入对象名、使用 <code>repr(obj)</code> 时调用它，理想情况下返回的字符串应该是一个有效的 Python 表达式，能用于重建对象。</p>
<blockquote class="plain-explain"><strong>大白话</strong> <code>__str__</code> 和 <code>__repr__</code> 的区别就像&quot;自我介绍&quot;和&quot;身份证号&quot;。向陌生人介绍自己，你会说&quot;我叫张三，今年25岁，是程序员&quot;（<code>__str__</code>——友好、人性化）。去医院挂号，护士要的是&quot;身份证号 110101200001010000&quot;（<code>__repr__</code>——精确、结构化）。两者都有用，但场合不同。如果你只实现一个，优先实现 <code>__repr__</code>——Python 在找不到 <code>__str__</code> 时会退而求其次用 <code>__repr__</code>。</blockquote>


<p><strong>为什么</strong>：没有 <code>__str__</code> 和 <code>__repr__</code> 的对象，打印出来是这个鬼样子：<code>&lt;__main__.Dog object at 0x7f8b3c0d4a90&gt;</code>——除了告诉你它是一个 Dog 对象、在内存的某个地址，没有任何有用信息。每次调试都要手动 <code>print(dog.name, dog.age)</code>？太累了。实现这两个方法后，直接 <code>print(dog)</code> 就能看到&quot;旺财，3岁，金毛&quot;——调试效率飙升。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 假设你要调试一个包含 100 个学生对象的列表。没实现 <code>__repr__</code>：你 <code>print(students)</code> 得到 100 个 <code>&lt;__main__.Student object at 0x...&gt;</code>——完全没用，想哭。实现了：<code>[Student(张三,85), Student(李四,92), ...]</code>——一眼看清所有数据，调试速度快 10 倍。</blockquote>


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

# ====== 1. 没有 __str__ / __repr__ 的痛苦 ======

class BadDog:
    &quot;&quot;&quot;没有实现字符串方法的类&quot;&quot;&quot;
    def __init__(self, name, age):
        self.name = name
        self.age = age

bad = BadDog(&quot;旺财&quot;, 3)
print(&quot;没实现 __str__：&quot;, bad)                   # &lt;__main__.BadDog object at 0x...&gt;
print(&quot;没实现 __repr__：&quot;, repr(bad))            # &lt;__main__.BadDog object at 0x...&gt;
# 两个都输出一样难看的默认格式——完全不知道对象里面有什么

# ====== 2. 实现 __str__ 和 __repr__ ======

class GoodDog:
    &quot;&quot;&quot;实现了字符串方法的类&quot;&quot;&quot;
    
    def __init__(self, name, age, breed):
        self.name = name
        self.age = age
        self.breed = breed
    
    def __str__(self):
        &quot;&quot;&quot;给用户看的——友好、人性化&quot;&quot;&quot;
        return f&quot;🐶 {self.name}，{self.age} 岁的 {self.breed}&quot;
    
    def __repr__(self):
        &quot;&quot;&quot;给开发者看的——精确、可用于重建对象&quot;&quot;&quot;
        return f&quot;GoodDog(name='{self.name}', age={self.age}, breed='{self.breed}')&quot;

dog = GoodDog(&quot;旺财&quot;, 3, &quot;金毛&quot;)
print(f&quot;print(dog):  {dog}&quot;)                     # 🐶 旺财，3 岁的 金毛 —— 友好！
print(f&quot;repr(dog):   {repr(dog)}&quot;)               # GoodDog(name='旺财', age=3, breed='金毛')
print(f&quot;str(dog):    {str(dog)}&quot;)                # 🐶 旺财，3 岁的 金毛

# 在列表中也各自发挥作用
dogs = [GoodDog(&quot;旺财&quot;, 3, &quot;金毛&quot;), GoodDog(&quot;小白&quot;, 1, &quot;萨摩耶&quot;)]
print(f&quot;\nprint(列表):  {dogs}&quot;)                 # 列表中每个元素用 __repr__
# 输出：[GoodDog(name='旺财', age=3, breed='金毛'), GoodDog(name='小白', age=1, breed='萨摩耶')]

for d in dogs:
    print(f&quot;遍历 print:  {d}&quot;)                   # 遍历时直接 print 用 __str__

# ====== 3. 如果只实现了 __repr__ —— Python 的兜底机制 ======

class ReprOnly:
    &quot;&quot;&quot;只实现了 __repr__&quot;&quot;&quot;
    def __init__(self, value):
        self.value = value
    
    def __repr__(self):
        return f&quot;ReprOnly({self.value})&quot;
    
    # 没有 __str__ —— Python 会找 __repr__ 来兜底

r = ReprOnly(42)
print(f&quot;只实现 __repr__: {r}&quot;)                   # ReprOnly(42) —— 用 __repr__ 兜底

# ====== 4. AI 场景：模型层对象的友好打印 ======

class DenseLayer:
    &quot;&quot;&quot;全连接层——类似 PyTorch 的 nn.Linear&quot;&quot;&quot;
    
    def __init__(self, in_features, out_features, activation=&quot;relu&quot;):
        self.in_features = in_features
        self.out_features = out_features
        self.activation = activation
        # 随机初始化参数
        self.W = np.random.randn(out_features, in_features) * 0.01
        self.b = np.zeros(out_features)
    
    def __str__(self):
        &quot;&quot;&quot;用户友好的打印&quot;&quot;&quot;
        return (f&quot;Dense({self.in_features} → {self.out_features}, &quot;
                f&quot;激活={self.activation}, 参数={self.count_params():,})&quot;)
    
    def __repr__(self):
        &quot;&quot;&quot;开发者精确的打印——可以直接复制重建对象&quot;&quot;&quot;
        return (f&quot;DenseLayer(in_features={self.in_features}, &quot;
                f&quot;out_features={self.out_features}, &quot;
                f&quot;activation='{self.activation}')&quot;)
    
    def count_params(self):
        &quot;&quot;&quot;计算参数量&quot;&quot;&quot;
        return self.W.size + self.b.size

# 构建一个简单的网络
layers = [
    DenseLayer(784, 256, &quot;relu&quot;),
    DenseLayer(256, 128, &quot;relu&quot;),
    DenseLayer(128, 10, &quot;softmax&quot;),
]

print(&quot;\n=== 模型结构 ===&quot;)
for layer in layers:
    print(f&quot;  {layer}&quot;)                          # 自动调用 __str__
    
total_params = sum(l.count_params() for l in layers)
print(f&quot;  总参数量: {total_params:,}&quot;)

print(f&quot;\n=== 层定义（可用代码重建）===&quot;)
for layer in layers:
    print(f&quot;  {repr(layer)}&quot;)                    # __repr__ 可用于重建</code></pre><p><strong>什么用</strong>：在 AI 开发中，好的 <code>__repr__</code> 是调试利器。PyTorch 的 <code>nn.Linear</code> 打印出来是 <code>Linear(in_features=10, out_features=5, bias=True)</code>——一眼看清结构。<code>nn.Sequential</code> 打印出完整的层列表。当你在 Jupyter Notebook 中调试模型时，输入 <code>model</code> 就能看到整个网络架构，不需要额外写代码。scikit-learn 的模型打印会显示所有超参数——<code>LogisticRegression(C=1.0, penalty=&#39;l2&#39;)</code>。这些都是 <code>__repr__</code> 的功劳。</p>
<h3>二、<code>__len__</code> 与 <code>__getitem__</code>——让你的对象像列表一样工作</h3>
<p><strong>是什么</strong>：<code>__len__(self)</code> 在调用 <code>len(obj)</code> 时触发，返回对象的&quot;长度&quot;（一个非负整数）。<code>__getitem__(self, index)</code> 在使用 <code>obj[index]</code> 索引访问时触发，<code>index</code> 可以是整数（如 <code>obj[3]</code>）、切片（如 <code>obj[1:5]</code>）或其他可哈希的类型。实现了这两个方法，你的自定义对象就能像 Python 内置的列表、字典一样使用了。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 想象你的类是一个&quot;智能书架&quot;。<code>__len__</code> 就是回答&quot;书架上现在有多少本书&quot;，<code>__getitem__</code> 就是&quot;按编号取书&quot;——你告诉它&quot;要第 3 本&quot;，它就把第 3 本书递给你。实现之后，<code>len(shelf)</code>、<code>shelf[3]</code>、<code>for book in shelf:</code> 这些操作全部自动可用——你的对象从此像一个真正的容器。</blockquote>


<p><strong>为什么</strong>：这两个方法让你自定义的类能融入 Python 的&quot;容器生态系统&quot;。好处：①可以用 <code>len(obj)</code> 而不是 <code>obj.size()</code>——统一接口；②支持 <code>for item in obj:</code> 迭代——不需要写额外的迭代器；③支持切片 <code>obj[2:5]</code>——Python 自动处理切片逻辑；④可以和任何期望&quot;序列类型&quot;的代码无缝协作——比如 <code>random.choice(obj)</code>、<code>max(obj)</code> 等。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 就像 USB 接口——所有 USB 设备（U 盘、鼠标、键盘、打印机）都遵循同一套标准接口，电脑不需要知道具体是什么设备，只要符合标准就能用。<code>__len__</code> 和 <code>__getitem__</code> 就是 Python 容器的&quot;USB 接口标准&quot;——任何实现了它们的类，Python 的 <code>for</code> 循环、<code>in</code> 操作符、切片语法都会自动识别并使用。</blockquote>


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

# ====== 1. 实现自定义的可索引数据集 ======

class SimpleDataset:
    &quot;&quot;&quot;模拟一个简单的数据集——像列表一样用&quot;&quot;&quot;
    
    def __init__(self, data):
        &quot;&quot;&quot;data 是一个列表或 numpy 数组&quot;&quot;&quot;
        self.data = list(data)                  # 内部用列表存储
    
    def __len__(self):
        &quot;&quot;&quot;返回数据集的大小&quot;&quot;&quot;
        return len(self.data)
    
    def __getitem__(self, index):
        &quot;&quot;&quot;支持索引访问——包括整数索引和切片&quot;&quot;&quot;
        if isinstance(index, slice):
            # 切片处理——返回一个新的 SimpleDataset
            return SimpleDataset(self.data[index])
        # 单个索引——返回具体数据
        return self.data[index]
    
    def __repr__(self):
        return f&quot;SimpleDataset(size={len(self)}, data={self.data[:3]}...)&quot;

# 创建数据集
ds = SimpleDataset([10, 20, 30, 40, 50, 60, 70, 80])

print(f&quot;数据集大小: {len(ds)}&quot;)                  # 8 —— 自动调用 __len__
print(f&quot;第 0 个元素: {ds[0]}&quot;)                  # 10 —— 自动调用 __getitem__
print(f&quot;第 3 个元素: {ds[3]}&quot;)                  # 40
print(f&quot;最后一个: {ds[-1]}&quot;)                    # 80 —— 负索引也能用！

# 切片
print(f&quot;\n切片 [2:5]: {ds[2:5]}&quot;)               # SimpleDataset(size=3, ...)

# 支持 for 循环（因为实现了 __len__ 和 __getitem__）
print(f&quot;\n遍历数据集:&quot;)
for i, item in enumerate(ds):
    if i &gt;= 5:                                  # 只展示前 5 个
        print(&quot;  ...&quot;)
        break
    print(f&quot;  ds[{i}] = {item}&quot;)

# ====== 2. 用 numpy 实现的数据集（AI 常用模式） ======

class NumpyDataset:
    &quot;&quot;&quot;基于 numpy 的数值数据集——AI 中最常见的模式&quot;&quot;&quot;
    
    def __init__(self, X, y=None):
        &quot;&quot;&quot;X 是特征矩阵，y 是可选的标签向量&quot;&quot;&quot;
        self.X = np.asarray(X)                  # 统一转成 numpy 数组
        self.y = np.asarray(y) if y is not None else None
        # 确保 X 和 y 的样本数一致
        if self.y is not None:
            assert len(self.X) == len(self.y), &quot;特征和标签的样本数不一致！&quot;
    
    def __len__(self):
        &quot;&quot;&quot;返回样本数量&quot;&quot;&quot;
        return len(self.X)
    
    def __getitem__(self, index):
        &quot;&quot;&quot;返回 (特征, 标签) 元组&quot;&quot;&quot;
        x = self.X[index]
        if self.y is not None:
            return x, self.y[index]             # 返回 (特征, 标签)
        return x                                # 无标签时只返回特征
    
    def __repr__(self):
        n_features = self.X.shape[1] if self.X.ndim &gt; 1 else 1
        label_str = f&quot;, labels={len(self.y)}&quot; if self.y is not None else &quot;&quot;
        return f&quot;NumpyDataset(samples={len(self)}{label_str}, features={n_features})&quot;

# 创建训练数据
np.random.seed(42)
X = np.random.randn(100, 5)                     # 100 个样本，每个 5 个特征
y = np.random.randint(0, 3, 100)                # 3 分类标签

dataset = NumpyDataset(X, y)
print(f&quot;\n{dataset}&quot;)                            # NumpyDataset(samples=100, labels=100, features=5)

# 像列表一样索引
sample_0 = dataset[0]
print(f&quot;第 0 个样本: 特征={sample_0[0].round(2)}, 标签={sample_0[1]}&quot;)

# 切片获取多个样本
batch = dataset[5:10]                           # 获取 5 个样本
print(f&quot;\nBatch 大小: {len(batch)}&quot;)
for idx, (feat, lbl) in enumerate(batch):
    print(f&quot;  样本 {5+idx}: 标签={lbl}, 特征和={feat.sum():.2f}&quot;)

# ====== 3. 实现类字典行为——__getitem__ + 自定义 key ======

class LabeledDataset:
    &quot;&quot;&quot;按标签名索引的数据集&quot;&quot;&quot;
    
    def __init__(self, data_dict):
        self._data = data_dict
    
    def __len__(self):
        return len(self._data)
    
    def __getitem__(self, key):
        &quot;&quot;&quot;支持整数索引和标签名索引&quot;&quot;&quot;
        if isinstance(key, str):
            return self._data[key]              # 按标签名查找
        if isinstance(key, int):
            keys = list(self._data.keys())
            return self._data[keys[key]]        # 按位置查找
        raise TypeError(f&quot;索引类型不支持: {type(key)}&quot;)
    
    def keys(self):
        return self._data.keys()

# 创建按标签索引的数据集
labeled = LabeledDataset({
    &quot;猫&quot;: [1, 2, 3],
    &quot;狗&quot;: [4, 5, 6, 7],
    &quot;鸟&quot;: [8, 9],
})

print(f&quot;\n按标签索引: 猫={labeled['猫']}&quot;)       # [1, 2, 3]
print(f&quot;按位置索引: [0]={labeled[0]}&quot;)           # [1, 2, 3]
print(f&quot;总类别数: {len(labeled)}&quot;)               # 3</code></pre><p><strong>什么用</strong>：在 AI 开发中，<code>__len__</code> 和 <code>__getitem__</code> 是 PyTorch <code>Dataset</code> 类的核心要求。任何自定义数据集必须实现这两个方法——<code>__len__</code> 告诉 DataLoader 有多少数据，<code>__getitem__</code> 让 DataLoader 能按索引取样本。PyTorch 的 <code>DataLoader</code> 内部就是通过 <code>len(dataset)</code> 和 <code>dataset[idx]</code> 来工作的——它不关心你的数据是从文件读的、从数据库查的还是实时生成的，只要实现了这两个方法就行。</p>
<h3>三、<code>__call__</code>——把对象变成可调用的&quot;函数&quot;</h3>
<p><strong>是什么</strong>：<code>__call__(self, ...)</code> 是最酷的魔术方法之一——它让类的实例可以像函数一样被调用：<code>obj()</code>。当你写 <code>model(x)</code> 时，Python 在后台调用的是 <code>model.__call__(x)</code>。<code>__call__</code> 让对象不再是静态的数据容器，而是一个可以&quot;执行&quot;的活动体。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 想象你的类是一只训练有素的警犬。警犬不仅是&quot;一只狗&quot;（有名字、品种等属性），更重要的是——你喊一声&quot;搜！&quot;，它就开始执行搜救任务。<code>__call__</code> 就是让对象响应&quot;搜！&quot;这个命令的能力。你不需要调用 <code>dog.search()</code>，直接 <code>dog()</code> 就行——简洁、直观。</blockquote>


<p><strong>为什么</strong>：<code>__call__</code> 让面向对象和函数式编程无缝结合。在很多场景下，你有一个对象需要&quot;执行一个主要的操作&quot;——比如模型的前向传播、数据预处理器的转换、回调函数的触发。把主要操作放在 <code>__call__</code> 中，对象的使用体验就像一个函数一样自然。更重要的是——任何期望函数的地方都可以传入实现了 <code>__call__</code> 的对象，这就是&quot;可调用对象&quot;模式。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 就像外卖——你点餐时不需要关心厨房里的厨师是真人还是机器人。只要它能做菜（有 <code>__call__</code>），你就可以&quot;调用&quot;它做出菜来。AI 中的 <code>model(x)</code> 就是这样——你不在乎 model 是 ResNet 还是 Transformer，只要它能接收输入返回输出就行。这就是统一接口的优雅。</blockquote>


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

# ====== 1. 基本的 __call__ ——计数器 ======

class Counter:
    &quot;&quot;&quot;每次调用计数器加 1&quot;&quot;&quot;
    def __init__(self):
        self.count = 0
    
    def __call__(self):
        &quot;&quot;&quot;调用对象就像调用函数&quot;&quot;&quot;
        self.count += 1
        return self.count

counter = Counter()
print(f&quot;调用 1 次: {counter()}&quot;)                # 1
print(f&quot;调用 2 次: {counter()}&quot;)                # 2
print(f&quot;调用 3 次: {counter()}&quot;)                # 3

# ====== 2. 带参数的 __call__ ——可配置的函数对象 ======

class Polynomial:
    &quot;&quot;&quot;多项式函数：f(x) = a_n * x^n + ... + a_1 * x + a_0&quot;&quot;&quot;
    
    def __init__(self, *coefficients):
        &quot;&quot;&quot;系数从高次到低次传入&quot;&quot;&quot;
        self.coeffs = coefficients
        self.degree = len(coefficients) - 1
    
    def __call__(self, x):
        &quot;&quot;&quot;计算多项式的值&quot;&quot;&quot;
        result = 0
        for power, coeff in enumerate(reversed(self.coeffs)):
            result += coeff * (x ** power)
        return result
    
    def __repr__(self):
        terms = []
        for power, coeff in enumerate(reversed(self.coeffs)):
            if coeff == 0:
                continue
            if power == 0:
                terms.append(f&quot;{coeff}&quot;)
            elif power == 1:
                terms.append(f&quot;{coeff}x&quot;)
            else:
                terms.append(f&quot;{coeff}x^{power}&quot;)
        return &quot;f(x) = &quot; + &quot; + &quot;.join(reversed(terms))

# f(x) = 2x^2 + 3x + 1
f = Polynomial(2, 3, 1)
print(f&quot;\n{repr(f)}&quot;)
print(f&quot;f(0) = {f(0)}&quot;)                         # 1
print(f&quot;f(2) = {f(2)}&quot;)                         # 2*4 + 3*2 + 1 = 15
print(f&quot;f(-1) = {f(-1)}&quot;)                       # 2 - 3 + 1 = 0

# ====== 3. __call__ 保持状态——有记忆的函数对象 ======

class RunningMean:
    &quot;&quot;&quot;计算序列的移动平均值——记住历史数据&quot;&quot;&quot;
    
    def __init__(self, window_size=3):
        self.window = window_size
        self.history = []                       # 保存最近 window_size 个值
    
    def __call__(self, x):
        &quot;&quot;&quot;加入新值，返回当前窗口的平均值&quot;&quot;&quot;
        self.history.append(x)
        if len(self.history) &gt; self.window:
            self.history.pop(0)                 # 移除最旧的值
        return sum(self.history) / len(self.history)

rm = RunningMean(window_size=3)
data = [10, 20, 30, 40, 50, 60]
print(f&quot;\n移动平均（窗口大小=3）:&quot;)
for val in data:
    avg = rm(val)
    print(f&quot;  输入 {val} → 移动平均 = {avg:.1f}&quot;)

# ====== 4. AI 场景：可调用的模型和数据处理器 ======

class ReLU:
    &quot;&quot;&quot;ReLU 激活函数——可调用对象&quot;&quot;&quot;
    def __call__(self, x):
        return np.maximum(0, x)
    
    def __repr__(self):
        return &quot;ReLU()&quot;

class Sigmoid:
    &quot;&quot;&quot;Sigmoid 激活函数——可调用对象&quot;&quot;&quot;
    def __call__(self, x):
        return 1 / (1 + np.exp(-np.clip(x, -500, 500)))  # clip 防溢出
    
    def __repr__(self):
        return &quot;Sigmoid()&quot;

class NeuralLayer:
    &quot;&quot;&quot;模拟一层神经网络——__call__ 执行前向传播&quot;&quot;&quot;
    
    def __init__(self, in_dim, out_dim, activation=None):
        self.W = np.random.randn(out_dim, in_dim) * 0.1
        self.b = np.zeros(out_dim)
        self.activation = activation            # 激活函数（也是可调用对象！）
    
    def __call__(self, x):
        &quot;&quot;&quot;前向传播——对象可以像函数一样调用&quot;&quot;&quot;
        z = np.dot(x, self.W.T) + self.b        # 线性变换
        if self.activation:
            z = self.activation(z)              # 多态调用激活函数
        return z
    
    def __repr__(self):
        return f&quot;NeuralLayer(W{self.W.shape}, act={self.activation})&quot;

# 构建 2 层网络
layer1 = NeuralLayer(4, 8, activation=ReLU())
layer2 = NeuralLayer(8, 3, activation=Sigmoid())

print(f&quot;\n=== 两层神经网络 ===&quot;)
print(f&quot;Layer 1: {layer1}&quot;)
print(f&quot;Layer 2: {layer2}&quot;)

# 前向传播——像函数调用一样自然
x = np.array([0.5, -0.3, 0.8, 1.2])
h = layer1(x)                                   # 第一层：线性 + ReLU
y = layer2(h)                                   # 第二层：线性 + Sigmoid
print(f&quot;输入: {x}&quot;)
print(f&quot;隐藏层: {h.round(3)}&quot;)
print(f&quot;输出: {y.round(3)}&quot;)</code></pre><p><strong>什么用</strong>：<code>__call__</code> 是 PyTorch <code>nn.Module</code> 最核心的设计。当你写 <code>output = model(input)</code> 时，Python 实际执行的是 <code>model.__call__(input)</code>，而 <code>nn.Module.__call__</code> 内部会调用你定义的 <code>forward()</code> 方法，同时处理钩子（hooks）、梯度追踪等底层逻辑。这也是为什么 <code>nn.Sequential</code> 可以把一列层当作一个整体调用——每个子层都实现了 <code>__call__</code>。Keras 的 <code>model.predict(x)</code> 本质也是类似的模式。</p>
<h3>四、更多实用魔术方法——<code>__eq__</code>、<code>__add__</code>、<code>__iter__</code> 等</h3>
<p><strong>是什么</strong>：Python 提供了几十种魔术方法，覆盖了对象可能参与的所有操作。<code>__eq__(self, other)</code> 在 <code>obj1 == obj2</code> 时调用（相等比较）；<code>__add__(self, other)</code> 在 <code>obj1 + obj2</code> 时调用（加法）；<code>__iter__(self)</code> 在 <code>for x in obj:</code> 时调用（迭代）；<code>__contains__(self, item)</code> 在 <code>item in obj</code> 时调用（成员检查）；<code>__bool__(self)</code> 在 <code>if obj:</code> 时调用（真值判断）。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 魔术方法就像&quot;操作系统的 API 接口&quot;——Python 规定了一套标准接口，你的类只要实现了某个接口，就能在对应的语法场景下工作。<code>__eq__</code> = &quot;如何比较相等&quot;，<code>__add__</code> = &quot;如何做加法&quot;，<code>__iter__</code> = &quot;如何被遍历&quot;。跟 USB 一样——你的设备只要支持 USB 协议（实现了对应方法），电脑就能通过 USB 接口和设备通信。</blockquote>


<p><strong>为什么</strong>：没有这些魔术方法，你只能通过 <code>obj.compare(other)</code>、<code>obj.add(other)</code> 这种丑陋的写法来操作对象——和内置类型（<code>[1,2] + [3,4]</code>）完全不统一。实现魔术方法后，你的自定义对象和内置类型行为一致：<code>vec1 + vec2</code>、<code>book1 == book2</code>、<code>if my_obj:</code>——Python 语法糖的威力全部解锁。</p>
<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-4"><code class="language-python">import numpy as np

# ====== 1. __eq__ —— 让对象可以比较是否相等 ======

class Point:
    &quot;&quot;&quot;二维坐标点——实现相等比较&quot;&quot;&quot;
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __eq__(self, other):
        &quot;&quot;&quot;定义什么是&quot;相等&quot;——坐标相同就是同一个点&quot;&quot;&quot;
        if not isinstance(other, Point):
            return NotImplemented               # 让 Python 尝试反向比较
        return self.x == other.x and self.y == other.y
    
    def __repr__(self):
        return f&quot;Point({self.x}, {self.y})&quot;
    
    def distance_to(self, other):
        &quot;&quot;&quot;计算到另一个点的欧氏距离&quot;&quot;&quot;
        return np.sqrt((self.x - other.x) ** 2 + (self.y - other.y) ** 2)

p1 = Point(3, 4)
p2 = Point(3, 4)
p3 = Point(5, 6)

print(f&quot;p1 == p2: {p1 == p2}&quot;)                  # True —— __eq__ 判断坐标相等
print(f&quot;p1 == p3: {p1 == p3}&quot;)                  # False
print(f&quot;p1 is p2: {p1 is p2}&quot;)                  # False —— is 判断内存地址，不同的对象！
# ⚠️ 重要区分：== 调用 __eq__（值相等），is 判断身份（内存地址相等）

# ====== 2. __add__ —— 让对象支持加法 ======

class Vector:
    &quot;&quot;&quot;二维向量——支持加法、标量乘法&quot;&quot;&quot;
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        &quot;&quot;&quot;向量加法：v1 + v2&quot;&quot;&quot;
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        return NotImplemented
    
    def __mul__(self, scalar):
        &quot;&quot;&quot;标量乘法：v * 2&quot;&quot;&quot;
        if isinstance(scalar, (int, float)):
            return Vector(self.x * scalar, self.y * scalar)
        return NotImplemented
    
    def __rmul__(self, scalar):
        &quot;&quot;&quot;反向标量乘法：2 * v（左操作数不是 Vector 的情况）&quot;&quot;&quot;
        return self.__mul__(scalar)
    
    def __abs__(self):
        &quot;&quot;&quot;向量的模（长度）—— abs(v)&quot;&quot;&quot;
        return np.sqrt(self.x ** 2 + self.y ** 2)
    
    def __repr__(self):
        return f&quot;Vector({self.x}, {self.y})&quot;

v1 = Vector(3, 4)
v2 = Vector(1, 2)
print(f&quot;\nv1 + v2 = {v1 + v2}&quot;)                  # Vector(4, 6)
print(f&quot;v1 * 3  = {v1 * 3}&quot;)                    # Vector(9, 12)
print(f&quot;3 * v1  = {3 * v1}&quot;)                    # Vector(9, 12) —— __rmul__
print(f&quot;|v1|    = {abs(v1):.2f}&quot;)               # 5.00 —— 模长

# ====== 3. __iter__ —— 让对象可迭代 ======

class Range:
    &quot;&quot;&quot;自定义的 Range 类——实现迭代&quot;&quot;&quot;
    def __init__(self, start, end, step=1):
        self.start = start
        self.end = end
        self.step = step
    
    def __iter__(self):
        &quot;&quot;&quot;返回一个迭代器——这里用生成器函数&quot;&quot;&quot;
        current = self.start
        while current &lt; self.end:
            yield current
            current += self.step
    
    def __contains__(self, item):
        &quot;&quot;&quot;支持 in 操作符&quot;&quot;&quot;
        if self.step &gt; 0:
            return self.start &lt;= item &lt; self.end and (item - self.start) % self.step == 0
        return False
    
    def __repr__(self):
        return f&quot;Range({self.start}, {self.end}, {self.step})&quot;

r = Range(0, 10, 2)
print(f&quot;\nRange 迭代: {[x for x in r]}&quot;)         # [0, 2, 4, 6, 8]
print(f&quot;4 in r: {4 in r}&quot;)                       # True —— __contains__
print(f&quot;5 in r: {5 in r}&quot;)                       # False

# ====== 4. __bool__ —— 控制对象的真值判断 ======

class Dataset:
    &quot;&quot;&quot;数据集——空数据集为 False&quot;&quot;&quot;
    def __init__(self, data=None):
        self.data = data if data is not None else []
    
    def __bool__(self):
        &quot;&quot;&quot;空数据集为 False，非空为 True&quot;&quot;&quot;
        return len(self.data) &gt; 0
    
    def __len__(self):
        return len(self.data)

empty_ds = Dataset()
full_ds = Dataset([1, 2, 3])
print(f&quot;\n空数据集 bool: {bool(empty_ds)}&quot;)      # False
print(f&quot;满数据集 bool: {bool(full_ds)}&quot;)         # True

# 可以在 if 语句中使用
if full_ds:
    print(&quot;数据集不为空，可以开始训练！&quot;)
if not empty_ds:
    print(&quot;数据集为空，请先加载数据！&quot;)

# ====== 5. AI 场景：实现完整的 Tensor 简化类 ======

class MyTensor:
    &quot;&quot;&quot;简化的张量类——演示多个魔术方法的组合&quot;&quot;&quot;
    
    def __init__(self, data):
        self.data = np.asarray(data, dtype=float)
    
    def __add__(self, other):
        if isinstance(other, MyTensor):
            return MyTensor(self.data + other.data)
        return MyTensor(self.data + other)
    
    def __mul__(self, other):
        if isinstance(other, MyTensor):
            return MyTensor(self.data * other.data)
        return MyTensor(self.data * other)
    
    def __getitem__(self, index):
        return self.data[index]
    
    def __len__(self):
        return len(self.data)
    
    def __abs__(self):
        &quot;&quot;&quot;L2 范数&quot;&quot;&quot;
        return float(np.sqrt(np.sum(self.data ** 2)))
    
    def __repr__(self):
        return f&quot;MyTensor({self.data.round(3)})&quot;

a = MyTensor([1, 2, 3])
b = MyTensor([4, 5, 6])
print(f&quot;\na + b    = {a + b}&quot;)                   # MyTensor([5. 7. 9.])
print(f&quot;a * 2    = {a * 2}&quot;)                     # MyTensor([2. 4. 6.])
print(f&quot;a[1]     = {a[1]}&quot;)                      # 2.0
print(f&quot;len(a)   = {len(a)}&quot;)                    # 3
print(f&quot;|a|      = {abs(a):.3f}&quot;)                # 3.742 —— L2 范数</code></pre><p><strong>什么用</strong>：这些魔术方法在 AI 框架的底层大量使用。PyTorch 的 Tensor 实现了几乎所有魔术方法——<code>a + b</code> 调用 <code>__add__</code>，<code>a @ b</code> 调用 <code>__matmul__</code>，<code>a[0]</code> 调用 <code>__getitem__</code>，<code>for x in dataloader:</code> 调用 <code>__iter__</code>。NumPy 的 ndarray 也一样——所有优雅的语法糖都建立在魔术方法之上。理解它们，你就能看懂框架源码，甚至设计自己的 DSL（领域特定语言）。</p>
<div class="demo-embed" data-demo-src="/demos/methods-demo1.html"><a href="/demos/methods-demo1.html">魔术工坊——Python 对象的行为定制实验室（动画演示）</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><code>__init__</code></td><td>对象创建时的初始化方法</td><td>定义模型层结构</td><td><code>__new__</code>、构造函数</td></tr><tr><td><code>__str__</code></td><td>给用户看，print() 调用</td><td>调试时打印模型结构</td><td><code>__repr__</code>、<code>str()</code></td></tr><tr><td><code>__repr__</code></td><td>给开发者看，repr() 调用</td><td>Jupyter 中显示模型信息</td><td><code>__str__</code>、调试</td></tr><tr><td><code>__len__</code></td><td>len(obj) 调用</td><td>DataLoader 获取数据集大小</td><td><code>__getitem__</code>、Dataset</td></tr><tr><td><code>__getitem__</code></td><td>obj[idx] 索引访问</td><td>DataLoader 按索引取样本</td><td>切片、迭代</td></tr><tr><td><code>__call__</code></td><td>obj() 让对象像函数一样调用</td><td>model(x) 前向传播</td><td>forward、可调用对象</td></tr><tr><td><code>__eq__</code></td><td>obj1 == obj2 相等比较</td><td>比较两个模型是否相同</td><td><code>__hash__</code>、<code>__ne__</code></td></tr><tr><td><code>__iter__</code></td><td>for x in obj 迭代</td><td>遍历数据集、数据加载器</td><td>迭代器、生成器</td></tr></tbody></table></div>
<h2>重点答疑</h2>
<h3>Q1: <code>__str__</code> 和 <code>__repr__</code> 到底该实现哪个？有什么区别？</h3>
<p>两个都实现最好，但如果只实现一个，优先 <code>__repr__</code>。区别：<code>__str__</code> 的目标是&quot;可读性&quot;——让用户觉得舒服、好看；<code>__repr__</code> 的目标是&quot;无歧义&quot;——让开发者一眼看清对象状态，理想情况下 <code>eval(repr(obj))</code> 能重建对象。实际规则：<code>print(obj)</code> → 先找 <code>__str__</code>，没有就找 <code>__repr__</code>；在列表中 <code>print([obj])</code> → 永远用 <code>__repr__</code>。快速记忆：<code>str</code> 是给人看的（show to read），<code>repr</code> 是给代码看的（representation）。</p>
<h3>Q2: <code>__call__</code> 和普通方法有什么区别？什么时候应该用 <code>__call__</code> 而不是普通方法？</h3>
<p>当一个对象只有一个&quot;主要操作&quot;时，用 <code>__call__</code> 比用普通方法更优雅。比如模型的主要操作是前向传播——写成 <code>model(x)</code> 比 <code>model.forward(x)</code> 更简洁自然。数据预处理器的唯一操作是转换——写成 <code>transform(data)</code> 比 <code>transform.apply(data)</code> 更直观。判断标准：如果你发现自己在纠结给方法起什么名字好（execute? run? apply? process?），而且这个方法注定是对象最常用的入口——直接用 <code>__call__</code>。</p>
<h3>Q3: 实现了 <code>__getitem__</code> 还需要实现 <code>__iter__</code> 吗？</h3>
<p>如果只实现了 <code>__getitem__</code>，Python 会尝试用&quot;旧式迭代协议&quot;——从索引 0 开始递增调用 <code>__getitem__</code>，直到抛出 <code>IndexError</code>。这虽然能用，但效率较低（不适合非整数索引的场景）。如果你有更高效的迭代方式（比如用生成器），应该实现 <code>__iter__</code>，Python 会优先使用它。推荐做法：<strong>都实现</strong>——<code>__getitem__</code> 支持索引和切片，<code>__iter__</code> 支持高效迭代。</p>
<h3>Q4: 魔术方法名为什么是双下划线？可以自定义新的魔术方法吗？</h3>
<p>双下划线（<code>__xxx__</code>）是 Python 语言规范中的保留命名惯例——所有当前和未来的语言级魔术方法都使用这个格式。你<strong>不应该</strong>自定义新的 <code>__xxx__</code> 格式的方法名——这会和未来 Python 版本中新引入的魔术方法冲突。如果你需要&quot;内部&quot;方法，用单下划线前缀（<code>_method</code>）就够了。双下划线前缀但不后缀（<code>__method</code>）是名称改编——那又是另一个故事了。</p>
<h3>Q5: 有哪些常见的魔术方法应该了解？</h3>
<p>除了本章已讲的，以下是高频使用的：<code>__enter__</code> / <code>__exit__</code>（上下文管理器，<code>with</code> 语句）；<code>__lt__</code> / <code>__le__</code> / <code>__gt__</code> / <code>__ge__</code>（比较运算符 <code>&lt; &lt;= &gt; &gt;=</code>）；<code>__hash__</code>（让对象可作为字典 key）；<code>__setitem__</code>（<code>obj[key] = value</code>）；<code>__delitem__</code>（<code>del obj[key]</code>）；<code>__contains__</code>（<code>item in obj</code>）；<code>__bool__</code>（<code>if obj:</code>）；<code>__new__</code>（底层对象创建，比 <code>__init__</code> 更早调用）。掌握这十几个就覆盖了 90% 的使用场景。</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>magic method</td><td>/ˈmædʒɪk ˈmeθəd/</td><td>魔术方法；双下划线包围的特殊方法</td></tr><tr><td>dunder</td><td>/ˈdʌndər/</td><td>double underscore 缩写；双下划线</td></tr><tr><td>representation</td><td>/ˌreprɪzenˈteɪʃən/</td><td>表示；<code>__repr__</code> 返回对象的代码表示</td></tr><tr><td>callable</td><td>/ˈkɔːləbl/</td><td>可调用的；实现了 <code>__call__</code> 的对象</td></tr><tr><td>iteration</td><td>/ˌɪtəˈreɪʃən/</td><td>迭代；<code>__iter__</code> 让对象支持 for 循环</td></tr><tr><td>index</td><td>/ˈɪndeks/</td><td>索引；<code>__getitem__</code> 支持 <code>obj[idx]</code></td></tr><tr><td>equality</td><td>/iˈkwɑːləti/</td><td>相等性；<code>__eq__</code> 定义 <code>==</code> 的行为</td></tr><tr><td>protocol</td><td>/ˈproʊtəkɔːl/</td><td>协议；实现一组魔术方法遵循某种接口规范</td></tr></tbody></table></div>
<div class="quiz-raw"><h2>面试练习</h2>
<h3>Q1 [单选] <code>print(obj)</code> 时，Python 首先尝试调用哪个魔术方法？</h3>
<ul>
<li>A. <code>__str__</code></li><li>B. <code>__repr__</code></li><li>C. <code>__print__</code></li><li>D. <code>__display__</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。<code>print(obj)</code> 先调用 <code>obj.__str__()</code>，如果 <code>__str__</code> 没实现，则退而求其次调用 <code>__repr__()</code>。C 和 D 不存在。</blockquote>


<h3>Q2 [多选] 关于 <code>__repr__</code>，以下说法正确的是？</h3>
<ul>
<li>A. 应该返回一个无歧义的、精确的字符串表示</li><li>B. 理想情况下 <code>eval(repr(obj))</code> 应该能重建对象</li><li>C. <code>__repr__</code> 的返回值必须是一个合法的 Python 表达式</li><li>D. 在交互式环境中输入对象名时调用 <code>__repr__</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 都正确。C 太绝对——&quot;理想情况下&quot;是的，但实际开发中很多对象的 <code>__repr__</code> 只是一个描述性字符串（如 <code>&lt;Dataset: 1000 samples&gt;</code>），并不要求一定可 eval。</blockquote>


<h3>Q3 [单选] 以下代码输出什么？<code>class A: def __call__(self): return 42; a = A(); print(a())</code></h3>
<ul>
<li>A. 42</li><li>B. <code>&lt;__main__.A object at 0x...&gt;</code></li><li>C. 报错，因为对象不能像函数一样调用</li><li>D. None</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。实现了 <code>__call__</code> 的对象可以像函数一样调用。<code>a()</code> 触发 <code>__call__</code>，返回 42。</blockquote>


<h3>Q4 [多选] 在 PyTorch 中，自定义 Dataset 必须实现哪些魔术方法？</h3>
<ul>
<li>A. <code>__len__</code></li><li>B. <code>__getitem__</code></li><li>C. <code>__iter__</code></li><li>D. <code>__call__</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B 正确。PyTorch 的 <code>Dataset</code> 抽象类要求子类必须实现 <code>__len__</code> 和 <code>__getitem__</code>。<code>__iter__</code> 不是必需的（DataLoader 会用 <code>__getitem__</code> 来迭代）。<code>__call__</code> 不是 Dataset 的要求。</blockquote>


<h3>Q5 [单选] <code>__init__</code> 和 <code>__new__</code> 的关系是？</h3>
<ul>
<li>A. <code>__init__</code> 在 <code>__new__</code> 之前调用</li><li>B. <code>__new__</code> 创建对象，<code>__init__</code> 初始化对象</li><li>C. 它们是同一个方法的不同名字</li><li>D. <code>__init__</code> 用于可变对象，<code>__new__</code> 用于不可变对象</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>__new__(cls)</code> 是类方法，负责创建并返回一个新实例（分配内存）。<code>__init__(self)</code> 是实例方法，接收 <code>__new__</code> 返回的实例并初始化它的属性。在日常开发中，几乎只需要重写 <code>__init__</code>，<code>__new__</code> 仅在实现单例模式等特殊场景中用到。</blockquote>


<h3>Q6 [多选] 实现了 <code>__len__</code> 和 <code>__getitem__</code> 的对象，可以免费获得哪些能力？</h3>
<ul>
<li>A. <code>for item in obj:</code> 遍历</li><li>B. <code>obj[3]</code> 索引访问</li><li>C. <code>obj[1:5]</code> 切片</li><li>D. <code>obj.key</code> 属性访问</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 都正确。只要实现了 <code>__len__</code> 和 <code>__getitem__</code>，<code>for</code> 循环（Python 从索引 0 开始递增调用 <code>__getitem__</code> 直到抛出 <code>IndexError</code>）、索引和切片都自动可用。D 的属性访问（<code>obj.key</code>）需要 <code>__getattr__</code> 魔术方法。</blockquote>


<h3>Q7 [单选] 以下关于 <code>__eq__</code> 的说法正确的是？</h3>
<ul>
<li>A. 如果不实现 <code>__eq__</code>，<code>==</code> 比较的是两个对象的内存地址</li><li>B. <code>__eq__</code> 和 <code>is</code> 是同一个操作</li><li>C. 实现 <code>__eq__</code> 后 <code>is</code> 的行为也会改变</li><li>D. <code>__eq__</code> 在 Python 中不能被重写</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。默认的 <code>__eq__</code>（继承自 <code>object</code>）比较的是 <code>self is other</code>，即内存地址。<code>is</code> 永远比较内存地址，不受 <code>__eq__</code> 影响。B 和 C 错误。D 错误——<code>__eq__</code> 经常被重写。</blockquote>


<h3>Q8 [多选] 以下哪些是 Python 的魔术方法？</h3>
<ul>
<li>A. <code>__init__</code></li><li>B. <code>__add__</code></li><li>C. <code>__getattr__</code></li><li>D. <code>__custom__</code>（你可以自定义任何 <code>__xxx__</code> 格式的方法）</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 都是 Python 定义的魔术方法。D 错误——虽然技术上你可以定义 <code>__custom__</code>，但强烈不建议。双下划线包围的名字是 Python 保留的，未来版本可能赋予它特殊含义，你的自定义方法名不应该用这个格式。</blockquote>


<h3>Q9 [单选] <code>class A: def __bool__(self): return False; if A(): print(&quot;True&quot;) else: print(&quot;False&quot;)</code> 输出什么？</h3>
<ul>
<li>A. True</li><li>B. False</li><li>C. 报错</li><li>D. None</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。<code>__bool__</code> 控制对象的真值判断。返回 <code>False</code> 表示对象为假，所以执行 <code>else</code> 分支打印 &quot;False&quot;。如果不实现 <code>__bool__</code>，Python 会尝试 <code>__len__</code>——如果 <code>len(obj)</code> 为 0 则为假。</blockquote>


<h3>Q10 [多选] 关于 <code>__call__</code> 在 PyTorch 中的应用，以下说法正确的是？</h3>
<ul>
<li>A. <code>nn.Module.__call__</code> 内部调用 <code>self.forward()</code></li><li>B. <code>model(x)</code> 等价于 <code>model.__call__(x)</code></li><li>C. <code>nn.Module.__call__</code> 除了调用 forward 还会执行钩子等逻辑</li><li>D. PyTorch 不推荐使用 <code>model(x)</code>，应该直接用 <code>model.forward(x)</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、C 都正确。D 错误——PyTorch 官方推荐用 <code>model(x)</code> 而不是 <code>model.forward(x)</code>，因为 <code>__call__</code> 在调用 <code>forward</code> 前后会执行注册的钩子函数（hooks），直接用 <code>forward</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": 0,
    "explanation": "A 正确。`print(obj)` 先调用 `obj.__str__()`，如果 `__str__` 没实现，则退而求其次调用 `__repr__()`。C 和 D 不存在。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 都正确。C 太绝对——\"理想情况下\"是的，但实际开发中很多对象的 `__repr__` 只是一个描述性字符串（如 `<Dataset: 1000 samples>`），并不要求一定可 eval。"
  },
  {
    "type": "single",
    "answer": 0,
    "explanation": "A 正确。实现了 `__call__` 的对象可以像函数一样调用。`a()` 触发 `__call__`，返回 42。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1
    ],
    "explanation": "A、B 正确。PyTorch 的 `Dataset` 抽象类要求子类必须实现 `__len__` 和 `__getitem__`。`__iter__` 不是必需的（DataLoader 会用 `__getitem__` 来迭代）。`__call__` 不是 Dataset 的要求。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`__new__(cls)` 是类方法，负责创建并返回一个新实例（分配内存）。`__init__(self)` 是实例方法，接收 `__new__` 返回的实例并初始化它的属性。在日常开发中，几乎只需要重写 `__init__`，`__new__` 仅在实现单例模式等特殊场景中用到。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 都正确。只要实现了 `__len__` 和 `__getitem__`，`for` 循环（Python 从索引 0 开始递增调用 `__getitem__` 直到抛出 `IndexError`）、索引和切片都自动可用。D 的属性访问（`obj.key`）需要 `__getattr__` 魔术方法。"
  },
  {
    "type": "single",
    "answer": 0,
    "explanation": "A 正确。默认的 `__eq__`（继承自 `object`）比较的是 `self is other`，即内存地址。`is` 永远比较内存地址，不受 `__eq__` 影响。B 和 C 错误。D 错误——`__eq__` 经常被重写。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 都是 Python 定义的魔术方法。D 错误——虽然技术上你可以定义 `__custom__`，但强烈不建议。双下划线包围的名字是 Python 保留的，未来版本可能赋予它特殊含义，你的自定义方法名不应该用这个格式。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。`__bool__` 控制对象的真值判断。返回 `False` 表示对象为假，所以执行 `else` 分支打印 \"False\"。如果不实现 `__bool__`，Python 会尝试 `__len__`——如果 `len(obj)` 为 0 则为假。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      2
    ],
    "explanation": "A、B、C 都正确。D 错误——PyTorch 官方推荐用 `model(x)` 而不是 `model.forward(x)`，因为 `__call__` 在调用 `forward` 前后会执行注册的钩子函数（hooks），直接用 `forward` 会跳过这些钩子，可能导致某些功能失效。"
  }
]</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>