第一部分：Python 基础 ——AI 开发的 “地基性建筑材料”

AI 开发的所有操作（处理文本、计算向量、调用 API）本质上都是对 “数据” 的操作，而 Python 基础就是帮你 “识别数据类型、存储数据、加工数据、输出数据” 的工具包。

1.1 数据类型：AI 场景里的 “三类核心原材料”

你在 AI 开发中接触的 99% 的数据，都可以归为以下三类，必须精准掌握它们的特征、常用操作、适用场景：

1.1.1 文本型（str）：AI 世界的 “母语”

大模型的 prompt、知识库的文档、

用户的提问、生成的回答、搜索的关键词 ——所有的自然语言内容都是文本型。

核心操作（高频 Top 8）：

  1. 字符串拼接：不要用+号（效率低、代码丑），用f-string（AI 开发的格式化标配）！ 
    # 传统做法（low，不推荐）
user_name = "李小白"
query = "你好" + user_name + "，请帮我写一份" + product_type + "的推广文案"

# 推荐做法（f-string，AI开发必用）
query = f"你好{user_name}，请帮我写一份{product_type}的推广文案"
  2. 去除冗余：用strip()（去首尾空格 / 换行 / 制表符）、lstrip()/rstrip()（单侧去）。 
    # AI场景：用户提问前可能误输了换行或空格
raw_query = "\n\n  帮我查天气  \t"
clean_query = raw_query.strip()  # 输出："帮我查天气"
  3. 分割文本：用split()（默认按空白字符，也可指定分隔符）。 
    # AI场景：处理批量用户ID（用逗号分隔的字符串）
user_ids_str = "1001,1002,1003"
user_ids = user_ids_str.split(",")  # 输出：["1001", "1002", "1003"]
  4. 替换文本：用replace()（简单替换）或re.sub()（正则高级替换）。 
    # AI场景：去掉文本里的邮箱（数据脱敏）
import re
text = "请联系客服邮箱：ai-dev@example.com，电话：13800138000"
clean_text = re.sub(r"[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+", "[邮箱已隐藏]", text)
  5. 统计长度：用len()（注意：中文字符在 Python 3.x 里占 1 个长度，没问题）。
  6. 判断前缀后缀：用startswith()/endswith()（判断用户是否输入了特定指令，比如 “退出对话”）。
  7. 大小写转换：用upper()/lower()/capitalize()（标准化用户输入的查询关键词）。
  8. 格式化输出（保留小数）：f-string也支持，比如f"价格：{price:.2f}元"（保留 2 位小数）。

避坑案例 1：字符串和数字拼接报错

# 错误做法
price = 19.9
text = "这件衣服的价格是" + price + "元"  # 报错：TypeError: can only concatenate str (not "float") to str

# 正确做法（f-string自动转）
text = f"这件衣服的价格是{price}元"
1.1.2 序列型（list、tuple）：AI 场景里的 “清单 / 队列 / 数组”

用来存储多个有序的、同类型或不同类型的数据，比如知识库的文档列表、大模型返回的候选回答队列、用户对话的上下文历史。

核心操作对比（list vs tuple）：

操作项 list（可变序列，用 [] 包裹） tuple（不可变序列，用 () 包裹）
添加元素 append()（尾部加）、insert()（指定位置加）、extend()（合并列表） 无法直接添加，只能通过+号或*号生成新 tuple
删除元素 pop()（尾部删）、remove()（按值删）、del()（按索引 / 切片删） 无法直接删除，只能通过切片生成新 tuple
修改元素 支持，如list[0] = 10 不支持，修改会报错
查询元素 都支持：索引（list[0]）、切片（list[1:3]）、in判断（"a" in list） 同上
性能 比 tuple 略差 比 list 快，占用内存少

场景化选择建议（AI 开发）：

  • 需要频繁修改的选 list：比如用户的对话上下文（每次对话都要添加 new question/answer）、大模型的候选回答队列（需要排序 / 过滤）。
  • 不需要修改的选 tuple：比如大模型的 API 参数列表（防止误改）、知识库的固定标签（如 ["电商", "金融", "医疗"]）。

list 的高频 Top 6 操作（AI 场景常用）：

  1. 遍历：用 for 循环（最常用）或列表推导式（下面会讲）。 
    # AI场景：遍历知识库文档，计算Embedding
docs = ["文档1", "文档2", "文档3"]
embeddings = []
for doc in docs:
    embedding = model.encode(doc)
    embeddings.append(embedding)
  2. 切片：取列表的部分元素，语法是list[start:end:step]（左闭右开）。 
    # AI场景：取用户最近的3条对话上下文
history = ["Q1", "A1", "Q2", "A2", "Q3", "A3"]
recent_history = history[-6:]  # 取最后6个元素（即最近3条Q&A）
  3. 排序 / 倒序：用sort()（原地排序）或sorted()（生成新列表排序）。 
    # AI场景：对大模型返回的候选回答按相似度排序（从高到低）
candidates = [
    {"answer": "回答1", "score": 0.85},
    {"answer": "回答2", "score": 0.92},
    {"answer": "回答3", "score": 0.78}
]
sorted_candidates = sorted(candidates, key=lambda x: x["score"], reverse=True)
  4. 去重：先转 set（集合，自动去重）再转 list（保留顺序）。 
    # AI场景：对用户搜索的关键词去重
raw_keywords = ["AI开发", "Python", "AI开发", "大模型"]
unique_keywords = list(set(raw_keywords))  # 注意：set会打乱顺序
# 保留顺序的去重方法
unique_keywords = []
for keyword in raw_keywords:
    if keyword not in unique_keywords:
        unique_keywords.append(keyword)
  5. 查找索引：用index()（找到第一个匹配的索引，没找到报错）。
  6. 统计次数：用count()（统计某个元素出现的次数）。

避坑案例 2：列表索引越界

# AI场景：取大模型返回的choices时，可能choices是空的
openai_response = {"choices": []}
try:
    answer = openai_response["choices"][0]["message"]["content"]
except IndexError:
    answer = "未获取到有效回答"
1.1.3 映射型（dict）：AI 场景里的 “数据库表项 / 配置文件 / API 返回格式”

用来存储键值对（key-value pairs） 数据，比如用户的个人信息（{"name": "李小白", "age": 25, "level": "vip1"}）、大模型的 API 配置（{"api_key": "sk-xxx", "model": "gpt-3.5-turbo"}）、API 返回的结构化数据（{"code": 200, "data": {"answer": "..."}, "msg": "success"}）。

核心操作（高频 Top 10）：

  1. 创建字典： 
    # 直接创建（最简单）
config = {"api_key": "sk-xxx", "model": "gpt-3.5-turbo"}
# 用dict()函数创建
config = dict(api_key="sk-xxx", model="gpt-3.5-turbo")
# 从两个列表创建（zip()函数）
keys = ["name", "age", "level"]
values = ["李小白", 25, "vip1"]
user_info = dict(zip(keys, values))
  2. 访问值：
    • 直接访问（dict[key]）：没找到 key 会报错。
    • 用get()方法（AI 开发必用）：没找到 key 返回默认值（避免 KeyError）。
    # AI场景：安全访问大模型返回的content
answer = openai_response.get("choices", [{}])[0].get("message", {}).get("content", "未获取到有效回答")
  3. 添加 / 修改键值对： 
    config["temperature"] = 0.7  # 添加或修改
config.update({"max_tokens": 1000, "top_p": 0.9})  # 批量添加/修改
  4. 删除键值对： 
    del config["top_p"]  # 直接删除
config.pop("max_tokens", None)  # 安全删除（没找到返回默认值）
  5. 遍历字典：
    • 遍历键：for key in config 或 for key in config.keys()。
    • 遍历值：for value in config.values()。
    • 遍历键值对（最常用）：for key, value in config.items()。
  6. 获取键 / 值 / 键值对列表： 
    keys = list(config.keys())
values = list(config.values())
items = list(config.items())
  7. 判断 key 是否存在： 
    if "api_key" in config:
    print("API密钥已配置")
  8. 合并字典： 
    dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
merged_dict = dict(dict1, **dict2)  # 注意：后面的字典会覆盖前面的
  9. 嵌套字典操作： 
    user_info = {"name": "李小白", "address": {"province": "北京", "city": "朝阳区"}}
city = user_info.get("address", {}).get("city", "未知城市")
  10. 字典推导式：（下面会讲，比 for 循环简洁 10 倍）。

避坑案例 3：字典的 key 必须是不可变类型

# 错误做法（list是可变类型，不能当key）
invalid_dict = {["name", "age"]: ["李小白", 25]}  # 报错：TypeError: unhashable type: 'list'

# 正确做法（用tuple当key，或者将list转成str）
valid_dict1 = {("name", "age"): ["李小白", 25]}
valid_dict2 = {str(["name", "age"]): ["李小白", 25]}

1.2 变量与赋值：AI 场景里的 “临时储物柜 + 货架编号”

Python 是动态类型语言，不需要像 C++/Java 那样先声明变量类型，直接赋值即可 —— 但这也带来了一些坑，必须注意。

核心概念：

  • 变量：本质上是一个 “指针”，指向内存中的某个数据地址。
  • 赋值：不是 “把数据放到变量里”，而是 “让变量的指针指向数据的地址”。

可变 / 不可变类型的坑（AI 开发高频踩坑点！）：

  • 不可变类型：值变了地址必变（修改时会重新创建变量），包括：str、int、float、bool、tuple。
  • 可变类型：值变了地址不变（修改时会影响引用它的所有变量），包括：list、dict、set。

避坑案例 4：可变类型的引用传递问题

# AI场景：复制用户对话上下文
history = ["Q1", "A1"]
new_history = history  # 这里不是复制，而是让new_history指向history的地址
new_history.append("Q2")
print(history)  # 输出：["Q1", "A1", "Q2"] （原变量被修改了！）

# 正确做法（浅拷贝）
import copy
new_history = copy.copy(history)  # 或 new_history = history[:]
new_history.append("A2")
print(history)  # 输出：["Q1", "A1", "Q2"] （原变量不变）

# 深度拷贝（适用于嵌套的可变类型）
deep_history = copy.deepcopy({"user": "李小白", "history": ["Q1", "A1"]})

1.3 控制流程：AI 场景里的 “决策树 + 流水线”

AI 程序的运行逻辑，本质上就是 “根据输入的条件，执行对应的操作，直到满足终止条件”—— 这就是控制流程的作用。

核心类型（高频 Top 3）：

1.3.1 条件判断（if-elif-else）：AI 场景里的 “分类器”

判断用户输入的问题类型（比如是文本生成、还是知识库问答）、API 返回的状态码（比如是 200 成功、还是 404 失败）、用户的等级（比如是 vip1、还是钻石会员）。

语法：

if 条件1:
    执行操作1
elif 条件2:
    执行操作2
else:
    执行默认操作

场景化示例（AI 知识库问答系统）：

query = "帮我查一下VIP1的权益"

if query.startswith("帮我查一下") and "权益" in query:
    level = extract_level(query)  # 假设这是提取等级的函数
    print(get_benefits(level))  # 假设这是获取权益的函数
elif query.startswith("写一份") and ("文案" in query or "报告" in query):
    product = extract_product(query)
    print(generate_copywriting(product))
else:
    print("抱歉，我暂时无法处理您的请求")
1.3.2 循环（for/while）：AI 场景里的 “批量处理器”

遍历知识库的文档、处理批量用户的推理任务、实现多轮对话（直到用户输入 “退出”）。

for 循环（适用于已知循环次数的场景）：

# AI场景：批量处理用户的搜索关键词（计算Embedding）
keywords = ["AI开发", "Python", "大模型"]
for keyword in keywords:
    embedding = model.encode(keyword)
    save_to_db(keyword, embedding)

while 循环（适用于未知循环次数的场景）：

# AI场景：实现多轮对话
while True:
    query = input("请输入您的问题（输入\"退出\"结束）：")
    if query == "退出":
        break
    answer = call_llm(query)
    print(answer)

循环优化技巧（AI 场景避免超时 / 内存溢出）：

  • 加延迟：调用大模型 API 时，避免触发频率限制（每次调用后 sleep 0.5 秒）。
  • 分段处理：处理大文件时，避免一次性读入内存（比如读取 1GB 的知识库文本，分成 100MB 一段）。
  • 使用生成器：处理大量数据时，生成器只在需要时生成数据，占用内存少（后面会讲）。

避坑案例 5：循环里忘记更新循环变量

# 错误做法（死循环！）
count = 1
while count <= 5:
    print(count)
    # 忘记写count += 1了

# 正确做法
count = 1
while count <= 5:
    print(count)
    count += 1
1.3.3 异常处理（try-except-finally）：AI 场景里的 “安全气囊”

AI 开发里充满了不确定性（API 请求超时、大模型返回格式错误、向量数据库连接失败）——必须用异常处理来捕获并处理这些错误，否则程序会直接崩溃！

语法：

try:
    可能会出错的代码
except 异常类型1:
    处理异常1的代码
except 异常类型2 as e:
    处理异常2的代码（e是异常对象，包含错误信息）
else:
    代码没出错时执行的代码（可选）
finally:
    无论代码是否出错都执行的代码（可选，比如关闭文件/数据库连接）

场景化示例（大模型 API 调用超时处理）：

import openai
import time
import os

openai.api_key = os.getenv("OPENAI_API_KEY")

def call_gpt3(prompt: str, max_tokens=1000, retry=3, delay=2):
    """
    调用OpenAI GPT-3.5-turbo接口，支持重试
    Args:
        prompt: 输入的prompt
        max_tokens: 最大输出长度
        retry: 重试次数
        delay: 重试间隔（秒）
    Returns:
        str: 大模型返回的回答
    """
    for i in range(retry):
        try:
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=[{"role": "user", "content": prompt}],
                max_tokens=max_tokens,
                timeout=10
            )
            return response["choices"][0]["message"]["content"]
        except openai.error.RateLimitError:
            print(f"第{i+1}次调用触发频率限制，{delay}秒后重试")
            time.sleep(delay)
            delay *= 2  # 重试间隔翻倍
        except openai.error.Timeout:
            print(f"第{i+1}次调用超时，{delay}秒后重试")
            time.sleep(delay)
            delay *= 2
        except Exception as e:
            print(f"第{i+1}次调用失败：{str(e)}")
            time.sleep(delay)
            delay *= 2
    return "抱歉，当前服务繁忙，请稍后重试"

1.4 函数：AI 场景里的 “模块化工具包”

AI 开发里写得最多的就是函数！ 比如把 “调用大模型”、“检索知识库”、“清洗文本” 都封装成函数，代码复用性极高，而且修改起来只需要改一处 —— 这就是软件工程里的 “高内聚、低耦合” 原则在 AI 开发里的体现。

核心概念：

  • 函数定义：用def关键字。
  • 参数传递：包括位置参数、默认参数、关键字参数、可变长度参数（*args、**kwargs）。
  • 返回值：用return关键字。
  • 作用域：变量分为全局变量（整个程序都能访问）和局部变量（只有函数内部能访问）。

高频函数写法（AI 场景常用）：

1.4.1 位置参数和默认参数
# 位置参数：必须传入的参数
# 默认参数：可以不传，不传时使用默认值
def generate_prompt(product_type: str, style="简约") -> str:
    """
    生成推广文案的prompt
    Args:
        product_type: 产品类型（如“T恤”）
        style: 文案风格（如“简约”、“炫酷”、“文艺”）
    Returns:
        str: 格式化后的prompt
    """
    prompt = f"请帮我写一份{style}风格的{product_type}推广文案，要求：\n1. 突出产品优势\n2. 语言简洁易懂\n3. 包含行动号召"
    return prompt

# 调用函数
prompt1 = generate_prompt("T恤")  # 风格使用默认值“简约”
prompt2 = generate_prompt("T恤", "炫酷")  # 传入位置参数
prompt3 = generate_prompt(product_type="T恤", style="文艺")  # 传入关键字参数（推荐，可读性高）
1.4.2 可变长度参数（*args、**kwargs）

适用于参数数量不确定的场景，比如大模型 API 的配置参数。

def call_llm_generic(**kwargs):
    """
    通用的大模型API调用函数
    Args:
        **kwargs: 大模型API的配置参数（如api_key、model、temperature等）
    Returns:
        str: 大模型返回的回答
    """
    import openai
    openai.api_key = kwargs.get("api_key", os.getenv("OPENAI_API_KEY"))
    try:
        response = openai.ChatCompletion.create(
            model=kwargs.get("model", "gpt-3.5-turbo"),
            messages=kwargs.get("messages", [{"role": "user", "content": "你好"}]),
            temperature=kwargs.get("temperature", 0.7),
            max_tokens=kwargs.get("max_tokens", 1000)
        )
        return response["choices"][0]["message"]["content"]
    except Exception as e:
        return f"调用失败：{str(e)}"

# 调用函数（只传入必要参数）
answer1 = call_llm_generic(messages=[{"role": "user", "content": "帮我写一首诗"}])

# 调用函数（传入所有参数）
answer2 = call_llm_generic(
    api_key="sk-xxx",
    model="gpt-4",
    messages=[{"role": "user", "content": "帮我写一首七言律诗"}],
    temperature=0.5,
    max_tokens=500
)
1.4.3 递归函数（慎用）

递归函数是指 “函数调用自身” 的函数 —— 在 AI 开发中，只有处理深度嵌套的数据结构（比如树形知识库）时才会用到，而且要注意设置递归深度限制，避免栈溢出！

import sys
sys.setrecursionlimit(1000)  # 设置递归深度限制（默认是1000）

def search_knowledge_base(tree: dict, query: str) -> str:
    """
    递归搜索树形知识库
    Args:
        tree: 树形知识库
        query: 搜索关键词
    Returns:
        str: 匹配的文档内容
    """
    if query in tree["content"]:
        return tree["content"]
    for child in tree.get("children", []):
        result = search_knowledge_base(child, query)
        if result:
            return result
    return "未找到匹配的文档"

# 树形知识库示例
knowledge_base = {
    "title": "AI开发",
    "content": "AI开发是指利用人工智能技术开发应用程序的过程",
    "children": [
        {
            "title": "Python语言",
            "content": "Python是AI开发的核心语言，生态完整",
            "children": []
        },
        {
            "title": "大模型",
            "content": "大模型是AI开发的核心组件，如GPT-4、LLaMA等",
            "children": []
        }
    ]
}

# 搜索知识库
print(search_knowledge_base(knowledge_base, "Python"))  # 输出：Python是AI开发的核心语言，生态完整

第二部分：Python 进阶 ——AI 开发的 “加速剂 + 高级工具”

掌握了基础部分，你已经可以写一些简单的 AI 脚本了 —— 但要写高性能、可维护、可扩展的 AI 程序，还需要掌握进阶部分的知识。

2.1 列表推导式 / 字典推导式 / 集合推导式：AI 场景里的 “数据处理快捷键”

比传统的 for 循环简洁 10 倍、代码可读性高、执行效率略快——AI 开发中处理批量文本 / 数据时，必须会用！

列表推导式：语法是[表达式 for 变量 in 序列 if 条件]

# 传统for循环：
docs = ["文档1", "文档2", "文档3"]
clean_docs = []
for doc in docs:
    if len(doc) > 0:
        clean_docs.append(doc.strip())

# 列表推导式：
clean_docs = [doc.strip() for doc in docs if len(doc) > 0]

字典推导式：语法是{键表达式: 值表达式 for 变量 in 序列 if 条件}

# AI场景：生成产品类型与推广文案风格的映射
product_types = ["T恤", "牛仔裤", "运动鞋"]
styles = ["简约", "炫酷", "文艺"]
prompt_map = {product: generate_prompt(product, style) for product, style in zip(product_types, styles)}

集合推导式：语法是{表达式 for 变量 in 序列 if 条件}（自动去重）

# AI场景：对用户搜索的关键词去重
raw_keywords = ["AI开发", "Python", "AI开发", "大模型"]
unique_keywords = {keyword for keyword in raw_keywords}

嵌套推导式（适用于二维数据）：

# AI场景：处理知识库的二维文档列表
knowledge_base = [["文档1.1", "文档1.2"], ["文档2.1", "文档2.2"]]
all_docs = [doc.strip() for sublist in knowledge_base for doc in sublist if len(doc) > 0]

2.2 生成器（Generator）：AI 场景里的 “内存优化器”

生成器只在需要时生成数据，占用内存少 ——处理百万级 / 千万级数据时，必须用生成器代替列表！

创建生成器的方法（高频 Top 2）：

2.2.1 用()包裹列表推导式
# 列表（一次性生成所有数据，占用内存大）
docs = ["文档" + str(i) for i in range(1000000)]

# 生成器（只生成一个指针，需要时才计算下一个值）
gen_docs = ("文档" + str(i) for i in range(1000000))

# 遍历生成器
for doc in gen_docs:
    print(doc)
2.2.2 用yield关键字定义函数
def generate_docs(n: int):
    """生成n个文档的生成器"""
    for i in range(n):
        yield f"文档{i}"

# 调用生成器函数
gen_docs = generate_docs(1000000)

生成器的优势（AI 场景）：

  • 占用内存少：比如生成 1000 万个文档，列表需要占用约 1GB 内存，而生成器只需要占用约 10KB 内存。
  • 执行效率高：不需要一次性计算所有值，适合处理流式数据。

2.3 装饰器（Decorator）：AI 场景里的 “代码增强器”

装饰器是一种函数的函数，可以在不修改原函数代码的前提下，给原函数添加新的功能 ——AI 开发中，常用于日志记录、性能监控、权限验证、缓存处理等。

场景化示例（给大模型 API 调用函数添加日志记录装饰器）：

import logging
import time

# 配置日志
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)

def log_api_call(func):
    """
    给API调用函数添加日志记录装饰器
    Args:
        func: 原API调用函数
    Returns:
        增强后的API调用函数
    """
    def wrapper(*args, **kwargs):
        start_time = time.time()
        logger.info(f"开始调用API：{func.__name__}")
        logger.info(f"调用参数：args={args}, kwargs={kwargs}")
        try:
            result = func(*args, **kwargs)
            logger.info(f"API调用成功，耗时：{time.time() - start_time:.2f}秒")
            logger.info(f"返回结果：{result[:50]}...")  # 只打印前50个字符
            return result
        except Exception as e:
            logger.error(f"API调用失败，耗时：{time.time() - start_time:.2f}秒，错误信息：{str(e)}")
            return f"调用失败：{str(e)}"
    return wrapper

# 给call_gpt3函数添加装饰器
@log_api_call
def call_gpt3(prompt: str, max_tokens=1000):
    import openai
    import os
    openai.api_key = os.getenv("OPENAI_API_KEY")
    try:
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=max_tokens
        )
        return response["choices"][0]["message"]["content"]
    except Exception as e:
        raise e

# 调用函数
print(call_gpt3("帮我写一首诗"))

2.4 文件处理：AI 场景里的 “本地知识库管理工具”

AI 开发中，经常需要处理本地的知识库文件（如 txt、csv、json、pdf 等）——必须会用 Python 的文件处理功能。

核心操作（高频 Top 6）：

2.4.1 打开文件

用open()函数，语法是open(file_path, mode='r', encoding='utf-8')——处理中文文本时，必须指定 encoding='utf-8'，否则会乱码！

模式 含义 是否覆盖原文件
r 只读（默认） 否
w 只写（文件不存在则创建） 是
a 追加写入（文件不存在则创建） 否
r+ 读写 否
w+ 读写（文件不存在则创建） 是
a+ 读写（追加写入） 否
2.4.2 关闭文件

必须关闭文件，否则会占用系统资源 ——推荐用 with 语句，会自动关闭文件！

# 传统做法（容易忘记关闭）
file = open("knowledge.txt", "r", encoding="utf-8")
content = file.read()
file.close()

# 推荐做法（with语句）
with open("knowledge.txt", "r", encoding="utf-8") as file:
    content = file.read()
2.4.3 读取文件
with open("knowledge.txt", "r", encoding="utf-8") as file:
    # 读取全部内容
    content = file.read()

    # 读取一行
    line = file.readline()

    # 读取所有行（返回列表）
    lines = file.readlines()
2.4.4 写入文件
with open("output.txt", "w", encoding="utf-8") as file:
    # 写入一行
    file.write("这是一行内容\n")

    # 写入多行（列表）
    lines = ["第1行\n", "第2行\n", "第3行\n"]
    file.writelines(lines)
2.4.5 处理 JSON 文件

JSON 是 AI 开发中最常用的结构化数据格式——Python 的json模块可以直接读写 JSON 文件。

import json

# 读取JSON文件
with open("config.json", "r", encoding="utf-8") as file:
    config = json.load(file)

# 写入JSON文件
new_config = {"api_key": "sk-xxx", "model": "gpt-4"}
with open("new_config.json", "w", encoding="utf-8") as file:
    json.dump(new_config, file, ensure_ascii=False, indent=4)  # ensure_ascii=False保留中文，indent=4格式化输出
2.4.6 处理 CSV 文件

CSV 是 AI 开发中最常用的表格数据格式——Python 的csv模块可以直接读写 CSV 文件，或者用pandas库（更简单，后面会讲）。

import csv

# 读取CSV文件
with open("user_info.csv", "r", encoding="utf-8") as file:
    reader = csv.DictReader(file)
    for row in reader:
        print(row["name"], row["age"], row["level"])

# 写入CSV文件
with open("new_user_info.csv", "w", encoding="utf-8", newline="") as file:
    writer = csv.DictWriter(file, fieldnames=["name", "age", "level"])
    writer.writeheader()
    writer.writerows([
        {"name": "李小白", "age": 25, "level": "vip1"},
        {"name": "王大白", "age": 30, "level": "gold"}
    ])

第三部分：Python 核心库 ——AI 开发的 “黄金组合武器”

你不需要自己写所有功能，直接安装→导入→使用别人写好的 AI 库！—— 这就是 Python 生态的强大之处。

3.1 数据处理库：pandas（数据分析的 Excel）

pandas 是数据处理的神器—— 处理 CSV/Excel/JSON 格式的知识库数据、用户对话历史、统计分析数据时，必须会用！

高频操作（AI 场景常用）：

3.1.1 读取数据
import pandas as pd

# 读取CSV文件
df = pd.read_csv("user_info.csv", encoding="utf-8")

# 读取Excel文件
df = pd.read_excel("knowledge_base.xlsx", sheet_name="Sheet1")

# 读取JSON文件
df = pd.read_json("config.json")
3.1.2 查看数据
# 查看前5行
print(df.head())

# 查看后5行
print(df.tail())

# 查看数据形状（行数×列数）
print(df.shape)

# 查看数据统计信息
print(df.describe())

# 查看数据类型
print(df.dtypes)
3.1.3 清洗数据
# 删除空值行
df = df.dropna()

# 删除重复行
df = df.drop_duplicates()

# 替换空值
df["age"] = df["age"].fillna(0)

# 修改数据类型
df["age"] = df["age"].astype(int)
3.1.4 筛选数据
# 筛选年龄大于25的用户
df_25 = df[df["age"] > 25]

# 筛选vip1和gold会员
df_vip = df[df["level"].isin(["vip1", "gold"])]

# 筛选名字包含“白”的用户
df_white = df[df["name"].str.contains("白")]
3.1.5 分组统计
# 统计各等级用户的数量
level_count = df.groupby("level")["name"].count()

# 统计各等级用户的平均年龄
level_avg_age = df.groupby("level")["age"].mean()

# 统计各等级用户的对话次数（假设df里有“dialogue_count”列）
level_dialogue_count = df.groupby("level")["dialogue_count"].sum()
3.1.6 写入数据
# 写入CSV文件
df.to_csv("new_user_info.csv", encoding="utf-8", index=False)

# 写入Excel文件
df.to_excel("new_knowledge_base.xlsx", sheet_name="Sheet1", index=False)

3.2 数值计算库：numpy（数学计算的计算器）

numpy 是数值计算的基础—— 处理 AI 里的向量 / 矩阵运算（比如大模型的 Embedding 向量计算、RAG 里的相似度计算）时，必须会用！

高频操作（AI 场景常用）：

3.2.1 创建数组
import numpy as np

# 创建一维数组（列表转数组）
arr1 = np.array([1, 2, 3, 4, 5])

# 创建二维数组（列表嵌套列表转数组）
arr2 = np.array([[1, 2, 3], [4, 5, 6]])

# 创建全零数组
arr3 = np.zeros((2, 3))

# 创建全一数组
arr4 = np.ones((2, 3))

# 创建随机数组（0-1之间）
arr5 = np.random.random((2, 3))
3.2.2 数组属性
# 数组形状
print(arr2.shape)  # 输出：(2, 3)

# 数组维度
print(arr2.ndim)  # 输出：2

# 数组大小
print(arr2.size)  # 输出：6

# 数组数据类型
print(arr2.dtype)  # 输出：int64
3.2.3 数组运算
# 基本运算（加法、减法、乘法、除法）
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
print(arr1 + arr2)  # 输出：[5 7 9]
print(arr1 * arr2)  # 输出：[4 10 18]

# 矩阵乘法（用@符号或np.dot()函数）
arr3 = np.array([[1, 2], [3, 4]])
arr4 = np.array([[5, 6], [7, 8]])
print(arr3 @ arr4)  # 输出：[[19 22] [43 50]]

# 数组广播（不同形状的数组运算）
arr5 = np.array([[1, 2, 3], [4, 5, 6]])
arr6 = np.array([10, 20, 30])
print(arr5 + arr6)  # 输出：[[11 22 33] [14 25 36]]
3.2.4 数组索引和切片
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 索引（取第2行第3列的元素，注意：Python是从0开始的！）
print(arr[1, 2])  # 输出：6

# 切片（取第2行到第3行，第1列到第2列的元素）
print(arr[1:3, 0:2])  # 输出：[[4 5] [7 8]]
3.2.5 向量计算（AI 场景重点！）
# 计算向量的点积（判断两个文本相似度的基础）
vec1 = np.array([0.1, 0.2, 0.3])
vec2 = np.array([0.4, 0.5, 0.6])
dot_product = np.dot(vec1, vec2)  # 输出：0.1*0.4 + 0.2*0.5 + 0.3*0.6 = 0.32

# 计算向量的模长
vec_norm = np.linalg.norm(vec1)

# 计算向量的余弦相似度（文本相似度计算的标准方法）
cosine_similarity = dot_product / (vec_norm * np.linalg.norm(vec2))

3.3 HTTP 请求库：requests（网络请求的浏览器）

requests 是网络请求的神器—— 调用大模型 API、外部 API 接口（如天气 API、翻译 API）时，必须会用！

高频操作（AI 场景常用）：

3.3.1 发送 GET 请求（获取数据）
import requests

# 发送GET请求（获取天气数据）
url = "https://api.example.com/weather"
params = {"city": "北京", "date": "2024-05-20"}
headers = {"User-Agent": "Mozilla/5.0"}
response = requests.get(url, params=params, headers=headers, timeout=10)

# 解析响应
if response.status_code == 200:
    data = response.json()
    print(data)
else:
    print(f"请求失败：{response.status_code}")
3.3.2 发送 POST 请求（传递数据）
# 发送POST请求（调用大模型API）
url = "https://api.openai.com/v1/chat/completions"
headers = {"Content-Type": "application/json", "Authorization": "Bearer sk-xxx"}
data = {
    "model": "gpt-3.5-turbo",
    "messages": [{"role": "user", "content": "帮我写一首诗"}]
}
response = requests.post(url, headers=headers, json=data, timeout=10)

# 解析响应
if response.status_code == 200:
    data = response.json()
    print(data["choices"][0]["message"]["content"])
else:
    print(f"请求失败：{response.status_code}，{response.text}")

3.4 文档生成库：pydantic（数据验证的守门员）

pydantic 是数据验证的神器——FastAPI 开发 AI 接口时必须用，自动验证参数 / 响应格式，避免脏数据！

场景化示例（AI 接口的数据验证）：

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from enum import Enum

app = FastAPI(title="客户等级查询系统")

class CustomerLevel(str, Enum):
    VIP1 = "vip1"
    VIP2 = "vip2"
    GOLD = "gold"

class QueryModel(BaseModel):
    """查询请求模型"""
    level: CustomerLevel = Field(..., description="客户等级（支持vip1/vip2/gold）")

class ResponseModel(BaseModel):
    """查询响应模型"""
    level: CustomerLevel = Field(..., description="标准化后的客户等级")
    benefits: list = Field(..., description="该等级对应的权益详情")
    discount: float = Field(..., description="购物折扣（0-1）")

CUSTOMER_BENEFITS_MAP = {
    CustomerLevel.VIP1: {"benefits": ["免费退换货", "生日礼券"], "discount": 0.95},
    CustomerLevel.VIP2: {"benefits": ["VIP1权益", "优先发货"], "discount": 0.9},
    CustomerLevel.GOLD: {"benefits": ["VIP2权益", "免费配送"], "discount": 0.85}
}

@app.post("/customer_level", response_model=ResponseModel)
def query_customer_level(query: QueryModel):
    try:
        level_info = CUSTOMER_BENEFITS_MAP[query.level]
        return ResponseModel(level=query.level, **level_info)
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

第四部分：Python 工程化 ——AI 开发的 “自动化流水线”

掌握了代码部分，你已经可以写高性能的 AI 程序了 —— 但要上线、维护、协作开发 AI 项目，还需要掌握工程化部分的知识。

4.1 虚拟环境：隔离不同项目的 “独立仓库”

避免不同项目的库版本冲突（比如项目 A 用 langchain 0.0.300，项目 B 用 langchain 0.1.0）——每个 AI 项目都应该创建一个独立的虚拟环境！

常用工具（AI 开发）：

4.1.1 venv（Python 自带，简单）
# 创建虚拟环境（Windows/Linux/macOS通用）
python -m venv venv

# 激活虚拟环境（Windows）
venv\Scripts\activate

# 激活虚拟环境（Linux/macOS）
source venv/bin/activate

# 安装库
pip install pandas numpy requests openai langchain

# 导出依赖
pip freeze > requirements.txt

# 关闭虚拟环境
deactivate
4.1.2 conda（Anaconda 自带，适合数据科学）
# 创建虚拟环境（Python版本3.11）
conda create -n ai-dev python=3.11

# 激活虚拟环境
conda activate ai-dev

# 安装库
conda install pandas numpy requests
pip install openai langchain

# 导出依赖
conda env export > environment.yml

# 关闭虚拟环境
conda deactivate

4.2 代码版本控制：Git/GitHub（代码的 “备份 + 协作工具”）

多人协作开发 AI 项目、管理代码历史、恢复旧版本 ——Git 是 AI 开发的标配！

高频命令（AI 开发常用）：

# 初始化本地仓库
git init

# 添加远程仓库
git remote add origin https://github.com/your-username/your-repo.git

# 查看代码状态
git status

# 暂存代码
git add .

# 提交代码（注意：提交信息要清晰）
git commit -m "feat: 新增客户等级查询接口"

# 推送到远程仓库（第一次推送到main分支）
git push -u origin main

# 拉取远程仓库的代码
git pull

# 切换分支
git checkout -b feature/customer-level

# 合并分支
git checkout main
git merge feature/customer-level

4.3 日志记录：logging（程序的 “黑匣子”）

调试 AI 程序、定位问题（比如记录大模型调用失败的时间、参数）——必须用 logging 库，不能用 print！

配置示例（AI 开发）：

import logging
import os

# 确保日志目录存在
log_dir = "logs"
if not os.path.exists(log_dir):
    os.makedirs(log_dir)

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
    handlers=[
        logging.FileHandler(os.path.join(log_dir, "ai-dev.log")),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# 使用日志
logger.info("程序开始运行")
logger.warning("API调用频率接近限制")
logger.error("大模型API调用失败")

第五部分：总结与学习建议

5.1 必须掌握的知识点汇总

模块 高频知识点
基础 str 的 f-string、strip ()、split ()；list 的 append ()、extend ()、切片；dict 的 get ()、items ()；if-elif-else；for/while 循环；try-except-finally；函数定义与调用
进阶 列表推导式 / 字典推导式；生成器；装饰器；文件处理（json/csv）
核心库 pandas 的 read_csv ()、head ()、dropna ()、groupby ()；numpy 的 array ()、dot ()、linalg.norm ()；requests 的 get ()、post ()；pydantic 的 BaseModel、Field
工程化 venv/conda 虚拟环境；Git 的 init、add、commit、push；logging 的 basicConfig

5.2 学习建议

  1. 紧扣 AI 场景学习：不要啃完所有语法细节，重点学习 AI 场景里常用的操作 —— 比如处理文本就学 str 的操作，处理数据就学 pandas/numpy，调用 API 就学 requests。
  2. 多写实战代码：找一些简单的 AI 项目练手（比如写一个对话机器人、写一个知识库问答系统），遇到问题就查文档或 Stack Overflow。
  3. 不要怕报错：报错是学习的好机会 —— 仔细看错误信息，定位问题所在，然后修复它。
  4. 关注 AI 生态的更新：Python 的 AI 库更新非常快（比如 langchain 每月都会更新几个版本），要定期关注官方文档或技术博客，了解新功能。

写在最后：AI 开发里的 Python 知识，核心就是 “会用常用库、会写简单函数、会处理异常、会避坑”—— 不需要你精通底层语法细节，重点是快速落地业务需求。

# python # numpy # pandas
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

cover

复刻“疯狂的鸽子”？用Python调用Sora2与Gemini-3-Pro实现全自动热点视频流水线（附源码解析）

avatar 2048 AI社区
cover

提示词工程学习笔记: IT技术行业提示词推荐

avatar 2048 AI社区

Agent Skills (Claude Skills) 详细攻略，一篇文章精通

Agent Skills 最近非常的火，起初，它还只是 Claude 中一个小功能模块，就在最近两个月，越来越多的人觉得 Skills 非常的好用。所以 Codex、Cursor、Opencode 等 AI 编程工具，陆续加入了对 Agent Skills 的支持。2025年12月18日，Anthropic 正式把 Agent Skills 发布成了开放标准：使得 Agent Skills 和 M

avatar 2048 AI社区