核心概念速览

• 类变量 (Class Variable)：定义在类的内部，但在任何方法的外部。它属于类本身，被所有该类的实例共享。
• 实例变量 (Instance Variable)：定义在类的方法（通常是 __init__ 方法）中，并且以 self. 开头。它属于特定的实例对象，每个实例都有一份自己独立的拷贝。

访问规则：查找顺序 (MRO - Method Resolution Order)

当你通过一个实例（例如 obj.attr）来访问一个属性时，Python 的查找顺序遵循以下规则，这个规则被称为 “LEGB 规则” 的一部分：

1. 先找实例自身：Python 会首先在实例自己的命名空间 (__dict__) 中查找该属性。
2. 再找类：如果实例中没有找到，Python 会去实例所属的类的命名空间中查找。
3. 最后找父类：如果类中也没有，Python 会沿着继承链去父类的命名空间中查找，直到找到为止。如果最终都没找到，就会抛出 AttributeError 异常。

简单来说，就是 实例属性的优先级高于类属性。

案例演示与步骤分析

让我们通过几个递进的案例来深入理解这个过程。

案例一：访问与修改

场景：定义一个 Dog 类，包含一个类变量 species 和一个实例变量 name。

python

运行

class Dog:
    # 1. 类变量：所有狗的默认物种
    species = "Canis lupus familiaris"

    def __init__(self, name, age):
        # 2. 实例变量：每个狗的名字和年龄都是独一无二的
        self.name = name
        self.age = age

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

步骤分析 1：访问类变量

• 通过类访问：Dog.speciesPython 直接在 Dog 类的命名空间中找到 species。结果：'Canis lupus familiaris'
• 通过实例访问：dog1.speciesPython 首先检查 dog1 的实例命名空间 (dog1.__dict__)，里面只有 {'name': 'Buddy', 'age': 3}，没有 species。查找失败，Python 接着检查 dog1 所属的类 Dog。在 Dog 类的命名空间中找到了 species。结果：'Canis lupus familiaris'
• 同样，dog2.species 的结果也是 'Canis lupus familiaris'。

步骤分析 2：修改类变量

• 通过类修改：Dog.species = "Wolf"这会直接修改 Dog 类命名空间中的 species 值。因为所有实例共享类变量，所以这个修改对所有实例都可见。print(dog1.species) -> 'Wolf'print(dog2.species) -> 'Wolf'
• 通过实例 "修改"：dog1.species = "Poodle"注意：这不是修改，而是创建！当你使用 实例.属性 = 值 的语法时，Python 的行为是在该实例的命名空间中创建一个新的属性。它不会去修改类的属性。现在，dog1.__dict__ 变成了 {'name': 'Buddy', 'age': 3, 'species': 'Poodle'}。从此以后，当你访问 dog1.species 时，Python 会在第一步（查找实例自身）就找到这个新创建的 species 属性，从而 “遮蔽”（shadow）了类的 species 属性。dog2 没有受到影响，因为它的实例命名空间中没有 species，所以它仍然会去访问类的 species。print(dog1.species) -> 'Poodle' (访问的是实例属性)print(dog2.species) -> 'Wolf' (访问的是类属性)print(Dog.species) -> 'Wolf' (类属性本身没变)

案例二：可变对象的陷阱

这是一个非常经典的面试题和错误来源。

场景：如果类变量是一个可变对象（如列表、字典），通过实例修改它会产生意想不到的结果。

python

运行

class Cat:
    # 类变量：一个空列表，计划用来存储每个猫的玩具
    toys = []

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

# 创建两个实例
cat1 = Cat("Whiskers")
cat2 = Cat("Tom")

错误操作：通过实例给 toys 列表添加元素。

python

运行

cat1.toys.append("Ball")
cat2.toys.append("Mouse")

步骤分析：

1. cat1.toys.append("Ball") 被执行时，Python 首先查找 cat1.toys。
2. 在 cat1 的实例命名空间中没有找到 toys。
3. Python 向上查找，在 Cat 类的命名空间中找到了 toys 列表。
4. append 方法是就地修改（in-place modification），它直接操作找到了的那个列表对象（也就是类变量 Cat.toys）。它没有创建新的实例变量。
5. 因此，cat1 和 cat2 都共享这个被修改过的列表。

结果：

python

运行

print(cat1.toys)  # 输出: ['Ball', 'Mouse']
print(cat2.toys)  # 输出: ['Ball', 'Mouse']
print(Cat.toys)   # 输出: ['Ball', 'Mouse']

这通常不是我们想要的结果。我们通常希望每个猫有自己独立的玩具列表。

正确做法：在 __init__ 方法中初始化可变的实例变量。

python

运行

class Cat:
    def __init__(self, name):
        self.name = name
        # 在实例化时，为每个实例创建一个独立的 toys 列表
        self.toys = []

cat1 = Cat("Whiskers")
cat2 = Cat("Tom")

cat1.toys.append("Ball")
cat2.toys.append("Mouse")

print(cat1.toys)  # 输出: ['Ball']
print(cat2.toys)  # 输出: ['Mouse']

总结与最佳实践

1. 明确用途：类变量：用于存储所有实例共享的数据，例如默认配置、计数等。实例变量：用于存储每个实例独有的数据。
2. 访问原则：访问类变量时，为了代码清晰，推荐使用 ClassName.variable 的方式，即使通过实例也能访问。这能明确告诉读者你正在操作的是一个共享的类属性。访问实例变量时，必须使用 self.variable。
3. 修改原则：要修改类变量的值，必须使用 ClassName.variable = new_value。避免使用 instance.variable = new_value 来修改类变量，因为这实际上是在创建一个实例变量，可能会导致混淆。
4. 警惕可变对象：当类变量是可变对象（列表、字典等）时，通过任何实例对其进行就地修改（如 append, extend, __setitem__）都会影响所有实例。如果每个实例需要一个独立的可变对象，请在 __init__ 方法中使用 self.variable = [] 或 self.variable = {} 来初始化。

希望这份详细的分析和案例能帮助你彻底理解 Python 中类变量与实例变量的访问机制！

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

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

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

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