WorkBuddy 写的代码功能都对，但你敢看执行时间吗？——五个常见性能反模式

# WorkBuddy 写的典型代码
def get_users_with_orders():
    users = db.query("SELECT * FROM users LIMIT 100")
    result = []
    for user in users:
        # ⚡ 每循环一次 = 一次数据库查询
        orders = db.query(f"SELECT * FROM orders WHERE user_id = {user.id}")
        result.append({"user": user, "orders": orders})
    return result
    # 100 个用户 = 101 次查询

def get_users_with_orders():
    # 方案 A：JOIN（适合数据量不大的情况）
    rows = db.query("""
        SELECT u.*, o.*
        FROM users u
        LEFT JOIN orders o ON o.user_id = u.id
        WHERE u.id IN (SELECT id FROM users LIMIT 100)
    """)
    return group_by_user(rows)

    # 方案 B：先批量取 ID，再 IN 查询（适合数据量大的情况）
    users = db.query("SELECT * FROM users LIMIT 100")
    user_ids = [u.id for u in users]
    orders = db.query(
        f"SELECT * FROM orders WHERE user_id IN ({','.join(map(str, user_ids))})"
    )
    orders_by_user = group_by(orders, key="user_id")
    return [{"user": u, "orders": orders_by_user.get(u.id, [])} for u in users]

# 在代码中搜索这个模式
# for ... in ...:
#     db.query / db.execute / ORM query
# 如果 query 出现在循环体内 → 大概率是 N+1

# WorkBuddy 写的又一段典型代码
def list_users(page=1, per_page=20):
    all_users = db.query("SELECT * FROM users")  # ⚡ 加载了全部 10 万条
    start = (page - 1) * per_page
    end = start + per_page
    return all_users[start:end]  # 然后在内存里切片

def list_users(page=1, per_page=20):
    offset = (page - 1) * per_page
    # 让数据库做分页，不要全量加载
    users = db.query(
        f"SELECT * FROM users ORDER BY id LIMIT {per_page} OFFSET {offset}"
    )
    total = db.query("SELECT COUNT(*) as cnt FROM users")[0].cnt
    return {"data": users, "total": total, "page": page}

# SELECT * FROM table（没有 LIMIT）
# 然后在 Python 里切片 [start:end]
# 或者用 len() 取总数（说明全量加载了）

def generate_report(transactions):
    report = []
    for txn in transactions:
        # ⚡ 每条记录都重新算一遍"本月第一天"
        month_start = datetime(txn.date.year, txn.date.month, 1)

        # ⚡ 每条记录都重新查一遍汇率
        rate = get_exchange_rate(txn.currency)  # 假设有 100 种货币，但实际只有 3 种

        report.append({
            "id": txn.id,
            "amount_cny": txn.amount * rate,
            "month": month_start
        })
    return report

from functools import lru_cache

@lru_cache(maxsize=10)
def get_rate_cached(currency):
    return get_exchange_rate(currency)

def generate_report(transactions):
    report = []
    # month_start 可以按交易日期分组，不用每条都算
    for txn in transactions:
        report.append({
            "id": txn.id,
            "amount_cny": txn.amount * get_rate_cached(txn.currency),
            "month": txn.date.replace(day=1)  # 更快的方式
        })
    return report

import copy

def process_items(items):
    results = []
    for item in items:
        # ⚡ 每条记录都深拷贝一次
        processed = copy.deepcopy(item)
        processed["status"] = compute_status(item)
        results.append(processed)
    return results

def process_items(items):
    results = []
    for item in items:
        # 浅拷贝够用（只改顶层字段）
        processed = dict(item)  # 或 item.copy()
        processed["status"] = compute_status(item)
        results.append(processed)
    return results

def batch_process_files(file_list):
    for filepath in file_list:
        # ⚡ 每次循环都创建新连接
        conn = create_db_connection()

        data = read_file(filepath)
        conn.execute("INSERT INTO logs VALUES (?)", (data,))

        conn.close()  # 每次循环打开+关闭

def batch_process_files(file_list):
    with create_db_connection() as conn:  # 一个连接处理所有文件
        for filepath in file_list:
            data = read_file(filepath)
            conn.execute("INSERT INTO logs VALUES (?)", (data,))
            # 批量提交，不要每条 commit
        conn.commit()  # 一次性提交

# 在 for 循环内搜索：
# - create_connection / connect / open
# - .close()
# 如果 for 循环内有连接打开 → 反模式

| 反模式 | 症状 | 修复 |
|--------|------|------|
| N+1 查询 | 循环内发 DB 请求 | JOIN 或 IN 批量查询 |
| 全量加载分页 | SELECT * 无 LIMIT | LIMIT + OFFSET |
| 循环内重复计算 | 每条记录重算同一值 | 提到循环外 / 缓存 |
| 过度深拷贝 | 到处 copy.deepcopy | 浅拷贝 / 不拷贝 |
| 循环内开连接 | 每次循环建新连接 | 一个连接复用 |

你：帮我检查这段代码的性能反模式，重点看：
   1. 有没有循环里的数据库查询
   2. 有没有全量加载再分页
   3. 有没有可以提到循环外的重复计算

[粘贴代码]

WorkBuddy：[逐条指出问题 + 给出修复建议]