专栏前言：本专栏专为零基础想入门大模型开发的同学打造，从最基础的环境搭建开始，一步步带你掌握大模型应用开发的全流程。上一篇我们完成了 Python 与 AI 开发环境的完整搭建，这一篇我们将用3 小时集中攻克大模型开发中90% 以上会用到的 Python 核心语法，为后续的大模型接口调用、数据处理和应用开发打下坚实基础。

作者声明：本文是我多年 Python 开发和大模型应用经验的总结，所有代码均经过实际运行验证。如果你在学习过程中遇到任何问题，欢迎在评论区留言，我会一一回复。

目录

⏰ 3 小时学习计划安排

一、大模型开发最常用的三大数据类型

1.1 字符串 (String)：大模型输入输出的核心载体

1.1.1 字符串的基本定义

1.1.2 大模型开发中最常用的字符串操作

1.2 列表 (List)：大模型对话历史的最佳存储方式

1.2.1 列表的基本定义

1.2.2 大模型开发中最常用的列表操作

1.3 字典 (Dict)：大模型 API 参数的标准格式

1.3.1 字典的基本定义

1.3.2 大模型开发中最常用的字典操作

二、流程控制：让代码拥有 "思考" 能力

2.1 条件判断：根据不同情况做出不同响应

2.1.1 基本语法

2.1.2 大模型开发中的应用示例

2.1.3 逻辑运算符

2.2 循环：批量处理大模型数据

2.2.1 for 循环：遍历序列

2.2.2 while 循环：条件循环

2.2.3 循环控制语句

2.3 函数：代码复用的利器

2.3.1 函数的定义与调用

2.3.2 函数的参数

2.3.3 函数的返回值

三、面向对象基础：为封装大模型接口做准备

3.1 类与对象的基本概念

3.2 类的属性与方法

3.2.1 定义一个简单的类

3.2.2 创建对象并使用

3.2.3 类的继承

3.3 为什么大模型开发需要面向对象

四、实战：从零写一个基于规则的聊天机器人

4.1 需求分析与设计思路

4.2 完整代码实现

4.3 运行效果与扩展方向

五、总结与下一篇预告

5.1 本文总结

5.2 下一篇预告

📖 推荐阅读与学习资源

---

⏰ 3 小时学习计划安排

        很多同学觉得 Python 语法太多学不完，但实际上，对于大模型开发来说，你只需要掌握最核心的 20% 语法，就能解决80% 以上的问题。我为大家制定了一个精准的 3 小时学习计划：

时间段	学习内容	学习目标
第 0-60 分钟	三大核心数据类型	熟练掌握字符串、列表、字典的常用操作
第 60-120 分钟	流程控制与函数	能够编写条件判断、循环和自定义函数
第 120-150 分钟	面向对象基础	理解类与对象的概念，能够定义简单的类
第 150-180 分钟	实战项目	独立完成基于规则的聊天机器人

💡 学习建议：不要只看不动手！每学完一个知识点，立即在 PyCharm 中敲代码验证。编程是一门实践学科，只有亲手写过，才能真正掌握。

---

一、大模型开发最常用的三大数据类型

在大模型开发中，我们几乎每天都在和这三种数据类型打交道：

• 字符串：处理用户输入、大模型输出、提示词 (Prompt)
• 列表：存储对话历史、批量处理多个问题
• 字典：构造 API 请求参数、解析 API 返回结果

其他数据类型如元组、集合、数字等虽然也会用到，但使用频率远低于这三种。

1.1 字符串 (String)：大模型输入输出的核心载体

字符串是由字符组成的序列，在 Python 中用单引号 (')、双引号 (") 或三引号 ('''/""") 包裹。

1.1.1 字符串的基本定义

# 单引号定义
name = '张三'

# 双引号定义
prompt = "你是一个 helpful 的AI助手"

# 三引号定义多行字符串（非常适合写长提示词）
system_prompt = """
你是一个专业的Python编程老师，擅长用通俗易懂的语言讲解复杂的概念。
你的回答应该包含以下几个部分：
1. 概念解释
2. 代码示例
3. 常见问题
"""

1.1.2 大模型开发中最常用的字符串操作

1. 字符串拼接

user_input = "什么是Python？"
full_prompt = system_prompt + "\n用户问题：" + user_input
print(full_prompt)

2. f-string 格式化（推荐） 这是 Python 3.6 + 引入的最简洁、最高效的字符串格式化方式，也是大模型开发中最常用的。

user_name = "小明"
question = "如何学习大模型开发？"
full_prompt = f"""
用户信息：
- 用户名：{user_name}
- 问题：{question}

请根据以上信息，给出详细的回答。
"""
print(full_prompt)

3. 字符串分割与连接

# 分割：将字符串按指定分隔符拆分成列表
response = "Python,Java,C++,JavaScript"
languages = response.split(",")
print(languages)  # 输出: ['Python', 'Java', 'C++', 'JavaScript']

# 连接：将列表中的字符串按指定分隔符连接成一个字符串
languages_list = ['Python', 'Java', 'C++']
result = "、".join(languages_list)
print(result)  # 输出: Python、Java、C++

4. 字符串替换

template = "你好，{name}！欢迎来到{platform}。"
message = template.replace("{name}", "张三").replace("{platform}", "大模型开发社区")
print(message)  # 输出: 你好，张三！欢迎来到大模型开发社区。

5. 去除首尾空白字符

user_input = "   什么是大模型？   "
clean_input = user_input.strip()
print(clean_input)  # 输出: 什么是大模型？

⚠️ 踩坑提醒：字符串是不可变对象，所有字符串操作都会返回一个新的字符串，原字符串不会被修改。

1.2 列表 (List)：大模型对话历史的最佳存储方式

        列表是有序的可变序列，可以存储任意类型的数据。在大模型开发中，列表最常用于存储对话历史，因为我们需要不断向其中添加新的对话内容。

1.2.1 列表的基本定义

# 空列表
chat_history = []

# 包含多个元素的列表
chat_history = [
    {"role": "system", "content": "你是一个 helpful 的AI助手"},
    {"role": "user", "content": "你好！"}
]

1.2.2 大模型开发中最常用的列表操作

1. 添加元素

# 在列表末尾添加一个元素
chat_history.append({"role": "assistant", "content": "你好！有什么我可以帮助你的吗？"})

# 在指定位置插入元素
chat_history.insert(1, {"role": "user", "content": "我是新来的"})

2. 访问元素

# 通过索引访问（索引从0开始）
first_message = chat_history[0]
print(first_message)

# 访问最后一个元素
last_message = chat_history[-1]
print(last_message)

# 切片访问（获取子列表）
# 格式: list[start:end]，包含start，不包含end
recent_messages = chat_history[-5:]  # 获取最近5条消息
print(recent_messages)

3. 修改元素

chat_history[1]["content"] = "我是一个Python初学者"

4. 删除元素

# 删除指定索引的元素
del chat_history[1]

# 删除并返回最后一个元素
last_message = chat_history.pop()

# 删除指定值的第一个匹配项
chat_history.remove({"role": "system", "content": "你是一个 helpful 的AI助手"})

5. 列表长度

message_count = len(chat_history)
print(f"当前对话历史有{message_count}条消息")

💡 实用技巧：在大模型对话中，为了避免上下文过长导致 token 超限，我们通常会保留最近的 N 条消息，这可以通过切片chat_history[-N:]轻松实现。

1.3 字典 (Dict)：大模型 API 参数的标准格式

        字典是无序的键值对集合，键必须是不可变类型（如字符串、数字），值可以是任意类型。几乎所有的大模型 API 都使用 JSON 格式传输数据，而 JSON 在 Python 中对应的就是字典。

1.3.1 字典的基本定义

# 空字典
api_params = {}

# 包含多个键值对的字典
api_params = {
    "model": "gpt-3.5-turbo",
    "messages": [
        {"role": "system", "content": "你是一个 helpful 的AI助手"},
        {"role": "user", "content": "你好！"}
    ],
    "temperature": 0.7,
    "max_tokens": 1000
}

1.3.2 大模型开发中最常用的字典操作

1. 访问值

# 通过键访问
model_name = api_params["model"]
print(model_name)  # 输出: gpt-3.5-turbo

# 使用get方法访问（推荐，键不存在时返回None或指定默认值）
temperature = api_params.get("temperature", 0.5)
print(temperature)  # 输出: 0.7

# 键不存在时返回默认值
top_p = api_params.get("top_p", 1.0)
print(top_p)  # 输出: 1.0

2. 添加 / 修改键值对

# 添加新的键值对
api_params["stream"] = True

# 修改已有键的值
api_params["temperature"] = 0.9

3. 删除键值对

# 删除指定键
del api_params["max_tokens"]

# 删除并返回指定键的值
messages = api_params.pop("messages")

4. 遍历字典

# 遍历所有键
for key in api_params.keys():
    print(key)

# 遍历所有值
for value in api_params.values():
    print(value)

# 遍历所有键值对
for key, value in api_params.items():
    print(f"{key}: {value}")

⚠️ 重要提醒：在 Python 3.7 及以上版本中，字典会保留插入顺序。但在更早的版本中，字典是无序的。如果你需要严格的顺序，可以使用collections.OrderedDict。

---

二、流程控制：让代码拥有 "思考" 能力

        流程控制是编程的基础，它让我们的代码能够根据不同的条件做出不同的响应，并且能够重复执行某些操作。

2.1 条件判断：根据不同情况做出不同响应

条件判断使用if-elif-else语句，它允许我们根据条件的真假来执行不同的代码块。

2.1.1 基本语法

age = 18

if age < 18:
    print("你是未成年人")
elif age == 18:
    print("你刚成年")
else:
    print("你是成年人")

2.1.2 大模型开发中的应用示例

user_input = "帮我写一个Python代码"

if "代码" in user_input or "编程" in user_input:
    response = "好的，我来帮你写代码。请问你需要实现什么功能？"
elif "问题" in user_input or "什么是" in user_input:
    response = "这是一个很好的问题。让我来为你解答..."
else:
    response = "我不太理解你的意思。你能换一种说法吗？"

print(response)

2.1.3 逻辑运算符

• and：与运算，两个条件都为 True 时结果为 True
• or：或运算，两个条件有一个为 True 时结果为 True
• not：非运算，取反

# 检查用户输入是否包含敏感词
sensitive_words = ["暴力", "色情", "赌博"]
user_input = "我想学习赌博技巧"

if any(word in user_input for word in sensitive_words):
    print("你的输入包含敏感内容，请重新输入")
else:
    print("输入合法")

2.2 循环：批量处理大模型数据

        循环允许我们重复执行一段代码，这在批量处理大模型数据时非常有用。Python 中有两种循环：for循环和while循环。

2.2.1 for 循环：遍历序列

# 遍历列表
questions = [
    "什么是Python？",
    "如何学习大模型开发？",
    "Python和Java哪个好？"
]

for question in questions:
    print(f"正在处理问题：{question}")
    # 这里可以调用大模型API获取回答
    # answer = call_llm_api(question)
    # print(f"回答：{answer}")

# 遍历字典
api_params = {
    "model": "gpt-3.5-turbo",
    "temperature": 0.7,
    "max_tokens": 1000
}

for key, value in api_params.items():
    print(f"{key}: {value}")

2.2.2 while 循环：条件循环

# 简单的聊天循环
print("欢迎使用聊天机器人！输入'退出'结束对话。")

while True:
    user_input = input("你：")
    
    if user_input == "退出":
        print("机器人：再见！")
        break
    
    response = f"我收到了你的消息：{user_input}"
    print(f"机器人：{response}")

2.2.3 循环控制语句

• break：跳出整个循环
• continue：跳过当前循环，继续下一次循环

# 跳过空输入
while True:
    user_input = input("你：").strip()
    
    if user_input == "退出":
        print("机器人：再见！")
        break
    
    if not user_input:
        continue  # 跳过空输入
    
    response = f"我收到了你的消息：{user_input}"
    print(f"机器人：{response}")

2.3 函数：代码复用的利器

        函数是一段可以重复使用的代码块，它接受输入参数，执行特定的操作，并返回结果。使用函数可以让我们的代码更加模块化、易于维护。

2.3.1 函数的定义与调用

# 定义函数
def greet(name):
    """
    生成问候语
    :param name: 用户名
    :return: 问候语字符串
    """
    return f"你好，{name}！欢迎来到大模型开发社区。"

# 调用函数
message = greet("张三")
print(message)

2.3.2 函数的参数

# 默认参数
def call_llm_api(prompt, model="gpt-3.5-turbo", temperature=0.7):
    """
    调用大模型API
    :param prompt: 提示词
    :param model: 模型名称，默认gpt-3.5-turbo
    :param temperature: 温度参数，默认0.7
    :return: 大模型返回的结果
    """
    # 这里是模拟API调用
    return f"调用{model}模型，温度{temperature}，提示词：{prompt}"

# 使用默认参数调用
result1 = call_llm_api("什么是Python？")
print(result1)

# 指定参数调用
result2 = call_llm_api("什么是大模型？", model="gpt-4", temperature=0.5)
print(result2)

2.3.3 函数的返回值

# 返回多个值
def process_user_input(user_input):
    """
    处理用户输入
    :param user_input: 用户输入的字符串
    :return: 处理后的输入、输入类型、是否包含敏感词
    """
    clean_input = user_input.strip()
    input_type = "question" if "?" in clean_input else "statement"
    has_sensitive = any(word in clean_input for word in ["暴力", "色情", "赌博"])
    
    return clean_input, input_type, has_sensitive

# 接收多个返回值
clean_input, input_type, has_sensitive = process_user_input("什么是Python？")
print(f"处理后的输入：{clean_input}")
print(f"输入类型：{input_type}")
print(f"是否包含敏感词：{has_sensitive}")

💡 最佳实践：

1. 函数名应该使用小写字母，单词之间用下划线分隔
2. 每个函数都应该有文档字符串 (docstring)，说明函数的功能、参数和返回值
3. 函数应该保持单一职责，一个函数只做一件事
4. 函数的参数不宜过多，一般不超过 5 个

---

三、面向对象基础：为封装大模型接口做准备

        面向对象编程 (OOP) 是一种编程范式，它将数据和操作数据的方法封装在一起，形成对象。在大模型开发中，我们经常需要封装大模型接口，面向对象编程可以让我们的代码更加清晰、易于扩展。

3.1 类与对象的基本概念

• 类 (Class)：是对象的模板，定义了对象拥有的属性和方法
• 对象 (Object)：是类的实例，是具体的存在

        可以把类比作 "图纸"，对象比作根据图纸建造的 "房子"。一张图纸可以建造很多栋房子，每个房子都有相同的结构，但可以有不同的装修和家具。

3.2 类的属性与方法

3.2.1 定义一个简单的类

class ChatBot:
    """聊天机器人类"""
    
    def __init__(self, name):
        """
        初始化方法
        :param name: 机器人的名字
        """
        # 实例属性
        self.name = name
        self.chat_history = []
    
    def greet(self):
        """生成问候语"""
        return f"你好！我是{self.name}，有什么我可以帮助你的吗？"
    
    def add_message(self, role, content):
        """
        添加消息到对话历史
        :param role: 角色（system/user/assistant）
        :param content: 消息内容
        """
        self.chat_history.append({"role": role, "content": content})
    
    def get_chat_history(self):
        """获取对话历史"""
        return self.chat_history

3.2.2 创建对象并使用

# 创建ChatBot类的实例
bot = ChatBot("小智")

# 调用对象的方法
print(bot.greet())  # 输出: 你好！我是小智，有什么我可以帮助你的吗？

# 添加消息到对话历史
bot.add_message("user", "你好！")
bot.add_message("assistant", "你好！有什么我可以帮助你的吗？")

# 获取对话历史
history = bot.get_chat_history()
print(history)

3.2.3 类的继承

        继承允许我们创建一个新类，继承现有类的属性和方法，并且可以添加新的属性和方法，或者重写现有方法。这在封装不同大模型接口时非常有用。

# 定义一个基础的大模型类
class BaseLLM:
    """基础大模型类"""
    
    def __init__(self, api_key):
        self.api_key = api_key
    
    def generate(self, prompt):
        """生成回答"""
        raise NotImplementedError("子类必须实现generate方法")

# 定义OpenAI大模型类，继承自BaseLLM
class OpenAILLM(BaseLLM):
    """OpenAI大模型类"""
    
    def __init__(self, api_key, model="gpt-3.5-turbo"):
        super().__init__(api_key)
        self.model = model
    
    def generate(self, prompt):
        """调用OpenAI API生成回答"""
        # 这里是模拟API调用
        return f"调用OpenAI {self.model}模型生成回答：{prompt}"

# 定义文心一言大模型类，继承自BaseLLM
class ErnieLLM(BaseLLM):
    """文心一言大模型类"""
    
    def __init__(self, api_key, model="ernie-3.5"):
        super().__init__(api_key)
        self.model = model
    
    def generate(self, prompt):
        """调用文心一言API生成回答"""
        # 这里是模拟API调用
        return f"调用文心一言 {self.model}模型生成回答：{prompt}"

3.3 为什么大模型开发需要面向对象

1. 代码复用：我们可以把大模型的通用功能封装在基类中，不同的大模型子类只需要实现自己特有的逻辑
2. 易于扩展：当我们需要支持新的大模型时，只需要创建一个新的子类，实现 generate 方法即可
3. 代码清晰：面向对象编程将数据和操作数据的方法封装在一起，让代码结构更加清晰
4. 便于维护：当我们需要修改某个大模型的实现时，只需要修改对应的子类，不会影响其他代码

💡 提前预告：在下一篇文章中，我们将使用面向对象的方式封装 OpenAI、文心一言等多个大模型的接口，实现一个统一的大模型调用工具。

---

四、实战：从零写一个基于规则的聊天机器人

        现在，我们将运用前面学到的所有知识，从零写一个基于规则的聊天机器人。这个机器人虽然简单，但它包含了大模型聊天机器人的基本框架，为后续接入真正的大模型打下基础。

4.1 需求分析与设计思路

功能需求：

1. 机器人有自己的名字
2. 能够和用户进行多轮对话
3. 能够识别用户输入中的关键词，给出相应的回答
4. 能够记住对话历史
5. 用户输入 "退出" 时结束对话

设计思路：

1. 使用类来封装聊天机器人的所有功能
2. 使用列表存储对话历史
3. 使用字典存储规则（关键词 - 回答）
4. 使用 while 循环实现聊天主循环
5. 使用条件判断匹配关键词

4.2 完整代码实现

class RuleBasedChatBot:
    """基于规则的聊天机器人"""
    
    def __init__(self, name="小智"):
        """
        初始化聊天机器人
        :param name: 机器人的名字
        """
        self.name = name
        self.chat_history = []
        
        # 定义规则：关键词 -> 回答
        self.rules = {
            "你好": f"你好！我是{self.name}，很高兴认识你！",
            "名字": f"我叫{self.name}，是一个基于规则的聊天机器人。",
            "能做什么": "我可以回答一些简单的问题，比如关于Python、大模型开发的问题。你可以问我'什么是Python'或者'如何学习大模型开发'。",
            "什么是Python": "Python是一种解释型、高级、通用的编程语言。它以简洁易读的语法著称，广泛应用于Web开发、数据分析、人工智能等领域。",
            "如何学习大模型开发": "学习大模型开发可以按照以下步骤：\n1. 掌握Python基础\n2. 学习机器学习基础\n3. 了解大模型的基本原理\n4. 学习大模型API的使用\n5. 动手做项目",
            "谢谢": "不客气！如果还有其他问题，随时可以问我。",
            "再见": "再见！祝你学习进步！"
        }
    
    def add_to_history(self, role, content):
        """
        添加消息到对话历史
        :param role: 角色（user/assistant）
        :param content: 消息内容
        """
        self.chat_history.append({"role": role, "content": content})
    
    def get_response(self, user_input):
        """
        根据用户输入生成回答
        :param user_input: 用户输入的字符串
        :return: 机器人的回答
        """
        # 去除首尾空白字符
        user_input = user_input.strip()
        
        # 遍历规则，匹配关键词
        for keyword, response in self.rules.items():
            if keyword in user_input:
                return response
        
        # 如果没有匹配到任何关键词，返回默认回答
        return "抱歉，我不太理解你的意思。你可以问我'你能做什么'来了解我的功能。"
    
    def chat(self):
        """启动聊天"""
        print(f"欢迎使用{self.name}聊天机器人！")
        print("输入'退出'可以结束对话。")
        print("-" * 50)
        
        # 聊天主循环
        while True:
            # 获取用户输入
            user_input = input("你：")
            
            # 检查是否退出
            if user_input.strip() == "退出":
                print(f"{self.name}：再见！祝你学习进步！")
                break
            
            # 添加用户输入到对话历史
            self.add_to_history("user", user_input)
            
            # 生成回答
            response = self.get_response(user_input)
            
            # 添加回答到对话历史
            self.add_to_history("assistant", response)
            
            # 输出回答
            print(f"{self.name}：{response}")
            print("-" * 50)

# 运行聊天机器人
if __name__ == "__main__":
    bot = RuleBasedChatBot("小智")
    bot.chat()

4.3 运行效果与扩展方向

运行效果：

欢迎使用小智聊天机器人！
输入'退出'可以结束对话。
--------------------------------------------------
你：你好
小智：你好！我是小智，很高兴认识你！
--------------------------------------------------
你：你叫什么名字
小智：我叫小智，是一个基于规则的聊天机器人。
--------------------------------------------------
你：你能做什么
小智：我可以回答一些简单的问题，比如关于Python、大模型开发的问题。你可以问我'什么是Python'或者'如何学习大模型开发'。
--------------------------------------------------
你：什么是Python
小智：Python是一种解释型、高级、通用的编程语言。它以简洁易读的语法著称，广泛应用于Web开发、数据分析、人工智能等领域。
--------------------------------------------------
你：谢谢
小智：不客气！如果还有其他问题，随时可以问我。
--------------------------------------------------
你：退出
小智：再见！祝你学习进步！

扩展方向：

1. 添加更多的规则和关键词
2. 支持模糊匹配
3. 添加敏感词过滤功能
4. 接入真正的大模型 API，替换基于规则的回答
5. 添加对话历史保存和加载功能

---

五、总结与下一篇预告

5.1 本文总结

在这篇文章中，我们用 3 小时集中攻克了大模型开发中 90% 以上会用到的 Python 核心语法：

1. 三大核心数据类型：

   • 字符串：处理大模型的输入输出和提示词
   • 列表：存储对话历史和批量处理数据
   • 字典：构造 API 请求参数和解析返回结果

2. 流程控制：

   • 条件判断：根据不同的用户输入做出不同的响应
   • 循环：实现聊天主循环和批量处理数据
   • 函数：封装可复用的代码块

3. 面向对象基础：

   • 类与对象的概念
   • 类的属性和方法
   • 类的继承
   • 为什么大模型开发需要面向对象

4. 实战项目：

   • 从零实现了一个基于规则的聊天机器人
   • 包含了多轮对话、对话历史记录、关键词匹配等功能

5.2 下一篇预告

下一篇文章，我们将正式进入大模型开发的世界：

• Anaconda/miniconda 安装与使用（AI 开发标配）
• CUDA 与 cuDNN 安装（NVIDIA 显卡加速必备，附 AMD/CPU 替代方案）
• PyTorch 安装与验证（大模型开发最主流框架）
• 常见环境报错解决方案（版本冲突、CUDA 不匹配等）

敬请期待！

---

📖 推荐阅读与学习资源

1. Python 官方文档：最权威的 Python 学习资料
2. 菜鸟教程 Python3 教程：适合初学者的入门教程
3. 廖雪峰 Python 教程：通俗易懂的 Python 教程
4. OpenAI 官方文档：OpenAI API 的官方文档

---

💬 互动： 如果你在学习过程中遇到任何问题，或者有什么建议，欢迎在评论区留言。我会一一回复。

如果你觉得这篇文章对你有帮助，欢迎点赞、收藏、关注。你的支持是我创作的最大动力！

📢 专栏订阅： 订阅我的专栏《Python 与 AI 开发环境从零搭建》，第一时间获取最新文章。 专栏地址：https://blog.csdn.net/qq_40303030/category_13173979.html