AI 应用开发工程师基础学习计划

📅 4 周基础学习计划

整体安排

阶段	时间	学习重点	每周投入
Week 1	Python 基础	语法、函数、类、异步	15-20 小时
Week 2	Python 进阶	API 调用、数据处理、项目实践	15-20 小时
Week 3	HTTP/API 基础	RESTful API、Postman、curl	10-15 小时
Week 4	大模型基础	LLM 概念、Prompt Engineering、OpenAI API	15-20 小时

总投入：约 55-75 小时（每天 2-3 小时，4 周完成）

Week 1：Python 基础（15-20 小时）

目标

掌握 Python 核心语法和面向对象编程，为后续学习打下基础。

每日安排（每天 2-3 小时）

Day 1-2：环境搭建与基础语法

学习内容：

• 安装 Python（推荐 3.10+）
• 安装 VS Code 或 PyCharm
• 变量与数据类型
• 运算符与表达式

实践任务：

python

# 练习 1：温度转换器
# 输入摄氏度，输出华氏度
celsius = float(input("请输入摄氏度："))
fahrenheit = (celsius * 9/5) + 32
print(f"{celsius}°C = {fahrenheit}°F")

# 练习 2：计算器
# 实现加减乘除四则运算
num1 = float(input("请输入第一个数："))
operator = input("请输入运算符（+、-、*、/）：")
num2 = float(input("请输入第二个数："))

if operator == '+':
    result = num1 + num2
elif operator == '-':
    result = num1 - num2
elif operator == '*':
    result = num1 * num2
elif operator == '/':
    result = num1 / num2
else:
    result = "无效的运算符"

print(f"结果：{result}")

验收标准：

• 能独立编写简单的 Python 脚本
• 理解变量、数据类型、运算符

Day 3-4：流程控制（条件与循环）

学习内容：

• if-elif-else 条件判断
• for 循环、while 循环
• break、continue
• 列表推导式

实践任务：

python

# 练习 3：猜数字游戏
import random

secret_number = random.randint(1, 100)
attempts = 0

print("欢迎来到猜数字游戏！我已经想好了一个 1-100 之间的数字。")

while True:
    guess = int(input("请输入你的猜测："))
    attempts += 1

    if guess < secret_number:
        print("太小了！")
    elif guess > secret_number:
        print("太大了！")
    else:
        print(f"恭喜你！你用了 {attempts} 次猜对了！")
        break

# 练习 4：计算列表中偶数的和
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_sum = sum([num for num in numbers if num % 2 == 0])
print(f"偶数之和：{even_sum}")

验收标准：

• 能熟练使用条件判断和循环
• 能用列表推导式简化代码

Day 5-6：函数与模块

学习内容：

• 函数定义与调用
• 参数传递（位置参数、关键字参数、默认参数）
• 返回值
• 模块导入（import）
• 标准库使用（random、math、datetime）

实践任务：

python

# 练习 5：实现常用工具函数
import math
from datetime import datetime

def calculate_circle_area(radius):
    """计算圆的面积"""
    return math.pi * radius ** 2

def is_prime(n):
    """判断是否为质数"""
    if n < 2:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True

def get_current_time():
    """获取当前时间"""
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

# 测试函数
print(f"半径为 5 的圆的面积：{calculate_circle_area(5):.2f}")
print(f"7 是质数吗？{is_prime(7)}")
print(f"当前时间：{get_current_time()}")

**验收标准 **：

• 能定义和调用函数
• 能使用模块和标准库

Day 7：面向对象编程（OOP）

**学习内容 **：

• 类与对象
• 属性与方法
• 构造函数（__init__）
• 继承（基础概念）

**实践任务 **：

python

# 练习 6：设计一个简单的图书管理系统
class Book:
    def __init__(self, title, author, isbn):
        self.title = title
        self.author = author
        self.isbn = isbn
        self.is_borrowed = False

    def borrow(self):
        if not self.is_borrowed:
            self.is_borrowed = True
            return f"《{self.title}》借阅成功"
        else:
            return f"《{self.title}》已被借出"

    def return_book(self):
        self.is_borrowed = False
        return f"《{self.title}》已归还"

    def __str__(self):
        status = "已借出" if self.is_borrowed else "可借阅"
        return f"《{self.title}》 - {self.author} (ISBN: {self.isbn}) - {status}"

# 测试
book1 = Book("Python 编程从入门到实践", "Eric Matthes", "978-1593279288")
book2 = Book("流畅的 Python", "Luciano Ramalho", "978-1491946008")

print(book1)
print(book1.borrow())
print(book1)
print(book1.return_book())
print(book1)

**验收标准 **：

• 理解类与对象的概念
• 能定义简单的类和方法

Week 1 阶段测试

**综合练习 **：编写一个学生成绩管理系统

• 功能：添加学生、录入成绩、计算平均分、排名
• 要求：使用类、列表、字典、函数

**代码框架 **：

python

class Student:
    def __init__(self, name, student_id):
        self.name = name
        self.student_id = student_id
        self.scores = {}

    def add_score(self, subject, score):
        """添加科目成绩"""
        pass

    def get_average(self):
        """计算平均分"""
        pass

    def __str__(self):
        return f"姓名：{self.name}，学号：{self.student_id}，平均分：{self.get_average():.2f}"

class GradeSystem:
    def __init__(self):
        self.students = []

    def add_student(self, name, student_id):
        """添加学生"""
        pass

    def add_score(self, student_id, subject, score):
        """为学生添加成绩"""
        pass

    def get_ranking(self):
        """获取学生排名"""
        pass

    def display_all(self):
        """显示所有学生信息"""
        pass

# 测试
system = GradeSystem()
system.add_student("张三", "001")
system.add_student("李四", "002")
system.add_score("001", "数学", 85)
system.add_score("001", "英语", 90)
system.add_score("002", "数学", 92)
system.add_score("002", "英语", 88)
system.display_all()
print("\n排名：")
system.get_ranking()

Week 2：Python 进阶（15-20 小时）

目标

掌握 API 调用、数据处理、异常处理等实战技能。

每日安排

Day 8-9：字符串与文件操作

**学习内容 **：

• 字符串方法（split、join、strip、replace）
• 文件读写（open、read、write）
• JSON 处理（json 模块）
• 异常处理（try-except）

**实践任务 **：

python

# 练习 7：简单的配置文件管理
import json
import os

class ConfigManager:
    def __init__(self, config_file="config.json"):
        self.config_file = config_file
        self.config = self.load_config()

    def load_config(self):
        """加载配置文件"""
        if os.path.exists(self.config_file):
            try:
                with open(self.config_file, 'r', encoding='utf-8') as f:
                    return json.load(f)
            except json.JSONDecodeError:
                print("配置文件格式错误，使用默认配置")
                return self.get_default_config()
        else:
            return self.get_default_config()

    def save_config(self):
        """保存配置文件"""
        with open(self.config_file, 'w', encoding='utf-8') as f:
            json.dump(self.config, f, ensure_ascii=False, indent=2)

    def get_default_config(self):
        """获取默认配置"""
        return {
            "app_name": "MyApp",
            "version": "1.0.0",
            "debug": True,
            "api_key": ""
        }

    def get(self, key, default=None):
        """获取配置项"""
        return self.config.get(key, default)

    def set(self, key, value):
        """设置配置项"""
        self.config[key] = value
        self.save_config()

# 测试
config = ConfigManager()
print(f"应用名称：{config.get('app_name')}")
config.set("api_key", "your_api_key_here")
print(f"API 密钥已设置：{config.get('api_key')}")

**验收标准 **：

• 能处理 JSON 文件
• 能处理文件读写异常

Day 10-11：数据结构与进阶技巧

**学习内容 **：

• 列表、字典、集合的进阶用法
• 列表推导式、字典推导式
• Lambda 函数
• 装饰器（基础概念）

**实践任务 **：

python

# 练习 8：数据分析工具
class DataAnalyzer:
    def __init__(self, data):
        self.data = data

    def filter_by_condition(self, condition_func):
        """根据条件过滤数据"""
        return [item for item in self.data if condition_func(item)]

    def sort_by_key(self, key, reverse=False):
        """根据指定键排序"""
        return sorted(self.data, key=lambda x: x[key], reverse=reverse)

    def group_by_key(self, key):
        """根据指定键分组"""
        groups = {}
        for item in self.data:
            value = item[key]
            if value not in groups:
                groups[value] = []
            groups[value].append(item)
        return groups

    def calculate_statistics(self, key):
        """计算统计信息（数值类型）"""
        values = [item[key] for item in self.data if isinstance(item.get(key), (int, float))]
        if not values:
            return None

        return {
            "count": len(values),
            "sum": sum(values),
            "average": sum(values) / len(values),
            "max": max(values),
            "min": min(values)
        }

# 测试数据
employees = [
    {"name": "张三", "department": "技术部", "salary": 15000},
    {"name": "李四", "department": "技术部", "salary": 18000},
    {"name": "王五", "department": "市场部", "salary": 12000},
    {"name": "赵六", "department": "市场部", "salary": 14000},
    {"name": "钱七", "department": "技术部", "salary": 16000},
]

analyzer = DataAnalyzer(employees)

# 过滤技术部员工
tech_employees = analyzer.filter_by_condition(lambda x: x["department"] == "技术部")
print("技术部员工：", [e["name"] for e in tech_employees])

# 按薪资排序
sorted_by_salary = analyzer.sort_by_key("salary", reverse=True)
print("薪资排名：", [e["name"] for e in sorted_by_salary])

# 按部门分组
grouped = analyzer.group_by_key("department")
print("按部门分组：", {k: [e["name"] for e in v] for k, v in grouped.items()})

# 计算薪资统计
stats = analyzer.calculate_statistics("salary")
print("薪资统计：", stats)

**验收标准 **：

• 能熟练使用列表推导式
• 能用 lambda 函数简化代码

Day 12-13：异步编程基础

**学习内容 **：

• 异步概念（为什么需要异步）
• async/await 语法
• 异步函数定义与调用
• asyncio 模块基础

**实践任务 **：

python

# 练习 9：模拟多个 API 请求
import asyncio
import time

async def simulate_api_request(api_name, delay):
    """模拟异步 API 请求"""
    print(f"[{time.strftime('%H:%M:%S')}] 开始调用 {api_name}...")
    await asyncio.sleep(delay)  # 模拟网络延迟
    print(f"[{time.strftime('%H:%M:%S')}] {api_name} 调用完成")
    return f"{api_name} 的结果"

async def main():
    """主函数"""
    # 同时调用多个 API
    tasks = [
        simulate_api_request("用户服务", 2),
        simulate_api_request("订单服务", 3),
        simulate_api_request("支付服务", 1)
    ]

    results = await asyncio.gather(*tasks)
    print("\n所有调用结果：", results)

# 运行异步程序
if __name__ == "__main__":
    asyncio.run(main())

**验收标准 **：

• 理解异步编程的基本概念
• 能编写简单的异步函数

Day 14：综合项目 - 数据处理工具

**项目目标 **：编写一个能读取 CSV 文件并进行数据分析的工具

**代码框架 **：

python

import csv
from datetime import datetime

class SalesDataAnalyzer:
    def __init__(self, csv_file):
        self.csv_file = csv_file
        self.data = self.load_data()

    def load_data(self):
        """加载 CSV 数据"""
        data = []
        try:
            with open(self.csv_file, 'r', encoding='utf-8') as f:
                reader = csv.DictReader(f)
                for row in reader:
                    # 转换数据类型
                    row['price'] = float(row['price'])
                    row['quantity'] = int(row['quantity'])
                    data.append(row)
        except FileNotFoundError:
            print(f"文件 {self.csv_file} 不存在")
        except Exception as e:
            print(f"加载数据时出错：{e}")

        return data

    def get_total_sales(self):
        """计算总销售额"""
        total = sum(item['price'] * item['quantity'] for item in self.data)
        return total

    def get_top_products(self, n=5):
        """获取销量前 N 的产品"""
        # 按销量排序
        sorted_data = sorted(self.data, key=lambda x: x['quantity'], reverse=True)
        return sorted_data[:n]

    def get_sales_by_category(self):
        """按类别统计销售额"""
        category_sales = {}
        for item in self.data:
            category = item['category']
            sales = item['price'] * item['quantity']
            category_sales[category] = category_sales.get(category, 0) + sales
        return category_sales

    def generate_report(self):
        """生成分析报告"""
        report = f"""
=== 销售数据分析报告 ===
生成时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}

1. 总销售额：¥{self.get_total_sales():,.2f}

2. 销量前 5 产品：
"""
        for i, product in enumerate(self.get_top_products(5), 1):
            report += f"   {i}. {product['name']} - 销量：{product['quantity']}\n"

        report += "\n3. 各类别销售额：\n"
        for category, sales in self.get_sales_by_category().items():
            report += f"   - {category}：¥{sales:,.2f}\n"

        return report

# 创建测试数据
def create_test_data():
    data = [
        {"name": "笔记本电脑", "category": "电子产品", "price": 5999, "quantity": 10},
        {"name": "手机", "category": "电子产品", "price": 3999, "quantity": 25},
        {"name": "键盘", "category": "配件", "price": 299, "quantity": 50},
        {"name": "鼠标", "category": "配件", "price": 99, "quantity": 80},
        {"name": "显示器", "category": "电子产品", "price": 1299, "quantity": 15},
        {"name": "耳机", "category": "配件", "price": 599, "quantity": 30},
        {"name": "平板电脑", "category": "电子产品", "price": 2499, "quantity": 20},
    ]

    with open('sales_data.csv', 'w', encoding='utf-8', newline='') as f:
        fieldnames = ['name', 'category', 'price', 'quantity']
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(data)

    print("测试数据已创建：sales_data.csv")

# 测试
create_test_data()
analyzer = SalesDataAnalyzer('sales_data.csv')
print(analyzer.generate_report())

**验收标准 **：

• 能处理 CSV 文件
• 能进行数据统计和分析
• 能生成格式化报告

Week 3：HTTP/API 基础（10-15 小时）

目标

理解 HTTP 协议、RESTful API 设计，能使用工具测试 API。

每日安排

Day 15：HTTP 协议基础

**学习内容 **：

• HTTP 请求方法（GET、POST、PUT、DELETE）
• HTTP 状态码（200、400、401、404、500）
• 请求头（Headers）与响应头
• URL 结构

**实践任务 **：

python

# 练习 10：手动构建 HTTP 请求字符串
def build_http_request(method, url, headers=None, body=None):
    """构建 HTTP 请求字符串"""
    # 解析 URL
    from urllib.parse import urlparse
    parsed = urlparse(url)
    path = parsed.path or "/"
    query = f"?{parsed.query}" if parsed.query else ""

    # 构建请求行
    request_line = f"{method} {path}{query} HTTP/1.1\r\n"

    # 构建请求头
    headers = headers or {}
    headers_lines = "\r\n".join([f"{k}: {v}" for k, v in headers.items()])

    # 构建完整请求
    request = request_line + headers_lines + "\r\n\r\n"

    # 如果有 body，添加到请求中
    if body:
        request += body

    return request

# 示例
request = build_http_request(
    method="POST",
    url="https://api.example.com/users",
    headers={
        "Content-Type": "application/json",
        "Authorization": "Bearer your_token_here"
    },
    body='{"name": "张三", "email": "zhangsan@example.com"}'
)

print("HTTP 请求示例：")
print(request)

**验收标准 **：

• 理解 HTTP 请求结构
• 能识别不同的 HTTP 方法用途

Day 16-17：使用 Python 调用 API

**学习内容 **：

• requests 库（安装：pip install requests）
• GET 请求
• POST 请求（JSON 数据）
• 处理响应（状态码、JSON 解析）
• 错误处理

**实践任务 **：

python

# 练习 11：调用免费 API
import requests

class APIClient:
    def __init__(self, base_url):
        self.base_url = base_url

    def get(self, endpoint, params=None):
        """发送 GET 请求"""
        url = f"{self.base_url}/{endpoint}"
        try:
            response = requests.get(url, params=params)
            response.raise_for_status()  # 检查 HTTP 错误
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"请求失败：{e}")
            return None

    def post(self, endpoint, data=None):
        """发送 POST 请求"""
        url = f"{self.base_url}/{endpoint}"
        try:
            response = requests.post(url, json=data)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"请求失败：{e}")
            return None

# 测试：调用免费的 JSONPlaceholder API
api = APIClient("https://jsonplaceholder.typicode.com")

# GET 请求示例
print("=== 获取用户列表 ===")
users = api.get("users")
if users:
    print(f"共 {len(users)} 个用户")
    print(f"第一个用户：{users[0]['name']}")

print("\n=== 获取单个用户 ===")
user = api.get("users/1")
if user:
    print(f"用户详情：")
    print(f"  姓名：{user['name']}")
    print(f"  邮箱：{user['email']}")
    print(f"  公司：{user['company']['name']}")

print("\n=== 创建新文章 ===")
new_post = {
    "title": "我的第一篇文章",
    "body": "这是文章内容",
    "userId": 1
}
created_post = api.post("posts", new_post)
if created_post:
    print(f"文章创建成功，ID：{created_post['id']}")

**验收标准 **：

• 能使用 requests 库发送 GET/POST 请求
• 能处理 API 响应和错误

Day 18：Postman 工具使用

**学习内容 **：

• 安装 Postman
• 创建请求
• 设置请求头和参数
• 保存请求到 Collection
• 环境变量管理

**实践任务 **：

1. 下载并安装 Postman
2. 测试以下 API：
   • GET https://jsonplaceholder.typicode.com/users
   • POST https://jsonplaceholder.typicode.com/posts
3. 创建一个 Collection，保存测试请求
4. 设置环境变量（如 base_url）

**验收标准 **：

• 能使用 Postman 发送各种 HTTP 请求
• 能理解请求和响应的结构

Day 19：RESTful API 设计原则

**学习内容 **：

• REST 架构风格
• 资源命名规范（复数名词）
• HTTP 方法语义
• 状态码使用规范
• 版本控制

**实践任务 **：

python

# 练习 12：设计一个简单的 RESTful API 规范
"""
用户管理 API 规范
Base URL: https://api.example.com/v1

资源：用户

1. 获取用户列表
   GET /users
   Query参数: page, limit, search

2. 获取单个用户
   GET /users/{user_id}

3. 创建用户
   POST /users
   Body: {"name": "张三", "email": "zhangsan@example.com"}

4. 更新用户
   PUT /users/{user_id}
   Body: {"name": "李四", "email": "lisi@example.com"}

5. 部分更新用户
   PATCH /users/{user_id}
   Body: {"email": "new_email@example.com"}

6. 删除用户
   DELETE /users/{user_id}
"""

# 使用 Python requests 测试 API 设计
class UserAPIClient:
    def __init__(self, base_url):
        self.base_url = base_url

    def get_users(self, page=1, limit=10, search=None):
        """获取用户列表"""
        params = {"page": page, "limit": limit}
        if search:
            params["search"] = search
        return requests.get(f"{self.base_url}/users", params=params)

    def get_user(self, user_id):
        """获取单个用户"""
        return requests.get(f"{self.base_url}/users/{user_id}")

    def create_user(self, user_data):
        """创建用户"""
        return requests.post(f"{self.base_url}/users", json=user_data)

    def update_user(self, user_id, user_data):
        """更新用户"""
        return requests.put(f"{self.base_url}/users/{user_id}", json=user_data)

    def delete_user(self, user_id):
        """删除用户"""
        return requests.delete(f"{self.base_url}/users/{user_id}")

# 测试（使用 JSONPlaceholder）
api = UserAPIClient("https://jsonplaceholder.typicode.com")
print("获取用户列表：", api.get_users().status_code)
print("获取单个用户：", api.get_user(1).status_code)

**验收标准 **：

• 理解 RESTful API 设计原则
• 能设计符合规范的 API 接口

Day 20-21：curl 命令使用

**学习内容 **：

• curl 基础语法
• GET 请求
• POST 请求
• 设置请求头
• 处理响应

**实践任务 **：

bash

# 练习 13：使用 curl 测试 API

# 1. GET 请求
curl https://jsonplaceholder.typicode.com/users

# 2. 获取单个用户
curl https://jsonplaceholder.typicode.com/users/1

# 3. POST 请求
curl -X POST https://jsonplaceholder.typicode.com/posts \
  -H "Content-Type: application/json" \
  -d '{"title": "foo", "body": "bar", "userId": 1}'

# 4. 设置请求头
curl -H "Authorization: Bearer your_token_here" \
  https://api.example.com/data

# 5. 只显示响应头
curl -I https://jsonplaceholder.typicode.com/users

# 6. 保存响应到文件
curl -o response.json https://jsonplaceholder.typicode.com/users

# 7. 查看详细信息（包含请求头和响应头）
curl -v https://jsonplaceholder.typicode.com/users

**验收标准 **：

• 能使用 curl 发送各种 HTTP 请求
• 能理解 curl 的常用参数

Week 4：大模型基础（15-20 小时）

目标

理解大语言模型核心概念，掌握 Prompt Engineering，能调用 OpenAI API。

每日安排

Day 22：LLM 核心概念

**学习内容 **：

• 什么是大语言模型（LLM）
• LLM 的工作原理（简化版）
• Token 概念与计费
• 上下文窗口
• Temperature 参数

**实践任务 **：

python

# 练习 14：理解 Token 概念
"""
Token 是 LLM 处理文本的基本单位

示例：
输入：我爱编程
Tokenization: ['我', '爱', '编程'] (可能不是完全准确，只是示例)

英文示例：
输入：Hello, world!
Tokenization: ['Hello', ',', 'world', '!']

Token 计费：
- OpenAI GPT-4: 输入 $0.03/1K tokens, 输出 $0.06/1K tokens
- OpenAI GPT-3.5: 输入 $0.0015/1K tokens, 输出 $0.002/1K tokens
"""

# 计算成本估算
def estimate_cost(model, input_tokens, output_tokens):
    """估算 API 调用成本"""
    pricing = {
        "gpt-4": {"input": 0.03, "output": 0.06},
        "gpt-3.5-turbo": {"input": 0.0015, "output": 0.002},
        "gpt-4o-mini": {"input": 0.00015, "output": 0.0006}
    }

    if model not in pricing:
        return f"未知模型：{model}"

    input_cost = (input_tokens / 1000) * pricing[model]["input"]
    output_cost = (output_tokens / 1000) * pricing[model]["output"]
    total_cost = input_cost + output_cost

    return {
        "model": model,
        "input_tokens": input_tokens,
        "output_tokens": output_tokens,
        "input_cost": f"${input_cost:.6f}",
        "output_cost": f"${output_cost:.6f}",
        "total_cost": f"${total_cost:.6f}"
    }

# 估算示例
print("成本估算示例：")
print(estimate_cost("gpt-4", 1000, 500))
print(estimate_cost("gpt-3.5-turbo", 1000, 500))
print(estimate_cost("gpt-4o-mini", 1000, 500))

**验收标准 **：

• 理解 Token 的概念
• 能估算 API 调用成本

Day 23-24：Prompt Engineering

**学习内容 **：

• 基础提示技巧
• 角色设定（Persona）
• 少样本示例（Few-shot）
• 思维链（Chain of Thought）
• 常见陷阱与优化

**实践任务 **：

python

# 练习 15：Prompt Engineering 技巧

# 技巧 1：角色设定
prompt_persona = """
你是一位资深的 Python 技术面试官，有 10 年以上的面试经验。
你的任务是评估候选人的 Python 编程能力。
请针对以下问题给出专业的面试问题和评价。
"""

# 技巧 2：少样本示例
prompt_few_shot = """
你是一个情感分析助手。请判断以下句子的情感是正面、负面还是中性。

示例 1：
输入：今天天气真不错！
输出：正面

示例 2：
输入：这个产品太差了，我很失望。
输出：负面

示例 3：
输入：会议将在明天上午 10 点开始。
输出：中性

现在请判断：
输入：我刚买了一部新手机，非常喜欢！
输出：
"""

# 技巧 3：思维链
prompt_cot = """
你是一个数学问题解决专家。请使用思维链的方式一步步推理，然后给出最终答案。

问题：一个农场有鸡和兔子共 35 只，总共有 94 条腿。请问鸡和兔子各有多少只？

思考过程：
"""

# 技巧 4：格式化输出
prompt_format = """
你是一个数据提取助手。请从以下文本中提取关键信息，并以 JSON 格式输出。

文本：
张三，男，28 岁，软件工程师，毕业于北京大学，月薪 15000 元。
李四，女，25 岁，产品经理，毕业于清华大学，月薪 12000 元。

输出格式：
{
  "people": [
    {
      "name": "姓名",
      "gender": "性别",
      "age": 年龄,
      "occupation": "职业",
      "university": "毕业院校",
      "salary": 薪资
    }
  ]
}
"""

print("Prompt Engineering 示例已准备好")
print("\n技巧 1 - 角色设定：")
print(prompt_persona)
print("\n技巧 2 - 少样本示例：")
print(prompt_few_shot)
print("\n技巧 3 - 思维链：")
print(prompt_cot)
print("\n技巧 4 - 格式化输出：")
print(prompt_format)

**验收标准 **：

• 能设计有效的 Prompt 模板
• 理解常见的 Prompt 技巧

Day 25-27：OpenAI API 基础

**学习内容 **：

• 注册 OpenAI 账号
• 获取 API Key
• 安装 OpenAI Python SDK
• 调用 Chat Completions API
• 处理流式响应
• 错误处理

**环境准备 **：

bash

# 安装 OpenAI 库
pip install openai

# 设置环境变量（Mac/Linux）
export OPENAI_API_KEY="your_api_key_here"

# Windows PowerShell
$env:OPENAI_API_KEY="your_api_key_here"

**实践任务 **：

python

# 练习 16：调用 OpenAI API
import os
from openai import OpenAI

# 初始化客户端
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

class OpenAIClient:
    def __init__(self, api_key=None):
        self.client = OpenAI(api_key=api_key or os.getenv("OPENAI_API_KEY"))

    def chat(self, messages, model="gpt-4o-mini", temperature=0.7, max_tokens=1000):
        """
        调用 Chat Completions API

        参数：
        - messages: 消息列表，格式：[{"role": "user", "content": "你好"}]
        - model: 模型名称，如 "gpt-4o-mini", "gpt-4", "gpt-3.5-turbo"
        - temperature: 温度参数，0-2，越高越随机
        - max_tokens: 最大生成 token 数
        """
        try:
            response = self.client.chat.completions.create(
                model=model,
                messages=messages,
                temperature=temperature,
                max_tokens=max_tokens
            )
            return response.choices[0].message.content
        except Exception as e:
            print(f"API 调用失败：{e}")
            return None

    def chat_stream(self, messages, model="gpt-4o-mini", temperature=0.7):
        """
        流式调用 API

        流式响应可以逐字显示，提升用户体验
        """
        try:
            stream = self.client.chat.completions.create(
                model=model,
                messages=messages,
                temperature=temperature,
                stream=True
            )

            full_response = ""
            for chunk in stream:
                if chunk.choices[0].delta.content:
                    content = chunk.choices[0].delta.content
                    print(content, end="", flush=True)
                    full_response += content

            print()  # 换行
            return full_response
        except Exception as e:
            print(f"API 调用失败：{e}")
            return None

# 测试
ai = OpenAIClient()

# 示例 1：简单对话
print("=== 示例 1：简单对话 ===")
messages = [
    {"role": "system", "content": "你是一个友好的助手。"},
    {"role": "user", "content": "请用一句话介绍什么是 Python。"}
]
response = ai.chat(messages)
print(response)

# 示例 2：多轮对话
print("\n=== 示例 2：多轮对话 ===")
messages = [
    {"role": "system", "content": "你是一个编程助手。"},
    {"role": "user", "content": "什么是列表推导式？"}
]
response = ai.chat(messages)
print(f"助手：{response}")

messages.append({"role": "assistant", "content": response})
messages.append({"role": "user", "content": "能给个例子吗？"})
response = ai.chat(messages)
print(f"助手：{response}")

# 示例 3：流式响应
print("\n=== 示例 3：流式响应 ===")
messages = [
    {"role": "user", "content": "请用 100 字解释什么是人工智能。"}
]
ai.chat_stream(messages)

**验收标准 **：

• 能成功调用 OpenAI API
• 能处理 API 响应和错误
• 能使用流式响应

Day 28：综合实战 - AI 写作助手

**项目目标 **：构建一个简单的 AI 写作助手，支持多种写作模式

python

# 练习 17：AI 写作助手
import os
from openai import OpenAI

class AIWritingAssistant:
    def __init__(self, api_key=None):
        self.client = OpenAI(api_key=api_key or os.getenv("OPENAI_API_KEY"))
        self.conversation_history = []

    def reset_conversation(self):
        """重置对话历史"""
        self.conversation_history = []

    def add_system_message(self, content):
        """添加系统消息"""
        self.conversation_history.append({"role": "system", "content": content})

    def add_user_message(self, content):
        """添加用户消息"""
        self.conversation_history.append({"role": "user", "content": content})

    def add_assistant_message(self, content):
        """添加助手消息"""
        self.conversation_history.append({"role": "assistant", "content": content})

    def generate(self, prompt=None, model="gpt-4o-mini", temperature=0.7, max_tokens=1000):
        """生成文本"""
        messages = self.conversation_history.copy()

        if prompt:
            messages.append({"role": "user", "content": prompt})

        try:
            response = self.client.chat.completions.create(
                model=model,
                messages=messages,
                temperature=temperature,
                max_tokens=max_tokens
            )

            result = response.choices[0].message.content

            # 保存到对话历史
            if prompt:
                self.add_user_message(prompt)
            self.add_assistant_message(result)

            return result
        except Exception as e:
            print(f"生成失败：{e}")
            return None

    # 专门的写作模式
    def write_blog_post(self, topic, word_count=500):
        """写博客文章"""
        self.reset_conversation()
        self.add_system_message("你是一位专业的博客作者，擅长写作引人入胜的技术文章。")

        prompt = f"""
请写一篇关于"{topic}"的博客文章，要求：
1. 字数约 {word_count} 字
2. 结构清晰，包含引言、正文、总结
3. 语言生动，适合技术爱好者阅读
"""
        return self.generate(prompt)

    def write_product_description(self, product_name, features):
        """写产品描述"""
        self.reset_conversation()
        self.add_system_message("你是一位优秀的文案，擅长撰写吸引人的产品描述。")

        features_text = "\n".join([f"- {f}" for f in features])
        prompt = f"""
请为"{product_name}"写一段产品描述，突出以下特点：
{features_text}

要求：
1. 语言简洁有力
2. 突出产品优势
3. 吸引目标用户
"""
        return self.generate(prompt)

    def write_email(self, recipient, purpose, key_points):
        """写邮件"""
        self.reset_conversation()
        self.add_system_message("你是一位专业的邮件写作助手，能撰写各种场合的商务邮件。")

        points_text = "\n".join([f"- {p}" for p in key_points])
        prompt = f"""
请给{recipient}写一封邮件，目的：{purpose}

需要包含以下要点：
{points_text}

要求：
1. 语言礼貌专业
2. 结构清晰
3. 语气适当
"""
        return self.generate(prompt)

# 测试
assistant = AIWritingAssistant()

print("=== 博客文章 ===")
blog = assistant.write_blog_post("Python 异步编程", 300)
print(blog)

print("\n=== 产品描述 ===")
product_desc = assistant.write_product_description(
    "智能手表 Pro",
    ["支持健康监测", "超长续航", "防水设计", "智能提醒"]
)
print(product_desc)

print("\n=== 邮件 ===")
email = assistant.write_email(
    "张经理",
    "汇报项目进度",
    ["项目已完成 80%", "预计下周交付", "需要确认测试时间"]
)
print(email)

**验收标准 **：

• 能构建完整的多轮对话应用
• 能针对不同场景设计 Prompt
• 能处理 API 调用错误

📊 学习进度检查清单

Week 1：Python 基础

• 能编写 Python 脚本（变量、数据类型、运算符）
• 能使用条件判断和循环
• 能定义和调用函数
• 能定义类和使用对象
• 能完成学生成绩管理系统项目

Week 2：Python 进阶

• 能处理 JSON 文件
• 能进行数据统计和分析
• 能编写简单的异步函数
• 能完成销售数据分析工具项目

Week 3：HTTP/API 基础

• 理解 HTTP 协议基础
• 能使用 requests 库调用 API
• 能使用 Postman 测试 API
• 能设计 RESTful API
• 能使用 curl 命令

Week 4：大模型基础

• 理解 LLM 核心概念
• 能估算 API 调用成本
• 能设计有效的 Prompt
• 能调用 OpenAI API
• 能完成 AI 写作助手项目

🎯 完成标准

完成这 4 周学习后，你应该能够：

1. 独立使用 Python 编写脚本和小型应用
2. 理解 HTTP/API 并能调用第三方 API
3. 理解大模型 基础概念并能调用 OpenAI API
4. **具备基础工程能力 **，可以开始学习 LangChain

📖 推荐学习资源

Python 学习

• Python 官方教程
• 廖雪峰 Python 教程
• Real Python

HTTP/API 学习

• MDN Web Docs - HTTP
• RESTful API 设计指南

大模型学习

• OpenAI API 文档
• Prompt Engineering Guide
• OpenAI Cookbook

**核心建议 **：

• **不要只看不练 **：每个练习都要亲手写代码
• **遇到问题先查文档 **：培养解决问题的能力
• 记录学习笔记：整理知识点和常见问题

完成这 4 周计划后，你就可以正式开始 LangChain 的学习了！