1. 核心概念：什么是类变量和实例变量？

在开始讨论访问步骤之前，我们首先要明确这两个概念的定义和区别。

• 类变量 (Class Variable)定义位置：在类的内部，但在任何方法（包括 __init__）的外部定义。所属对象：属于类本身。共享机制：被该类的所有实例（对象）共享。无论你通过哪个实例或类本身去访问它，你访问的都是同一个变量。常见用途：用于定义所有实例都共有的属性或常量，例如计数、默认配置等。
• 实例变量 (Instance Variable)定义位置：通常在类的 __init__ 方法中，通过 self.variable_name 的形式定义。也可以在其他实例方法中通过 self 动态添加。所属对象：属于具体的实例（对象）。共享机制：每个实例都拥有一份独立的拷贝。修改一个实例的变量，不会影响其他实例。常见用途：用于存储每个实例独有的数据，例如用户的姓名、年龄、ID 等。

代码示例：

python

运行

class Dog:
    # 类变量：所有 Dog 实例共享
    species = "Canis lupus familiaris"
    count = 0  # 用于记录实例的数量

    def __init__(self, name, age):
        # 实例变量：每个 Dog 实例独有的
        self.name = name
        self.age = age
        
        # 访问并修改类变量
        Dog.count += 1

2. 核心规则：变量查找顺序 (MRO)

这是理解访问步骤的关键。当你使用 instance.variable_name 的形式访问一个变量时，Python 会遵循以下顺序进行查找，这个顺序被称为 “方法解析顺序”（Method Resolution Order, MRO）的一部分，但同样适用于属性（变量）查找。

查找顺序：

1. 首先，在实例自身的命名空间中查找 (instance.__dict__)Python 会检查该对象是否拥有一个名为 variable_name 的实例变量。你可以通过 print(my_dog.__dict__) 来查看一个实例的所有实例变量。如果找到，就直接返回该变量的值。查找结束。
2. 如果实例中没有，再到实例所属的类的命名空间中查找 (Class.__dict__)如果在实例中找不到，Python 会去创建这个实例的类（my_dog.__class__）中查找。如果在类中找到了名为 variable_name 的类变量，就返回该类变量的值。查找结束。
3. 如果类中也没有，再到父类的命名空间中查找如果在当前类中也找不到，Python 会按照 MRO 的顺序，依次到各个父类中查找。如果在任何父类中找到，就返回其值。
4. 如果最终都找不到，抛出 AttributeError 异常如果在实例、类、父类的整个查找链中都没有找到该变量，Python 就会抛出 AttributeError: 'ClassName' object has no attribute 'variable_name'。

记忆口诀： 先找自己（实例），再找老家（类），最后找祖宗（父类）。

3. 详细访问步骤与实例解析

我们用一个完整的例子来分解访问的每一步。

python

运行

class Animal:
    kingdom = "Animalia"  # 父类的类变量

class Dog(Animal):
    species = "Canis lupus familiaris"  # 子类的类变量

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

# 创建实例
dog1 = Dog("Buddy")

场景一：访问实例变量dog1.name

1. 查找实例 dog1 的 __dict__：dog1.__dict__ 的内容是 {'name': 'Buddy'}。Python 找到了 'name' 这个键。
2. 返回值：直接返回 'Buddy'。查找停止。

场景二：访问类变量dog1.species

1. 查找实例 dog1 的 __dict__：dog1.__dict__ 的内容是 {'name': 'Buddy'}。Python 没有找到 'species' 这个键。
2. 查找实例所属的类 Dog 的 __dict__：Dog.__dict__ 中包含 'species' 这个键，其值为 "Canis lupus familiaris"。Python 找到了 'species'。
3. 返回值：返回 "Canis lupus familiaris"。查找停止。

场景三：访问父类的类变量dog1.kingdom

1. 查找实例 dog1 的 __dict__：没有找到 'kingdom'。
2. 查找类 Dog 的 __dict__：也没有找到 'kingdom'。
3. 查找父类 Animal 的 __dict__：Animal.__dict__ 中包含 'kingdom'，其值为 "Animalia"。Python 找到了 'kingdom'。
4. 返回值：返回 "Animalia"。查找停止。

场景四：访问一个不存在的变量dog1.age

1. 查找实例 dog1 的 __dict__：没找到。
2. 查找类 Dog 的 __dict__：没找到。
3. 查找父类 Animal 的 __dict__：没找到。
4. 抛出异常：AttributeError: 'Dog' object has no attribute 'age'。

4. 修改变量的关键区别：“遮蔽” (Shadowing)

访问变量的规则相对统一，但修改变量时，类变量和实例变量的行为有巨大差异，这是最容易出错的地方。

4.1 修改实例变量

这很直接。使用 instance.variable = value 时，Python 总是在实例的命名空间中操作。

• 如果变量已存在于实例中，就更新它的值。
• 如果变量不存在于实例中，就创建一个新的实例变量。

示例：

python

运行

dog1.age = 3  # 在 dog1.__dict__ 中新增一个 age 变量
print(dog1.__dict__)  # 输出: {'name': 'Buddy', 'age': 3}

dog1.name = "Max"  # 更新 dog1.__dict__ 中的 name 变量
print(dog1.name)  # 输出: Max

4.2 修改类变量

这里有两种方式，效果完全不同。

方式一：通过类名修改 (Class.variable = new_value)

这是真正地修改类变量。这个操作会直接更新类命名空间中的变量值，由于所有实例共享类变量，所以这个改动会影响到所有实例。

示例：

python

运行

print(f"修改前, dog1.species: {dog1.species}")  # 输出: Canis lupus familiaris
print(f"修改前, Dog.species: {Dog.species}")    # 输出: Canis lupus familiaris

# 通过类名修改
Dog.species = "Canis familiaris"

print(f"修改后, dog1.species: {dog1.species}")  # 输出: Canis familiaris (所有实例都受影响)
print(f"修改后, Dog.species: {Dog.species}")    # 输出: Canis familiaris

方式二：通过实例修改 (instance.variable = new_value)

这不是修改类变量，而是在实例中创建一个同名的实例变量。这个新创建的实例变量会 “遮蔽”（shadow）掉类变量。从此以后，当你通过这个实例访问 variable 时，会优先找到这个实例变量，而类变量的值并未改变。

示例：

python

运行

dog2 = Dog("Lucky")

# 初始时，dog2 和 dog1 都访问的是类变量 species
print(f"dog1.species: {dog1.species}")  # 输出: Canis lupus familiaris
print(f"dog2.species: {dog2.species}")  # 输出: Canis lupus familiaris

# 通过 dog1 实例 "修改" species
dog1.species = "Wolf"  # 关键点：这在 dog1 实例中创建了一个新的 species 变量

# 查看结果
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 的字典，证实了新变量的存在
print(dog1.__dict__)  # 输出: {'name': 'Buddy', 'species': 'Wolf'}

5. 特殊情况：可变对象作为类变量

这是一个非常经典的陷阱。如果类变量是一个可变对象（如列表 list、字典 dict），通过实例对其进行原地修改（in-place modification），会直接影响到类变量本身，从而影响所有实例。

原因：当你执行
instance.mutable_class_var.append(...) 时，你并没有给实例创建一个新变量（这不像 = 赋值），而是遵循查找规则找到了类变量，并调用了它的方法来修改它。

示例：

python

运行

class Cat:
    toys = []  # 可变对象作为类变量

cat1 = Cat()
cat2 = Cat()

# 通过 cat1 实例向 toys 列表添加元素
cat1.toys.append("ball")

# 查看结果，发现 cat2 的 toys 也变了！
print(f"cat1's toys: {cat1.toys}")  # 输出: ['ball']
print(f"cat2's toys: {cat2.toys}")  # 输出: ['ball']
print(f"Cat's toys: {Cat.toys}")    # 输出: ['ball'] (类变量本身被修改了)

正确做法：如果每个实例需要一个独立的可变对象，应该在 __init__ 方法中初始化它。

python

运行

class Cat:
    def __init__(self):
        self.toys = []  # 每个实例都有自己独立的 toys 列表

cat1 = Cat()
cat2 = Cat()

cat1.toys.append("ball")

print(f"cat1's toys: {cat1.toys}")  # 输出: ['ball']
print(f"cat2's toys: {cat2.toys}")  # 输出: [] (cat2不受影响)

6. 总结

最佳实践：

1. 明确意图：如果你想修改所有实例共享的值，请始终使用 Class.variable 的形式。
2. 全面详解 Python 类变量与实例变量的访问步骤全面详解 Python 类变量与实例变量的访问步骤全面详解 Python 类变量与实例变量的访问步骤避免混淆：如果你想为某个实例设置一个特定的值，请使用 instance.variable，但要清楚这会创建一个实例变量。
3. 慎用可变类变量：除非你明确需要一个所有实例共享的可变状态（例如一个全局计数器或缓存），否则应避免使用可变对象作为类变量。对于每个实例独有的可变状态，请在 __init__ 中初始化。

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

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

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

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