核心概念速览

在深入细节之前，我们先快速区分一下两者：

• 类变量 (Class Variable):定义位置: 在类的内部，但在任何方法的外部。所属对象: 属于类本身。共享性: 被所有该类的实例（对象）共享。一个实例对它的修改（在特定条件下）会影响所有其他实例。用途: 通常用于定义所有实例都通用的属性或常量，例如物种名、默认配置等。
• 实例变量 (Instance Variable):定义位置: 通常在 __init__ 方法中，通过 self.变量名 的形式定义。所属对象: 属于单个实例（对象）。共享性: 每个实例都有自己独立的一份拷贝，互不影响。用途: 用于存储每个实例独有的数据，例如姓名、年龄、ID 等。

访问规则与步骤梳理

当你使用 实例.变量名（例如 obj.name）的形式来访问一个变量时，Python 会遵循以下查找顺序，这个顺序被称为 "属性查找链" (Attribute Lookup Chain)：

1. 先找实例自身: Python 会首先在该实例的专属命名空间（__dict__）中查找这个变量名。如果找到了，就直接返回该实例变量的值。查找结束。如果没找到，则继续下一步。
2. 再找类: 如果在实例中没找到，Python 会去创建这个实例的类的命名空间（__dict__）中查找。如果找到了，就返回类变量的值。查找结束。如果没找到，则继续向父类查找（遵循 MRO - Method Resolution Order），直到找到为止。如果最终在整个继承链中都没找到，就会抛出 AttributeError 异常。

核心原则: 实例属性的优先级高于类属性。

实例讲解与原理剖析

让我们通过一个完整的例子来演示这个过程。

python

运行

class Dog:
    # 1. 类变量：所有狗都共享这个属性
    species = "Canis lupus familiaris" 
    count = 0 # 另一个类变量，用于计数

    def __init__(self, name, age):
        # 2. 实例变量：每个狗对象都有自己独特的 name 和 age
        self.name = name
        self.age = age
        Dog.count += 1 # 使用类名来修改类变量，确保所有实例共享同一份计数

    def description(self):
        # 在方法中访问实例变量和类变量
        return f"{self.name} is a {Dog.species} and is {self.age} years old."

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

# --- 访问变量 ---

# 1. 访问实例变量
print(f"Dog1's name: {dog1.name}")  # 输出: Dog1's name: Buddy
print(f"Dog2's name: {dog2.name}")  # 输出: Dog2's name: Max
# 解释：Python 直接在 dog1 和 dog2 的 __dict__ 中找到了 'name'。

# 2. 访问类变量 (通过实例)
print(f"Dog1's species: {dog1.species}") # 输出: Dog1's species: Canis lupus familiaris
print(f"Dog2's species: {dog2.species}") # 输出: Dog2's species: Canis lupus familiaris
# 解释：Python 在 dog1 的 __dict__ 中没有找到 'species'，于是去 Dog 类的 __dict__ 中找到了。

# 3. 访问类变量 (通过类名)
print(f"Species from Dog class: {Dog.species}") # 输出: Species from Dog class: Canis lupus familiaris
# 解释：这是访问类变量最直接、最明确的方式。

# 4. 查看 count 类变量
print(f"Total dogs created: {Dog.count}") # 输出: Total dogs created: 2
print(f"Dog1 sees count as: {dog1.count}") # 输出: Dog1 sees count as: 2
# 解释：count 被两个实例共享，所以值为 2。

关键点：修改变量

修改变量的行为是理解二者区别的关键。

情况一：修改实例变量

这只会影响当前实例。

python

运行

dog1.age = 4 # 修改 dog1 的实例变量
print(f"Dog1's new age: {dog1.age}")   # 输出: Dog1's new age: 4
print(f"Dog2's age remains: {dog2.age}") # 输出: Dog2's age remains: 5

情况二：通过实例 “修改” 类变量 ( 注意！)

这不会修改类变量，而是会在该实例中创建一个同名的实例变量，从而 “遮蔽”（shadow）掉类变量。

python

运行

# 假设我们想让 dog1 变成另一个物种
dog1.species = "Wolf" # 这里是关键！

# 查看 dog1 的 species
print(f"Dog1's species now: {dog1.species}") # 输出: Dog1's species now: Wolf
# 解释：Python 在 dog1 的 __dict__ 中找到了新创建的 'species' 实例变量，直接返回它。

# 查看 dog2 和 Dog 类的 species
print(f"Dog2's species still: {dog2.species}") # 输出: Dog2's species still: Canis lupus familiaris
print(f"Dog class species still: {Dog.species}") # 输出: Dog class species still: Canis lupus familiaris
# 解释：dog2 和 Dog 类的 species 完全不受影响。

# 查看 dog1 的 __dict__，可以发现 'species' 已经成为了它的实例属性
print(dog1.__dict__) # 输出: {'name': 'Buddy', 'age': 4, 'species': 'Wolf'}

情况三：通过类名修改类变量

这才是真正地修改了类变量，所有未被 “遮蔽” 的实例都会受到影响。

python

运行

# 真正地修改类变量
Dog.species = "Domestic Dog"

# 查看 dog2 的 species (它没有自己的 species 实例变量)
print(f"Dog2's species now: {dog2.species}") # 输出: Dog2's species now: Domestic Dog

# 查看 dog1 的 species (它有自己的 species 实例变量，所以被遮蔽了)
print(f"Dog1's species remains: {dog1.species}") # 输出: Dog1's species remains: Wolf

# 查看 Dog 类的 species
print(f"Dog class species now: {Dog.species}") # 输出: Dog class species now: Domestic Dog

可变对象作为类变量的 “陷阱”

当类变量是可变对象（如列表 list、字典 dict）时，通过实例修改它的内容会影响所有实例。这是因为你修改的是对象本身，而不是创建一个新的实例变量。

python

运行

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

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

    def teach_trick(self, trick):
        self.tricks.append(trick) # 通过 self 修改列表内容

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

cat1.teach_trick("sit")

print(f"Cat1's tricks: {cat1.tricks}") # 输出: Cat1's tricks: ['sit']
print(f"Cat2's tricks: {cat2.tricks}") # 输出: Cat2's tricks: ['sit'] (Oh no! Cat2 knows it too!)
print(f"Cat class tricks: {Cat.tricks}") # 输出: Cat class tricks: ['sit']

# 原因：cat1.tricks 和 cat2.tricks 指向的是同一个列表对象。
print(f"cat1.tricks id: {id(cat1.tricks)}")
print(f"cat2.tricks id: {id(cat2.tricks)}")
print(f"Cat.tricks id:  {id(Cat.tricks)}")
# 上面三行的输出会是同一个内存地址。

如何避免这个陷阱？

如果每个实例需要一个独立的可变对象，应该在 __init__ 方法中定义它。

python

运行

class Cat:
    def __init__(self, name):
        self.name = name
        self.tricks = [] # 在实例初始化时创建，每个实例都有自己的列表

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

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

cat1.teach_trick("sit")

print(f"Cat1's tricks: {cat1.tricks}") # 输出: Cat1's tricks: ['sit']
print(f"Cat2's tricks: {cat2.tricks}") # 输出: Cat2's tricks: [] (Good! Cat2 doesn't know it)

总结与最佳实践

1. 明确区分: 清楚地知道哪些数据是所有实例共享的（用类变量），哪些是每个实例独有的（用实例变量）。
2. 访问方式:访问实例变量：始终使用 self.变量名。访问类变量：在方法内部，为了代码清晰，推荐使用 类名.变量名（如 Dog.species），即使 self.变量名 也能工作。在类外部，可以使用 类名.变量名 或 实例.变量名（但要注意实例是否有同名属性遮蔽了它）。
3. 修改方式:修改实例变量：使用 self.变量名 = ...。修改类变量：必须使用 类名.变量名 = ...。避免使用 self.变量名 = ... 来修改类变量，因为这实际上是创建了一个实例变量。
4. 警惕可变类变量: 避免使用可变对象（列表、字典等）作为类变量，除非你明确希望所有实例共享它。如果需要每个实例独立拥有，请在 __init__ 中初始化。

通过遵循这些原则，你可以有效地利用类变量和实例变量，编写出结构清晰、行为可预测的 Python 代码。
weibo.com/ttarticle/p/ShOw?id=2309405222524693905634

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

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

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