<!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>__init__</code> 中通过 <code>self.xxx</code> 定义，每个对象独立拥有一份副本，改自己的不影响别人。类属性直接在 <code>class</code> 代码块中定义，是所有实例共享的&quot;公共数据&quot;——一处修改，处处生效。理解两者的区别和属性查找顺序（实例 → 类 → 父类），是写出正确 OOP 代码的前提。在 AI 中，类属性常用于存储默认超参数，实例属性存储模型的具体参数。</p>
<blockquote class="highlight-box"><strong>💡 核心要点：</strong>①实例属性通过 <code>self.属性名 = 值</code> 在 <code>__init__</code> 中定义，每个对象独有一份，互不影响 ②类属性直接在类体内（方法外）通过 <code>属性名 = 值</code> 定义，所有实例共享同一份数据 ③属性查找顺序：实例属性 → 类属性 → 父类属性（MRO 链），实例属性会&quot;遮蔽&quot;同名的类属性 ④修改不可变类属性必须通过 <code>类名.属性</code>，通过 <code>实例.属性 = 值</code> 实际上是在实例上创建了同名实例属性 ⑤<code>property</code> 装饰器可以把方法伪装成属性，实现带有逻辑验证的属性访问</blockquote>


<h2>教学与演示</h2>
<h3>一、实例属性——每个对象独一无二的数据</h3>
<p><strong>是什么</strong>：实例属性（Instance Attributes）是绑定在具体对象上的变量。它们通常在 <code>__init__</code> 方法中通过 <code>self.属性名 = 值</code> 创建，也可以在对象的任何其他方法中动态添加（但不推荐）。每个实例拥有自己独立的实例属性副本——修改对象 A 的实例属性不会影响对象 B 的同名属性。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 实例属性就像每个人的私人日记。张三有一本日记（张三的实例属性），李四也有一本日记（李四的实例属性）。张三在他的日记上写&quot;今天很开心&quot;，不会出现在李四的日记里。日记格式（类定义）是一样的，但内容（属性值）是各自独立的。这就是为什么 100 个 Student 对象可以有 100 个不同的 name 属性——它们各记各的日记。</blockquote>


<p><strong>为什么</strong>：实例属性是对象&quot;个性化&quot;的根本机制。没有实例属性，所有对象千篇一律——世界将非常无聊。更重要的是，实例属性让每个对象能维护自己的&quot;状态&quot;——一个银行账户对象的 balance 属性随着存款取款不断变化，但这种变化只影响这一个账户。从内存角度看，实例属性存储在对象的 <code>__dict__</code> 字典中，每个对象有自己独立的 <code>__dict__</code>。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 游戏中的 100 个怪物——它们都是 <code>Monster</code> 类的实例，都有 <code>hp</code>（血量）和 <code>position</code>（位置）属性。如果没有实例属性，你打一个怪物，其他 99 个也跟着掉血——这还玩个啥？实例属性保证了你打的是谁就谁掉血，玩家体验才正常。</blockquote>


<p><strong>怎么做</strong>：</p>
<pre data-runnable="code-demo-1"><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;每个学生创建时指定自己的 name 和 score&quot;&quot;&quot;
        self.name = name                        # 实例属性：姓名
        self.score = score                      # 实例属性：成绩
        self.grade = self._calc_grade()         # 实例属性：根据成绩计算的等级
    
    def _calc_grade(self):
        &quot;&quot;&quot;根据分数计算等级&quot;&quot;&quot;
        if self.score &gt;= 90:
            return &quot;A&quot;
        elif self.score &gt;= 75:
            return &quot;B&quot;
        elif self.score &gt;= 60:
            return &quot;C&quot;
        else:
            return &quot;D&quot;
    
    def update_score(self, new_score):
        &quot;&quot;&quot;更新成绩——同时自动更新等级&quot;&quot;&quot;
        self.score = new_score                  # 修改实例属性
        self.grade = self._calc_grade()         # 联动更新相关实例属性
        print(f&quot;{self.name} 成绩更新为 {self.score} 分，等级 {self.grade}&quot;)

# 创建三个学生——每个都有自己独立的属性
stu1 = Student(&quot;张三&quot;, 92)
stu2 = Student(&quot;李四&quot;, 78)
stu3 = Student(&quot;王五&quot;, 55)

# 每个对象的属性各不相同
students = [stu1, stu2, stu3]
for stu in students:
    print(f&quot;{stu.name}: {stu.score} 分 → 等级 {stu.grade}&quot;)

# 修改一个对象不影响其他对象
print(f&quot;\n--- 修改王五的成绩 ---&quot;)
stu3.update_score(82)                           # 王五从 D 变成 B
print(f&quot;张三的成绩仍然是: {stu1.score} 分&quot;)     # 92 —— 不受影响！

# ====== 2. 查看实例的 __dict__ ——属性的内部存储 ======

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.tricks = []                        # 可变类型的实例属性
    
    def learn_trick(self, trick):
        self.tricks.append(trick)

dog1 = Dog(&quot;旺财&quot;, 3)
dog2 = Dog(&quot;小白&quot;, 1)

# __dict__ 揭示了实例属性的内部存储——就是一个字典！
print(f&quot;\ndog1.__dict__ = {dog1.__dict__}&quot;)
# {'name': '旺财', 'age': 3, 'tricks': []}
print(f&quot;dog2.__dict__ = {dog2.__dict__}&quot;)
# {'name': '小白', 'age': 1, 'tricks': []}

# 实例属性本质上就是 __dict__ 里的键值对
# self.name = &quot;旺财&quot; 等价于 self.__dict__['name'] = &quot;旺财&quot;

dog1.learn_trick(&quot;坐下&quot;)
print(f&quot;\n旺财的 tricks: {dog1.tricks}&quot;)        # ['坐下']
print(f&quot;小白的 tricks: {dog2.tricks}&quot;)          # [] —— 互不影响

# ====== 3. 实例属性的动态添加——允许但不推荐 ======

dog1.color = &quot;金色&quot;                              # 运行时动态添加属性
print(f&quot;\n旺财有 color 属性: {dog1.color}&quot;)     # 金色
# print(dog2.color)                              # AttributeError —— 小白没有 color 属性
# ⚠️ 这就是动态添加的害处——有的对象有，有的没有，代码容易出错！

# ====== 4. AI 场景：模型实例的属性 ======

class LinearRegressor:
    &quot;&quot;&quot;线性回归模型——实例属性存储训练后的参数&quot;&quot;&quot;
    
    def __init__(self, learning_rate=0.01):
        self.lr = learning_rate                 # 实例属性：学习率
        self.weights = None                     # 实例属性：权重（训练前为 None）
        self.bias = None                        # 实例属性：偏置
        self.loss_history = []                  # 实例属性：记录训练过程
    
    def fit(self, X, y, epochs=100):
        &quot;&quot;&quot;训练模型——修改实例属性&quot;&quot;&quot;
        n_samples, n_features = X.shape
        # 初始化参数（创建实例属性）
        self.weights = np.random.randn(n_features) * 0.01
        self.bias = 0.0
        
        for epoch in range(epochs):
            # 前向传播
            y_pred = np.dot(X, self.weights) + self.bias  # 引用实例属性
            # 计算损失
            loss = np.mean((y_pred - y) ** 2)
            self.loss_history.append(loss)      # 修改实例属性
            # 梯度下降
            grad_w = (2 / n_samples) * np.dot(X.T, (y_pred - y))
            grad_b = (2 / n_samples) * np.sum(y_pred - y)
            self.weights -= self.lr * grad_w    # 修改实例属性
            self.bias -= self.lr * grad_b       # 修改实例属性
    
    def predict(self, X):
        &quot;&quot;&quot;预测——读取实例属性&quot;&quot;&quot;
        if self.weights is None:
            raise RuntimeError(&quot;模型尚未训练！请先调用 fit()&quot;)
        return np.dot(X, self.weights) + self.bias

# 训练两个不同的回归模型
np.random.seed(42)
X = np.random.randn(50, 3)
y = 2 * X[:, 0] + 3 * X[:, 1] - 1 * X[:, 2] + 0.5 + np.random.randn(50) * 0.1

model1 = LinearRegressor(learning_rate=0.05)
model2 = LinearRegressor(learning_rate=0.01)

model1.fit(X, y, epochs=100)
model2.fit(X, y, epochs=100)

# 两个模型是独立的实例——参数各不相同
print(f&quot;\nModel1 权重: {model1.weights.round(3)}&quot;)
print(f&quot;Model2 权重: {model2.weights.round(3)}&quot;)
print(f&quot;Model1 最终损失: {model1.loss_history[-1]:.6f}&quot;)
print(f&quot;Model2 最终损失: {model2.loss_history[-1]:.6f}&quot;)</code></pre><p><strong>什么用</strong>：在 AI 中，实例属性承载了模型的&quot;灵魂&quot;。训练好的神经网络模型中，数百万个权重参数全部存在实例属性中。<code>model.parameters()</code> 遍历的就是这些实例属性。不同 <code>learning_rate</code> 创建的优化器实例有不同的行为。理解实例属性是独立的，你才能理解为什么可以同时训练多个模型、做集成学习——每个模型实例互不干扰，各自维护自己的参数。</p>
<h3>二、类属性——所有实例共享的数据</h3>
<p><strong>是什么</strong>：类属性（Class Attributes）是直接定义在 <code>class</code> 代码块中（方法外部）的变量。它们属于类本身，而不是某个特定实例。所有实例共享同一份类属性——通过 <code>类名.属性</code> 或 <code>实例.属性</code> 读取的值来自同一片内存。但修改时有陷阱：<code>实例.属性 = 新值</code> 会在实例上创建同名实例属性，不再影响类属性。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 类属性就像教室公告栏上贴的&quot;班规&quot;。整个班级（类）的每个学生（实例）都能看到同一份班规——如果班主任修改班规（<code>类名.属性 = 新值</code>），所有看到的学生都会知道规则变了。但如果一个学生在自己笔记本上抄了班规然后自己改了（<code>实例.属性 = 新值</code>）——他改的只是自己的笔记本，公告栏上的原文没变，不影响其他人。</blockquote>


<p><strong>为什么</strong>：类属性解决的是&quot;所有对象共有的配置&quot;问题。比如定义一个 <code>Circle</code> 类，π 是 3.14159...——所有圆共用一个 π 就够了，不需要每个圆实例都存一份。再比如 <code>Dog</code> 类的 <code>species = &quot;犬科&quot;</code>——这个事实对所有的狗都成立，存一份就行。类属性节省内存、便于统一管理——修改类属性可以影响&quot;所有未来创建的对象&quot;以及&quot;没有覆盖该属性的已有对象&quot;。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 银行的年利率是类属性——对所有账户都适用，央行一调整，所有账户的计息规则都变。但每个账户的余额是实例属性——各自独立。你不会希望每个账户对象都存一份&quot;当前利率&quot;，那样央行调一次利率你就要更新 1000 万个对象——疯了。</blockquote>


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

# ====== 1. 类属性的定义和访问 ======

class Dog:
    &quot;&quot;&quot;狗类——类属性定义所有狗共有的信息&quot;&quot;&quot;
    
    species = &quot;犬科&quot;                            # 类属性：所有狗都属于犬科
    leg_count = 4                               # 类属性：狗都有四条腿
    total_dogs = 0                              # 类属性：统计创建了多少只狗
    
    def __init__(self, name):
        &quot;&quot;&quot;创建狗时修改类属性&quot;&quot;&quot;
        self.name = name                        # 实例属性：名字
        Dog.total_dogs += 1                     # 通过类名修改类属性
        self.id = Dog.total_dogs                # 实例属性：编号
    
    def bark(self):
        print(f&quot;{self.name}：汪汪！(ID={self.id}, {self.species}, {self.leg_count}条腿)&quot;)

# 访问类属性——通过类名或实例名
print(f&quot;Dog.species = {Dog.species}&quot;)            # 犬科
print(f&quot;Dog.leg_count = {Dog.leg_count}&quot;)        # 4

dog1 = Dog(&quot;旺财&quot;)
dog2 = Dog(&quot;小白&quot;)
dog3 = Dog(&quot;大黑&quot;)

# 所有实例共享类属性的值
dog1.bark()                                      # 旺财：汪汪！(ID=1, 犬科, 4条腿)
dog2.bark()                                      # 小白：汪汪！(ID=2, 犬科, 4条腿)
dog3.bark()                                      # 大黑：汪汪！(ID=3, 犬科, 4条腿)

print(f&quot;\n总共创建了 {Dog.total_dogs} 只狗&quot;)     # 3 —— 通过类名读取

# ====== 2. 修改类属性的正确与错误方式 ======

class Counter:
    count = 0                                   # 类属性
    
    def __init__(self):
        Counter.count += 1                      # ✅ 正确：通过类名修改类属性

c1 = Counter()
c2 = Counter()
print(f&quot;\nCounter.count = {Counter.count}&quot;)     # 2 —— 正确

# ❌ 错误示范：通过实例修改&quot;类属性&quot;
class Bad:
    shared = [1, 2, 3]                          # 类属性——注意这是个可变对象！

b1 = Bad()
b2 = Bad()

# 情况 1：通过实例赋值——在实例上创建同名属性
b1.shared = 100
print(f&quot;\nb1.shared = {b1.shared}&quot;)              # 100 —— 这是实例属性！
print(f&quot;b2.shared = {b2.shared}&quot;)               # [1, 2, 3] —— 类属性没变！
print(f&quot;Bad.shared = {Bad.shared}&quot;)             # [1, 2, 3] —— 类属性还是原样

# 情况 2：通过实例修改可变类属性——这才会影响所有实例
b1_fixed = Bad()
b2_fixed = Bad()
b1_fixed.shared.append(4)                       # 不是赋值，是调用方法修改对象本身
print(f&quot;\nb1_fixed.shared = {b1_fixed.shared}&quot;) # [1, 2, 3, 4]
print(f&quot;b2_fixed.shared = {b2_fixed.shared}&quot;)   # [1, 2, 3, 4] —— 也变了！
print(f&quot;Bad.shared = {Bad.shared}&quot;)             # [1, 2, 3, 4] —— 类属性真变了！
# ⚠️ 关键认知：赋值创建副本，方法调用修改原对象

# ====== 3. 属性查找顺序——实例优先 ======

class Demo:
    value = &quot;类属性&quot;                            # 类属性

d = Demo()
# 查找顺序：先看实例有没有 value，没有才看类
print(f&quot;\nd.value = {d.value}&quot;)                  # 类属性 —— 实例没有，找到了类属性

d.value = &quot;实例属性&quot;                            # 在实例上创建同名实例属性
print(f&quot;d.value = {d.value}&quot;)                    # 实例属性 —— 找到了实例属性（遮蔽类属性）
print(f&quot;Demo.value = {Demo.value}&quot;)              # 类属性 —— 类属性没被修改！
# 实例属性 &quot;遮蔽&quot; 了同名的类属性，但类属性本身还在

# 删除实例属性后，类属性重新可见
del d.value
print(f&quot;删除后 d.value = {d.value}&quot;)             # 类属性 —— 又看到了类属性

# ====== 4. AI 场景：模型配置作为类属性 ======

class ResNetConfig:
    &quot;&quot;&quot;ResNet 模型的默认配置——使用类属性&quot;&quot;&quot;
    
    # 类属性：所有 ResNet 变体的默认值
    default_initialization = &quot;kaiming_normal&quot;
    default_batch_norm_momentum = 0.1
    default_activation = &quot;relu&quot;
    
    def __init__(self, layers, num_classes=1000):
        &quot;&quot;&quot;实例属性：具体模型的配置&quot;&quot;&quot;
        self.layers = layers                    # 层数配置（如 [3, 4, 6, 3]）
        self.num_classes = num_classes
    
    def get_config(self):
        &quot;&quot;&quot;返回完整配置——结合类属性和实例属性&quot;&quot;&quot;
        return {
            &quot;layers&quot;: self.layers,
            &quot;num_classes&quot;: self.num_classes,
            &quot;initialization&quot;: self.default_initialization,   # 类属性
            &quot;bn_momentum&quot;: self.default_batch_norm_momentum,  # 类属性
            &quot;activation&quot;: self.default_activation,            # 类属性
        }

# 两个不同深度的 ResNet 配置
resnet18_config = ResNetConfig([2, 2, 2, 2])
resnet50_config = ResNetConfig([3, 4, 6, 3])

print(f&quot;\nResNet18 配置: {resnet18_config.get_config()}&quot;)
print(f&quot;ResNet50 配置: {resnet50_config.get_config()}&quot;)

# 修改类属性——所有未来创建的配置都会用新值
ResNetConfig.default_activation = &quot;silu&quot;         # 全局切换到 SiLU 激活
resnet101_config = ResNetConfig([3, 4, 23, 3])
print(f&quot;\n全局切换激活函数后——ResNet101: {resnet101_config.get_config()}&quot;)
# 已存在的对象不受影响（它们在自己的 __init__ 中读取的是旧值）</code></pre><p><strong>什么用</strong>：在 AI 框架中，类属性常用于存储默认配置。PyTorch 中 <code>nn.BatchNorm2d</code> 的默认 <code>momentum=0.1</code> 就是类属性的典型应用。scikit-learn 的估计器用类属性存储超参数的默认值。在自定义训练框架中，你可以用类属性统一管理所有模型的默认学习率、批次大小等超参数——修改一处，全局生效。但要注意：不要把可变对象（列表、字典）作为类属性的默认值——这是 Python 面向对象编程的经典陷阱。</p>
<h3>三、属性查找顺序与经典陷阱</h3>
<p><strong>是什么</strong>：当你在代码中写 <code>obj.some_attr</code> 时，Python 并不是简单地&quot;去某个地方找&quot;——它遵循一套精确的查找顺序（descriptor 协议 + MRO）。对于普通的属性访问：①先在实例的 <code>__dict__</code> 中找 ②找不到再去类的 <code>__dict__</code> 中找 ③再找不到就去父类的 <code>__dict__</code> 中找（按 MRO 链）。如果在任何地方都找不到，调用 <code>__getattr__</code>（如果定义了的话）。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 属性查找就像&quot;先翻口袋，再翻背包，最后翻储藏室&quot;。你想知道 <code>dog.name</code> 是什么——Python 先翻翻这个 dog 对象的&quot;口袋&quot;（实例 <code>__dict__</code>）：有没有 name？有的话直接拿出来。没有？翻翻 Dog 类的&quot;背包&quot;（类 <code>__dict__</code>）：有没有 name？还没有？顺着 MRO 链翻父类的&quot;储藏室&quot;：Animal 类里有没有？一路追溯到 object。全翻遍了都没找到？报 AttributeError。</blockquote>


<p><strong>为什么</strong>：理解查找顺序能避免三个经典陷阱。陷阱一：把可变对象（如空列表）作为默认参数——所有实例共享同一个列表。陷阱二：通过实例赋值&quot;修改类属性&quot;——其实创建了实例属性。陷阱三：类属性被实例属性意外&quot;遮蔽&quot;——一顿操作后发现自己改了假属性。这三个陷阱是 Python 初学者最容易踩的坑，理解属性查找机制就能彻底免疫。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 就像公司饮水机（类属性），每个人都去接水——如果有人在饮水机上贴了标签&quot;这是我的水&quot;（创建同名实例属性），以后他再去接水时 Python 先翻他口袋发现&quot;哦，你自己带了水&quot;——然后就喝他自己的瓶装水（实例属性），再也不碰饮水机了（类属性被遮蔽）。但他忘了自己口袋里的水喝完就没了（del 实例属性），而饮水机里还有水。</blockquote>


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

# ====== 陷阱 1：可变对象作为&quot;默认属性&quot; ======

print(&quot;=== 陷阱 1：可变类属性的共享问题 ===&quot;)

class Team:
    members = []                                # ⚠️ 可变类属性——所有实例共享！
    
    def __init__(self, name):
        self.name = name
    
    def add_member(self, person):
        self.members.append(person)             # 修改的是类属性中的列表

team_a = Team(&quot;Alpha 队&quot;)
team_b = Team(&quot;Beta 队&quot;)

team_a.add_member(&quot;张三&quot;)
team_a.add_member(&quot;李四&quot;)
team_b.add_member(&quot;王五&quot;)

# 两队共用一个列表！
print(f&quot;team_a.members: {team_a.members}&quot;)      # ['张三', '李四', '王五']
print(f&quot;team_b.members: {team_b.members}&quot;)      # ['张三', '李四', '王五'] —— 一样的！
print(f&quot;Team.members: {Team.members}&quot;)          # ['张三', '李四', '王五']

# ✅ 正确做法：在 __init__ 中初始化可变属性
class FixedTeam:
    def __init__(self, name):
        self.name = name
        self.members = []                       # ✅ 实例属性——各自独立
    
    def add_member(self, person):
        self.members.append(person)

ft_a = FixedTeam(&quot;Alpha&quot;)
ft_b = FixedTeam(&quot;Beta&quot;)
ft_a.add_member(&quot;张三&quot;)
ft_b.add_member(&quot;王五&quot;)
print(f&quot;\n正确做法:&quot;)
print(f&quot;ft_a.members: {ft_a.members}&quot;)          # ['张三']
print(f&quot;ft_b.members: {ft_b.members}&quot;)          # ['王五'] —— 互相独立！

# ====== 陷阱 2：通过实例&quot;修改&quot;类属性 ======

print(&quot;\n=== 陷阱 2：实例赋值 vs 类名赋值 ===&quot;)

class Config:
    debug = False                               # 类属性：调试模式

config1 = Config()
config2 = Config()

# 想统一开启调试模式——写法 1（错误）
config1.debug = True
print(f&quot;config1.debug = {config1.debug}&quot;)        # True —— 看起来改成功了？
print(f&quot;config2.debug = {config2.debug}&quot;)        # False —— 但另一个实例没变！
print(f&quot;Config.debug = {Config.debug}&quot;)          # False —— 类属性也没变！
# config1.__dict__ 现在是 {'debug': True} —— 创建了实例属性！

# 想统一开启调试模式——写法 2（正确）
Config.debug = True                              # ✅ 通过类名修改
print(f&quot;\n通过类名修改后:&quot;)
print(f&quot;config1.debug = {config1.debug}&quot;)        # True（现在是类属性 True）
print(f&quot;config2.debug = {config2.debug}&quot;)        # True —— 生效了！

# 但 config1 之前创建的实例属性还在！需要清理
del config1.debug                                # 删除实例属性
print(f&quot;\n清理后 config1.debug = {config1.debug}&quot;)  # True —— 类属性

# ====== 陷阱 3：实例属性遮蔽类属性 ======

print(&quot;\n=== 陷阱 3：属性遮蔽 ===&quot;)

class Base:
    version = &quot;1.0&quot;                             # 类属性

class Derived(Base):
    pass

d = Derived()
print(f&quot;初始 d.version = {d.version}&quot;)           # 1.0 —— 继承自 Base

d.version = &quot;2.0&quot;                               # 在实例上创建了同名属性
print(f&quot;赋值后 d.version = {d.version}&quot;)         # 2.0 —— 实例属性遮蔽了类属性
print(f&quot;Derived.version = {Derived.version}&quot;)    # 1.0 —— 类属性没变

# ⚠️ 正确的修改方式：
Derived.version = &quot;2.0&quot;                          # 通过类名修改
print(f&quot;Derived.version = {Derived.version}&quot;)    # 2.0

# ====== 4. 可视化属性查找 ======

class A:
    x = &quot;A 的类属性&quot;

class B(A):
    y = &quot;B 的类属性&quot;

b = B()
b.z = &quot;b 的实例属性&quot;

print(f&quot;\n=== 属性查找演示 ===&quot;)
print(f&quot;b.z → {b.z}  (来自实例 __dict__)&quot;)
print(f&quot;b.y → {b.y}  (来自 B 的 __dict__)&quot;)
print(f&quot;b.x → {b.x}  (来自 A 的 __dict__，MRO 链)&quot;)
# B.__mro__ → (B, A, object)</code></pre><p><strong>什么用</strong>：在 AI 开发中，陷阱 1 是最常见的——把空列表 <code>[]</code> 作为类属性用于记录训练日志，结果多个并发训练的模型写入了同一个列表。PyTorch 中 <code>nn.Module</code> 通过精巧的设计避免了这些问题——它使用 <code>__setattr__</code> 魔术方法拦截属性赋值，自动区分参数（<code>nn.Parameter</code>）、子模块和普通属性。理解底层机制，你在调试&quot;为什么两个模型的参数共享了&quot;这类诡异 bug 时就能秒定位。</p>
<h3>四、<code>property</code>——把方法伪装成属性</h3>
<p><strong>是什么</strong>：<code>property</code> 是 Python 内置的装饰器，可以把类的方法&quot;伪装&quot;成属性——访问时像读属性一样自然（<code>obj.value</code>），但实际上内部执行的是你定义的方法逻辑。<code>@property</code> 定义 getter（读取逻辑），<code>@xxx.setter</code> 定义 setter（赋值逻辑），<code>@xxx.deleter</code> 定义 deleter（删除逻辑）。这让属性访问可以附带验证、计算、日志等复杂逻辑，而调用方完全无感。</p>
<blockquote class="plain-explain"><strong>大白话</strong> property 就像银行的 ATM 机。你查余额时，看着是&quot;读取一个数字&quot;（<code>account.balance</code>），但背后 ATM 机做了一堆事：联网验证、查数据库、计算利息、格式化显示——你完全不知道也不需要知道这些。同样，<code>student.score = 95</code> 看起来只是赋值一个数字，但如果 score 用了 property，它可能在后台校验&quot;分数必须在 0-100 之间&quot;、自动更新等级、发通知给家长——而你写代码时只看到赋值操作。</blockquote>


<p><strong>为什么</strong>：没有 property 时，如果你想在属性访问/赋值时附加逻辑，只能用 <code>get_score()</code> 和 <code>set_score()</code> 方法——这破坏了&quot;统一使用属性&quot;的优雅性。更糟的是，如果项目最初用了直接属性访问（<code>obj.score = 95</code>），后来想加验证逻辑——你需要把所有的 <code>obj.score = 95</code> 改成 <code>obj.set_score(95)</code>，这是大规模重构。property 让你在不改变外部接口的情况下，给属性添加逻辑——API 不变，能力升级。</p>
<blockquote class="plain-explain"><strong>大白话</strong> 就像给家里的大门加指纹锁。以前进门只要推门（直接属性访问），现在加了指纹锁后——推门动作不变，但内部流程多了扫描指纹、比对数据库、记录进出门时间等步骤。你推门的动作不变，但门的&quot;智能&quot;升级了。property 就是代码世界的指纹锁——升级属性的智能，不改调用方的代码。</blockquote>


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

# ====== 1. 基本的 @property 使用 ======

class Student:
    &quot;&quot;&quot;使用 property 保护成绩属性&quot;&quot;&quot;
    
    def __init__(self, name, score=0):
        self.name = name
        self._score = None                      # 内部存储用&quot;私有&quot;属性
        self.score = score                      # 触发 setter 的验证逻辑！
    
    @property
    def score(self):
        &quot;&quot;&quot;读取成绩——像读普通属性一样&quot;&quot;&quot;
        return self._score
    
    @score.setter
    def score(self, value):
        &quot;&quot;&quot;设置成绩——带验证逻辑！&quot;&quot;&quot;
        if not isinstance(value, (int, float)):
            raise TypeError(f&quot;成绩必须是数字，不能是 {type(value)}&quot;)
        if value &lt; 0 or value &gt; 100:
            raise ValueError(f&quot;成绩必须在 0-100 之间，你传了 {value}&quot;)
        self._score = value
    
    @property
    def grade(self):
        &quot;&quot;&quot;计算属性——等级是根据成绩自动算出来的，不需要存&quot;&quot;&quot;
        if self._score is None:
            return &quot;未设置&quot;
        if self._score &gt;= 90:
            return &quot;A&quot;
        elif self._score &gt;= 75:
            return &quot;B&quot;
        elif self._score &gt;= 60:
            return &quot;C&quot;
        else:
            return &quot;D&quot;
    
    @property
    def passed(self):
        &quot;&quot;&quot;只读计算属性——是否及格&quot;&quot;&quot;
        return self._score is not None and self._score &gt;= 60

stu = Student(&quot;张三&quot;, 85)
print(f&quot;{stu.name}: 成绩={stu.score}, 等级={stu.grade}, 及格={stu.passed}&quot;)
# 张三: 成绩=85, 等级=B, 及格=True

# 通过 setter 修改——自动触发验证
stu.score = 92                                   # 触发 @score.setter 验证
print(f&quot;更新后: {stu.name}: 成绩={stu.score}, 等级={stu.grade}&quot;)

try:
    stu.score = 150                              # 触发 ValueError！
except ValueError as e:
    print(f&quot;错误: {e}&quot;)

try:
    stu.score = &quot;优秀&quot;                           # 触发 TypeError！
except TypeError as e:
    print(f&quot;错误: {e}&quot;)

# grade 和 passed 是只读 property（没有 setter）
# stu.grade = &quot;C&quot;                                # AttributeError: can't set attribute

# ====== 2. property 的 deleter ======

class Resource:
    def __init__(self, name):
        self._name = name
        self._loaded = True
    
    @property
    def name(self):
        return self._name
    
    @name.deleter
    def name(self):
        &quot;&quot;&quot;删除时触发清理逻辑&quot;&quot;&quot;
        print(f&quot;正在释放资源: {self._name}&quot;)
        self._loaded = False
        self._name = None

r = Resource(&quot;数据库连接&quot;)
print(f&quot;\n资源名: {r.name}&quot;)
del r.name                                       # 打印&quot;正在释放资源: 数据库连接&quot;
print(f&quot;删除后: {r.name}&quot;)                       # None

# ====== 3. 高级用法：缓存属性 ======

class ExpensiveComputation:
    &quot;&quot;&quot;演示：计算一次，缓存结果——通过 property 实现懒加载&quot;&quot;&quot;
    
    def __init__(self, data):
        self.data = data
        self._cached_result = None
    
    @property
    def result(self):
        &quot;&quot;&quot;第一次访问时计算，之后直接返回缓存&quot;&quot;&quot;
        if self._cached_result is None:
            print(&quot;&gt;&gt;&gt; 计算中……（只执行一次）&quot;)
            # 模拟耗时计算
            self._cached_result = {
                &quot;mean&quot;: float(np.mean(self.data)),
                &quot;std&quot;: float(np.std(self.data)),
                &quot;min&quot;: float(np.min(self.data)),
                &quot;max&quot;: float(np.max(self.data)),
            }
        return self._cached_result

ec = ExpensiveComputation(np.array([1, 5, 10, 50, 100]))
print(f&quot;\n第一次访问: {ec.result}&quot;)              # 触发计算
print(f&quot;第二次访问: {ec.result}&quot;)                # 直接用缓存！

# ====== 4. AI 场景：模型超参数的 property 封装 ======

class ModelHyperParams:
    &quot;&quot;&quot;用 property 管理模型超参数&quot;&quot;&quot;
    
    def __init__(self, learning_rate=0.01, batch_size=32):
        self._lr = None
        self._batch_size = None
        self.learning_rate = learning_rate       # 触发 setter
        self.batch_size = batch_size             # 触发 setter
        self._history = []                       # 参数修改历史
    
    @property
    def learning_rate(self):
        return self._lr
    
    @learning_rate.setter
    def learning_rate(self, value):
        &quot;&quot;&quot;学习率必须为正数&quot;&quot;&quot;
        if value &lt;= 0:
            raise ValueError(f&quot;学习率必须为正数，得到 {value}&quot;)
        self._lr = value
        self._history.append(f&quot;learning_rate → {value}&quot;)
    
    @property
    def batch_size(self):
        return self._batch_size
    
    @batch_size.setter
    def batch_size(self, value):
        &quot;&quot;&quot;批次大小必须是正整数&quot;&quot;&quot;
        if not isinstance(value, int) or value &lt;= 0:
            raise ValueError(f&quot;批次大小必须为正整数，得到 {value}&quot;)
        if value &amp; (value - 1) != 0 and value &gt; 1:
            print(f&quot;⚠️ 警告：{value} 不是 2 的幂，可能影响 GPU 效率&quot;)
        self._batch_size = value
        self._history.append(f&quot;batch_size → {value}&quot;)
    
    @property
    def effective_lr(self):
        &quot;&quot;&quot;计算有效学习率（考虑批次大小的缩放）&quot;&quot;&quot;
        return self._lr * np.sqrt(self._batch_size / 32)
    
    @property
    def config_summary(self):
        &quot;&quot;&quot;只读属性：配置摘要&quot;&quot;&quot;
        return {
            &quot;learning_rate&quot;: self._lr,
            &quot;batch_size&quot;: self._batch_size,
            &quot;effective_lr&quot;: round(self.effective_lr, 6),
        }

params = ModelHyperParams(learning_rate=0.001, batch_size=64)
print(f&quot;\n模型超参数: {params.config_summary}&quot;)
# {'learning_rate': 0.001, 'batch_size': 64, 'effective_lr': 0.001414}

# 修改参数
params.learning_rate = 0.005
print(f&quot;修改后: {params.config_summary}&quot;)</code></pre><p><strong>什么用</strong>：在 AI 开发中，property 的使用场景丰富。你可以用 <code>@property</code> 创建只读的计算属性——比如模型的总参数量 <code>model.total_params</code> 在每次访问时动态计算。训练过程中的学习率衰减规则可以用 property setter 实现——每次设置 <code>model.lr</code> 时自动检查和验证。PyTorch 的 <code>nn.Module</code> 内部大量使用 property 来管理 <code>training</code> 状态等属性，确保状态切换时所有子模块同步更新。</p>
<div class="demo-embed" data-demo-src="/demos/class-instance-demo1.html"><a href="/demos/class-instance-demo1.html">属性双面镜——实例属性 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>模型参数、训练状态</td><td><code>__dict__</code>、self</td></tr><tr><td>类属性</td><td>在 class 体内定义，所有实例共享</td><td>默认超参数配置</td><td>共享变量、静态变量</td></tr><tr><td>属性查找</td><td>实例 → 类 → 父类（MRO 链）</td><td>理解模型参数如何被找到</td><td>MRO、<code>__dict__</code></td></tr><tr><td>属性遮蔽</td><td>实例属性覆盖同名的类属性</td><td>调试参数共享 bug</td><td>赋值 vs 修改</td></tr><tr><td>property</td><td>把方法伪装成属性访问</td><td>带验证的超参数设置</td><td>getter、setter、deleter</td></tr><tr><td>可变陷阱</td><td>可变类属性在所有实例间共享</td><td>训练日志的意外共享</td><td>列表、字典默认值</td></tr><tr><td>计算属性</td><td>不存储、每次访问动态计算</td><td>模型总参数量、推理延迟</td><td>缓存、懒加载</td></tr></tbody></table></div>
<h2>重点答疑</h2>
<h3>Q1: 实例属性和类属性到底什么时候用哪个？</h3>
<p>一个简单判断标准：问自己&quot;这个属性的值对所有实例都一样吗？&quot;如果是——用类属性；如果每个实例的值不同——用实例属性。举例：所有狗的 <code>species = &quot;犬科&quot;</code> → 类属性；每只狗的 <code>name</code> 各不相同 → 实例属性。另一个角度：这个属性会不会变？不变的→类属性；会变的→实例属性。如果拿不准，优先用实例属性（在 <code>__init__</code> 中定义）——更安全，不会出现意外共享。</p>
<h3>Q2: <code>obj.attr = value</code> 到底是修改类属性还是创建实例属性？</h3>
<p>规则很简单：<strong>赋值永远在实例上创建或更新实例属性，不会修改类属性</strong>。无论 <code>attr</code> 之前是类属性还是不存在，<code>obj.attr = value</code> 都会在 <code>obj.__dict__</code> 中写入。类属性仍然在 <code>类.__dict__</code> 中完好无损——只是被实例属性遮蔽了。如果想修改类属性，必须通过类名：<code>ClassName.attr = value</code>。唯一例外是修改可变对象（如 <code>obj.shared_list.append(x)</code>）——这不是赋值，是调用方法修改对象本身，会直接影响类属性。</p>
<h3>Q3: <code>@property</code> 装饰器和直接定义属性有什么不同？性能有影响吗？</h3>
<p><code>@property</code> 本质上是在每次属性访问时调用一个方法。性能上有微小的额外开销（一次函数调用），但通常可以忽略不计（除非在超高频的热路径上）。和直接属性的最大区别在于：①可以在访问/赋值时运行验证和计算逻辑；②可以实现只读属性；③可以保持外部 API 不变的情况下升级内部实现。代价是：property 的逻辑被隐藏了——阅读代码的人可能以为只是简单赋值，没意识到后台计算了一大堆东西。建议：只在&quot;需要逻辑&quot;的时候用 property，不要把简单属性都包装成 property。</p>
<h3>Q4: 什么时候用 <code>_name</code>（单下划线），什么时候用 <code>__name</code>（双下划线）？</h3>
<p><code>_name</code>（单下划线）是约定——告诉同事：&quot;这是内部属性，请勿直接访问。如果你非要访问也行，但别怪我 API 变了不通知你。&quot;适用于大多数场景。<code>__name</code>（双下划线）触发名称改编，适用于你确实想阻止外部访问的情况——比如框架类中不想让子类意外覆盖的关键属性。实际工作中：<strong>90% 的情况用单下划线就够了</strong>。双下划线用得太多反而会让调试和测试变麻烦（因为名字被改了）。</p>
<h3>Q5: 为什么说&quot;不要在类属性中放可变对象&quot;是经典陷阱？</h3>
<p>因为类属性和实例属性共享机制的区别。当你在类体内写 <code>scores = []</code> 时，这个 <code>[]</code> 只在类定义时创建一次。之后所有实例的 <code>self.scores</code> 访问都指向同一个列表对象——你以为每个实例有自己的空列表，其实它们在共用！当你用 <code>self.scores.append(95)</code> 时修改的是共享列表，所有实例都能看到变化。正确做法是在 <code>__init__</code> 中写 <code>self.scores = []</code>——每次创建实例时都创建一个新的空列表。这个陷阱是 Python 面试题中的&quot;常客&quot;。</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 attribute</td><td>/ˈɪnstəns ˈætrɪbjuːt/</td><td>实例属性；绑定在对象上的独立数据</td></tr><tr><td>class attribute</td><td>/klæs ˈætrɪbjuːt/</td><td>类属性；所有实例共享的数据</td></tr><tr><td>attribute lookup</td><td>/ˈætrɪbjuːt ˈlʊkʌp/</td><td>属性查找；Python 解析 <code>obj.attr</code> 的顺序</td></tr><tr><td>shadowing</td><td>/ˈʃædoʊɪŋ/</td><td>遮蔽；实例属性覆盖同名的类属性</td></tr><tr><td>property</td><td>/ˈprɑːpərti/</td><td>特性装饰器；把方法伪装成属性</td></tr><tr><td>getter</td><td>/ˈɡetər/</td><td>读取器；<code>@property</code> 定义的读取方法</td></tr><tr><td>setter</td><td>/ˈsetər/</td><td>设置器；<code>@xxx.setter</code> 定义的赋值方法</td></tr><tr><td><strong>dict</strong></td><td>/ˈdʌndər dɪkt/</td><td>存储实例属性的字典属性</td></tr></tbody></table></div>
<div class="quiz-raw"><h2>面试练习</h2>
<h3>Q1 [单选] 以下代码输出什么？<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 = 2</code> 创建了实例属性 a.x，不影响类属性 A.x。所以 <code>A.x</code> 仍然是 1。</blockquote>


<h3>Q2 [多选] 关于实例属性，以下说法正确的是？</h3>
<ul>
<li>A. 实例属性通常在 <code>__init__</code> 中定义</li><li>B. 每个对象有自己独立的实例属性副本</li><li>C. 实例属性的值对所有对象都相同</li><li>D. 实例属性可以通过 <code>self.属性名</code> 在方法中访问</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确。C 错误——那正是类属性的特点，实例属性的值可以各不相同，这正是它存在的意义。</blockquote>


<h3>Q3 [单选] 以下哪个是 Python 的属性查找顺序？</h3>
<ul>
<li>A. 类属性 → 实例属性 → 父类属性</li><li>B. 实例属性 → 类属性 → 父类属性（MRO 链）</li><li>C. 父类属性 → 类属性 → 实例属性</li><li>D. 随机查找</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。Python 先在实例的 <code>__dict__</code> 中找，然后去类的 <code>__dict__</code>，再按 MRO 链去父类中找。实例优先于类。</blockquote>


<h3>Q4 [单选] 以下关于 <code>@property</code> 的说法，错误的是？</h3>
<ul>
<li>A. <code>@property</code> 可以把方法变成属性访问</li><li>B. 可以定义 setter 来控制属性赋值逻辑</li><li>C. 可以实现只读属性（只有 getter，没有 setter）</li><li>D. <code>@property</code> 可以让属性的访问速度变得更快</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>D 错误。<code>@property</code> 不会让访问变快——事实上它增加了一层函数调用，稍微慢一丁点。它的价值在于&quot;封装逻辑&quot;而非性能。</blockquote>


<h3>Q5 [多选] 以下代码中哪些会修改类属性？</h3>
<ul>
<li>A. <code>obj.attr = 10</code></li><li>B. <code>ClassName.attr = 10</code></li><li>C. <code>obj.shared_list.append(5)</code>（shared_list 是类属性，可变对象）</li><li>D. <code>obj._ClassName__private = 10</code></li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B、C 正确。B 通过类名直接赋值。C 通过实例调用可变对象的修改方法（append）——这不是赋值，所以修改了共享对象本身。A 创建实例属性。D 修改的是实例上的名称改编属性。</blockquote>


<h3>Q6 [单选] 将可变对象放在类属性中的主要风险是？</h3>
<ul>
<li>A. 浪费内存空间</li><li>B. 所有实例意外共享同一个列表/字典</li><li>C. Python 不支持用可变对象作为属性</li><li>D. 访问速度变慢</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>B 正确。可变类属性（如 <code>items = []</code>）只创建一次，所有实例通过 <code>self.items</code> 都指向同一个列表对象。一个实例的修改会影响所有实例——这就是&quot;意外共享&quot;陷阱。</blockquote>


<h3>Q7 [多选] 以下关于属性遮蔽（Shadowing）的说法正确的是？</h3>
<ul>
<li>A. 实例属性会遮蔽同名的类属性</li><li>B. 删除实例属性后，类属性重新可见</li><li>C. 被遮蔽的类属性会被自动删除</li><li>D. <code>del obj.attr</code> 可以解除遮蔽</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、B、D 正确。C 错误——被遮蔽的类属性依然完好地存在，只是通过实例暂时不可见。删除实例属性后它就重新可见了。</blockquote>


<h3>Q8 [单选] 如何实现一个&quot;计算属性&quot;——每次访问时动态计算值，而不是存储静态值？</h3>
<ul>
<li>A. 在 <code>__init__</code> 中用公式计算并赋值</li><li>B. 使用类属性静态定义</li><li>C. 使用 <code>@property</code> 装饰方法</li><li>D. Python 不支持计算属性</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>C 正确。<code>@property</code> 让方法看起来像属性，每次访问 <code>obj.prop</code> 时都会执行方法体计算最新值。A 存储的是静态值，如果相关属性变化了不会自动更新。</blockquote>


<h3>Q9 [单选] <code>class A: x = []; a = A(); b = A(); a.x.append(1); print(b.x)</code> 输出什么？</h3>
<ul>
<li>A. [1]</li><li>B. []</li><li>C. 报错</li><li>D. None</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A 正确。<code>x = []</code> 是类属性（可变对象），所有实例共享同一个列表。<code>a.x.append(1)</code> 修改了这个共享列表，所以 <code>b.x</code> 也看到 <code>[1]</code>。</blockquote>


<h3>Q10 [多选] 在 PyTorch 中，模型的参数（weights, biases）存储在哪里？</h3>
<ul>
<li>A. 实例属性中</li><li>B. 类属性中</li><li>C. 通过 <code>nn.Parameter</code> 包装后注册到模块</li><li>D. 作为全局变量</li></ul>
<blockquote class="quiz-answer"><strong>解答：</strong>A、C 正确。PyTorch 的模型参数是实例属性——每个模型实例有自己的权重副本。它们通过 <code>nn.Parameter</code> 包装，由 <code>nn.Module.__setattr__</code> 自动识别并注册到 <code>_parameters</code> 字典中。B 错误（参数不是类属性——那会导致所有模型实例共享权重）。</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 正确。`a.x = 2` 创建了实例属性 a.x，不影响类属性 A.x。所以 `A.x` 仍然是 1。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确。C 错误——那正是类属性的特点，实例属性的值可以各不相同，这正是它存在的意义。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。Python 先在实例的 `__dict__` 中找，然后去类的 `__dict__`，再按 MRO 链去父类中找。实例优先于类。"
  },
  {
    "type": "single",
    "answer": 3,
    "explanation": "D 错误。`@property` 不会让访问变快——事实上它增加了一层函数调用，稍微慢一丁点。它的价值在于\"封装逻辑\"而非性能。"
  },
  {
    "type": "multi",
    "answer": [
      1,
      2
    ],
    "explanation": "B、C 正确。B 通过类名直接赋值。C 通过实例调用可变对象的修改方法（append）——这不是赋值，所以修改了共享对象本身。A 创建实例属性。D 修改的是实例上的名称改编属性。"
  },
  {
    "type": "single",
    "answer": 1,
    "explanation": "B 正确。可变类属性（如 `items = []`）只创建一次，所有实例通过 `self.items` 都指向同一个列表对象。一个实例的修改会影响所有实例——这就是\"意外共享\"陷阱。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      1,
      3
    ],
    "explanation": "A、B、D 正确。C 错误——被遮蔽的类属性依然完好地存在，只是通过实例暂时不可见。删除实例属性后它就重新可见了。"
  },
  {
    "type": "single",
    "answer": 2,
    "explanation": "C 正确。`@property` 让方法看起来像属性，每次访问 `obj.prop` 时都会执行方法体计算最新值。A 存储的是静态值，如果相关属性变化了不会自动更新。"
  },
  {
    "type": "single",
    "answer": 0,
    "explanation": "A 正确。`x = []` 是类属性（可变对象），所有实例共享同一个列表。`a.x.append(1)` 修改了这个共享列表，所以 `b.x` 也看到 `[1]`。"
  },
  {
    "type": "multi",
    "answer": [
      0,
      2
    ],
    "explanation": "A、C 正确。PyTorch 的模型参数是实例属性——每个模型实例有自己的权重副本。它们通过 `nn.Parameter` 包装，由 `nn.Module.__setattr__` 自动识别并注册到 `_parameters` 字典中。B 错误（参数不是类属性——那会导致所有模型实例共享权重）。"
  }
]</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>