一、开篇回顾 + 今日目标

开篇回顾

Day5 我们掌握了 Python 函数的基础定义、参数、返回值，学会了封装大模型参数校验、prompt 处理、批量调用等核心函数，解决了代码复用的问题。但在实际大模型开发中，还会遇到更灵活的函数使用场景，同时想要调用真实大模型、使用第三方工具，必须掌握函数进阶用法和模块导入，这是从模拟调用走向实战的关键一步。

今日目标

1. 掌握函数进阶用法：函数嵌套、lambda 匿名函数、函数参数进阶（可变参数），适配复杂大模型逻辑处理；
2. 精通 Python 模块导入：import、from...import、自定义模块、常用内置模块，学会调用现成代码库；
3. 结合大模型场景，实现内置模块处理数据 + 进阶函数封装，完成真实大模型 API 调用的前置准备；
4. 规避函数进阶与模块导入的常见坑，能独立编写可复用、可扩展的大模型基础脚本。

二、核心知识点（大模型开发专属）

（一）函数进阶用法

1. 函数嵌套（大模型流程封装必备）

# 示例1：快速处理模型温度参数，保留一位小数
format_temp = lambda temp: round(temp, 1)
print(format_temp(0.78))  # 输出0.8

# 示例2：结合列表推导式，过滤合法模型配置（大模型高频）
model_configs = [
    {"model": "qwen-7b", "temperature": 0.8},
    {"model": "chatglm3-6b", "temperature": 1.3},
    {"model": "llama-7b", "temperature": 0.6}
]
# 匿名函数快速筛选温度合法的配置
valid_configs = list(filter(lambda x<= x["<= 1.0, model_configs))
print("合法配置：", valid_configs)

# 示例3：快速给prompt添加后缀
add_suffix = lambda p: p + " 请用100字以内回答"
print(add_suffix("介绍大模型"))

• 核心定义：在一个函数内部定义另一个函数，外层函数称为外层函数，内层函数只能在函数内部调用，适合拆分复杂业务逻辑，让大模型调用流程更清晰。
• 适用场景：大模型调用的完整流程（参数校验→prompt 处理→模拟调用），把每个子步骤封装成内层函数，外层函数统一调度。
• 语法 & 示例：

• # 函数嵌套：封装完整大模型调用流程
  def model_call_flow(prompt, model="qwen-7b", temperature=0.7):
      # 内层函数1：校验模型参数
      def check_params(temp):
          return<= 1.0
  
      # 内层函数2：处理prompt
      def process_prompt(p):
          if p.strip() == "":
              return None
          return f"【专业提问】{p}"
  
      # 外层函数逻辑：调度内层函数
      if not check_params(temperature):
          return "❌ 参数校验失败：温度需在0-1.0之间"
      processed_p = process_prompt(prompt)
      if not processed_p:
          return "❌ Prompt无效：不能为空或纯空格"
      # 模拟调用
      return f"✅ 调用{model}成功，处理后Prompt：{processed_p}，响应生成中..."
  
  # 调用外层函数
  result1 = model_call_flow("什么是RAG检索增强生成？")
  result2 = model_call_flow("", temperature=1.2)
  print(result1)
  print(result2)
  

• 核心优势：逻辑分层清晰，内层函数仅对外层函数可见，避免全局函数过多，代码更整洁。

• 2. Lambda 匿名函数（极简逻辑快速处理）

• 核心定义：无需使用def定义，一行代码完成简单函数的编写，没有函数名，适合一次性使用、逻辑简单的场景。
• 语法：lambda 参数1,参数2...: 表达式
• 大模型适用场景：prompt 排序、参数过滤、列表字典快速处理等简单逻辑，替代简短的 def 函数。
• 实战示例：

• 核心优势：逻辑分层清晰，内层函数仅对外层函数可见，避免全局函数过多，代码更整洁。

2. Lambda 匿名函数（极简逻辑快速处理）

• 核心定义：无需使用def定义，一行代码完成简单函数的编写，没有函数名，适合一次性使用、逻辑简单的场景。
• 语法：lambda 参数1,参数2...: 表达式
• 大模型适用场景：prompt 排序、参数过滤、列表字典快速处理等简单逻辑，替代简短的 def 函数。
• 实战示例：

# 示例1：快速处理模型温度参数，保留一位小数
format_temp = lambda temp: round(temp, 1)
print(format_temp(0.78))  # 输出0.8

# 示例2：结合列表推导式，过滤合法模型配置（大模型高频）
model_configs = [
    {"model": "qwen-7b", "temperature": 0.8},
    {"model": "chatglm3-6b", "temperature": 1.3},
    {"model": "llama-7b", "temperature": 0.6}
]
# 匿名函数快速筛选温度合法的配置
valid_configs = list(filter(lambda x<= x["<= 1.0, model_configs))
print("合法配置：", valid_configs)

# 示例3：快速给prompt添加后缀
add_suffix = lambda p: p + " 请用100字以内回答"
print(add_suffix("介绍大模型"))

• 注意：lambda 仅适合单行表达式，复杂逻辑（多分支、循环）仍用普通函数。

3. 可变参数（灵活接收任意数量参数）

• 核心定义：函数接收不确定数量的参数，分为 ** 可变位置参数*args和可变关键字参数**kwargs，适合大模型中不确定参数数量的场景（如批量传入多个 prompt、多个模型配置）。
• 语法说明：
  • *args：接收任意数量的位置参数，以元组形式存储；
  • **kwargs：接收任意数量的关键字参数，以字典形式存储。
• 大模型实战示例：

# 1. 可变位置参数：批量接收多个prompt
def batch_process_prompts(*prompts, prefix="请回答："):
    result = []
    for p in prompts:
        if p.strip():
            result.append(f"{prefix}{p}")
    return result

# 传入任意数量的prompt
print(batch_process_prompts("大模型原理", "Python调用模型", "RAG实战"))

# 2. 可变关键字参数：接收任意模型配置参数
def create_model_config(**kwargs):
    default_config = {"model": "qwen-7b", "temperature": 0.7, "max_tokens": 1024}
    # 更新自定义配置
    default_config.update(kwargs)
    return default_config

# 传入任意数量的配置参数
config1 = create_model_config(temperature=0.8, top_p=0.9)
config2 = create_model_config(model="chatglm3-6b", max_tokens=512)
print(config1)
print(config2)

（二）模块与导入（大模型实战核心）

1. 模块基础概念

• 模块：一个.py文件就是一个模块，里面包含函数、变量、类，用于封装代码，实现代码复用；
• 作用：把大模型相关的函数（参数校验、prompt 处理）单独放在一个 py 文件，其他脚本直接导入使用，无需重复编写。

2. 常用导入方式

导入方式	语法	示例
导入整个模块	import 模块名	import math
导入指定内容	from 模块名 import 函数/变量	from math import sqrt
导入并起别名	import 模块名 as 别名	import math as m
导入全部内容	from 模块名 import *	from math import *（不推荐）

3. 内置模块（大模型高频使用）

Python 自带的内置模块无需安装，直接导入使用，大模型开发常用以下 3 个：

• math 模块：处理数学计算（模型参数计算、数值格式化）；
• random 模块：生成随机数（模拟模型随机响应、随机温度参数）；
• json 模块：处理 JSON 数据（大模型 API 请求 / 响应数据格式化）。

内置模块实战示例：

# 导入内置模块
import math
import random
import json

# 1. math模块：模型参数计算（温度参数取整、tokens计算）
temp = 0.76
format_temp = math.round(temp, 1)  # 保留一位小数
tokens = math.ceil(800 / 1.5)  # 向上取整计算tokens
print(f"格式化温度：{format_temp}，计算tokens：{tokens}")

# 2. random模块：模拟随机模型响应、随机温度
random_temp = random.uniform(0.5, 0.9)  # 生成0.5-0.9之间的随机温度
responses = ["好的，这就为您解答", "我来详细说明一下", "针对这个问题，我的回答是"]
random_response = random.choice(responses)  # 随机选择响应
print(f"随机温度：{random_temp:.1f}，随机响应：{random_response}")

# 3. json模块：处理大模型配置（字典转JSON字符串，存储配置）
model_config = {"model": "qwen-7b", "temperature": 0.7, "max_tokens": 1024}
# 字典转JSON字符串
config_json = json.dumps(model_config, ensure_ascii=False, indent=4)
print("配置JSON：\n", config_json)
# JSON字符串转字典
config_dict = json.loads(config_json)
print("转换后字典：", config_dict)

4. 自定义模块（封装大模型工具）

• 步骤：
  1. 新建一个.py文件（如model_utils.py），把 Day5、Day6 的大模型相关函数放进去；
  2. 在主脚本中导入该模块，调用里面的函数。
• 示例：

# 新建model_utils.py文件（自定义模块）
def check_model_params(temperature, max_tokens):
    temp<= temperature<= 1.0
    token_valid = 2<= 2048
    return temp_valid and token_valid

def process_prompt(prompt, prefix="请专业回答："):
    return f"{prefix}{prompt.strip()}" if prompt.strip() else None

# 主脚本中导入自定义模块
import model_utils
from model_utils import check_model_params

# 调用自定义模块函数
valid = model_utils.check_model_params(0.7, 512)
processed_p = model_utils.process_prompt("什么是大模型")
print(f"参数是否合法：{valid}，处理后Prompt：{processed_p}")

（三）函数 + 模块结合实战（大模型前置脚本）

把函数进阶和模块导入结合，封装一个完整的大模型预处理工具，实现参数校验→prompt 处理→配置格式化全流程，可直接导入使用。

# 导入内置模块
import json
import random

# 进阶函数封装：大模型预处理工具
def model_preprocess(prompts, **kwargs):
    # 内层函数：参数校验
    def validate_params(config):
       <= config.get("temperature", 0.<= 1.0 and 256<= config.get("max_tokens", 1024<= 2048
    
    # 匿名函数：快速过滤有效prompt
    valid_prompts = list(filter(lambda p: p.strip(), prompts))
    if not valid_prompts:
        return {"code": 400, "msg": "无有效Prompt"}
    
    # 生成模型配置
    default_config = {"model": "qwen-7b", "temperature": random.uniform(0.5, 0.9), "max_tokens": 1024}
    default_config.update(kwargs)
    if not validate_params(default_config):
        return {"code": 400, "msg": "模型参数不合法"}
    
    # 处理prompt
    processed_p = [f"【用户提问】{p}" for p in valid_prompts]
    # 格式化结果为JSON（适配API调用）
    result = {"code": 200, "config": default_config, "processed_prompts": processed_p}
    return json.dumps(result, ensure_ascii=False, indent=4)

# 调用实战
prompts = ["大模型怎么调用", "", "RAG技术有什么用", "   "]
pre_result = model_preprocess(prompts, model="chatglm3-6b")
print(pre_result)

三、今日实操（代码可直接复制运行）

实操 1：函数嵌套 + lambda 匿名函数综合练习

# 实操1：嵌套函数+lambda，实现模型响应快速处理
def generate_response(prompt, temperature=0.7):
    # 内层函数：参数校验
    def check_temp(temp):<=<= 1.0
    # lambda：快速生成响应前缀
    get_prefix = lambda temp: "【精准回答】" if< 0.7 else "【发散回答】"
    
    if not check_temp(temperature):
        return "❌ 温度参数错误"
    if not prompt.strip():
        return "❌ 提问不能为空"
    prefix = get_prefix(temperature)
    return f"{prefix}：{prompt} - 正在生成专业响应..."

# 测试
print(generate_response("Python函数进阶用法", 0.6))
print(generate_response("大模型参数调优", 0.9))

实操 2：可变参数 + 内置模块处理模型配置

# 实操2：可变参数接收多个模型配置，用math/random处理
import math
import random

def batch_create_configs(*models, **default_kwargs):
    configs = []
    for model in models:
        # 随机生成温度，保留一位小数
        temp = math.round(random.uniform(0.5, 0.9), 1)
        config = {"model": model, "temperature": temp, "max_tokens": 1024}
        config.update(default_kwargs)
        configs.append(config)
    return configs

# 传入多个模型名称，自定义max_tokens
configs = batch_create_configs("qwen-7b", "chatglm3-6b", "llama-7b", max_tokens=512)
print("批量模型配置：", configs)

实操 3：内置 json 模块 + 自定义函数，存储大模型对话历史

# 实操3：对话历史格式化与存储
import json

def save_chat_history(chat_history, filename="chat_history.json"):
    # 过滤无效对话
    valid_chat = [msg for msg in chat_history if msg.get("content").strip()]
    # 写入JSON文件
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(valid_chat, f, ensure_ascii=False, indent=4)
    return f"✅ 对话历史已保存至{filename}"

# 测试对话历史
chat = [
    {"role": "user", "content": "什么是模块导入"},
    {"role": "assistant", "content": "模块导入就是调用其他py文件的代码"},
    {"role": "user", "content": ""}
]
print(save_chat_history(chat))

四、易错点汇总（新手必避坑）

1. 函数嵌套误区：内层函数无法在函数外部直接调用，只能在外层函数内部使用；
2. lambda 滥用：复杂逻辑用 lambda 会导致代码可读性差，仅适合单行简单逻辑；
3. 可变参数顺序：函数参数顺序必须是 ** 必选参数→*args→默认参数→kwargs，否则报错；
4. 模块导入错误：
   • 导入不存在的模块 / 函数，会报ModuleNotFoundError；
   • 自定义模块和主脚本不在同一文件夹，无法直接导入；
   • 重复导入模块，不影响运行但代码不规范；
5. json 模块坑：json.dumps默认不支持中文，需加ensure_ascii=False；
6. 内置函数重名：自定义函数名不要和内置模块 / 函数重名（如不要定义math.py、json.py），会覆盖内置模块。

五、今日练习（10 分钟快速巩固）

1. 用 lambda 匿名函数编写一个函数，接收模型温度参数，判断是否合法（0-1.0），返回布尔值；
2. 定义一个带*args的函数，批量传入多个模型名称，返回包含随机温度的配置列表；
3. 导入random模块，编写一个函数，随机返回 3 条大模型模拟响应；
4. 新建一个自定义模块ai_utils.py，把参数校验、prompt 处理函数放进去，在主脚本中导入并调用。

六、次日预告

Day7 将讲解 Python文件操作（读取 / 写入 txt、csv、json 文件）和异常处理（try-except），这是大模型开发中处理对话日志、配置文件、避免程序崩溃的核心技能，学会后就能实现大模型响应本地存储、配置文件读取，离实战调用又近一步！