一、Claude Code 是什么？
Claude Code 是 Anthropic 官方推出的 AI 命令行编程助手，可以直接在终端中与 Claude 大模型对话，帮你写代码、改 Bug、分析项目、执行文件操作等。
Claude Code 有以下优势：
- 直接操作文件：可以读取、创建、修改项目中的代码文件；
- 理解项目上下文：在项目目录中启动后，能自动分析项目结构；
- 执行终端命令：可以运行构建、测试等 shell 命令；
- 集成 IDE：支持 VS Code 扩展，在编辑器中直接使用。
二、安装Claude Code
Windows操作系统要求：Windows 10（Build 19041+）或 Windows 11。
2.1 安装 Git for Windows
如果你已经装过 Git，在终端输入 git --version 能显示版本号就跳过这步。
安装步骤：
打开 git-scm.com/download/wi... ，下载安装包；
双击运行安装程序，一路点 Next 使用默认选项即可；
安装完成后，打开 PowerShell 或 CMD，输入：git --version
看到类似 git version 2.44.0.windows.1 的输出，说明安装成功。
2.2 安装 Node.js for Windows
推荐版本：Node.js 18 LTS 或更高版本
访问 Node.js 官网
下载 LTS 版本安装包
运行安装程序，按提示完成安装
验证安装：node --version npm --version
2.2 安装Claude Code for Windows
在git的终端中安装Claude。
bash
# 国内用户如下载慢，使用镜像源
npm install -g @anthropic-ai/claude-code --registry=https://registry.npmmirror.com
安装完成之后输入：claude --version
能看到类似 2.1.181 (Claude Code) 的版本号输出，说明安装成功。
三、CC Switch 是什么？
CC Switch 是一款跨平台桌面应用，专为使用 AI 编程工具的开发者设计。它帮助你统一管理 Claude Code 、Claude Desktop 、Codex 、Gemini CLI 、OpenCode 、OpenClaw 和 Hermes 等受管应用的配置。
在日常开发中，可能会遇到这些痛点：
- 多供应商切换麻烦：使用不同的 API 供应商（官方、中转服务商），需要手动修改配置文件
- 配置分散难管理：Claude Code、Claude Desktop、Codex、Gemini、OpenCode、OpenClaw、Hermes 各有独立的配置文件，格式不同
- 无法监控用量：不知道 API 调用了多少次，花了多少钱
- 服务不稳定：单一供应商出问题时，整个工作流中断
CC Switch 通过统一的界面解决这些问题。
3.1 安装 CC Switch for Windows
访问 Releases 页面，若打开比较慢，可以使用网盘链接。
这里下载 CC-Switch-v3.16.3-Windows-Portable.zip， 绿色版解压到任意目录
运行 CC-Switch.exe
3.2 添加供应商
点击主界面右上角的 + 按钮
选择自定义配置
拉到最下面，填入如下配置：
json
{
"env": {
"ANTHROPIC_AUTH_TOKEN": "在此处获取: https://console.bce.baidu.com/qianfan/resource/subscribe",
"ANTHROPIC_BASE_URL": "https://qianfan.baidubce.com/anthropic/coding",
"CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": 1,
"API_TIMEOUT_MS": 600000,
"ANTHROPIC_MODEL": "qianfan-code-latest",
"ANTHROPIC_SMALL_FAST_MODEL": "qianfan-code-latest"
},
"permissions": {
"allow": [
],
"deny": [
]
}
}修改ANTHROPIC_AUTH_TOKEN值为您Coding Plan的专属Key
供应商名称这里可以随意输入，比如 百度千帆 Coding Plan，下面其他字段会根据Json配置文件自动填入，无需自己改动，点击右下角添加即可。
配置完成。
3.3 测试Claude Code
如果 Claude Code 首次启动时提示需要登录或显示初始化引导，请在 CC Switch 中开启「跳过 Claude Code 初次安装确认」选项：
启动Claude输入简单的问题进行测试：
在CC Switch上也可以看到使用Token。
四、使用Claude Code
在 VS Code 的扩展市场中搜索并安装 Claude Code 相关扩展。安装完成后，左侧活动栏或编辑器右上区域通常会出现相应入口。
此外需要注意CC Switch上打开 启用到Claude Code插件。
Claude Code 作为 Anthropic 推出的AI编程助手，正在改变我们的开发方式。本文将通过5个场景，展示Claude Code如何在实际开发中发挥作用。所有代码示例均可直接执行。
4.1 智能代码重构
问题背景
现在有一段混乱的Python代码，需要重构优化：
重构前的代码：
python
def p(d):
r=[]
for i in d:
if i%2==0:
r.append(i*2)
else:
r.append(i*3)
return r
def c(l):
s=0
for i in l:
s+=i
return s/len(l) if len(l)>0 else 0
def f(n):
if n<=1:
return False
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True使用Claude Code重构，输入如下提示词：
请重构左侧Python代码，要求：
使用有意义的函数名和变量名
添加类型注解和文档字符串
遵循PEP 8规范
添加错误处理
优化代码结构
重构完成如下：
重构后的代码如下：
python
from typing import List
def transform_by_parity(numbers: List[int]) -> List[int]:
"""根据奇偶性对列表中的数字进行变换。
偶数乘以 2，奇数乘以 3。
Args:
numbers: 待变换的整数列表。
Returns:
变换后的整数列表。
Raises:
TypeError: 如果输入不是列表或元素不是整数。
"""
if not isinstance(numbers, list):
raise TypeError(f"期望 list 类型，收到 {type(numbers).__name__}")
result = []
for num in numbers:
if not isinstance(num, int):
raise TypeError(f"列表元素应为 int 类型，收到 {type(num).__name__}")
result.append(num * 2 if num % 2 == 0 else num * 3)
return result
def calculate_average(numbers: List[float]) -> float:
"""计算数值列表的算术平均值。
Args:
numbers: 数值列表（int 或 float）。
Returns:
列表的平均值；空列表返回 0.0。
Raises:
TypeError: 如果输入不是列表。
"""
if not isinstance(numbers, list):
raise TypeError(f"期望 list 类型，收到 {type(numbers).__name__}")
if len(numbers) == 0:
return 0.0
return sum(numbers) / len(numbers)
def is_prime(n: int) -> bool:
"""判断一个整数是否为质数。
Args:
n: 待判断的整数。
Returns:
True 表示是质数，False 表示不是。
Raises:
TypeError: 如果输入不是整数。
"""
if not isinstance(n, int):
raise TypeError(f"期望 int 类型，收到 {type(n).__name__}")
if n <= 1:
return False
if n <= 3:
return True
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i * i <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True运行这个重构代码，结果如下：
4.2 Bug自动修复
问题代码
python
def process_data(data):
result = []
for i in range(len(data) + 1): # Bug: 索引越界
result.append(data[i] * 2)
return result
def divide_numbers(a, b):
return a / b # Bug: 未处理除零错误
def find_user(users, user_id):
for user in users:
if user['id'] == user_id:
return user
# Bug: 未找到用户时没有返回值使用Claude Code修复，提示词如下：
分析以下代码中的bug，并提供修复方案：
识别所有潜在的错误
解释每个bug的原因
提供修复后的完整代码
添加异常处理
修复完成，总结如下：
修复后的代码如下：
python
from typing import Any, Dict, List, Optional
def process_data(data: List[int]) -> List[int]:
"""将列表中每个元素乘以 2 并返回新列表。
Args:
data: 待处理的整数列表。
Returns:
每个元素乘以 2 后的新列表。
Raises:
TypeError: 如果输入不是列表或元素不是数值类型。
"""
if not isinstance(data, list):
raise TypeError(f"期望 list 类型，收到 {type(data).__name__}")
result: List[int] = []
for i in range(len(data)): # 修复：移除 +1，避免索引越界
if not isinstance(data[i], (int, float)):
raise TypeError(f"列表元素应为数值类型，索引 {i} 处收到 {type(data[i]).__name__}")
result.append(data[i] * 2)
return result
def divide_numbers(a: float, b: float) -> float:
"""计算两个数的商。
Args:
a: 被除数。
b: 除数。
Returns:
a 除以 b 的结果。
Raises:
TypeError: 如果参数不是数值类型。
ZeroDivisionError: 如果除数为零。
"""
if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
raise TypeError("参数应为数值类型")
if b == 0:
raise ZeroDivisionError("除数不能为零") # 修复：显式抛出有意义的错误信息
return a / b
def find_user(users: List[Dict[str, Any]], user_id: int) -> Optional[Dict[str, Any]]:
"""在用户列表中查找指定 ID 的用户。
Args:
users: 用户字典列表，每个字典需包含 'id' 键。
user_id: 要查找的用户 ID。
Returns:
匹配的用户字典；未找到时返回 None。
Raises:
TypeError: 如果输入类型不正确。
"""
if not isinstance(users, list):
raise TypeError(f"期望 list 类型，收到 {type(users).__name__}")
for user in users:
if not isinstance(user, dict):
raise TypeError(f"列表元素应为 dict 类型，收到 {type(user).__name__}")
if user.get("id") == user_id: # 修复：用 get() 避免 KeyError
return user
return None # 修复：显式返回 None，语义更清晰运行这个修复后的代码，结果如下：
4.3 自动化测试生成
待测试的业务代码
python
class ShoppingCart:
def __init__(self):
self.items = []
self.discount = 0
def add_item(self, name: str, price: float, quantity: int = 1):
self.items.append({
'name': name,
'price': price,
'quantity': quantity
})
def remove_item(self, name: str):
self.items = [item for item in self.items if item['name'] != name]
def apply_discount(self, percentage: float):
self.discount = percentage
def get_total(self) -> float:
subtotal = sum(item['price'] * item['quantity'] for item in self.items)
return subtotal * (1 - self.discount / 100)Claude Code生成的测试代码，使用提示词：
为ShoppingCart类生成完整的单元测试，要求：
使用pytest框架
覆盖所有边界情况
测试正常流程和异常情况
包含性能测试
测试覆盖如下：
生成的测试代码：
python
import pytest
import time
class ShoppingCart:
def __init__(self):
self.items = []
self.discount = 0
def add_item(self, name: str, price: float, quantity: int = 1):
self.items.append({
'name': name,
'price': price,
'quantity': quantity
})
def remove_item(self, name: str):
self.items = [item for item in self.items if item['name'] != name]
def apply_discount(self, percentage: float):
self.discount = percentage
def get_total(self) -> float:
subtotal = sum(item['price'] * item['quantity'] for item in self.items)
return subtotal * (1 - self.discount / 100)
# ============================================================
# Fixtures
# ============================================================
@pytest.fixture
def cart():
"""返回一个空的购物车实例。"""
return ShoppingCart()
@pytest.fixture
def cart_with_items(cart):
"""返回一个预装了商品的购物车。"""
cart.add_item("Apple", 5.0, 3)
cart.add_item("Banana", 3.0, 2)
return cart
# ============================================================
# __init__ 测试
# ============================================================
class TestInit:
def test_empty_items(self, cart):
"""新购物车商品列表应为空。"""
assert cart.items == []
def test_default_discount(self, cart):
"""新购物车折扣应默认为 0。"""
assert cart.discount == 0
def test_get_total_empty(self, cart):
"""空购物车总价应为 0。"""
assert cart.get_total() == 0
# ============================================================
# add_item 测试
# ============================================================
class TestAddItem:
def test_add_single_item(self, cart):
"""添加单个商品。"""
cart.add_item("Apple", 5.0)
assert len(cart.items) == 1
assert cart.items[0] == {"name": "Apple", "price": 5.0, "quantity": 1}
def test_add_item_with_quantity(self, cart):
"""添加指定数量的商品。"""
cart.add_item("Apple", 5.0, 3)
assert cart.items[0]["quantity"] == 3
def test_add_multiple_items(self, cart):
"""添加多个不同商品。"""
cart.add_item("Apple", 5.0)
cart.add_item("Banana", 3.0)
assert len(cart.items) == 2
def test_add_duplicate_name(self, cart):
"""添加同名商品应作为独立条目存在（非合并）。"""
cart.add_item("Apple", 5.0, 1)
cart.add_item("Apple", 4.0, 2)
assert len(cart.items) == 2
assert cart.items[0]["price"] == 5.0
assert cart.items[1]["price"] == 4.0
def test_add_item_zero_price(self, cart):
"""价格为 0 的商品应正常添加。"""
cart.add_item("Gift", 0.0)
assert cart.items[0]["price"] == 0.0
assert cart.get_total() == 0.0
def test_add_item_negative_price(self, cart):
"""负价格商品应正常添加（当前代码无校验）。"""
cart.add_item("Refund", -10.0)
assert cart.items[0]["price"] == -10.0
def test_add_item_zero_quantity(self, cart):
"""数量为 0 的商品应正常添加。"""
cart.add_item("Apple", 5.0, 0)
assert cart.items[0]["quantity"] == 0
assert cart.get_total() == 0.0
def test_add_item_negative_quantity(self, cart):
"""负数量商品应正常添加（当前代码无校验）。"""
cart.add_item("Apple", 5.0, -1)
assert cart.items[0]["quantity"] == -1
def test_add_item_float_quantity(self, cart):
"""浮点数数量应正常添加。"""
cart.add_item("Apple", 5.0, 1.5)
assert cart.items[0]["quantity"] == 1.5
def test_add_item_empty_name(self, cart):
"""空字符串名称应正常添加。"""
cart.add_item("", 5.0)
assert cart.items[0]["name"] == ""
def test_add_item_very_large_price(self, cart):
"""极大价格应正常处理。"""
cart.add_item("Luxury", 1e10)
assert cart.get_total() == 1e10
def test_add_item_very_small_price(self, cart):
"""极小价格应正常处理。"""
cart.add_item("Tiny", 0.001)
assert cart.items[0]["price"] == 0.001
# ============================================================
# remove_item 测试
# ============================================================
class TestRemoveItem:
def test_remove_existing_item(self, cart_with_items):
"""移除已存在的商品。"""
cart_with_items.remove_item("Apple")
assert len(cart_with_items.items) == 1
assert cart_with_items.items[0]["name"] == "Banana"
def test_remove_nonexistent_item(self, cart_with_items):
"""移除不存在的商品不应报错。"""
original_len = len(cart_with_items.items)
cart_with_items.remove_item("Orange")
assert len(cart_with_items.items) == original_len
def test_remove_from_empty_cart(self, cart):
"""从空购物车移除商品不应报错。"""
cart.remove_item("Apple")
assert cart.items == []
def test_remove_duplicate_names(self, cart):
"""移除同名商品应删除所有匹配项。"""
cart.add_item("Apple", 5.0, 1)
cart.add_item("Apple", 4.0, 2)
cart.remove_item("Apple")
assert len(cart.items) == 0
def test_remove_preserves_others(self, cart_with_items):
"""移除商品不应影响其他商品。"""
cart_with_items.remove_item("Apple")
assert len(cart_with_items.items) == 1
banana = cart_with_items.items[0]
assert banana["name"] == "Banana"
assert banana["price"] == 3.0
assert banana["quantity"] == 2
def test_remove_case_sensitive(self, cart_with_items):
"""移除商品应区分大小写。"""
cart_with_items.remove_item("apple") # 小写
assert len(cart_with_items.items) == 2 # 未匹配，商品仍在
def test_remove_then_add(self, cart_with_items):
"""移除后再添加同名商品。"""
cart_with_items.remove_item("Apple")
cart_with_items.add_item("Apple", 6.0, 1)
assert len(cart_with_items.items) == 2
assert cart_with_items.items[1]["price"] == 6.0
# ============================================================
# apply_discount 测试
# ============================================================
class TestApplyDiscount:
def test_apply_normal_discount(self, cart):
"""应用正常折扣。"""
cart.apply_discount(10)
assert cart.discount == 10
def test_apply_zero_discount(self, cart):
"""应用 0% 折扣。"""
cart.apply_discount(0)
assert cart.discount == 0
def test_apply_100_discount(self, cart):
"""应用 100% 折扣（全额减免）。"""
cart.apply_discount(100)
assert cart.discount == 100
def test_apply_over_100_discount(self, cart):
"""超过 100% 的折扣（当前代码无校验，总价为负）。"""
cart.add_item("Apple", 10.0)
cart.apply_discount(150)
assert cart.get_total() == -5.0
def test_apply_negative_discount(self, cart):
"""负折扣（加价，当前代码无校验）。"""
cart.add_item("Apple", 10.0)
cart.apply_discount(-10)
assert cart.get_total() == 11.0
def test_apply_float_discount(self, cart):
"""浮点数折扣。"""
cart.apply_discount(12.5)
assert cart.discount == 12.5
def test_discount_overrides_previous(self, cart):
"""多次应用折扣应覆盖前一次。"""
cart.apply_discount(10)
cart.apply_discount(20)
assert cart.discount == 20
def test_discount_applied_to_total(self, cart_with_items):
"""折扣应正确应用于总价。"""
# subtotal = 5*3 + 3*2 = 21
cart_with_items.apply_discount(10)
# total = 21 * 0.9 = 18.9
assert cart_with_items.get_total() == pytest.approx(18.9)
# ============================================================
# get_total 测试
# ============================================================
class TestGetTotal:
def test_total_empty_cart(self, cart):
"""空购物车总价应为 0。"""
assert cart.get_total() == 0
def test_total_single_item(self, cart):
"""单个商品的总价。"""
cart.add_item("Apple", 10.0, 2)
assert cart.get_total() == 20.0
def test_total_multiple_items(self, cart_with_items):
"""多个商品的总价。"""
# 5*3 + 3*2 = 21
assert cart_with_items.get_total() == 21.0
def test_total_with_discount(self, cart_with_items):
"""折扣后总价。"""
cart_with_items.apply_discount(50)
assert cart_with_items.get_total() == 10.5
def test_total_with_100_discount(self, cart_with_items):
"""100% 折扣后总价应为 0。"""
cart_with_items.apply_discount(100)
assert cart_with_items.get_total() == 0.0
def test_total_with_zero_price_item(self, cart):
"""包含零价格商品的总价。"""
cart.add_item("Gift", 0.0, 5)
cart.add_item("Apple", 10.0, 1)
assert cart.get_total() == 10.0
def test_total_float_precision(self, cart):
"""浮点精度测试。"""
cart.add_item("A", 0.1, 1)
cart.add_item("B", 0.2, 1)
assert cart.get_total() == pytest.approx(0.3)
def test_total_very_large_numbers(self, cart):
"""极大数值的总价。"""
cart.add_item("Luxury", 1e10, 100)
assert cart.get_total() == 1e12
def test_total_after_remove(self, cart_with_items):
"""移除商品后总价应更新。"""
cart_with_items.remove_item("Apple")
# 3*2 = 6
assert cart_with_items.get_total() == 6.0
def test_total_does_not_modify_cart(self, cart_with_items):
"""get_total 不应修改购物车状态。"""
original_items = cart_with_items.items.copy()
cart_with_items.get_total()
assert cart_with_items.items == original_items
def test_total_idempotent(self, cart_with_items):
"""多次调用 get_total 结果应一致。"""
first = cart_with_items.get_total()
second = cart_with_items.get_total()
assert first == second
# ============================================================
# 集成测试（多操作组合）
# ============================================================
class TestIntegration:
def test_full_shopping_flow(self, cart):
"""完整购物流程：添加 → 折扣 → 移除 → 计算总价。"""
cart.add_item("Apple", 5.0, 3)
cart.add_item("Banana", 3.0, 2)
cart.apply_discount(10)
cart.remove_item("Banana")
# subtotal = 5*3 = 15, discount 10% → 13.5
assert cart.get_total() == pytest.approx(13.5)
def test_add_remove_add_same_item(self, cart):
"""添加 → 移除 → 再次添加同一商品。"""
cart.add_item("Apple", 5.0, 2)
cart.remove_item("Apple")
assert cart.get_total() == 0.0
cart.add_item("Apple", 6.0, 3)
assert cart.get_total() == 18.0
def test_discount_then_more_items(self, cart):
"""先设折扣，后添加商品，折扣仍应生效。"""
cart.apply_discount(20)
cart.add_item("Apple", 10.0, 2)
assert cart.get_total() == 16.0
def test_multiple_discounts_in_session(self, cart):
"""多次更改折扣。"""
cart.add_item("Apple", 100.0)
cart.apply_discount(10)
assert cart.get_total() == 90.0
cart.apply_discount(50)
assert cart.get_total() == 50.0
cart.apply_discount(0)
assert cart.get_total() == 100.0
# ============================================================
# 性能测试
# ============================================================
class TestPerformance:
def test_add_many_items_performance(self, cart):
"""添加 10000 件商品应在合理时间内完成。"""
start = time.perf_counter()
for i in range(10000):
cart.add_item(f"Item_{i}", 1.0, 1)
elapsed = time.perf_counter() - start
assert elapsed < 1.0, f"添加 10000 件商品耗时 {elapsed:.3f}s，超过 1s"
def test_remove_from_large_cart_performance(self, cart):
"""从 10000 件商品中移除应在合理时间内完成。"""
for i in range(10000):
cart.add_item(f"Item_{i}", 1.0, 1)
start = time.perf_counter()
cart.remove_item("Item_5000")
elapsed = time.perf_counter() - start
assert elapsed < 1.0, f"从 10000 件商品中移除耗时 {elapsed:.3f}s，超过 1s"
def test_get_total_large_cart_performance(self, cart):
"""10000 件商品计算总价应在合理时间内完成。"""
for i in range(10000):
cart.add_item(f"Item_{i}", 1.0, 1)
start = time.perf_counter()
total = cart.get_total()
elapsed = time.perf_counter() - start
assert total == 10000.0
assert elapsed < 1.0, f"10000 件商品计算总价耗时 {elapsed:.3f}s，超过 1s"
def test_repeated_get_total_performance(self, cart):
"""重复调用 get_total 1000 次应在合理时间内完成。"""
for i in range(1000):
cart.add_item(f"Item_{i}", 1.0, 1)
start = time.perf_counter()
for _ in range(1000):
cart.get_total()
elapsed = time.perf_counter() - start
assert elapsed < 2.0, f"1000 次 get_total 耗时 {elapsed:.3f}s，超过 2s"
def test_remove_all_items_performance(self, cart):
"""逐一移除 5000 件商品应在合理时间内完成。"""
for i in range(5000):
cart.add_item(f"Item_{i}", 1.0, 1)
start = time.perf_counter()
for i in range(5000):
cart.remove_item(f"Item_{i}")
elapsed = time.perf_counter() - start
assert len(cart.items) == 0
assert elapsed < 5.0, f"逐一移除 5000 件商品耗时 {elapsed:.3f}s，超过 5s"运行测试结果如下：
4.4 性能优化实战
优化前的慢速代码
python
def find_duplicates(data):
"""查找列表中的重复元素（低效版本）"""
duplicates = []
for i in range(len(data)):
for j in range(i + 1, len(data)):
if data[i] == data[j] and data[i] not in duplicates:
duplicates.append(data[i])
return duplicates
def calculate_statistics(numbers):
"""计算统计信息（低效版本）"""
result = {}
# 计算平均值
total = 0
count = 0
for num in numbers:
total += num
count += 1
result['mean'] = total / count if count > 0 else 0
# 计算中位数
sorted_nums = []
for num in numbers:
sorted_nums.append(num)
# 冒泡排序
for i in range(len(sorted_nums)):
for j in range(len(sorted_nums) - 1):
if sorted_nums[j] > sorted_nums[j + 1]:
sorted_nums[j], sorted_nums[j + 1] = sorted_nums[j + 1], sorted_nums[j]
n = len(sorted_nums)
if n % 2 == 0:
result['median'] = (sorted_nums[n//2 - 1] + sorted_nums[n//2]) / 2
else:
result['median'] = sorted_nums[n//2]
# 计算标准差
mean = result['mean']
variance_sum = 0
for num in numbers:
variance_sum += (num - mean) ** 2
result['std_dev'] = (variance_sum / len(numbers)) ** 0.5
return result
Claude Code优化后的代码：
python
from typing import Any, Dict, List
from collections import Counter
def find_duplicates(data: List[Any]) -> List[Any]:
"""查找列表中的重复元素。
使用 Counter 统计频次，仅保留出现次数 > 1 的元素，
时间复杂度从 O(n²) 降至 O(n)。
Args:
data: 待查找的列表。
Returns:
包含所有重复元素的列表（按首次出现顺序）。
"""
counter = Counter(data)
seen = set()
duplicates = []
for item in data:
if counter[item] > 1 and item not in seen:
duplicates.append(item)
seen.add(item)
return duplicates
def calculate_statistics(numbers: List[float]) -> Dict[str, float]:
"""计算统计信息：平均值、中位数、标准差。
使用内置 sum/len/sorted 替代手动循环和冒泡排序，
时间复杂度从 O(n²) 降至 O(n log n)（排序主导）。
Args:
numbers: 数值列表。
Returns:
包含 mean、median、std_dev 的字典。
Raises:
ValueError: 如果输入列表为空。
"""
if not numbers:
raise ValueError("输入列表不能为空")
n = len(numbers)
# 平均值：内置 sum，O(n)
mean = sum(numbers) / n
# 中位数：内置 sorted，O(n log n)，远优于冒泡排序 O(n²)
sorted_nums = sorted(numbers)
if n % 2 == 0:
median = (sorted_nums[n // 2 - 1] + sorted_nums[n // 2]) / 2
else:
median = sorted_nums[n // 2]
# 标准差：生成器表达式替代手动循环
variance = sum((x - mean) ** 2 for x in numbers) / n
std_dev = variance ** 0.5
return {"mean": mean, "median": median, "std_dev": std_dev}运行代码，对比优化前后：
4.5 API文档自动生成
源代码示例
python
from typing import List, Dict, Optional
from dataclasses import dataclass
from datetime import datetime
@dataclass
class User:
id: int
name: str
email: str
created_at: datetime
class UserService:
def __init__(self, db_connection):
self.db = db_connection
def create_user(self, name: str, email: str) -> User:
"""创建新用户"""
user = User(
id=len(self.db) + 1,
name=name,
email=email,
created_at=datetime.now()
)
self.db.append(user)
return user
def get_user(self, user_id: int) -> Optional[User]:
"""根据ID获取用户"""
for user in self.db:
if user.id == user_id:
return user
return None
def update_user(self, user_id: int, name: str = None, email: str = None) -> bool:
"""更新用户信息"""
user = self.get_user(user_id)
if not user:
return False
if name:
user.name = name
if email:
user.email = email
return True
def delete_user(self, user_id: int) -> bool:
"""删除用户"""
user = self.get_user(user_id)
if not user:
return False
self.db.remove(user)
return True
def list_users(self, limit: int = 100, offset: int = 0) -> List[User]:
"""获取用户列表"""
return self.db[offset:offset + limit]使用Claude Code生成的API文档，提示词如下：
为UserService类生成完整的API文档，要求：
使用Markdown格式
包含所有方法的详细说明
提供使用示例
说明参数和返回值
列出可能的错误情况
生成结果如下：
API文档如下：
python
# UserService API 文档
> 版本：1.0
> 最后更新：2026-06-18
---
## 目录
- [概述](#概述)
- [数据模型](#数据模型)
- [User](#user)
- [类：UserService](#类userservice)
- [__init__](#__init__)
- [create_user](#create_user)
- [get_user](#get_user)
- [update_user](#update_user)
- [delete_user](#delete_user)
- [list_users](#list_users)
- [完整使用示例](#完整使用示例)
- [已知限制](#已知限制)
---
## 概述
`UserService` 提供用户的增删改查（CRUD）操作，基于内存列表作为数据存储。每个用户包含 ID、姓名、邮箱和创建时间。
```python
from datetime import datetime
from typing import List, Dict, Optional
from dataclasses import dataclass
```
---
## 数据模型
### User
用户数据类，使用 `@dataclass` 定义。
| 字段 | 类型 | 说明 |
|------|------|------|
| `id` | `int` | 用户唯一标识，由系统自动生成 |
| `name` | `str` | 用户姓名 |
| `email` | `str` | 用户邮箱地址 |
| `created_at` | `datetime` | 创建时间，自动记录 |
---
## 类：UserService
### `__init__`
初始化 UserService 实例。
```python
def __init__(self, db_connection: List[User]) -> None
```
#### 参数
| 参数 | 类型 | 必填 | 说明 |
|------|------|------|------|
| `db_connection` | `List[User]` | 是 | 数据存储列表，通常传入空列表 `[]` |
#### 示例
```python
db = []
service = UserService(db)
```
---
### `create_user`
创建新用户，自动分配递增 ID 并记录创建时间。
```python
def create_user(self, name: str, email: str) -> User
```
#### 参数
| 参数 | 类型 | 必填 | 说明 |
|------|------|------|------|
| `name` | `str` | 是 | 用户姓名 |
| `email` | `str` | 是 | 用户邮箱地址 |
#### 返回值
| 类型 | 说明 |
|------|------|
| `User` | 创建成功的用户对象，包含自动生成的 `id` 和 `created_at` |
#### 可能的错误情况
| 场景 | 说明 |
|------|------|
| ID 冲突 | 当从列表中间删除用户后，新用户的 `id` 可能与已有用户重复（见 [已知限制](#已知限制)） |
| 重复邮箱 | 当前实现未校验邮箱唯一性，同一邮箱可创建多个用户 |
| 空字符串 | `name` 或 `email` 传入空字符串不会被拦截 |
#### 示例
```python
db = []
service = UserService(db)
user = service.create_user("张三", "zhangsan@example.com")
print(user.id) # 1
print(user.name) # 张三
print(user.email) # zhangsan@example.com
print(user.created_at) # 2026-06-18 10:30:00.123456
```
---
### `get_user`
根据用户 ID 查找用户。
```python
def get_user(self, user_id: int) -> Optional[User]
```
#### 参数
| 参数 | 类型 | 必填 | 说明 |
|------|------|------|------|
| `user_id` | `int` | 是 | 要查找的用户 ID |
#### 返回值
| 类型 | 说明 |
|------|------|
| `User` | 找到的用户对象 |
| `None` | 未找到对应用户时返回 `None` |
#### 可能的错误情况
| 场景 | 说明 |
|------|------|
| 用户不存在 | 返回 `None`，不会抛出异常 |
| 无效 ID | 传入负数或非整数类型（如浮点数、字符串）不会被拦截 |
#### 示例
```python
# 查找存在的用户
user = service.get_user(1)
print(user.name) # 张三
# 查找不存在的用户
user = service.get_user(999)
print(user) # None
```
---
### `update_user`
更新用户信息，支持部分更新（仅更新传入的非 None 字段）。
```python
def update_user(self, user_id: int, name: str = None, email: str = None) -> bool
```
#### 参数
| 参数 | 类型 | 必填 | 默认值 | 说明 |
|------|------|------|--------|------|
| `user_id` | `int` | 是 | --- | 要更新的用户 ID |
| `name` | `str` | 否 | `None` | 新的用户姓名，`None` 表示不更新 |
| `email` | `str` | 否 | `None` | 新的邮箱地址，`None` 表示不更新 |
#### 返回值
| 类型 | 说明 |
|------|------|
| `bool` | `True` 更新成功，`False` 用户不存在 |
#### 可能的错误情况
| 场景 | 说明 |
|------|------|
| 用户不存在 | 返回 `False` |
| 空字符串更新 | 传入 `name=""` 时，由于 `if name:` 为 `False`，空字符串**不会**更新该字段 |
| 两个参数均为 None | 不会修改任何字段，但返回 `True` |
#### 示例
```python
# 更新姓名
success = service.update_user(1, name="李四")
print(success) # True
print(user.name) # 李四
# 同时更新姓名和邮箱
success = service.update_user(1, name="王五", email="wangwu@example.com")
# 更新不存在的用户
success = service.update_user(999, name="赵六")
print(success) # False
# 仅更新邮箱
success = service.update_user(1, email="new@example.com")
```
---
### `delete_user`
根据用户 ID 删除用户。
```python
def delete_user(self, user_id: int) -> bool
```
#### 参数
| 参数 | 类型 | 必填 | 说明 |
|------|------|------|------|
| `user_id` | `int` | 是 | 要删除的用户 ID |
#### 返回值
| 类型 | 说明 |
|------|------|
| `bool` | `True` 删除成功，`False` 用户不存在 |
#### 可能的错误情况
| 场景 | 说明 |
|------|------|
| 用户不存在 | 返回 `False` |
| 重复删除 | 第二次删除同一用户返回 `False` |
| ID 冲突风险 | 删除用户后 `create_user` 的 ID 生成逻辑可能与已有 ID 冲突（见 [已知限制](#已知限制)） |
#### 示例
```python
# 删除存在的用户
success = service.delete_user(1)
print(success) # True
# 删除不存在的用户
success = service.delete_user(999)
print(success) # False
```
---
### `list_users`
获取用户列表，支持分页。
```python
def list_users(self, limit: int = 100, offset: int = 0) -> List[User]
```
#### 参数
| 参数 | 类型 | 必填 | 默认值 | 说明 |
|------|------|------|--------|------|
| `limit` | `int` | 否 | `100` | 返回的最大用户数量 |
| `offset` | `int` | 否 | `0` | 跳过的记录数（起始位置） |
#### 返回值
| 类型 | 说明 |
|------|------|
| `List[User]` | 用户列表，可能为空 |
#### 可能的错误情况
| 场景 | 说明 |
|------|------|
| offset 超出范围 | 返回空列表 `[]`，不会报错 |
| 负数参数 | `limit` 或 `offset` 为负数时，Python 切片不会报错但行为不符合预期 |
| 超大 limit | 当前未做上限校验 |
#### 示例
```python
# 获取所有用户（默认最多 100 条）
users = service.list_users()
# 分页查询：第 2 页，每页 10 条
users = service.list_users(limit=10, offset=10)
# 获取前 5 条
users = service.list_users(limit=5)
# offset 超出范围时返回空列表
users = service.list_users(offset=9999)
print(users) # []
```
---
## 完整使用示例
```python
from datetime import datetime
from typing import List, Optional
from dataclasses import dataclass
@dataclass
class User:
id: int
name: str
email: str
created_at: datetime
class UserService:
def __init__(self, db_connection):
self.db = db_connection
def create_user(self, name: str, email: str) -> User:
user = User(
id=len(self.db) + 1,
name=name,
email=email,
created_at=datetime.now()
)
self.db.append(user)
return user
def get_user(self, user_id: int) -> Optional[User]:
for user in self.db:
if user.id == user_id:
return user
return None
def update_user(self, user_id: int, name: str = None, email: str = None) -> bool:
user = self.get_user(user_id)
if not user:
return False
if name:
user.name = name
if email:
user.email = email
return True
def delete_user(self, user_id: int) -> bool:
user = self.get_user(user_id)
if not user:
return False
self.db.remove(user)
return True
def list_users(self, limit: int = 100, offset: int = 0) -> List[User]:
return self.db[offset:offset + limit]
# ===== 使用流程 =====
# 1. 初始化
db = []
service = UserService(db)
# 2. 创建用户
alice = service.create_user("Alice", "alice@example.com")
bob = service.create_user("Bob", "bob@example.com")
print(f"创建用户: {alice.name} (ID={alice.id})")
print(f"创建用户: {bob.name} (ID={bob.id})")
# 3. 查询用户
user = service.get_user(1)
print(f"查询用户: {user.name}, {user.email}")
# 4. 更新用户
service.update_user(1, name="Alice Wang", email="alice.wang@example.com")
user = service.get_user(1)
print(f"更新用户: {user.name}, {user.email}")
# 5. 列出所有用户
users = service.list_users()
print(f"用户列表: {[u.name for u in users]}")
# 6. 分页查询
page1 = service.list_users(limit=1, offset=0)
page2 = service.list_users(limit=1, offset=1)
print(f"第1页: {[u.name for u in page1]}")
print(f"第2页: {[u.name for u in page2]}")
# 7. 删除用户
service.delete_user(2)
users = service.list_users()
print(f"删除后用户列表: {[u.name for u in users]}")
```
**输出：**
```
创建用户: Alice (ID=1)
创建用户: Bob (ID=2)
查询用户: Alice, alice@example.com
更新用户: Alice Wang, alice.wang@example.com
用户列表: ['Alice Wang', 'Bob']
第1页: ['Alice Wang']
第2页: ['Bob']
删除后用户列表: ['Alice Wang']
```
---
## 已知限制
| # | 限制 | 影响 | 建议修复 |
|---|------|------|----------|
| 1 | **ID 冲突风险** | `id = len(self.db) + 1`，删除中间用户后新用户 ID 可能重复 | 使用自增计数器或 UUID |
| 2 | **邮箱无唯一校验** | 同一邮箱可创建多个用户 | `create_user` 中添加邮箱查重 |
| 3 | **空字符串不更新** | `update_user(name="")` 不会更新姓名，因为 `if name:` 对空字符串为 `False` | 改用 `if name is not None:` 判断 |
| 4 | **无输入校验** | 参数类型、格式、范围均未校验 | 添加类型检查和参数验证 |
| 5 | **内存存储** | 所有数据存储在内存列表中，程序退出即丢失 | 使用数据库持久化 |
| 6 | **无并发控制** | 多线程环境下不安全 | 添加锁机制或使用线程安全数据结构 |总结下最佳实践。
五、总结
通过以上5个场景，展示了Claude Code在实际开发中的强大能力：
✅ 代码重构：从混乱代码到优雅实现，提升代码质量
✅ Bug修复：自动识别并修复错误，增强代码健壮性
✅ 测试生成：自动生成完整测试用例，覆盖率达到100%
✅ 性能优化：275倍性能提升，从O(n²)优化到O(n)
✅ 文档生成：专业API文档，节省80%文档编写时间
Claude Code不仅是编程助手，更是提升开发效率、保证代码质量的强大工具。通过合理使用提示工程，可以让Claude Code成为你的24小时编程伙伴。
关键要点：
-
清晰具体的提示词能获得更好的结果
-
迭代式对话逐步完善代码
-
始终验证生成代码的正确性
-
结合测试确保代码质量
-
将Claude Code集成到开发工作流中
开始使用Claude Code，让你的开发效率提升10倍！