Python中实例变量（Instance Variables）和类变量（Class Variables）的区别：中英双语

实例变量和类变量的区别：全面解析

在 Python 面向对象编程中，实例变量和类变量是两种常用的变量类型。它们在作用范围、存储位置和使用场景上存在显著区别。本文将详细介绍它们的概念、区别及使用方法，并通过示例帮助理解。

---

1. 实例变量是什么？

1.1 定义

实例变量是绑定到某个具体实例对象的数据，每个实例都有自己独立的实例变量。

它通过 self 关键字引用，并且只能通过对象访问。

1.2 定义方式

在 __init__ 方法中定义实例变量：

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

1.3 使用示例

p1 = Person("Alice", 25)
p2 = Person("Bob", 30)

print(p1.name, p1.age)  # 输出: Alice 25
print(p2.name, p2.age)  # 输出: Bob 30

分析：

p1 和 p2 是两个不同的实例，它们各自拥有独立的 name 和 age 属性。

修改一个实例的属性值不会影响另一个实例。

p1.age = 26
print(p1.age)  # 输出: 26
print(p2.age)  # 输出: 30

1.4 特点总结

1. 作用范围： 实例变量属于实例，只在该实例的作用域内有效。
2. 存储位置： 每个实例的实例变量存储在自己的 __dict__ 字典中。
3. 访问方式： 必须通过实例对象访问，不能通过类名直接访问。
4. 应用场景： 用于存储实例的特有数据，例如用户信息、配置参数等。

---

2. 类变量是什么？

2.1 定义

类变量是绑定到类本身的数据，而不是某个实例对象。

它通过 cls 引用，并且被类的所有实例共享。

2.2 定义方式

在类体中、方法外定义类变量：

class Person:
    species = "Human"  # 类变量

2.3 使用示例

p1 = Person()
p2 = Person()

print(p1.species)  # 输出: Human
print(p2.species)  # 输出: Human

# 修改类变量
Person.species = "Superhuman"
print(p1.species)  # 输出: Superhuman
print(p2.species)  # 输出: Superhuman

分析：

类变量 species 是共享的，所有实例都可以访问它。

修改类变量时，所有实例都会受到影响。

2.4 特点总结

1. 作用范围： 类变量属于类，对所有实例共享。
2. 存储位置： 类变量存储在类的 __dict__ 中，而不是实例的 __dict__。
3. 访问方式： 可以通过类名或实例访问，但建议通过类名访问。
4. 应用场景： 用于存储共享数据，例如计数器、常量等。

---

3. 实例变量和类变量的关键区别

特点	实例变量	类变量
绑定对象	绑定到具体实例	绑定到类本身
存储位置	每个实例单独存储在 实例的__dict__ 中	存储在 类的__dict__ 中
作用范围	只作用于特定实例	所有实例共享
访问方式	只能通过实例访问	可以通过类或实例访问，但推荐用类名访问
修改方式	修改后只影响当前实例	修改后影响所有实例
应用场景	存储实例特有数据	存储共享数据

---

4. 示例对比：深入理解

class Counter:
    # 类变量
    count = 0

    def __init__(self, name):
        # 实例变量
        self.name = name
        Counter.count += 1

    def display(self):
        print(f"Name: {self.name}, Count: {Counter.count}")

4.1 使用实例

c1 = Counter("A")
c2 = Counter("B")

c1.display()  # 输出: Name: A, Count: 2
c2.display()  # 输出: Name: B, Count: 2

# 修改实例变量
c1.name = "C"
c1.display()  # 输出: Name: C, Count: 2

# 修改类变量
Counter.count = 5
c1.display()  # 输出: Name: C, Count: 5
c2.display()  # 输出: Name: B, Count: 5

4.2 代码解析

1. 实例变量 (name)：
2. 每个实例都有独立的 name，互不干扰。
3. 类变量 (count)：
4. count 是类变量，用于统计创建的实例数量，所有实例共享同一个值。
5. 修改类变量会影响所有实例的访问结果。

---

5. Transformers 库中的实际应用示例

from transformers import AutoModel

class ModelWrapper:
    # 类变量：共享模型类型
    default_model_type = "bert-base-uncased"

    def __init__(self, model_name=None):
        # 实例变量：具体模型名称
        self.model_name = model_name or self.default_model_type
        self.model = AutoModel.from_pretrained(self.model_name)

    def display(self):
        print(f"Loaded model: {self.model_name}")

示例调用

model1 = ModelWrapper()
model1.display()  # 输出: Loaded model: bert-base-uncased

model2 = ModelWrapper("gpt2")
model2.display()  # 输出: Loaded model: gpt2

# 修改类变量
ModelWrapper.default_model_type = "roberta-base"

model3 = ModelWrapper()
model3.display()  # 输出: Loaded model: roberta-base

分析：

1. 类变量 default_model_type 是共享的，可以动态修改默认值。
2. 实例变量 model_name 是特定于每个实例的，确保实例化时可以指定不同的模型。

---

6. 总结与建议

实例变量： 适合存储与具体对象相关的数据，例如用户信息或配置参数。

类变量： 适合存储共享数据或统计信息，例如默认设置或计数器。

访问规则：

1. 类变量可通过类名或实例访问，但推荐通过类名操作。
2. 实例变量只能通过实例访问。

选择指南：

如果数据是每个实例独有的，请使用实例变量。

如果数据需要被所有实例共享，请使用类变量。

示例问题： 如果某个模型需要记录训练批次数量（共享），同时记录训练时的特定超参数（实例独有），如何设计？

答案： 使用类变量存储批次数量，用实例变量存储超参数配置。

Difference Between Instance Variables and Class Variables in Python

In Python, instance variables and class variables are two important types of attributes used in object-oriented programming. They differ in scope, storage, and usage. This blog provides a detailed explanation, including examples, to clarify their differences.

---

1. What is an Instance Variable?

1.1 Definition

An instance variable is associated with a specific instance of a class.

It is defined inside methods (usually __init__) using the self keyword.

Each instance has its own copy of instance variables.

1.2 Declaration

Instance variables are defined inside the constructor (__init__):

class Person:
    def __init__(self, name, age):
        self.name = name  # Instance variable
        self.age = age    # Instance variable

1.3 Example Usage

p1 = Person("Alice", 25)
p2 = Person("Bob", 30)

print(p1.name, p1.age)  # Output: Alice 25
print(p2.name, p2.age)  # Output: Bob 30

Key Observations:

Each instance (p1 and p2) has its own independent values for name and age.

Changes in one instance do not affect others:

p1.age = 26
print(p1.age)  # Output: 26
print(p2.age)  # Output: 30

1.4 Key Features

1. Scope: Specific to the instance where it is defined.
2. Storage: Stored in the __dict__ of each instance.
3. Access: Accessed only through instance objects.
4. Use Case: Suitable for storing unique attributes of an instance, such as user-specific settings.

---

2. What is a Class Variable?

2.1 Definition

A class variable is shared across all instances of a class.

It is defined outside any method but inside the class body.

Changes to class variables affect all instances.

2.2 Declaration

class Person:
    species = "Human"  # Class variable

2.3 Example Usage

p1 = Person()
p2 = Person()

print(p1.species)  # Output: Human
print(p2.species)  # Output: Human

# Modify class variable
Person.species = "Superhuman"
print(p1.species)  # Output: Superhuman
print(p2.species)  # Output: Superhuman

Key Observations:

The variable species is shared by all instances.

Changing the class variable affects all instances since they refer to the same data.

2.4 Key Features

1. Scope: Shared across all instances of a class.
2. Storage: Stored in the class’s __dict__, not in individual instances.
3. Access: Can be accessed through the class name or an instance (but class name is recommended).
4. Use Case: Suitable for storing shared data, such as counters or default values.

---

3. Key Differences Between Instance and Class Variables

Feature	Instance Variable	Class Variable
Binding	Bound to a specific instance.	Bound to the class itself.
Storage	Stored in the instance’s __dict__.	Stored in the class’s __dict__.
Scope	Specific to one instance.	Shared across all instances.
Access	Accessed through an instance only.	Accessed through class or instance.
Modification	Modifies only that instance’s variable.	Modifies the variable for all instances.
Use Case	Stores unique data for each instance.	Stores shared data or constants.

---

4. A Practical Example: Counter Class

class Counter:
    # Class variable
    count = 0

    def __init__(self, name):
        # Instance variable
        self.name = name
        Counter.count += 1  # Increment class variable

    def display(self):
        print(f"Name: {self.name}, Count: {Counter.count}")

4.1 Example Usage

c1 = Counter("A")
c2 = Counter("B")

c1.display()  # Output: Name: A, Count: 2
c2.display()  # Output: Name: B, Count: 2

# Modify instance variable
c1.name = "C"
c1.display()  # Output: Name: C, Count: 2

# Modify class variable
Counter.count = 5
c1.display()  # Output: Name: C, Count: 5
c2.display()  # Output: Name: B, Count: 5

Analysis:

1. The instance variable name is unique to each instance.
2. The class variable count tracks the number of instances and is shared across all instances.

---

5. Real-world Example with Transformers Library

from transformers import AutoModel

class ModelWrapper:
    # Class variable: shared default model type
    default_model_type = "bert-base-uncased"

    def __init__(self, model_name=None):
        # Instance variable: specific model name for the instance
        self.model_name = model_name or self.default_model_type
        self.model = AutoModel.from_pretrained(self.model_name)

    def display(self):
        print(f"Loaded model: {self.model_name}")

Example Usage

model1 = ModelWrapper()
model1.display()  # Output: Loaded model: bert-base-uncased

model2 = ModelWrapper("gpt2")
model2.display()  # Output: Loaded model: gpt2

# Modify class variable
ModelWrapper.default_model_type = "roberta-base"

model3 = ModelWrapper()
model3.display()  # Output: Loaded model: roberta-base

Analysis:

Class variable (default_model_type): Sets the default model type and is shared by all instances.

Instance variable (model_name): Allows each instance to load its own specific model.

---

6. Best Practices and Recommendations

1. Use instance variables for data that is unique to each object (e.g., user-specific configurations).
2. Use class variables for data shared across all instances (e.g., counters, constants, or defaults).
3. Always access class variables using the class name to avoid unintentional instance-specific behavior.
4. Avoid modifying mutable objects (like lists or dictionaries) stored in class variables, as they may lead to unexpected behaviors when shared between instances.

Example Issue:

class Example:
    shared_list = []  # Class variable

obj1 = Example()
obj2 = Example()

obj1.shared_list.append(1)  # Modifies shared_list
print(obj2.shared_list)     # Output: [1] (unexpected behavior)

---

7. Final Thoughts

Understanding the differences between instance variables and class variables is essential for writing clean, maintainable, and bug-free code. Always evaluate whether your data should be unique (instance variable) or shared (class variable) before deciding which type to use.

We also demonstrated how these concepts apply in the Transformers library, providing a practical example for AI and NLP enthusiasts. By leveraging these principles, you can design scalable and flexible systems effectively!

后记

2024年12月23日15点17分于上海，在GPT4o大模型辅助下完成。

作者：阿正的梦工坊