核心原则：LEGB 规则与查找顺序

在 Python 中，当你使用一个变量名（比如 self.name 或 MyClass.name）时，Python 会遵循一个特定的查找顺序来确定你指的是哪个变量。这个顺序可以概括为：

1. 实例自身 (Instance): 先在当前实例对象的 __dict__ 属性中查找。
2. 类 (Class): 如果实例中找不到，再到实例所属的类的 __dict__ 属性中查找。
3. 父类 (Parent Classes): 如果类中也找不到，会按照方法解析顺序（MRO, Method Resolution Order）去父类中查找。
4. 报错: 如果在所有地方都找不到，就会抛出 AttributeError 异常。

1. 实例变量 (Instance Variables)

实例变量是绑定到具体实例对象的变量。每个实例都拥有一份自己独立的实例变量副本，修改一个实例的变量不会影响其他实例。

访问流程：

当你执行 instance.variable_name 时：

1. 检查实例的 __dict__: Python 首先检查这个具体实例对象内部的 __dict__ 字典。这个字典存储了该实例所有的属性。
2. 找到则返回: 如果在 __dict__ 中找到了名为 variable_name 的键，就返回其对应的值。
3. 未找到则继续查找: 如果在实例的 __dict__ 中没有找到，Python 会转而执行类变量的查找流程。

代码示例：

python

运行

class Dog:
    species = "Canis familiaris"  # 这是一个类变量

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

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

# 访问实例变量
print(f"{dog1.name} is {dog1.age} years old.")  # 输出: Buddy is 3 years old.
print(f"{dog2.name} is {dog2.age} years old.")  # 输出: Max is 5 years old.

# 证明实例变量是独立的
dog1.age = 4
print(f"After birthday, {dog1.name} is {dog1.age} years old.")  # 输出: After birthday, Buddy is 4 years old.
print(f"{dog2.name} is still {dog2.age} years old.")            # 输出: Max is still 5 years old.

# 查看实例的 __dict__
print(dog1.__dict__)  # 输出: {'name': 'Buddy', 'age': 4}
print(dog2.__dict__)  # 输出: {'name': 'Max', 'age': 5}

在这个例子中，访问 dog1.name 时，Python 直接在 dog1 的 __dict__ 中找到了 'name' 键，因此直接返回了 'Buddy'。

2. 类变量 (Class Variables)

类变量是绑定到类本身的变量。它被所有该类的实例所共享。

访问流程：

访问类变量有两种方式：Class.variable_name 和 instance.variable_name。

a) 通过类名访问 (Class.variable_name)

这是最直接、最明确的方式。

1. 检查类的 __dict__: Python 直接检查 Class 这个类对象的 __dict__ 字典。
2. 找到则返回: 如果找到，返回对应的值。
3. 未找到则查找父类: 如果在当前类的 __dict__ 中没有找到，Python 会沿着继承链（MRO）去父类的 __dict__ 中查找。
4. 报错: 如果最终都找不到，抛出 AttributeError。

b) 通过实例访问 (instance.variable_name)

这种方式比较特殊，它会触发我们开头提到的完整查找流程。

1. 先检查实例 __dict__: Python 首先检查 instance 对象的 __dict__。
2. 实例中有则返回: 如果实例自己定义了这个变量（即它是一个实例变量），则返回实例变量的值。类变量会被实例变量 “遮蔽”（shadowing）。
3. 实例中没有则检查类 __dict__: 如果实例中没有这个变量，Python 会接着检查 instance.__class__（即实例所属的类）的 __dict__。
4. 类中有则返回: 如果在类的 __dict__ 中找到了，就返回类变量的值。
5. 类中也没有则查找父类: 如果类中也没有，继续沿着继承链查找父类。
6. 报错: 如果最终都找不到，抛出 AttributeError。

代码示例：

python

运行

class Dog:
    species = "Canis familiaris"  # 类变量，所有狗共享
    count = 0                     # 另一个类变量，用于计数

    def __init__(self, name):
        self.name = name          # 实例变量
        Dog.count += 1            # 在构造函数中修改类变量

# 1. 通过类名访问
print(f"所有狗的物种都是: {Dog.species}")  # 输出: 所有狗的物种都是: Canis familiaris

# 2. 创建实例
dog1 = Dog("Buddy")
dog2 = Dog("Max")

# 3. 通过实例访问类变量（因为实例自身没有 species 变量）
print(f"{dog1.name} 的物种是: {dog1.species}")  # 输出: Buddy 的物种是: Canis familiaris
print(f"{dog2.name} 的物种是: {dog2.species}")  # 输出: Max 的物种是: Canis familiaris

# 4. 类变量被所有实例共享
print(f"总共创建了 {Dog.count} 只狗。")      # 输出: 总共创建了 2 只狗。
print(f"通过 dog1 看到的总数: {dog1.count}") # 输出: 通过 dog1 看到的总数: 2
print(f"通过 dog2 看到的总数: {dog2.count}") # 输出: 通过 dog2 看到的总数: 2

# 5. 实例变量遮蔽类变量的情况
print("\n--- 实例变量遮蔽类变量 ---")
print(f"修改前，dog1.species: {dog1.species}") # 输出: 修改前，dog1.species: Canis familiaris

dog1.species = "Wolf"  # 这里我们给 dog1 实例创建了一个同名的实例变量！

print(f"修改后，dog1.species: {dog1.species}") # 输出: 修改后，dog1.species: Wolf (现在访问的是实例变量)
print(f"dog2.species 不受影响: {dog2.species}") # 输出: dog2.species 不受影响: Canis familiaris (它访问的仍然是类变量)
print(f"Dog.species 也不受影响: {Dog.species}")  # 输出: Dog.species 也不受影响: Canis familiaris

# 查看 __dict__ 来验证
print(f"dog1.__dict__: {dog1.__dict__}") # 输出: dog1.__dict__: {'name': 'Buddy', 'species': 'Wolf'}
print(f"Dog.__dict__: {Dog.__dict__}")   # 输出: ... 'species': 'Canis familiaris', 'count': 2 ...

3. 总结与最佳实践

最佳实践建议：

1. 访问类变量：为了代码的清晰和避免错误，强烈建议始终使用 Class.variable_name 的方式来访问和修改类变量，尤其是在类的方法内部。
2. python
3. 运行
4. class Dog: count = 0 def __init__(self, name): self.name = name # 推荐的方式 Dog.count += 1
5. 修改类变量：绝对不要在实例方法中使用 self.class_variable 的方式去修改一个可变的类变量（如列表、字典），除非你明确知道你在做什么。
6. python
7. 运行详解 Python 访问类变量与实例变量的流程步骤
8. class WrongExample: items = [] # 可变的类变量 def add_item(self, item): # 危险操作！这会修改共享的类变量 self.items.append(item) a = WrongExample() a.add_item("apple") print(a.i详解 Python 访问类变量与实例变量的流程步骤详解 Python 访问类变量与实例变量的流程步骤tems) # 输出: ['apple'] b = WrongExample() print(b.items) # 输出: ['apple'] # b 实例也看到了这个变化！
9. 如果你想每个实例有自己的 items 列表，应该在 __init__ 方法中初始化它：
10. python
11. 运行
12. class CorrectExample: def __init__(self): self.items = [] # 每个实例都有自己的 items 列表 def add_item(self, item): self.items.append(item) a = CorrectExample() a.add_item("apple") print(a.items) # 输出: ['apple'] b = CorrectExample() print(b.items) # 输出: [] # b 实例不受影响

希望这个详细的解释能帮助你彻底理解 Python 中类变量和实例变量的访问机制！

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

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

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

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