跑模型之前
先把机器打通

模型页讲「一个 token 怎么走完网络」，数学页讲「那些符号是什么意思」。这一页讲第三件事：你坐在电脑前，怎么把环境、代码、数据和接口串成一条能跑的线。

真正要带走的是服务器上天天用的那一套：目录怎么长、命令怎么拼、Python 怎么装数据、MySQL 怎么查、FastAPI 怎么对外、Docker 怎么把「我电脑能跑」变成「哪都能跑」。

Windows 用 C:、D: 把世界切开。Linux 用一棵树：根叫 /，往下全是路径。硬盘、进程、网卡，最后都能在某个文件名下面找到。

真实服务器你摸不到机箱，日常都是 SSH 连上去。连上之后面对的就是这棵树：没有 C: D:，只有从 / 长出来的路径。

软件从哪来

Ubuntu 用 APT。先 sudo apt update 刷新目录，再 sudo apt install 包名。国内把源换成清华 / 阿里，下载才不会卡死。这和后面 conda、Docker 换镜像源是同一件事：默认源在海外，先换近的。

sudo apt update
sudo apt install -y ssh net-tools vim

命令不是魔法单词，是 /usr/bin 里的小程序。权限则是「谁能碰这个文件」。把这两件事摸熟，后面的脚本、Docker、SSH 都只是在复用它们。

Ubuntu 默认的解析器是 bash。脚本第一行 #!/bin/bash 是在指定「用谁来读我」。变量默认全是字符串，等号两边不能有空格。

判断和循环

条件写成 [ $a -gt 10 ]，方括号内侧必须有空格。-eq -ne -lt -le -gt -ge 比整数；-e -f -d -r -w -x 问文件。if / case / for / while 的关键字都要收尾：fi、esac、done。

#!/bin/bash
if [ $# -eq 0 ]; then
  echo '请携带年龄'
elif [ $1 -lt 18 ]; then
  echo '未成年人'
else
  echo '成年人'
fi

S=$[(2+3)*4]          # 算术用 $[] 或 $(())
sum=0
for ((i=1;i<=100;i++)); do sum=$[$sum+$i]; done

语法规则（缩进、注释、标识符）一天就能混个眼熟。真正决定你会不会写的，是四只盒子：list、tuple、dict、set，以及它们可不可变。

三个推导式，外加一个圆括号

Python 原生只认四种写法。方括号立刻造出整份 list；花括号看有没有冒号，决定是 set 还是 dict；圆括号不造容器——它返回生成器，next() 一次才算一个。面试常把后两个问成一对：列表推导式吃内存，生成器表达式吃时间。

匿名函数：就一行

lambda 参数: 表达式。没有名字、不能写语句，复杂逻辑别塞。真正出场的地方是「函数当参数」：sorted(..., key=)、filter、map。能写成推导式的，优先推导式——更像人话。

students = [{'name': '张三', 'age': 36}, {'name': '李四', 'age': 14}]
sorted(students, key=lambda s: s['age'])
[s['name'] for s in students if s['age'] > 18]   # 比 filter+map 更清楚

流程控制就这些

顺序、分支、循环。分支用 if / elif / else，3.10 以后还有 match-case。循环里 continue 跳过本轮，break 离开，for-else / while-else 的 else 在「没被 break」时才走。输出优先 f-string：f'{name} 的 loss={loss:.4f}'。

高频面试把 Python 进阶压成三叠：闭包把状态揣走；三器分别解决遍历、内存和监控；三程决定 CPU 密集还是 I/O 密集该派谁上场。

参数怎么传

位置参数、默认值、关键字、*args 收成元组、**kwargs 收成字典。默认值只求值一次，所以不要写 def f(xs=[])。不可变对象当参数，函数里重新赋值不影响外面；可变对象当参数，.append 会影响外面。

def train(model, data, lr=1e-4, *hooks, **opt):
    ...
train(net, ds, 3e-4, log, wandb, device='cuda')

闭包：外层走了，变量还在

内部函数引用了外部函数的局部变量，并且外部函数把内部函数 return 出去——这三件齐了就是闭包。外层结束本该销毁的变量，被内层「捕获」留在内存里。装饰器、函数工厂、藏一点私有状态，全靠它。

三器：迭代器、生成器、装饰器

一句话带走：迭代器解决遍历，生成器解决内存，装饰器解决监控。循环的本质是先 iter() 拿到迭代器，再不断 next()，取完抛 StopIteration 结束。

def batched(xs, n):
    buf = []
    for x in xs:
        buf.append(x)
        if len(buf) == n:
            yield buf
            buf = []
    if buf: yield buf

装饰器本质是闭包：外层收下原函数，内层在调用前后加活，再把原函数的返回值递出去。functools.wraps 用来把原函数的名字抄回来，不然堆栈里全是 wrapper。

类只要三件事

三程：进程、线程、协程

同步：点完菜站在柜台等，期间什么也不干。异步：拿号回去刷手机，叫到再取。进程是操作系统分资源的独立房间；线程是房间里的几双手，共享家具；协程是自己排队，遇到 await 就让位，不劳操作系统。

list 能装东西，但装一百万个数就慢，还不能广播。NumPy 的 ndarray 是「同一类型、矩形、连续内存」的多维数组。Pandas 在它外面加了标签，变成 Series 和 DataFrame。

Series 和 DataFrame

Series 是带索引的一列；DataFrame 是带行索引、列标签的一张表。loc 按标签取，iloc 按下标取。两列相加按索引对齐，对不上的格子填 NaN——和广播是亲戚，只不过对齐的是标签不是位置。

df.loc['aa':'cc', ['id', 'name']]   # 标签，含末尾
df.iloc[0:3, 2]                    # 位置，不含末尾
df.groupby('dept')['salary'].mean()
pd.merge(left, right, on='id', how='left')
pd.concat([a, b], axis=0)          # 0 往下接，1 往右接

库是文件夹，表是带类型的 Excel，行是一条记录，列是字段。SQL 不是编程语言，是「描述你想要什么」的语言。分类记五个字母就够：DDL 建结构，DML 改数据，DQL 查询，DCL 管权限，TCL 管事务。

SELECT 真正的执行顺序

手写顺序是 SELECT … FROM … WHERE … GROUP BY … HAVING … ORDER BY … LIMIT。引擎心里的顺序是：先 FROM / JOIN 拿表，WHERE 滤行，GROUP BY 分组，HAVING 滤组，SELECT 算列，ORDER BY 排序，LIMIT 切开。所以 HAVING 里可以用聚合，WHERE 里不行；别名在 WHERE 里也还看不见。

SELECT d.dname, AVG(e.salary) AS avg_sal
FROM t_employee e
JOIN t_department d ON e.did = d.id
WHERE e.salary IS NOT NULL
GROUP BY d.dname
HAVING AVG(e.salary) > 10000
ORDER BY avg_sal DESC
LIMIT 5;

浏览器打过来的是 HTTP。FastAPI 做的事：按路径找到函数，把参数从 URL 或 JSON 里拆出来，校验类型，再把返回值变成 JSON。底下用 Uvicorn 跑，调度靠协程。

进程、线程、协程的对比在 05 三程。FastAPI 选协程，因为 Web 几乎全是等网络。下面只看 await 让不让路。

路径、查询、请求体

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.get('/items/{item_id}')
async def read_item(item_id: int, q: str | None = None):
    return {'id': item_id, 'q': q}

@app.post('/items')
async def create_item(item: Item):
    return item

/items/{item_id} 里的是路径参数，?q= 是查询参数，POST JSON 用 Pydantic 模型当请求体。类型写在函数签名里，FastAPI 负责转换和 422。模块一多，用 APIRouter 拆到 routers/user.py 再 include_router。

没有容器的时候，开发机和服务器永远差那么一点：Python 版本、系统库、环境变量。「在我电脑上能跑」就是这样来的。Docker 的目标是一次打包，到处跑。

两份文件就够上线

# Dockerfile  自定义镜像的菜谱
FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# docker-compose.yml  多容器一起起
services:
  db:
    image: mysql:8.0
    environment: { MYSQL_ROOT_PASSWORD: secret }
    volumes: [mysql-data:/var/lib/mysql]
  api:
    build: .
    ports: ["8000:8000"]
    depends_on: [db]
volumes:
  mysql-data:

docker compose up -d 会先起 MySQL，再起 API。镜像源换成国内的，pull 才不会超时。Windows 上 Docker Desktop 依赖 WSL2，需要先打开 CPU 虚拟化。

先有一台 Linux。目录和权限让你在这台机器上走动。Shell 把走动写成脚本。Python 描述逻辑，NumPy / Pandas 描述数字和表，MySQL 把表存住，FastAPI 把函数暴露出去，Docker 把这一切封进箱子。