第4.1章:快速学习Python的类与对象

《Python AI 应用开发入门》第 4.1 节。

理解类、对象、属性、方法、self 和实例化，并使用 ChatSession 封装会话状态。

本节目标

学完本节后，你应当能够：

1. 1. 解释类和对象的区别。
2. 2. 定义类并创建多个相互独立的对象。
3. 3. 使用 __init__ 设置对象的初始状态。
4. 4. 解释 self 为什么代表当前对象。
5. 5. 区分属性和方法。
6. 6. 通过方法读取和修改对象状态。
7. 7. 避免把可变数据错误地放在所有对象共享的位置。
8. 8. 判断什么时候适合使用类，什么时候普通函数已经足够。
9. 9. 使用 ChatSession 封装聊天会话。

1. 为什么需要对象

上一章可以用字典保存会话，用函数操作它：

session = {    "title": "Python 学习",    "messages": [],}def add_message(session, role, content):    session["messages"].append(        {            "role": role,            "content": content,        }    )

这种写法没有错。程序较小时，字典和函数往往已经足够。

随着功能增加，问题会逐渐出现：

• • 每个函数都要接收 session。
• • 调用者必须记住字典有哪些键。
• • 任意代码都能直接把 messages 改成错误类型。
• • 与会话有关的状态和函数可能散落在多个文件中。

类可以把“会话的数据”和“操作会话的行为”放进同一个边界。

2. 类是蓝图，对象是实例

使用 class 定义类：

class ChatSession:    pass

类描述一类对象应该具有什么结构和行为。现在它还是一个空蓝图。

在类名后加括号会创建对象，这个过程叫实例化：

first_session = ChatSession()second_session = ChatSession()

first_session 和 second_session 都是 ChatSession 的实例，但它们是两个不同对象：

print(isinstance(first_session, ChatSession))  # Trueprint(first_session is second_session)         # False

可以这样理解：

• • 类：描述“聊天会话”这种对象的蓝图。
• • 对象：按照蓝图创建出来的具体聊天会话。
• • 实例：对象相对于其类的称呼。
• • 实例化：调用类并创建实例的过程。

类名通常使用大驼峰命名，例如 ChatSession、ModelClient、UserProfile。

3. 使用 init 设置初始状态

空对象还没有标题和消息。可以在类中定义 __init__：

class ChatSession:    def __init__(self, title):        self.title = title        self.messages = []

创建对象时：

session = ChatSession("Python 学习")

Python 大致会完成：

1. 1. 创建一个新的 ChatSession 对象。
2. 2. 调用 __init__ 初始化这个对象。
3. 3. 把新对象传给参数 self。
4. 4. 把字符串 "Python 学习" 传给参数 title。
5. 5. 执行两条属性赋值。

完成后可以读取属性：

print(session.title)     # Python 学习print(session.messages)  # []

__init__ 常被称为初始化方法。它负责让新对象从一开始就处于可用状态。

注意：__init__ 不是“创建对象本身”的普通函数，它是在对象已经产生后设置初始状态。初学阶段把它理解为“创建实例时自动执行的初始化方法”即可。

4. self 表示当前对象

self 是实例方法的第一个参数，表示本次调用正在操作的对象。

class ChatSession:    def __init__(self, title):        self.title = title

调用：

session = ChatSession("Python 学习")

执行 __init__ 时，self 指向刚创建的 session。因此：

self.title = title

可以理解为“把参数 title 保存到当前对象的 title 属性中”。

再创建一个对象：

python_session = ChatSession("Python")ai_session = ChatSession("AI")print(python_session.title)  # Pythonprint(ai_session.title)      # AI

两次调用中的 self 分别指向不同对象，所以属性不会混在一起。

self 不是 Python 关键字，理论上可以换成其他名字，但所有正常 Python 代码都使用 self。不要改变这个约定。

5. 属性保存状态

属性是属于对象的数据，使用点号访问：

session.titlesession.messages

下面给会话增加模型名称：

class ChatSession:    def __init__(self, title, model="demo-model"):        self.title = title        self.model = model        self.messages = []

每个实例拥有自己的属性值：

first = ChatSession("快速问答")second = ChatSession("代码助手", model="code-model")print(first.model)   # demo-modelprint(second.model)  # code-model

需要每个对象独立拥有的可变数据，应该在 __init__ 中创建。self.messages = [] 每次初始化都会创建新列表：

first.messages.append("只属于 first")print(first.messages)   # ['只属于 first']print(second.messages)  # []

6. 方法定义对象行为

定义在类中、用来操作对象的函数称为方法：

class ChatSession:    def __init__(self, title):        self.title = title        self.messages = []    def add_message(self, role, content):        message = {            "role": role,            "content": content,        }        self.messages.append(message)    def message_count(self):        return len(self.messages)

通过对象调用方法：

session = ChatSession("函数答疑")session.add_message("user", "什么是对象？")print(session.message_count())  # 1

执行：

session.add_message("user", "什么是对象？")

时，Python 会自动把 session 作为第一个参数传给 self。因此调用位置不需要手动传入 self。

方法与普通函数的核心差别不在语法能力，而在归属关系：方法属于类，并且通常通过 self 读取或修改当前对象。

7. 在方法中验证数据

不要让无效状态进入对象：

class ChatSession:    ALLOWED_ROLES = ("system", "user", "assistant")    def __init__(self, title):        cleaned_title = title.strip()        if not cleaned_title:            raise ValueError("会话标题不能为空")        self.title = cleaned_title        self.messages = []    def add_message(self, role, content):        cleaned_role = role.strip().lower()        cleaned_content = content.strip()        if cleaned_role not in self.ALLOWED_ROLES:            raise ValueError(f"不支持的消息角色：{role}")        if not cleaned_content:            raise ValueError("消息内容不能为空")        self.messages.append(            {                "role": cleaned_role,                "content": cleaned_content,            }        )

这里保证：

• • 标题始终是非空字符串。
• • 角色始终来自允许集合。
• • 消息内容始终非空。

对象需要始终满足的规则称为不变量。把修改入口集中到方法中，更容易维护这些规则。

ALLOWED_ROLES 暂时只需要理解为类中定义的共享常量。实例属性与类属性会在下一节详细区分。

8. 返回数据时避免暴露内部列表

如果直接返回内部列表：

def get_messages(self):    return self.messages

调用者可以绕过 add_message()：

messages = session.get_messages()messages.append({"role": "错误角色", "content": ""})

可以返回一个浅复制：

def get_messages(self):    return self.messages.copy()

这样调用者修改返回的列表，不会增删会话内部的列表项：

messages = session.get_messages()messages.clear()print(session.message_count())  # 原会话数量不变

这里复制的是列表容器，列表中的字典仍然是同一批字典。完整的数据保护会在使用数据类后继续改进。

9. 一个完整的 ChatSession

class ChatSession:    ALLOWED_ROLES = ("system", "user", "assistant")    def __init__(self, title, model="demo-model"):        cleaned_title = title.strip()        if not cleaned_title:            raise ValueError("会话标题不能为空")        self.title = cleaned_title        self.model = model        self.messages = []    def add_message(self, role, content):        cleaned_role = role.strip().lower()        cleaned_content = content.strip()        if cleaned_role not in self.ALLOWED_ROLES:            raise ValueError(f"不支持的消息角色：{role}")        if not cleaned_content:            raise ValueError("消息内容不能为空")        self.messages.append(            {                "role": cleaned_role,                "content": cleaned_content,            }        )    def message_count(self):        return len(self.messages)    def recent_messages(self, limit=5):        if limit <= 0:            raise ValueError("limit 必须大于 0")        return self.messages[-limit:].copy()    def get_messages(self):        return self.messages.copy()    def to_dict(self):        return {            "title": self.title,            "model": self.model,            "messages": self.get_messages(),        }

使用：

session = ChatSession("Python 类答疑")session.add_message("user", "类和对象有什么区别？")session.add_message("assistant", "类是蓝图，对象是具体实例。")print(session.message_count())print(session.recent_messages(limit=1))print(session.to_dict())

to_dict() 把对象转换为上一章熟悉的字典结构，之后可以交给 JSON 存储模块。类并不替代 JSON；对象适合程序运行期间维护行为，字典和 JSON 适合交换与持久化数据。

10. 常见错误

忘记在方法中写 self

class ChatSession:    def add_message(role, content):        pass

通过实例调用时，Python 仍会自动传入当前对象，参数数量便无法对应。实例方法的第一个参数应写成 self。

忘记使用 self. 保存属性

class ChatSession:    def __init__(self, title):        title = title.strip()

这里只修改了局部变量，没有创建 self.title。初始化后访问 session.title 会触发 AttributeError。

在方法外忘记实例化

# 错误：类本身不是某一个具体会话# ChatSession.add_message("user", "你好")session = ChatSession("问答")session.add_message("user", "你好")

把类当成字典

# session["title"]session.title

对象通常通过属性和方法提供接口，不再使用字典下标访问所有内容。

11. 什么时候使用类

适合使用类的信号：

• • 多个函数总是在操作同一组状态。
• • 需要同时创建多个相互独立的实例。
• • 数据必须始终满足一组规则。
• • 行为需要根据具体实现替换。
• • 一个概念具有清楚的生命周期，例如会话从创建到关闭。

普通函数更合适的情况：

• • 逻辑只是一次简单转换。
• • 不需要长期保存状态。
• • 输入和输出已经非常明确。
• • 创建类只会增加命名和调用层级。

例如清理文本仍然适合普通函数：

def normalize_text(text):    return text.strip()

面向对象不是目标，而是组织复杂状态的一种工具。

动手练习

练习 1：创建会话

定义 ChatSession：

• • __init__ 接收标题和模型名称。
• • 每个对象拥有独立消息列表。
• • 创建两个实例并证明它们互不影响。

练习 2：维护会话规则

实现：

• • add_message(role, content)。
• • message_count()。
• • recent_messages(limit=5)。
• • 拒绝空标题、空消息、无效角色和非正数 limit。

练习 3：导出字典

实现 to_dict()，返回可交给 json.dumps() 的字典。修改返回字典中的消息列表后，确认原会话的消息数量没有变化。

随堂小测

1. 1. 类、对象、实例和实例化分别是什么？
2. 2. 创建 ChatSession("学习") 时，__init__ 何时执行？
3. 3. self 表示什么？为什么调用方法时不手动传入？
4. 4. title 与 self.title 有什么区别？
5. 5. 为什么每个会话的消息列表应在 __init__ 中创建？
6. 6. 属性和方法分别表示什么？
7. 7. 为什么不建议直接返回内部可变列表？
8. 8. 什么情况下普通函数比类更合适？

参考答案

1. 1. 类是蓝图；对象是按蓝图创建的具体值；对象也是该类的实例；调用类创建实例的过程叫实例化。
2. 2. 新对象产生后，Python 会自动调用 __init__ 设置初始状态。
3. 3. self 表示当前实例；通过实例调用方法时，Python 自动把该实例传给第一个参数。
4. 4. title 是当前函数调用中的局部参数，self.title 是保存在对象上的属性。
5. 5. 这样每次实例化都会创建新列表，多个会话不会共享消息。
6. 6. 属性保存对象状态，方法定义对象能够执行的行为。
7. 7. 调用者可能绕过验证逻辑，直接破坏对象内部状态。
8. 8. 逻辑简单、无长期状态且输入输出明确时，普通函数通常更直接。