一、核心概念区分

在开始之前，我们首先要明确两个基本概念：

1. 类变量 (Class Variable)定义位置：在类的内部，但在任何方法的外部。作用域：属于整个类，被该类的所有实例（对象）共享。内存存储：只在内存中创建一份。常见用途：用于定义所有实例都共享的属性或常量，例如计数、默认配置等。
2. 实例变量 (Instance Variable)定义位置：通常在类的 __init__ 方法中，通过 self.variable_name 的形式定义。作用域：属于特定的实例（对象）。每个实例都有自己独立的一份。内存存储：每个实例创建时，都会为其实例变量分配新的内存空间。常见用途：用于存储每个对象独有的数据。

二、访问步骤解析

Python 在访问一个对象的属性（例如 obj.attr）时，会遵循一个特定的查找顺序，这个顺序通常被称为 “MRO”（Method Resolution Order），但对于属性查找同样适用。

核心原则： 先在实例自身查找，找不到再去实例所属的类中查找。

1. 访问实例变量 (self.attr)

当你执行 self.attr 时，查找步骤如下：

1. 检查实例自身的 __dict__：Python 首先会检查这个对象（self）是否拥有一个名为 attr 的实例变量。每个实例都有一个内置的字典 __dict__ 来存储它的实例变量。
2. 如果找到：直接返回该变量的值。
3. 如果没找到：Python 会继续去该实例所属的类中查找。
4. 检查类的 __dict__：Python 会检查 self.__class__（即类对象）的 __dict__，看是否存在一个名为 attr 的类变量。
5. 如果找到：返回类变量的值。
6. 如果最终没找到：抛出 AttributeError 异常。

示例代码：

python

运行

class Dog:
    species = "Canis lupus familiaris"  # 类变量

    def __init__(self, name, age):
        self.name = name  # 实例变量
        self.age = age    # 实例变量

# 创建两个实例
dog1 = Dog("Buddy", 3)
dog2 = Dog("Max", 5)

# 1. 访问实例变量 (在实例 __dict__ 中找到)
print(f"{dog1.name} is {dog1.age} years old.")  # 输出: Buddy is 3 years old.
print(dog1.__dict__)  # 输出: {'name': 'Buddy', 'age': 3}

# 2. 访问类变量 (在实例 __dict__ 中未找到，去类 __dict__ 中找到)
print(f"{dog1.name} is a {dog1.species}.")  # 输出: Buddy is a Canis lupus familiaris.
print(dog1.__class__.__dict__)  # 输出: {... 'species': 'Canis lupus familiaris', ...}

2. 访问类变量 (Class.attr或self.attr)

你可以通过两种方式访问类变量：

• 通过类名访问 (Dog.species)：这是最直接、最清晰的方式。它会直接在类的 __dict__ 中查找。
• 通过实例访问 (dog1.species)：如上所述，它会遵循 “先实例，后类” 的查找顺序。

三、常见问题与陷阱

理解了访问步骤后，我们来看几个最容易出错的场景。

问题 1：通过实例 “修改” 类变量

这是最经典的陷阱！通过实例给类变量赋值，不会修改类变量本身，而是会在该实例中创建一个同名的实例变量，从而 “遮蔽”（shadow）了类变量。

错误示例：

python

运行

class Counter:
    count = 0  # 类变量，用于计数

# 创建实例
c1 = Counter()
c2 = Counter()

# 错误地尝试通过实例修改类变量
c1.count += 1  # 这行代码等价于 c1.count = c1.count + 1

print(f"c1.count: {c1.count}")   # 输出: c1.count: 1 (c1 现在有了自己的 count 实例变量)
print(f"c2.count: {c2.count}")   # 输出: c2.count: 0 (c2 仍然访问的是类变量)
print(f"Counter.count: {Counter.count}") # 输出: Counter.count: 0 (类变量根本没变！)

print(c1.__dict__)  # 输出: {'count': 1}
print(c2.__dict__)  # 输出: {}

分析：

1. c1.count += 1 首先执行右边的 c1.count。因为 c1 没有 count 实例变量，所以它找到了类变量 Counter.count，其值为 0。
2. 然后执行 0 + 1，得到 1。
3. 最后执行赋值操作 c1.count = 1。这个赋值操作在 c1 的 __dict__ 中创建了一个新的实例变量 count，其值为 1。
4. 从此以后，当你再访问 c1.count 时，Python 会直接返回这个实例变量的值，而不再去看类变量。

正确做法（如果想修改类变量）：

始终通过类名来修改类变量。

python

运行

Counter.count += 1

print(f"c1.count: {c1.count}")   # 输出: c1.count: 1 (c1 自己的实例变量仍然存在)
print(f"c2.count: {c2.count}")   # 输出: c2.count: 1 (c2 访问的是被修改后的类变量)
print(f"Counter.count: {Counter.count}") # 输出: Counter.count: 1

问题 2：可变对象作为类变量

当类变量是可变对象（如列表 list、字典 dict）时，情况会变得更加复杂和危险。因为所有实例共享这个可变对象，所以任何一个实例对它的原地修改都会影响到所有其他实例。

危险示例：

python

运行

class Dog:
    tricks = []  # 可变对象作为类变量

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

    def teach_trick(self, trick):
        # 这里的 self.tricks 实际上是 Dog.tricks
        self.tricks.append(trick)

dog1 = Dog("Buddy")
dog2 = Dog("Max")

dog1.teach_trick("sit")
dog2.teach_trick("shake")

print(f"{dog1.name}'s tricks: {dog1.tricks}") # 输出: Buddy's tricks: ['sit', 'shake']
print(f"{dog2.name}'s tricks: {dog2.tricks}") # 输出: Max's tricks: ['sit', 'shake']
print(f"Dog.tricks: {Dog.tricks}")           # 输出: Dog.tricks: ['sit', 'shake']

分析：

dog1.teach_trick("sit") 中的 self.tricks.append("sit") 操作，因为 dog1 没有 tricks 实例变量，所以它找到了类变量 Dog.tricks 并对其进行了原地修改（append）。同样，dog2 的操作也是如此。因此，所有实例和类本身看到的 tricks 列表都是被修改过的同一个列表。

正确做法（如果每个实例需要自己的可变对象）：

在 __init__ 方法中为每个实例创建一个新的可变对象。

python

运行

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

    def teach_trick(self, trick):
        self.tricks.append(trick)

dog1 = Dog("Buddy")
dog2 = Dog("Max")

dog1.teach_trick("sit")
dog2.teach_trick("shake")

print(f"{dog1.name}'s tricks: {dog1.tricks}") # 输出: Buddy's tricks: ['sit']
print(f"{dog2.name}'s tricks: {dog2.tricks}") # 输出: Max's tricks: ['shake']

四、总结与最佳实践

1. 明确意图：如果一个属性是所有实例共享的，定义为类变量。如果一个属性是每个实例独有的，定义为实例变量（在 __init__ 中用 self）。
2. 修改类变量：要修改类变量的值，始终使用类名（例如 Dog.species = "Wolf"），而不是实例名。这能清晰地表达你的意图，避免意外创建实例变量。
3. 警惕可变类变量：除非你明确希望所有实例共享一个可变对象（例如，一个全局的计数器列表），否则不要使用列表、字典等可变对象作为类变量。如果每个实例需要自己的可变对象，请在 __init__ 方法中初始化它。
4. 访问类变量：为了代码的可读性和清晰性，当你想访问类变量时，优先考虑使用类名（Dog.species），即使通过实例（self.species）也能访问到。这能明确告诉其他开发者，你正在使用的是一个共享的类属性。weibo.com/ttarticle/p/ShOw?id=2309405222534026494045

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

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

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