2.1 没有 Socket 之前，程序都是”单机程序”#

在没有 Socket 的年代，程序基本只能跟自己和本地文件打交道。它想让另一台机器上的另一个程序收到点东西，就得自己去处理网卡、网线、信号、重传、校验……这显然不现实。

于是操作系统站出来了：我把底下那些麻烦事全包了，给你一个简单的接口，你只管往里写数据。

这个接口就是 Socket。

2.2 一次 “hello world” 的旅程#

假设 A 想给 B 发一句 hello world。我们自己写代码时只是 send("hello world") 或者 printf("hello world")，但这句话实际上要走完下面这条路：

flowchart LR
    A["A 的应用层hello world"] --> B["传输层加 TCP 头"]
    B --> C["网络层加 IP 头"]
    C --> D["链路层加帧头"]
    D --> E["物理层变成电信号 / 光信号"]
    E --> F["B 的物理层"]
    F --> G["B 的链路层"]
    G --> H["B 的网络层"]
    H --> I["B 的传输层"]
    I --> J["B 的应用层hello world"]

每一层都在原始数据外面加一层自己的头（这个过程叫封装），到了对面再一层层拆开。

你可以把它想象成寄快递：你的信是”数据”，装进信封写明收件人是”传输层头”，再装进快递袋写明区域分拣是”网络层头”，最后扔上货车走公路是”物理层”。收件人那边反过来拆。

2.3 Socket 抽象掉了什么#

如果每发一句话都要你自己去处理 TCP 头、IP 头、帧头、电信号，那写 Web 程序的人得疯。

Socket 的作用，就是把这底下四层整体收起来，对外只给你一个”管子”。

flowchart TB
    subgraph APP["应用层 —— 你写代码的地方"]
        A1["HTTP / HTTPS / WebSocket 等"]
    end
    subgraph SOCK["Socket 接口 —— 操作系统提供"]
        S1["socket() · connect() · send() · recv()"]
    end
    subgraph LOW["下面这几层 —— Socket 帮你挡住"]
        T["传输层　TCP / UDP（端口在这里）"]
        N["网络层　IP（IP 地址在这里）"]
        L["链路层　网卡 / MAC 地址"]
        P["物理层　光纤 / 电缆 / 无线电"]
    end
    APP --> SOCK
    SOCK --> T
    T --> N
    N --> L
    L --> P

3.1 网卡和 MAC地址（这个Mac并不是巧不思在美国创建的Bpple公司的Mac系列产品）#

网卡（Network Interface Card） 是设备连接网络的硬件组件，负责接收和发送数据包，并通过有线或无线方式接入局域网或互联网。

网卡需要驱动程序才能工作：操作系统通过驱动程序给网卡下命令。驱动大致负责四件事：

• 通信管理：数据包的收发
• 性能优化：缓存、分段、重组，提升传输效率
• 兼容性支持：不同品牌型号的网卡需要各自的驱动
• 错误检测：发现碰撞、丢包等问题并处理或上报

MAC 地址则是网卡出厂自带的、类似身份号的物理地址，它是”这一块网卡”的身份，而不是”这台设备在互联网上的门牌号”（后者是 IP 地址）。

3.2 TCP 和 UDP#

两者都在传输层，但脾气完全不同：

HTTP 选择的是 TCP。所以你打开网页时，数据是会被可靠、按顺序送到的。

4.1 超文本传输协议#

HTTP = HyperText Transfer Protocol，超文本传输协议。

“超文本”这个词容易让人误会成”只能传文字”。实际上它指的是”不止是纯文本”：图片、音频、视频、JSON 都能传。准确的说法是，它不限于传输文本字符串。

4.2 谁和谁达成的协议#

HTTP 是**客户端（发送方）和服务器（接收方）**之间达成的约定。

• 客户端：绝大多数情况下是浏览器；但也可以是 requests、curl、你写的爬虫，只要是主动发起请求的一方，就是客户端
• 服务器：负责接收请求、处理、把结果打包回传

4.3 HTTP 的四个关键特性#

5.1 请求首行（三个部分）#

1
POST /login?from=web     HTTP/1.1
2
└─┬┘ └───┬───┘ └──┬──┘
3
方法   路径 + 参数         协议版本

• 方法：要干什么（GET / POST / PUT / DELETE …）
• 路径：访问哪个资源；路径和参数之间用 ? 隔开，没有参数也行
• 协议版本：用哪个版本的 HTTP

5.2 请求头#

请求首行之后，是一行一个的键值对，有多少行不固定，具体看浏览器。

每一个请求头都是在给服务器递一张”说明卡片”：

回想上一篇爬虫里的 User-Agent 伪装，现在你应该明白它到底在干嘛了：我们就是在伪造这张说明卡片，让服务器以为”来的是个浏览器”。

5.3 空行和请求体#

请求头和请求体之间必须有一个空行，它是两者的分隔符，不能省。

请求体是真正放数据的地方。POST 请求会把账号、密码这类数据放进请求体里。

5.4 一个完整的请求示例#

1
POST /login HTTP/1.1
2
Host: www.example.com
3
Content-Type: application/json
4
Content-Length: 42
5
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
6

7
{"username": "alice", "password": "123456"}

注意最后那个空行，它上面是头，下面是体。

8.1 状态行与状态码#

1
HTTP/1.1     200   OK
2
└──┬──┘ └┬┘ └┬┘
3
 协议版本 状态码 说明

状态码告诉客户端”这次怎么样了”：

8.2 响应头与响应体#

响应头同样是键值对，告诉客户端”我给你的东西是什么、多大、什么格式”：

1
HTTP/1.1 200 OK
2
Content-Type: application/json
3
Content-Length: 27
4

5
{"token": "abc123", "ok": true}

响应体就是真正要的数据。响应体和响应头之间同样用一个空行隔开。

10.1 前后端不分离#

后端既处理数据、又负责把数据渲染进 HTML 页面，然后把整个页面返回给客户端，事先说明，前后端不分离这个概念现在企业开发很少用，你只要了解就好

flowchart LR
    C["浏览器"] --> S["后端<查数据库 + 渲染 HTML"]
    S --> C

它需要遵循模板语法，把数据库里的数据”嵌入”到 HTML 里再返回。好处是简单，坏处是后端要操心页面。

10.2 前后端分离（）#

flowchart LR
    C["浏览器 / App"] -->|请求数据| B["后端 API只返回 JSON"]
    B -->|JSON| C
    C --> R["前端负责渲染页面"]

后端从此不再关心任何一行 HTML 代码。这正是现代 Web 开发的主流方式，也是 FastAPI 这类框架最擅长的场景。

如果你是刚接触编程/计算机，这部分内容对你来讲可能理解起来会很抽象，上面的内容理解后就已经达到了科普基础内容的目的，接下来的内容适合你已经频繁接触编程/计算机一段时间后再来理解#

在开发 API 的过程中，每个程序员的习惯都不一样，导致最终的代码风格千差万别。如果能有一套统一的习惯，别人大致一看就知道这个接口是干什么的，那就方便多了，这就是 RESTful 想解决的问题。

11.1 反面例子#

假设你做了一个学生网站：

1
http://example.com/student/inquire    # 查询学生
2
http://example.com/student/add        # 添加学生
3
http://example.com/student/delete     # 删除学生

这是初级开发最喜欢的方式，但不够好：动作被塞进了路径里，路径越写越长，语义也重复。

11.2 用 HTTP 方法来表达动作#

把动作从路径里拿出来，路径只表示”操作哪个资源”：

1
http://example.com/student

那服务器怎么知道你要干嘛？看请求方法：

路径负责”对谁做”，方法负责”做什么”。这就是 RESTful 风格的核心思想。

14.1 服务器不只是”一台机器”#

先纠正一个概念：我们平时说的”Web服务器”，通常指的不是那台计算机，而是计算机上启动的 Web 应用程序。

当你在本地跑 uvicorn main:app，你的电脑同时扮演了两个角色：它既是物理上的机器，也是运行着 Web 程序的服务器。

14.2 WSGI 和 ASGI#

Web 框架和 Web 服务器之间需要一个”翻译官”，否则双方说不通话。Python 世界里有两套翻译规则：

uvicorn 就是一个遵循 ASGI 规范的服务器。

14.3 为什么 Flask 不用装 ASGI 服务器，FastAPI 就要？#

这是很多人的困惑。答案是：Flask 是同步框架，用的是 WSGI，自带开发服务器；FastAPI 是异步框架，基于 ASGI，需要配一个 ASGI 服务器来跑。

flowchart LR
    C["客户端"] --> U["uvicorn（ASGI 服务器）"]
    U --> F["FastAPI 应用"]
    F --> U --> C

14.4 三者的分工#

三个角色各自负责的部分：

16.1 让参数变成可选#

上面的写法有个问题：所有参数都必须传，少一个就报错。但现实中的招聘网站显然不是这样，你搜”python”，城市和工作经验明明是可填可不填的。

解决办法：给参数一个默认值 None。

1
from typing import Optional
2

3
@app.get("/jobs")
4
def search_jobs(
5
    keyword: str,
6
    city: Optional[str] = None,
7
    years: Optional[str] = None,
8
):
9
    return {"keyword": keyword, "city": city, "years": years}

17.1 在类里定义数据类型#

FastAPI 里，除了在函数上写类型注解，还可以用类来定义一整个数据结构。这个类就是”请求体的数据类型”。

1
from pydantic import BaseModel
2

3
class User(BaseModel):
4
    name: str
5
    age: int
6

7
@app.post("/users")
8
def create_user(user: User):
9
    return {"received": user}

17.2 为什么 User 会自动变成请求体？#

这是新手最容易困惑的地方：我只是写了个 user: User，为什么它就成了请求体，还自动出现在 /docs 里？

1
async def data(data: User):

括号里这部分有两个作用：

1. 限制 data 的数据类型：因为 User 继承自 BaseModel，FastAPI 会用 Pydantic 自动校验传进来的数据格式
2. 自动识别为请求体：FastAPI 规定，参数类型是 BaseModel 的，默认就从请求体里取数据，你不需要额外声明

17.3 Pydantic 是什么#

Pydantic 就是负责检查客户端发来的数据是否符合标准的那一环。 想让它生效，类就必须继承 BaseModel。

客户端传错类型的处理流程是这样的：

sequenceDiagram
    autonumber
    participant C as 客户端
    participant U as uvicorn
    participant F as FastAPI
    participant P as Pydantic
    C->>U: POST /users 带数据
    U->>F: 头部没问题，交给应用
    F->>P: 按 User 模型校验请求体
    alt 校验通过
        P-->>F: 返回校验后的对象
        F-->>C: 200 + 处理结果
    else 校验失败
        P-->>F: 抛出校验错误
        F-->>C: 422 + 具体的错误原因
    end

18.1 用 Field 加约束#

1
from pydantic import BaseModel, Field
2

3
class User(BaseModel):
4
    name: str = Field(min_length=2, max_length=20, pattern=r"^[a-zA-Z]")
5
    age: int = Field(default=0, ge=0, le=100)

• ge=0 / le=100：大于等于 0，小于等于 100（不在范围内直接报错）
• pattern：正则约束，这里要求 name 必须以字母开头
• default=0：默认值

18.2 用 validator 写自定义校验#

如果要校验的规则比较复杂（比如”必须全是字母”），就用校验器：

1
from pydantic import BaseModel, field_validator
2

3
class User(BaseModel):
4
    name: str
5

6
    @field_validator("name")
7
    @classmethod
8
    def name_must_be_alpha(cls, value: str) -> str:
9
        assert value.isalpha(), "name must be alpha"
10
        return value

• cls 代表类对象本身
• value 是当前要校验的值，你输入什么，它就是什么
• assert 用来判断是否符合要求：通过就继续往下走，不通过就抛出后面那句话作为错误信息

20.1 为什么要异步#

I/O 操作指的是程序与外部世界交换数据的过程：读文件、发网络请求、查数据库等等。这类操作的特点是要等。

同步编程里，程序发出 I/O 请求后只能干等着。而异步编程里，程序发起 I/O 后不必等它完成，可以先去干别的事，等结果回来了再处理。

对于 Web 服务器来说，这意味着一个请求在等数据库返回的时候，服务器可以去处理别的请求，并发能力因此大幅提升。

20.2 async 和 await#

1
import httpx
2

3
@app.get("/proxy")
4
async def proxy():
5
    async with httpx.AsyncClient() as client:
6
        resp = await client.get("https://example.com")   # 等待期间，服务器能去处理别的请求
7
    return {"status": resp.status_code}

下一步可以玩什么#

• 把上一篇的爬虫改成 FastAPI 服务：写一个 /api/novel/{chapter} 接口，让浏览器也能拿到数据
• 学一下 依赖注入（Depends），它是 FastAPI 处理登录鉴权、数据库连接的标准姿势
• 用 APIRouter 把接口拆成多个文件，再用 include_router 组装起来（大项目必学）

如果你跟着敲完了，或者卡在某个环节，欢迎来关于页找我聊。上一篇在这里：Python 爬虫入门：写一个能跑起来的小说爬虫。