类变量与实例变量的区别详解

类变量属于类本身，被所有实例共享，修改会影响全部实例；实例变量属于每个实例，独立存在，互不影响。类变量适用于共享数据如常量、计数器，实例变量用于对象独有属性如姓名、状态。可变类变量易引发意外共享，继承中子类可遮蔽父类类变量，而实例变量通过super()继承并保持独立。

类变量和实例变量的核心区别在于它们的作用域和生命周期：类变量是属于类本身的，被该类的所有实例共享；而实例变量则独属于每个独立创建的实例，每个实例都有自己的一份。理解这一点，就像理解一个家族的族规（类变量）和每个家庭成员的私有财产（实例变量）一样，虽然比喻有点老套，但确实能帮我快速区分。

解决方案

简单来说，类变量是直接在类定义内部、任何方法之外声明的变量。它们在类被加载时创建，并且所有该类的实例都共享同一个类变量的副本。这意味着，如果你通过类名或者任何一个实例去修改一个可变的类变量，这个修改会反映在所有其他实例上。

class MyClass:
    class_variable = "我是类变量，大家共享" # 类变量

    def __init__(self, instance_data):
        self.instance_variable = instance_data # 实例变量
        print(f"新实例创建，我的实例变量是: {self.instance_variable}")

# 访问类变量
print(MyClass.class_variable) # 输出: 我是类变量，大家共享

# 创建实例
obj1 = MyClass("obj1的数据")
obj2 = MyClass("obj2的数据")

# 访问实例变量
print(obj1.instance_variable) # 输出: obj1的数据
print(obj2.instance_variable) # 输出: obj2的数据

# 通过实例访问类变量
print(obj1.class_variable) # 输出: 我是类变量，大家共享
print(obj2.class_variable) # 输出: 我是类变量，大家共享

# 修改类变量
MyClass.class_variable = "类变量被修改了"
print(obj1.class_variable) # 输出: 类变量被修改了 (所有实例都受影响)
print(obj2.class_variable) # 输出: 类变量被修改了

# 修改实例变量
obj1.instance_variable = "obj1的新数据"
print(obj1.instance_variable) # 输出: obj1的新数据
print(obj2.instance_variable) # 输出: obj2的数据 (obj2不受影响)

实例变量则不同，它们通常在类的 __init__ 方法中，使用 self 关键字来定义。每当你创建一个新的实例时，__init__ 方法就会被调用，为这个新实例创建一套全新的实例变量。所以，即使两个实例的实例变量名相同，它们在内存中也是独立的，一个实例修改自己的实例变量，不会影响到其他实例。

什么时候应该选择类变量，什么时候选择实例变量？

我个人在决定使用哪种变量时，主要看这个数据是否需要被所有对象共享，或者它是不是某个对象的专属属性。

选择类变量的场景：

• 常量或默认值： 如果你有一些所有实例都应该遵守的固定值，比如一个默认的配置参数，或者一个计算圆周率的常量 PI，类变量是理想的选择。它们只占用一份内存，并且易于访问。
• 计数器： 比如你想统计某个类创建了多少个实例，就可以用一个类变量作为计数器，每创建一个实例就在 __init__ 里自增一次。
• 共享资源或状态： 当所有实例需要访问同一个资源或共享一个状态时，比如一个数据库连接池、一个全局缓存对象，或者某种通用配置。
• 性能考量： 对于那些不随实例变化的数据，使用类变量可以避免每个实例都存储一份相同的副本，从而节省内存。

我个人倾向于把那些“全局”但又局限于某个类范畴的东西放进类变量，这样代码读起来也更直观，一眼就能看出这是类级别的共享属性。

选择实例变量的场景：

• 对象特有的属性： 这是最常见的用途。如果每个对象都需要有自己的“身份证明”——比如姓名、年龄、ID、余额、状态等——那毫无疑问，实例变量是唯一选择。它们定义了每个对象的独特状态。
• 封装对象行为所需的数据： 比如一个 Car 类的 speed 或 color，这些都是特定于某辆车的属性。
• 需要独立修改的属性： 当你希望一个对象的属性修改不会影响到其他对象时，就必须使用实例变量。

记住，如果每个对象都需要有自己的“身份证明”，那毫无疑问，实例变量是唯一选择。

修改类变量会带来哪些意想不到的问题？

我见过太多新手（包括我自己刚开始时）在这里栽跟头，以为只是改了自己实例的属性，结果发现所有兄弟姐妹都跟着“变脸”了，那种困惑真是记忆犹新。这个问题主要发生在类变量是一个可变对象（比如列表、字典或自定义对象）时。

考虑下面这个例子：

class Player:
    # 这是一个可变对象作为类变量
    team_roster = [] # 默认球队花名册

    def __init__(self, name):
        self.name = name
        # 错误示范：直接操作类变量的可变对象
        # self.team_roster.append(name) # 这样会修改所有Player实例共享的team_roster

# 创建第一个玩家
player1 = Player("Alice")
Player.team_roster.append(player1.name) # 通过类名添加，没问题

# 创建第二个玩家
player2 = Player("Bob")
# 如果player2也想加入花名册，并且错误地直接操作类变量
# player2.team_roster.append(player2.name) # 此时player1.team_roster也会看到Bob

print(Player.team_roster) # 输出: ['Alice']

# 假设我们想让每个玩家都有自己的背包
class Adventurer:
    # 错误的类变量：所有冒险者共享同一个背包
    backpack = []

    def __init__(self, name):
        self.name = name
        # 这样会导致所有Adventurer实例共享同一个backpack列表
        # 如果一个Adventurer捡到东西，所有Adventurer的背包都会多出这个东西
        # self.backpack.append("初始物品") # 这是一个常见的错误！

# 正确的做法是让backpack成为实例变量
class ProperAdventurer:
    def __init__(self, name):
        self.name = name
        self.backpack = [] # 每个ProperAdventurer都有自己的独立背包

adventurer1 = ProperAdventurer("Arthur")
adventurer2 = ProperAdventurer("Merlin")

adventurer1.backpack.append("Excalibur")
adventurer2.backpack.append("Magic Wand")

print(f"{adventurer1.name}'s backpack: {adventurer1.backpack}") # 输出: Arthur's backpack: ['Excalibur']
print(f"{adventurer2.name}'s backpack: {adventurer2.backpack}") # 输出: Merlin's backpack: ['Magic Wand']

# 如果是类变量，并且通过实例赋值一个不可变类型，会发生“遮蔽”
class Config:
    version = "1.0"

conf1 = Config()
conf2 = Config()

print(f"初始版本: {conf1.version}, {conf2.version}") # 1.0, 1.0

conf1.version = "1.1" # 这不是修改类变量，而是为conf1创建了一个新的实例变量version
print(f"conf1修改后: {conf1.version}, {conf2.version}, {Config.version}") # 1.1, 1.0, 1.0

当一个实例通过 self.class_variable = new_value 尝试修改类变量时，如果 new_value 是一个不可变类型（如字符串、数字、元组），Python 不会修改类变量，而是会为这个特定实例创建一个新的实例变量，这个实例变量会“遮蔽”同名的类变量。而如果 class_variable 本身是一个可变对象，并且你通过 self.class_variable.append() 或 self.class_variable['key'] = value 这样的操作去修改它的内容，那么你实际上是在修改所有实例共享的那个类变量对象。这两种行为的差异是导致混乱的根源。

在继承场景下，类变量和实例变量的行为有何不同？

继承体系下的类变量，就像家族的祖传秘方，子孙后代都能用，但如果你想改秘方，最好是自己重新写一份，而不是直接在祖传秘方上涂涂改改，否则容易出乱子。实例变量就简单多了，每个孩子都有自己的玩具，跟父母的玩具是分开的，爱怎么玩就怎么玩，互不影响。

类变量在继承中的行为：

子类会继承父类的类变量。

1. 直接继承与共享： 如果子类没有定义同名的类变量，它会直接使用父类的类变量。所有子类实例和父类实例都共享同一个父类定义的类变量。
2. 子类“遮蔽”： 如果子类定义了一个与父类同名的类变量，那么对于这个子类及其实例来说，它会使用自己定义的类变量，从而“遮蔽”了父类的同名类变量。父类及其其他子类则不受影响。
3. 可变类变量的陷阱： 如果父类有一个可变的类变量（比如一个列表），而子类或子类的实例直接去修改这个列表的内容（而不是重新赋值），那么父类和所有其他子类都会看到这个修改。这是因为它们都在操作同一个内存中的对象。

class Parent:
    shared_list = [1, 2] # 可变类变量
    version = "1.0"      # 不可变类变量

class Child(Parent):
    pass # 继承所有父类属性

class GrandChild(Parent):
    version = "2.0" # 遮蔽了父类的version

# 访问父类的类变量
print(Parent.shared_list, Parent.version) # [1, 2], 1.0

# Child继承了Parent的类变量
print(Child.shared_list, Child.version) # [1, 2], 1.0

# GrandChild遮蔽了version
print(GrandChild.shared_list, GrandChild.version) # [1, 2], 2.0

# 修改Parent的shared_list (通过类名)
Parent.shared_list.append(3)
print(Parent.shared_list)   # [1, 2, 3]
print(Child.shared_list)    # [1, 2, 3] (Child也看到了修改)
print(GrandChild.shared_list) # [1, 2, 3] (GrandChild也看到了修改)

# 通过Child修改shared_list，也会影响Parent和GrandChild
Child.shared_list.append(4)
print(Parent.shared_list)   # [1, 2, 3, 4]

# 通过GrandChild的实例修改version (遮蔽行为)
gc_instance = GrandChild()
gc_instance.version = "3.0" # 为gc_instance创建了实例变量version
print(gc_instance.version)   # 3.0
print(GrandChild.version)    # 2.0 (类变量未变)
print(Parent.version)        # 1.0 (父类也未变)

实例变量在继承中的行为：

实例变量的行为相对直接。

1. 通过 super().__init__() 继承： 子类通常会在自己的 __init__ 方法中调用 super().__init__() 来初始化父类的实例变量。这样，每个子类实例都会拥有父类定义的那些实例变量，并且这些变量是该子类实例独有的。
2. 独立性： 子类实例的实例变量是完全独立的，对一个子类实例的实例变量的修改不会影响到其他任何实例，无论是父类的实例还是其他子类的实例。

class Vehicle:
    def __init__(self, brand):
        self.brand = brand
        self.engine_status = "off"

class Car(Vehicle):
    def __init__(self, brand, model):
        super().__init__(brand) # 调用父类的__init__来初始化brand和engine_status
        self.model = model # Car特有的实例变量

my_car = Car("Toyota", "Camry")
your_car = Car("Honda", "Civic")

print(f"My car: {my_car.brand} {my_car.model}, Engine: {my_car.engine_status}")
print(f"Your car: {your_car.brand} {your_car.model}, Engine: {your_car.engine_status}")

my_car.engine_status = "on" # 修改my_car的实例变量
print(f"My car engine: {my_car.engine_status}")   # on
print(f"Your car engine: {your_car.engine_status}") # off (your_car不受影响)

总的来说，处理继承时，对类变量要格外小心，尤其是可变类型，它可能带来意想不到的全局副作用。而实例变量则保持了良好的封装性和独立性，通常更易于管理。