好的，我们来详细、清晰地讲解 Python 中的类变量和实例变量。

这是一个 Python 面向对象编程（OOP）中的核心概念，理解它们的区别和联系对于编写高效、可维护的代码至关重要。

1. 核心定义与区别

首先，我们用一个表格来快速区分它们：

2. 访问步骤演示

我们通过一个完整的示例来演示如何访问和修改这两种变量。

示例场景：创建一个 Dog 类

假设我们要创建很多狗的对象。所有的狗都有一些共同的属性（比如物种都是 "Canis lupus familiaris"），但每只狗又有自己独特的名字和年龄。

• 物种：这是所有狗共享的，适合用类变量。
• 名字和年龄：这是每只狗独有的，适合用实例变量。

2.1 代码实现

python

运行

class Dog:
    # 1. 类变量 (Class Variable)
    # 定义在类的内部，所有方法的外部
    species = "Canis lupus familiaris"
    count = 0  # 另一个类变量，用于记录创建了多少只狗

    def __init__(self, name, age):
        # 2. 实例变量 (Instance Variable)
        # 定义在方法内部，通过 `self.` 前缀
        self.name = name
        self.age = age
        
        # 访问并修改类变量
        Dog.count += 1

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

    def speak(self, sound):
        # 临时变量，不是实例或类变量
        return f"{self.name} says {sound}"

# --- 访问演示 ---

# 1. 通过类名访问类变量
print(f"通过类名访问物种: {Dog.species}")
print(f"当前狗的数量 (通过类名): {Dog.count}")
print("-" * 20)

# 2. 创建实例
dog1 = Dog("Buddy", 3)
dog2 = Dog("Daisy", 5)

# 3. 通过实例访问实例变量
print(f"Dog1的名字: {dog1.name}")
print(f"Dog2的年龄: {dog2.age}")
print("-" * 20)

# 4. 通过实例访问类变量 (这是允许的，但有陷阱)
print(f"通过dog1访问物种: {dog1.species}")
print(f"通过dog2访问物种: {dog2.species}")
print(f"当前狗的数量 (通过dog1): {dog1.count}")
print("-" * 20)

# 5. 检查修改前的状态
print("修改前:")
print(f"Dog.species: {Dog.species}")
print(f"dog1.species: {dog1.species}")
print(f"dog2.species: {dog2.species}")
print("-" * 20)

# 6. 修改类变量 (正确方式)
Dog.species = "Canis familiaris" # 科学名称更新了
print("通过类名修改类变量后:")
print(f"Dog.species: {Dog.species}")
print(f"dog1.species: {dog1.species}") # 所有实例都看到了变化
print(f"dog2.species: {dog2.species}")
print("-" * 20)

# 7. 修改类变量 (错误/陷阱方式)
# 这实际上是给 dog1 实例创建了一个同名的实例变量！
dog1.species = "Wolf" 
print("通过实例(dog1)尝试修改类变量后:")
print(f"Dog.species: {Dog.species}")      # 类变量本身没变
print(f"dog1.species: {dog1.species}")    # dog1现在有了自己的'species'实例变量
print(f"dog2.species: {dog2.species}")    # dog2不受影响，仍然访问类变量
print("-" * 20)

# 8. 查看最终狗的数量
print(f"最终创建的狗的总数是: {Dog.count}")

2.2 运行结果与分析

plaintext

通过类名访问物种: Canis lupus familiaris
当前狗的数量 (通过类名): 0
--------------------
Dog1的名字: Buddy
Dog2的年龄: 5
--------------------
通过dog1访问物种: Canis lupus familiaris
通过dog2访问物种: Canis lupus familiaris
当前狗的数量 (通过dog1): 2
--------------------
修改前:
Dog.species: Canis lupus familiaris
dog1.species: Canis lupus familiaris
dog2.species: Canis lupus familiaris
--------------------
通过类名修改类变量后:
Dog.species: Canis familiaris
dog1.species: Canis familiaris
dog2.species: Canis familiaris
--------------------
通过实例(dog1)尝试修改类变量后:
Dog.species: Canis familiaris
dog1.species: Wolf
dog2.species: Canis familiaris
--------------------
最终创建的狗的总数是: 2

关键分析：

1. 访问顺序：当你使用 instance.variable_name 时，Python 会：

   • 首先在该实例自己的命名空间（__dict__）中查找 variable_name。
   • 如果找不到，再去该实例所属的类的命名空间中查找。
   • 所以 dog1.species 一开始会找到 Dog.species。

2. 修改陷阱：

   • Dog.species = "..."：这是真正地修改了类变量。因为所有实例共享这个变量，所以所有实例访问 species 时都会得到新值。
   • dog1.species = "..."：这不是修改类变量。这行代码的实际作用是给 dog1 这个实例新增了一个名为 species 的实例变量。从此以后，当你访问 dog1.species 时，Python 会直接返回这个新的实例变量，而不会再去查找类变量。这被称为 “属性遮蔽 (Attribute Shadowing)”。

3. 技巧与最佳实践总结

1. 明确用途：

   • 如果一个值对于类的所有实例都是相同的，并且不希望被轻易改变，就用类变量。例如，圆周率 pi、配置信息、计数器等。
   • 如果一个值对于每个实例都是独特的，或者需要在实例创建后可以独立修改，就用实例变量。例如，用户的 id、name、email 等。

2. 修改类变量的正确方式：

   • 为了代码的清晰和避免错误，始终通过类名来修改类变量，如 Dog.count += 1。
   • 避免使用 self.class_variable 的方式进行修改，因为这很容易让人误解，并且如果子类继承，可能会产生意想不到的行为。

3. 可变对象的警告 (非常重要！)

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

   示例：

   python

   运行

   class Cat:
       toys = []  # 可变类变量
   
   cat1 = Cat()
   cat2 = Cat()
   
   cat1.toys.append("Ball")
   
   print(cat1.toys)  # 输出: ['Ball']
   print(cat2.toys)  # 输出: ['Ball']  <-- Oh no! cat2也有了这个玩具！
   print(Cat.toys)   # 输出: ['Ball']
   

   解决方案：如果每个实例需要一个独立的可变对象副本，应该在 __init__ 方法中初始化它。

   python

   运行

   class Cat:
       def __init__(self):
           self.toys = []  # 每个实例都有自己的 toys 列表
   
   cat1 = Cat()
   cat2 = Cat()
   cat1.toys.append("Ball")
   
   print(cat1.toys)  # 输出: ['Ball']
   print(cat2.toys)  # 输出: []
   

4. 使用 self.__class__.variable

   • 在实例方法中，self.__class__ 指向实例所属的类。在某些需要动态确定类的场景下（例如在继承中），使用 self.__class__.count 比 ClassName.count 更灵活。但对于初学者，直接使用类名更清晰。

   python

   运行

   class Dog:
       count = 0
       def __init__(self):
           self.__class__.count += 1 # 和 Dog.count += 1 效果一样
   
   Dog()
   Dog()
   print(Dog.count) # 输出: 2
   

5. 查看命名空间

   • 你可以通过 instance.__dict__ 查看实例的属性字典，通过 Class.__dict__ 查看类的属性字典，这对于理解变量存储位置非常有帮助。

   python

   运行

   print(dog1.__dict__)
   # 输出: {'name': 'Buddy', 'age': 3, 'species': 'Wolf'} 
   # (注意这里有'species'，因为我们给它创建了实例变量)
   
   print(dog2.__dict__)
   # 输出: {'name': 'Daisy', 'age': 5}
   # (dog2没有自己的'species'变量)
   
   print(Dog.__dict__)
   # 输出: {..., 'species': 'Canis familiaris', 'count': 2, ...}
   # (类的命名空间里'species'还是原来的值)
   

总结

掌握类变量和实例变量的关键在于理解 **“共享”与“独有”** 的概念。

• 类变量：所有实例共享的 “共性” 数据。
• 实例变量：每个实例独有的 “个性” 数据。

遵循最佳实践，特别是通过类名修改类变量和警惕可变对象作为类变量，可以帮助你避免绝大多数相关的编程错误。