1. 核心定义：类变量 vs. 实例变量

首先，我们明确这两个概念：

• 类变量 (Class Variable)定义位置：在类的内部，但在任何方法（包括 __init__）的外部。归属：属于类本身。共享性：被该类的所有实例共享。无论你创建多少个对象，它们都访问同一个类变量。作用：通常用于定义所有实例都共有的属性或常量，比如物种（"Dog"）、默认配置等。
• 实例变量 (Instance Variable)定义位置：通常在类的 __init__ 方法中，使用 self.变量名 的形式定义。也可以在其他实例方法中定义。归属：属于单个实例（对象）。唯一性：每个实例都有自己独立的一份拷贝，互不影响。作用：用于存储每个对象独有的数据，比如名字（"旺财"）、年龄（3）等。

代码示例：

python

运行

class Dog:
    # 1. 类变量：所有 Dog 实例共享
    species = "Canis lupus familiaris" 
    count = 0  # 用于记录创建了多少只狗

    def __init__(self, name, age):
        # 2. 实例变量：每个 Dog 实例独有的
        self.name = name
        self.age = age
        Dog.count += 1  # 每次创建实例，类变量 count 加 1

# --- 创建实例 ---
dog1 = Dog("旺财", 3)
dog2 = Dog("小白", 5)

# 访问类变量
print(f"狗的物种是: {Dog.species}")      # 输出: 狗的物种是: Canis lupus familiaris
print(f"dog1 的物种是: {dog1.species}")  # 输出: dog1 的物种是: Canis lupus familiaris
print(f"dog2 的物种是: {dog2.species}")  # 输出: dog2 的物种是: Canis lupus familiaris

# 访问实例变量
print(f"{dog1.name} 的年龄是: {dog1.age}") # 输出: 旺财 的年龄是: 3
print(f"{dog2.name} 的年龄是: {dog2.age}") # 输出: 小白 的年龄是: 5

# 访问记录数量的类变量
print(f"总共创建了 {Dog.count} 只狗") # 输出: 总共创建了 2 只狗

2. 关键区别一览表

3. 访问机制详解：“查找链” (Lookup Chain)

这是理解两者访问差异的核心。当你通过一个实例（比如 dog1）去访问一个属性（比如 species）时，Python 会遵循以下步骤：

1. 第一步：查找实例自身的命名空间 (Instance Namespace)Python 首先会检查这个属性是否存在于该实例自己的 __dict__ 字典中。__dict__ 存储了所有实例变量。如果找到了，就直接返回该值。
2. 第二步：查找类的命名空间 (Class Namespace)如果在实例的 __dict__ 中没有找到，Python 会接着去创建该实例的类（Dog）的 __dict__ 中查找。如果在类的 __dict__ 中找到了（比如 species），就返回该值。
3. 第三步：查找父类的命名空间 (Parent Class Namespace)如果在类中也没找到，Python 会沿着继承链向上，依次在父类、祖父类... 中查找，直到找到为止。
4. 第四步：抛出异常如果在整个查找链中都没有找到该属性，Python 就会抛出 AttributeError 异常。

用一个流程图来表示：

实例.属性 -> 检查实例的 __dict__ -> (找到就返回) -> 检查类的 __dict__ -> (找到就返回) -> 检查父类的 __dict__ -> ... -> (未找到则抛出 AttributeError)

4. 最容易混淆的点：修改操作

访问属性和修改属性的机制是不同的。错误地修改属性是导致 bug 的常见原因。

场景一：通过实例读取类变量

这会遵循上面的 “查找链”。因为实例的 __dict__ 中没有 species，所以会找到并返回类的 species。

python

运行

print(dog1.species) # 'Canis lupus familiaris'

场景二：通过实例 “修改” 类变量（实际上是创建了一个新的实例变量）

python

运行

print(f"修改前, dog1.species: {dog1.species}") # 'Canis lupus familiaris'
print(f"修改前, dog2.species: {dog2.species}") # 'Canis lupus familiaris'

# 关键点：通过实例名修改
dog1.species = "Wolf" 

print("-" * 20)
print(f"修改后, dog1.species: {dog1.species}") # 'Wolf'
print(f"修改后, dog2.species: {dog2.species}") # 'Canis lupus familiaris' (没变！)
print(f"修改后, Dog.species: {Dog.species}")   # 'Canis lupus familiaris' (也没变！)

# 看看 dog1 的 __dict__
print(dog1.__dict__) # {'name': '旺财', 'age': 3, 'species': 'Wolf'}

发生了什么？

当执行 dog1.species = "Wolf" 时，Python 并没有去修改 Dog 类的 species 变量。

它在 dog1 这个实例的 __dict__ 中创建了一个全新的实例变量，也叫 species。

现在，当你再次访问 dog1.species 时，查找链在第一步（检查实例的 __dict__）就找到了这个新创建的 species 变量，并返回它的值 "Wolf"。而 dog2 和 Dog 类的 species 变量完全不受影响。

场景三：通过类名修改类变量（这才是真正的修改）

要想真正修改类变量，并让所有实例都看到这个变化，你必须使用 类名.变量名 的方式。

python

运行

print(f"修改前, Dog.species: {Dog.species}")   # 'Canis lupus familiaris'
print(f"修改前, dog2.species: {dog2.species}") # 'Canis lupus familiaris'

# 关键点：通过类名修改
Dog.species = "Domestic Dog"

print("-" * 20)
print(f"修改后, Dog.species: {Dog.species}")   # 'Domestic Dog'
print(f"修改后, dog2.species: {dog2.species}") # 'Domestic Dog' (dog2 的值变了)

# 注意：之前被我们“污染”的 dog1 不受影响
print(f"修改后, dog1.species: {dog1.species}") # 'Wolf' (因为它自己的 __dict__ 里有)

结论：

• 实例.变量名 = 值：创建或修改实例变量。
• 类名.变量名 = 值：创建或修改类变量。

5. 可变对象作为类变量的 “陷阱”

当类变量是可变对象（如列表 list、字典 dict）时，情况会变得更加微妙和危险。

python

运行

class Cat:
    # 类变量，是一个可变的列表
    toys = []

    def __init__(self, name):
        self.name = name

cat1 = Cat("咪咪")
cat2 = Cat("花花")

# 给 cat1 的 toys 添加一个玩具
cat1.toys.append("毛线球")

# 查看结果
print(f"{cat1.name} 的玩具: {cat1.toys}") # 输出: 咪咪 的玩具: ['毛线球']
print(f"{cat2.name} 的玩具: {cat2.toys}") # 输出: 花花 的玩具: ['毛线球'] (Oh no! cat2 也有了！)
print(f"Cat 类的玩具: {Cat.toys}")         # 输出: Cat 类的玩具: ['毛线球']

为什么会这样？

因为 cat1.toys 遵循查找链，最终找到了 Cat 类的 toys 列表。append() 方法是在原地修改（mutate）这个列表对象。它并没有创建新的实例变量，而是直接修改了所有实例共享的那个类变量对象。

如何避免这个陷阱？

如果你想让每个实例都有自己独立的可变对象（比如一个空列表），你应该在 __init__ 方法中定义它。

python

运行

class Cat:
    def __init__(self, name):
        self.name = name
        # 在 __init__ 中定义，每个实例都有自己的 toys 列表
        self.toys = []

cat1 = Cat("咪咪")
cat2 = Cat("花花")

cat1.toys.append("毛线球")

print(f"{cat1.name} 的玩具: {cat1.toys}") # 输出: 咪咪 的玩具: ['毛线球']
print(f"{cat2.name} 的玩具: {cat2.toys}") # 输出: 花花 的玩具: [] (正确了！)

6. 最佳实践与总结

1. 明确意图：如果一个属性对所有实例都相同，且不会改变（或很少改变），就用类变量。例如，物理常数、配置默认值、计数器等。如果一个属性是每个实例独有的，会根据对象不同而变化，就用实例变量。例如，用户的姓名、ID、银行账户余额等。
2. 访问和修改的准则：访问类变量：推荐使用 类名.变量名，这样代码意图更清晰。使用 实例名.变量名 虽然也能访问，但可能会让人误以为它是实例变量。修改类变量：必须使用 类名.变量名 的方式，以确保所有实例都能看到这个修改。避免使用 实例名.变量名 的方式去修改类变量，因为这实际上是在创建一个新的实例变量，很容易引起混淆和 bug。
3. 警惕可变类变量：除非你明确需要所有实例共享一个可变对象（如一个全局缓存），否则不要使用可变对象作为类变量。如果每个实例需要自己的可变对象，请在 __init__ 方法中初始化它。

通过以上步骤的详解，你应该已经完全掌握了 Python 中类变量和实例变量的访问机制及其关键区别。记住 “查找链” 和 “修改的陷阱” 是掌握这个知识点的核心

weibo.com/ttarticle/p/ShOw?id=2309405222435149971710

weibo.com/ttarticle/p/ShOw?id=2309405222435108028421

weibo.com/ttarticle/p/ShOw?id=2309405222519157686523

weibo.com/ttarticle/p/ShOw?id=2309405222508588040656