Python 类变量和实例变量的实现与区别(附示例)

更新时间：2025年03月21日 09:41:56 作者：AI Agent首席体验官

本文主要介绍了Python 类变量和实例变量的实现与区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

1. Python 类的实例变量与类变量基础

1.1. 什么是类的实例变量？

类的**实例变量（Instance Variable）是属于某个具体实例（对象）**的变量，每个实例都有自己独立的实例变量，互不干扰。
实例变量是在 __init__ 方法中通过 self.变量名 进行定义的。

示例：

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

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

print(p1.name)  # Alice
print(p2.name)  # Bob

在上面代码中，name 和 age 是实例变量，每个实例 (p1、p2) 都有各自的 name 和 age，互不影响。

1.2. 什么是类变量？

类变量（Class Variable）是属于整个类的变量，所有实例共享同一个变量，它通常在类体内定义，而不是 __init__ 方法中。

示例：

class Person:
    species = "Human"  # 类变量，所有实例共享

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

p1 = Person("Alice")
p2 = Person("Bob")

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

# 修改类变量
Person.species = "Homo sapiens"
print(p1.species)  # Homo sapiens
print(p2.species)  # Homo sapiens

在这里，species 是类变量，所有 Person 的实例 (p1, p2) 都共享 species 这个变量，修改它会影响所有实例。

1.3. 类的实例变量和类变量的区别和联系

对比项	实例变量（Instance Variable）	类变量（Class Variable）
定义位置	`__init__` 方法中，使用 `self.变量名`	直接在类体内定义
作用范围	只属于某个对象，每个对象独立	属于整个类，所有实例共享
访问方式	`self.变量名`	`类名.变量名` 或 `self.变量名`
修改影响	只影响当前实例，不影响其他实例	修改类变量，影响所有实例

联系：

类变量可以通过实例访问，但如果实例修改了它，会变成实例变量，不会影响类本身。
实例变量不会影响类变量，每个实例都有自己独立的实例变量。

示例：

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

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

p1 = Person("Alice")
p2 = Person("Bob")

p1.species = "Alien"  # 仅 p1 变成了实例变量，不影响类变量
print(p1.species)  # Alien
print(p2.species)  # Human
print(Person.species)  # Human

解释：

p1.species = "Alien" 实际上创建了 p1 的实例变量 species，不会影响 Person.species 和 p2.species。
p2 仍然访问的是 Person.species，值仍然是 "Human"。

如果想真正修改 species，应该使用 Person.species = "新值"。

2. Python 类的实例变量与类变量综合实战

2.1. Python 类的实例变量与类变量常见协作场景

在实际开发中，类的实例变量和类变量经常协同工作，以实现灵活且高效的数据管理。以下是几种常见的应用场景：

场景 1：计数所有创建的实例

在某些应用中，我们可能希望统计类的实例总数，这可以通过类变量来实现，而每个实例仍然有自己的属性。

示例：

class Person:
    count = 0  # 类变量，记录实例数量

    def __init__(self, name):
        self.name = name  # 实例变量
        Person.count += 1  # 每创建一个实例，计数+1

p1 = Person("Alice")
p2 = Person("Bob")

print(Person.count)  # 2
print(p1.count)  # 2 （可以通过实例访问类变量）
print(p2.count)  # 2

应用场景：

统计用户数
计算数据库对象数量
资源管理

场景 2：设置默认值

有时，我们希望所有对象都共享一个默认配置，但同时又允许单独修改某个实例的配置。这时类变量可以提供默认值，而实例变量可以实现个性化调整。

示例：

class Config:
    default_language = "English"  # 类变量，作为默认语言

    def __init__(self, username, language=None):
        self.username = username
        self.language = language if language else Config.default_language  # 实例变量

c1 = Config("Alice")  # 未指定语言，使用默认值
c2 = Config("Bob", "Spanish")  # 自定义语言

print(c1.language)  # English
print(c2.language)  # Spanish

应用场景：

软件全局默认配置（语言、主题、权限）
设备默认设置（屏幕分辨率、声音）

场景 3：共享不可变对象

如果某些属性对于所有实例都是相同的，且不会被修改，使用类变量可以避免在每个实例中重复存储，节省内存。

示例：

class MathConstants:
    PI = 3.1415926535  # 类变量
    E = 2.7182818284   # 类变量

# 所有实例共享相同的常量
print(MathConstants.PI)  # 3.1415926535
print(MathConstants.E)   # 2.7182818284

应用场景：

物理/数学常量
共享配置（API URL、数据库配置）

场景 4：限制最大实例数量

某些情况下，我们希望控制某个类的实例数量，防止创建过多实例占用资源。

示例：

class DatabaseConnection:
    max_instances = 3  # 类变量，最大实例数
    instances = []  # 存储实例

    def __new__(cls, *args, **kwargs):
        if len(cls.instances) >= cls.max_instances:
            raise Exception("达到最大连接数")
        instance = super().__new__(cls)
        cls.instances.append(instance)
        return instance

db1 = DatabaseConnection()
db2 = DatabaseConnection()
db3 = DatabaseConnection()
# db4 = DatabaseConnection()  # 这里会抛出异常

应用场景：

数据库连接池
线程池
资源管理

2.2. Python 类的实例变量与类变量在项目中使用思路和技巧

在项目开发中，合理使用类变量和实例变量可以提高代码的可读性、性能和维护性。以下是一些关键思路和技巧：

技巧 1：类变量用于存储“全局”信息

如果某个属性对于所有实例都是相同的，而且在实例之间共享，则应该用类变量存储，而不是每个实例都保存一份。

错误示例（浪费内存）：

class Server:
    def __init__(self):
        self.host = "localhost"  # 每个实例都存一份，浪费空间

优化后（使用类变量）：

class Server:
    host = "localhost"  # 共享同一个值

技巧 2：避免实例意外修改类变量

如果你不小心在实例上修改了类变量，Python 会自动在实例上创建一个新的实例变量，这可能会导致意外行为。

示例（错误操作）：

class Company:
    name = "TechCorp"

c1 = Company()
c2 = Company()

c1.name = "Startup Inc."  # 这里实际上创建了实例变量，不影响类变量

print(c1.name)  # Startup Inc.
print(c2.name)  # TechCorp
print(Company.name)  # TechCorp

正确做法：

如果不希望被修改，可以用类方法来修改类变量，而不是直接修改。

class Company:
    name = "TechCorp"

    @classmethod
    def set_name(cls, new_name):
        cls.name = new_name  # 通过类方法修改

Company.set_name("NewCorp")
print(Company.name)  # NewCorp

技巧 3：动态调整类变量

在某些情况下，我们可能希望在运行时动态调整类变量的值，所有实例都会自动适应新的值。

示例：

class AppSettings:
    theme = "Light"

    @classmethod
    def change_theme(cls, new_theme):
        cls.theme = new_theme  # 修改类变量，所有实例都会受影响

s1 = AppSettings()
s2 = AppSettings()

print(s1.theme)  # Light
AppSettings.change_theme("Dark")
print(s2.theme)  # Dark （所有实例都受影响）

应用场景：

主题切换
业务模式调整（例如电商促销模式）

技巧 4：避免使用可变对象作为类变量

如果类变量是一个可变对象（如列表、字典、集合），所有实例都会共享该对象，可能会导致意外的修改。

错误示例（所有实例共享同一个列表）：

class Users:
    user_list = []  # 共享列表

    def add_user(self, user):
        self.user_list.append(user)

u1 = Users()
u1.add_user("Alice")

u2 = Users()
u2.add_user("Bob")

print(u1.user_list)  # ['Alice', 'Bob']
print(u2.user_list)  # ['Alice', 'Bob']  （意外共享）

解决方案（使用 __init__ 让每个实例有独立的列表）：

class Users:
    def __init__(self):
        self.user_list = []  # 每个实例独立的列表

    def add_user(self, user):
        self.user_list.append(user)

u1 = Users()
u1.add_user("Alice")

u2 = Users()
u2.add_user("Bob")

print(u1.user_list)  # ['Alice']
print(u2.user_list)  # ['Bob']

总结

类变量适合存储所有实例共享的数据（如全局配置、计数器）。
实例变量适合存储每个对象独立的数据（如用户信息）。
避免实例意外修改类变量（如果修改类变量，最好使用 @classmethod）。
可变对象（列表、字典）尽量作为实例变量，以防数据污染。

这些思路和技巧可以帮助你在项目中更好地管理 Python 类的变量，使代码更清晰、高效、易维护！

2.3. Python 类的实例变量与类变量项目中使用注意事项

在项目开发中，正确管理 Python 类的实例变量与类变量可以提高代码的可读性、性能和维护性，避免潜在的 bug。以下是一些关键的注意事项，涵盖了常见的陷阱和最佳实践。

1. 避免实例变量覆盖类变量

问题：当实例变量和类变量同名时，Python 不会修改类变量，而是会在该实例上创建一个新的实例变量。这可能导致意外行为。

错误示例：

class Product:
    discount = 0.1  # 类变量

p1 = Product()
p2 = Product()

p1.discount = 0.2  # 这里并不会修改类变量，而是创建了 p1 的实例变量

print(p1.discount)  # 0.2 （p1 有自己的实例变量）
print(p2.discount)  # 0.1 （p2 仍然使用类变量）
print(Product.discount)  # 0.1 （类变量未变）

解决方案：

使用 @classmethod 进行类变量的修改，确保所有实例共享该变量。

class Product:
    discount = 0.1  # 类变量

    @classmethod
    def set_discount(cls, new_discount):
        cls.discount = new_discount

Product.set_discount(0.2)
print(Product.discount)  # 0.2

2. 使用 slots 限制实例变量

Python 的对象默认存储在字典（__dict__）中，这会导致实例变量的存储开销较大。
如果你希望限制对象的实例变量，可以使用 __slots__，防止意外添加新变量，并节省内存。

示例：

class User:
    __slots__ = ["name", "age"]  # 限制实例只能有这两个变量

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

u = User("Alice", 25)
u.gender = "Female"  # AttributeError: 'User' object has no attribute 'gender'

适用场景：

内存优化（特别是大量实例时）
防止意外创建实例变量

3. 避免可变类变量引发的 Bug

如果类变量是一个可变对象（如列表、字典、集合），则所有实例都共享该对象，这可能导致数据污染。

错误示例：

class Team:
    members = []  # 共享列表

    def add_member(self, name):
        self.members.append(name)

t1 = Team()
t1.add_member("Alice")

t2 = Team()
t2.add_member("Bob")

print(t1.members)  # ['Alice', 'Bob']
print(t2.members)  # ['Alice', 'Bob']  （意外共享）

解决方案：在 __init__ 里初始化实例变量，确保每个实例有独立的数据。

class Team:
    def __init__(self):
        self.members = []  # 每个实例独立的列表

    def add_member(self, name):
        self.members.append(name)

t1 = Team()
t1.add_member("Alice")

t2 = Team()
t2.add_member("Bob")

print(t1.members)  # ['Alice']
print(t2.members)  # ['Bob']

4. 区分类方法和实例方法

在项目中，我们经常会有既需要操作实例变量，又需要操作类变量的情况，此时应当正确区分实例方法（self）和类方法（cls）。

示例：

class Employee:
    company = "TechCorp"  # 类变量

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

    @classmethod
    def set_company(cls, new_company):
        cls.company = new_company  # 修改类变量

    def get_info(self):
        return f"{self.name} works at {self.company}"

# 使用类方法修改公司名称
Employee.set_company("NewTech")

e1 = Employee("Alice")
e2 = Employee("Bob")

print(e1.get_info())  # Alice works at NewTech
print(e2.get_info())  # Bob works at NewTech

适用场景：

实例方法用于获取/修改实例变量（如 self.name）。
类方法用于修改类变量（如 cls.company）。

5. 继承时要小心类变量

类变量在继承时，子类会共享父类的变量，但如果子类修改它，可能会影响所有的子类实例。

错误示例：

class Parent:
    shared_list = []

class Child(Parent):
    pass

c1 = Child()
c2 = Child()

c1.shared_list.append("data")

print(c2.shared_list)  # ['data'] （意外共享）

解决方案：在子类中重新初始化变量：

class Parent:
    shared_list = []  # 父类的类变量

class Child(Parent):
    def __init__(self):
        self.shared_list = []  # 子类创建自己的实例变量

c1 = Child()
c1.shared_list.append("data")

c2 = Child()
print(c2.shared_list)  # []  （不受 c1 影响）

6. isinstance 检测实例变量，hasattr 防止访问未定义变量

在实际项目中，访问未定义的实例变量可能导致 AttributeError。
建议使用 hasattr 检测变量是否存在，并使用 isinstance 检查变量类型。

示例：

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

u = User("Alice")

print(hasattr(u, "name"))  # True
print(hasattr(u, "age"))  # False

适用场景：

避免 AttributeError
动态对象管理

总结

注意事项	问题描述	解决方案
避免实例变量覆盖类变量	直接修改 `self.变量名` 可能不会真正改变类变量	使用 `@classmethod` 修改类变量
使用 `__slots__` 限制实例变量	默认 `__dict__` 存储实例变量，消耗内存	`__slots__` 限制变量
可变类变量会被所有实例共享	`list`、`dict` 共享可能会污染数据	在 `__init__` 中初始化
区分实例方法与类方法	误用 `self` 或 `cls` 可能导致修改范围错误	`@classmethod` 修改类变量，实例方法操作 `self`
子类继承时小心类变量共享	子类修改类变量可能影响所有子类	在 `__init__` 里重新定义
使用 `hasattr` 和 `isinstance` 进行健壮性检测	访问未定义变量会报错	`hasattr(instance, 'attr')` 检测

掌握这些技巧，可以让你的Python 类设计更高效、稳定，避免意外 bug！

3. Python 类变量与实例变量综合实战

在项目开发中，合理使用类变量（Class Variable）和实例变量（Instance Variable）可以提高代码的可读性、性能和可维护性。本文将通过完整案例展示如何选择、使用并优化类变量与实例变量，同时深入讲解背后的设计思路、最佳实践、常见错误及注意事项。

案例背景

智能物流管理系统

假设我们正在开发一个智能物流管理系统，用于追踪不同的快递订单，同时需要管理公司配送规则。
系统涉及的核心实体是订单（Order），其中：

每个订单都有唯一的订单编号、收件人、地址（这些数据属于订单个体，应该用实例变量）。
所有订单共享统一的配送费率、税率（这些属于系统全局设定，应该用类变量）。
需要跟踪所有创建的订单数量，并为每个订单生成一个唯一 ID（类变量适合存储全局计数器）。

核心概念

在开发本系统时，以下问题需要明确：

什么时候使用类变量？什么时候使用实例变量？
如何利用类变量优化全局共享数据？
如何避免类变量带来的潜在 Bug？

代码实现

class Order:
    # === 类变量（所有订单共享） ===
    delivery_fee = 5.0  # 固定配送费
    tax_rate = 0.1  # 税率（10%）
    order_count = 0  # 订单计数器

    def __init__(self, recipient, address, base_price):
        # === 实例变量（每个订单独立） ===
        self.order_id = Order.order_count + 1  # 订单 ID
        self.recipient = recipient  # 收件人
        self.address = address  # 收件地址
        self.base_price = base_price  # 商品基础价格

        # 更新全局订单计数
        Order.order_count += 1  

    def calculate_total(self):
        """计算订单总价（基础价格 + 配送费 + 税）"""
        tax = self.base_price * Order.tax_rate
        total_price = self.base_price + Order.delivery_fee + tax
        return total_price

    @classmethod
    def update_delivery_fee(cls, new_fee):
        """更新配送费"""
        cls.delivery_fee = new_fee

    @classmethod
    def update_tax_rate(cls, new_rate):
        """更新税率"""
        cls.tax_rate = new_rate

    @staticmethod
    def get_system_info():
        """返回系统配置信息"""
        return f"当前配送费: {Order.delivery_fee}, 当前税率: {Order.tax_rate}"

# === 测试 ===
order1 = Order("Alice", "New York", 50)
order2 = Order("Bob", "San Francisco", 75)

print(f"订单1总价: ${order1.calculate_total()}")  
print(f"订单2总价: ${order2.calculate_total()}")  

# 更新配送费
Order.update_delivery_fee(8.0)
print("修改配送费后:")
print(f"订单1总价: ${order1.calculate_total()}")  
print(f"订单2总价: ${order2.calculate_total()}")  

# 获取系统信息
print(Order.get_system_info())

代码解析与思维推理

1. 什么时候选择类变量？什么时候选择实例变量？

变量类型	适用场景	在本案例的应用
类变量（class variable）	适用于所有实例共享的属性	配送费（`delivery_fee`）、税率（`tax_rate`）、订单计数器（`order_count`）
实例变量（instance variable）	适用于每个实例独有的属性	订单 ID（`order_id`）、收件人（`recipient`）、地址（`address`）、商品价格（`base_price`）

思考：

配送费、税率等全局设置，所有订单都应该遵循相同的规则，因此用类变量。
订单编号、收件人、地址等数据，每个订单都是独立的，因此用实例变量。

2. 如何使用类变量优化全局数据？

在物流系统中，配送费和税率经常调整，使用类变量可以：

统一管理所有订单的配送费、税率，而不用逐个修改订单对象。
当 Order.update_delivery_fee() 被调用时，所有订单都会自动使用新的配送费。

示例：

Order.update_delivery_fee(8.0)  # 修改全局配送费
print(Order.get_system_info())  # 现在所有订单的配送费都是 8.0

3. 如何避免类变量的潜在 Bug？

⚠️ 错误示例（实例变量意外覆盖类变量）：

order1.delivery_fee = 10  # 只会影响 order1，不会影响 Order 类
print(order1.delivery_fee)  # 10
print(order2.delivery_fee)  # 5.0 （未受影响）
print(Order.delivery_fee)  # 5.0 （类变量没变）

🔹 解决方案：

使用 @classmethod 进行类变量修改，确保所有实例共享相同的全局数据。

4. 思维推理：如何优化订单 ID？

订单 ID 需要：

每个订单有唯一编号（实例变量）。
需要一个全局计数器来管理唯一 ID（类变量）。

实现方式：

self.order_id = Order.order_count + 1  # 订单 ID
Order.order_count += 1  # 计数器自增

这样，每个新订单都能自动获得唯一的订单编号，且所有订单共享计数器，保证编号不会重复。

使用类变量与实例变量的注意事项

✅ 1. 避免实例变量意外覆盖类变量

order1.tax_rate = 0.2  # 只会影响 order1，不会修改 Order 类的 tax_rate

解决方案：

任何全局数据修改，应使用 @classmethod 进行修改，而不是直接修改实例变量。

✅ 2. 避免可变类变量导致数据污染

如果类变量是可变对象（list, dict），所有实例会共享该对象，可能会导致数据污染。

错误示例（多个实例共享同一个列表）：

class Order:
    items = []  # 共享列表（错误）

    def add_item(self, item):
        self.items.append(item)

o1 = Order()
o2 = Order()
o1.add_item("Laptop")
print(o2.items)  # ['Laptop']（意外共享）

解决方案：

在 __init__ 里初始化实例变量：

class Order:
    def __init__(self):
        self.items = []  # 每个实例独立的列表

总结

📌 何时使用类变量？

当变量适用于所有对象，不因实例不同而变化，如全局配置（配送费、税率）。
当需要统计全局数据（订单计数器）。

📌 何时使用实例变量？

当变量是实例独有的（订单编号、收件人、商品价格）。
当数据需要独立存储，不影响其他实例。

📌 最佳实践

✅ 类变量存全局信息，实例变量存个体数据。✅ 修改类变量时，使用 @classmethod 以确保同步更新。✅ 避免可变类变量（list, dict）导致数据污染。

通过本案例，我们掌握了如何在项目中正确使用 Python 类变量与实例变量，提升代码的可读性、性能和维护性！

到此这篇关于Python 类变量和实例变量的实现与区别(附示例)的文章就介绍到这了,更多相关Python 类变量和实例变量内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Python通过fnmatch模块实现文件名匹配
这篇文章主要介绍了Python通过fnmatch模块实现文件名匹配,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
2020-09-09
Python从入门到实战之数据结构篇
数据结构中有很多树的结构，其中包括二叉树、二叉搜索树、2-3树、红黑树等等。本文中对数据结构进行了总结，不求严格精准，但求简单易懂
2021-11-11
Python安装Gradio和常见安装问题解决办法
Gradio是一款便捷的Python库,专门用于创建机器学习模型的Web应用,安装通常简单,但偶尔会遇到依赖问题或环境配置错误,这篇文章主要介绍了Python安装Gradio和常见安装问题解决办法,需要的朋友可以参考下
2024-10-10
python中if嵌套命令实例讲解
在本篇文章里小编给大家整理的是一篇关于python中if嵌套命令实例讲解内容，有兴趣的朋友们可以学习下。
2021-02-02
torchxrayvision包安装过程（附pytorch1.6cpu版安装）
这篇文章主要介绍了torchxrayvision包安装过程(附pytorch1.6cpu版安装),文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-08-08
Python 中的Selenium异常处理实例代码
本文通过实例代码给大家介绍了Python 中的Selenium异常处理的相关知识，非常不错，具有参考借鉴价值，需要的朋友参考下吧
2018-05-05
解决pycharm上的jupyter notebook端口被占用问题
今天小编就为大家分享一篇解决pycharm上的jupyter notebook端口被占用问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2019-12-12
朴素贝叶斯算法的python实现方法
这篇文章主要介绍了朴素贝叶斯算法的python实现方法,详细分析了朴素贝叶斯算法的特性及用途,并给出了基于python的实现方法,需要的朋友可以参考下
2014-11-11
Python4种配色方案详解(适合科研的配色)
配色的选择是在我们论文文章画图过程中经常面临的一个问题,下面这篇文章主要介绍了Python4种配色方案的相关资料,感兴趣的朋友一起看看吧
2020-02-02
详解python中的三种命令行模块(sys.argv,argparse,click)
这篇文章主要介绍了python中的三种命令行模块(sys.argv,argparse,click)的相关资料，帮助大家更好的理解和使用python，感兴趣的朋友可以了解下
2020-12-12

Python 类变量和实例变量的实现与区别(附示例)

目录

1. Python 类的实例变量与类变量基础

1.1. 什么是类的实例变量？

1.2. 什么是类变量？

1.3. 类的实例变量和类变量的区别和联系

2. Python 类的实例变量与类变量 综合实战

2.1. Python 类的实例变量与类变量常见协作场景

场景 1：计数所有创建的实例

场景 2：设置默认值

场景 3：共享不可变对象

场景 4：限制最大实例数量

2.2. Python 类的实例变量与类变量在项目中使用思路和技巧

技巧 1：类变量用于存储“全局”信息

技巧 2：避免实例意外修改类变量

技巧 3：动态调整类变量

技巧 4：避免使用可变对象作为类变量

2.3. Python 类的实例变量与类变量 项目中使用注意事项

1. 避免实例变量覆盖类变量

2. 使用 __slots__ 限制实例变量

3. 避免可变类变量引发的 Bug

4. 区分 类方法 和 实例方法

5. 继承时要小心类变量

6. isinstance 检测实例变量，hasattr 防止访问未定义变量

3. Python 类变量与实例变量综合实战

案例背景

智能物流管理系统

核心概念

代码实现

代码解析与思维推理

1. 什么时候选择类变量？什么时候选择实例变量？

2. 如何使用类变量优化全局数据？

3. 如何避免类变量的潜在 Bug？

4. 思维推理：如何优化订单 ID？

使用类变量与实例变量的注意事项

✅ 1. 避免实例变量意外覆盖类变量

✅ 2. 避免可变类变量导致数据污染

总结

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具

2. Python 类的实例变量与类变量综合实战

2.3. Python 类的实例变量与类变量项目中使用注意事项

2. 使用 slots 限制实例变量

4. 区分类方法和实例方法