核心结论先行

当你通过一个实例（instance.attr）来访问一个属性时，Python 的查找顺序如下：

1. 先找实例自己：在实例的专属命名空间（__dict__）中查找。
2. 再找类：如果实例中没有，就在实例所属的类的命名空间（__dict__）中查找。
3. 最后找父类：如果类中也没有，就按照 ** 方法解析顺序（MRO）** 去父类中依次查找。

1. 什么是类变量和实例变量？

在深入流程之前，我们先明确两个基本概念：

• 类变量 (Class Variable)：定义在类的内部，但在任何方法的外部。属于类本身，被所有该类的实例共享。可以通过 类名.变量名 或 实例名.变量名 访问（在特定条件下）。
• 实例变量 (Instance Variable)：通常在 __init__ 方法中通过 self.变量名 的形式定义。属于特定的实例，每个实例都有一份自己的拷贝，互不影响。只能通过 实例名.变量名 访问。

代码示例：

python

运行

class Dog:
    # 类变量：所有狗都共享这个物种和腿的数量
    species = "Canis lupus familiaris"
    legs = 4

    def __init__(self, name, age):
        # 实例变量：每个狗都有自己的名字和年龄
        self.name = name
        self.age = age

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

2. 访问操作流程详解

场景一：访问实例变量 (self.name)

当执行 dog1.name 时：

1. 检查 dog1 的实例字典：Python 会先查看 dog1 对象内部的 __dict__ 属性。print(dog1.__dict__) 的输出是：{'name': 'Buddy', 'age': 3}
2. 找到属性：Python 在 dog1.__dict__ 中找到了键 'name'，于是直接返回其对应的值 'Buddy'。查找结束。

场景二：通过实例访问类变量 (dog1.species)

当执行 dog1.species 时：

1. 检查 dog1 的实例字典：Python 首先查看 dog1.__dict__。dog1.__dict__ 的内容是 {'name': 'Buddy', 'age': 3}。
2. 实例中未找到：字典里没有 'species' 这个键。
3. 检查 dog1 的类 (Dog) 的字典：Python 接着去 dog1 所属的类 Dog 的 __dict__ 中查找。print(Dog.__dict__) 的输出会包含 'species': 'Canis lupus familiaris' 和 'legs': 4 等。
4. 在类中找到属性：Python 在 Dog.__dict__ 中找到了键 'species'，返回其对应的值 'Canis lupus familiaris'。查找结束。

场景三：通过类访问类变量 (Dog.species)

当执行 Dog.species 时：

1. 检查 Dog 的类字典：Python 直接在 Dog 类的 __dict__ 中查找。
2. 找到属性：在 Dog.__dict__ 中找到了 'species'，返回其值 'Canis lupus familiaris'。查找结束。

关键点：通过类名访问时，不会去实例中查找。Dog.name 会直接报错 AttributeError: type object 'Dog' has no attribute 'name'，因为 name 是实例变量。

3. 核心陷阱：修改操作

访问的流程相对简单，但修改操作是最容易出错的地方，因为它会改变变量的归属。

陷阱一：通过实例 “修改” 类变量

看下面的代码：

python

运行

print(f"修改前, Dog.legs = {Dog.legs}")       # 输出: 修改前, Dog.legs = 4
print(f"修改前, dog1.legs = {dog1.legs}")     # 输出: 修改前, dog1.legs = 4

# 关键点：通过实例进行赋值操作
dog1.legs = 3 

print(f"修改后, Dog.legs = {Dog.legs}")       # 输出: 修改后, Dog.legs = 4 (类变量没变！)
print(f"修改后, dog1.legs = {dog1.legs}")     # 输出: 修改后, dog1.legs = 3 (实例变量变了)
print(dog1.__dict__)                           # 输出: {'name': 'Buddy', 'age': 3, 'legs': 3}

发生了什么？

1. 当执行 dog1.legs = 3 时，Python 并没有去 Dog 类的 __dict__ 中修改 legs 的值。
2. 相反，它在 dog1 实例自己的 __dict__ 中创建了一个全新的实例变量，也命名为 legs。
3. 从此以后，当你再通过 dog1.legs 访问时，Python 会优先在 dog1.__dict__ 中找到这个新创建的实例变量，而 **“遮蔽”（shadowing）** 了类变量 Dog.legs。
4. 其他实例，如 dog2，不受影响，因为它们的 __dict__ 中没有 legs，所以它们仍然会去访问类变量 Dog.legs。print(dog2.legs) 仍然输出 4。

结论：通过实例对一个属性进行赋值，永远是在给这个实例创建或修改它自己的实例变量，除非该属性是一个可变对象（见下一个陷阱）。

陷阱二：通过实例修改可变类变量（如列表、字典）

这是一个更隐蔽的陷阱。

python

运行

class Cat:
    # 类变量：一个空列表，打算用来记录所有猫的名字
    all_names = []

    def __init__(self, name):
        self.name = name
        # 错误的做法：通过实例去修改可变类变量
        self.all_names.append(name) 

cat1 = Cat("Kitty")
cat2 = Cat("Luna")

print(cat1.all_names)  # 输出: ['Kitty', 'Luna']
print(cat2.all_names)  # 输出: ['Kitty', 'Luna']
print(Cat.all_names)   # 输出: ['Kitty', 'Luna']

为什么这次类变量被修改了？

1. self.all_names.append(name) 这行代码不是赋值操作 (=)，而是就地修改操作。
2. Python 执行 self.all_names 时，遵循查找链：在 cat1 的 __dict__ 中找不到 all_names。于是去 Cat 类的 __dict__ 中找到了 all_names，它指向一个列表对象 []。
3. 接着，.append(name) 方法被调用，它直接修改了那个被所有实例共享的列表对象。
4. 因为没有使用 =，所以没有在实例 cat1 或 cat2 的 __dict__ 中创建新的实例变量。

如何正确修改类变量？

如果你想在方法中修改类变量本身，最佳实践是明确使用类名。

python

运行

class Cat:
    all_names = []

    def __init__(self, name):
        self.name = name
        # 正确的做法：明确通过类名来修改类变量
        Cat.all_names.append(name)

cat1 = Cat("Kitty")
cat2 = Cat("Luna")

print(Cat.all_names)  # 输出: ['Kitty', 'Luna']

4. 总结与最佳实践

1. 访问规则：实例.属性 的查找顺序是 实例自身 -> 类 -> 父类。
2. 修改规则：实例.属性 = 值：总是创建或修改实例变量。类.属性 = 值：总是创建或修改类变量。实例.属性.方法()（如 append）：如果 属性 是可变对象且在实例中找不到，则会找到并就地修改类变量。这很危险，应避免。
3. 最佳实践：当你想操作类变量时，无论在类的内部还是外部，都始终使用 类名.变量名 的形式，以保证代码的清晰和意图的明确。当你想操作实例变量时，始终使用 self.变量名 的形式。避免使用可变对象（如列表、字典）作为类变量，除非你明确希望所有实例共享并修改它。如果不确定，就把它放在 __init__ 里作为实例变量。

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

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

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

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