Python后端开发之旅（二）

[Web 应用开发入门对比------FastAPI & uvicorn](#Web 应用开发入门对比——FastAPI & uvicorn)
- [🚀 问题一：**FastAPI + uvicorn 是什么？**](#🚀 问题一：FastAPI + uvicorn 是什么？)
- - [✅ 简单回答：](#✅ 简单回答：)
  - [🔍 详细解释（类比 Java）](#🔍 详细解释（类比 Java）)
  - [💡 FastAPI 和 Uvicorn 如何协作？](#💡 FastAPI 和 Uvicorn 如何协作？)
- [🚀 问题二：**ASGI 是什么？**](#🚀 问题二：ASGI 是什么？)
- - [✅ 简单回答：](#✅ 简单回答：)
  - [🔍 详细解释（类比 Java）](#🔍 详细解释（类比 Java）)
  - [⚠️ 为什么需要 ASGI？](#⚠️ 为什么需要 ASGI？)
  - [📦 常见 ASGI 服务器（类似 Tomcat）](#📦 常见 ASGI 服务器（类似 Tomcat）)
- [🚀 问题三：**FastAPI vs Flask vs Django，区别与优势**](#🚀 问题三：FastAPI vs Flask vs Django，区别与优势)
- - [📊 三方对比表](#📊 三方对比表)
  - [🔍 深度解析](#🔍 深度解析)
  - [✅ FastAPI 的核心优势------❤️](#✅ FastAPI 的核心优势——❤️)
  - - [1. **自动生成 API 文档（Auto Docs）**](#1. 自动生成 API 文档（Auto Docs）)
    - [2. **类型驱动开发（Type Hints + Pydantic）**](#2. 类型驱动开发（Type Hints + Pydantic）)
    - [3. **异步支持（async/await）**](#3. 异步支持（async/await）)
    - [4. **性能媲美 Go / Node.js**](#4. 性能媲美 Go / Node.js)
- [✅ 总结建议](#✅ 总结建议)
- [🌟 补充：推荐学习路径](#🌟 补充：推荐学习路径)
Web进阶------FastAPI
- [✅ 1. 快速对比：FastAPI vs Flask](#✅ 1. 快速对比：FastAPI vs Flask)
- [✅ 2. 快速入门：用 5 分钟启动一个 FastAPI 应用](#✅ 2. 快速入门：用 5 分钟启动一个 FastAPI 应用)
- - [1. 安装](#1. 安装)
  - [2. 创建 `main.py`](#2. 创建 main.py)
  - [3. 启动服务](#3. 启动服务)
- [✅ 3. 核心概念（类比Java 风格解释）](#✅ 3. 核心概念（类比Java 风格解释）)
- [✅ 4. 数据模型：Pydantic（类似"DTO"）](#✅ 4. 数据模型：Pydantic（类似“DTO”）)
- [✅ 5. 异步 API：像写 Spring WebFlux 一样](#✅ 5. 异步 API：像写 Spring WebFlux 一样)
- [✅ 6. 错误处理：类似 Java 的异常处理](#✅ 6. 错误处理：类似 Java 的异常处理)
- [✅ 7. 工程化建议：项目结构（适合团队协作）](#✅ 7. 工程化建议：项目结构（适合团队协作）)
- - 示例：`app/routers/users.py`
  - [==示例：`main.py` 主入口==](#==示例：main.py 主入口==)
- [✅ 8. 依赖注入：类似 Spring 的 `@Autowired`](#✅ 8. 依赖注入：类似 Spring 的 @Autowired)
Web进阶------LangChain
- [✅ 1. LangChain 0.1.x vs 1.0：版本演进与主要区别](#✅ 1. LangChain 0.1.x vs 1.0：版本演进与主要区别)
- [✅ 2. 快速入门 LangChain（1.0）](#✅ 2. 快速入门 LangChain（1.0）)
- - [📦 1. 安装](#📦 1. 安装)
  - [🧩 2. 核心概念图谱（类比 Java）](#🧩 2. 核心概念图谱（类比 Java）)
  - [🧱 3. 基础组件详解](#🧱 3. 基础组件详解)
  - - [✅ 3.1 LLM（大语言模型）](#✅ 3.1 LLM（大语言模型）)
    - - [使用 OpenAI（最常见）](#使用 OpenAI（最常见）)
      - [自定义 LLM 类（高级用法）------invoke()](#自定义 LLM 类（高级用法）——invoke())
    - [✅ 3.2 提示模板（PromptTemplate）](#✅ 3.2 提示模板（PromptTemplate）)
    - [✅ 3.3 工具（Tools）和工具包（Toolkits）](#✅ 3.3 工具（Tools）和工具包（Toolkits）)
    - - [自定义工具（类似 Java 的 Service）](#自定义工具（类似 Java 的 Service）)
      - 工具包（Toolkit）
    - [✅ 3.4 消息（Messages）与历史记录（Memory）](#✅ 3.4 消息（Messages）与历史记录（Memory）)
    - - 消息格式（类似聊天上下文）
      - 记忆机制（Memory）
    - [✅ 3.5 输出解析（Output Parsing）](#✅ 3.5 输出解析（Output Parsing）)
    - - [目标：让模型返回结构化数据（如 JSON）](#目标：让模型返回结构化数据（如 JSON）)
    - [✅ 3.6 回调处理（Callbacks）](#✅ 3.6 回调处理（Callbacks）)
    - - 用于日志、追踪、调试
    - [✅ 3.7 LCEL（LangChain Expression Language）](#✅ 3.7 LCEL（LangChain Expression Language）)
    - - [示例：一个简单的 LCEL 流程](#示例：一个简单的 LCEL 流程)
      - 更复杂的例子：带条件判断
- [✅ 3. [调用方式区别](https://blog.csdn.net/cooldream2009/article/details/153470815)](#✅ 3. 调用方式区别)
- [✅ 4. 项目实战：构建一个智能问答助手](#✅ 4. 项目实战：构建一个智能问答助手)
- - [🎯 功能：](#🎯 功能：)
  - [🛠️ 代码结构](#🛠️ 代码结构)

Web 应用开发入门对比------FastAPI & uvicorn

🚀 问题一：FastAPI + uvicorn 是什么？

✅ 简单回答：

FastAPI 是一个现代、高性能的 Python Web 框架。
Uvicorn 是一个 ASGI 服务器，用来运行 FastAPI 应用。
它们一起工作，就像 Spring Boot + Tomcat 或 Spring WebFlux + Netty。

🔍 详细解释（类比 Java）

概念	类比 Java	说明
FastAPI	`Spring MVC` / `Spring WebFlux`	一个用于构建 API 的框架，支持异步和同步
Uvicorn	`Tomcat` / `Jetty` / `Undertow`	一个 ASGI 服务器，负责接收 HTTP 请求并交给 FastAPI 处理
ASGI	`Servlet API` / `WebFlux`	协议标准，定义了应用和服务器之间如何通信

✅ 假设你写了一个 Java Spring Boot 应用，它运行在 Tomcat 上 ------ 这样：

Spring Boot = FastAPI

Tomcat = Uvicorn

Servlet API = ASGI

💡 FastAPI 和 Uvicorn 如何协作？

python 复制代码

# main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def home():
    return {"message": "Hello from FastAPI!"}

然后启动：

bash 复制代码

uvicorn main:app --reload

main:app：表示文件名 main.py 中的变量 app
--reload：开发模式，代码变更自动重启热重载模式
uvicorn：作为 ASGI 服务器，监听 8000 端口

🧠 类比：就像你用 mvn spring-boot:run 启动 Spring Boot 应用一样！

🚀 问题二：ASGI 是什么？

✅ 简单回答：

ASGI （Asynchronous Server Gateway Interface）是 Python 的异步 Web 协议标准
它是 WSGI 的升级版，支持 异步请求处理 （像 async/await）

🔍 详细解释（类比 Java）

概念	Java 对应	说明
WSGI	`Servlet API`（同步）	传统 Python Web 标准，每个请求由线程处理
ASGI	`WebFlux` / `Reactive`	支持异步 IO，适合高并发、长连接场景（如 WebSocket）

✅ 举个例子：

你有一个 Java Spring 应用，它用 @Async 或 CompletableFuture 实现异步。

在 Python 中，ASGI 就相当于这个"异步能力"的底层协议。

⚠️ 为什么需要 ASGI？

场景	WSGI	ASGI
同步请求	✅	✅
异步请求（如 `async def`）	❌	✅
WebSocket	❌	✅
长轮询	❌	✅

🧠 想象：如果你的 Java 应用有很多数据库查询、外部 API 调用，用了 CompletableFuture，那么 Python 的 async/await + ASGI 就是类似的。

📦 常见 ASGI 服务器（类似 Tomcat）

名称	类似 Java 中的
`Uvicorn`	`Tomcat` / `Jetty`
`Hypercorn`	`Netty`
`Daphne`	`Django Channels` 的服务器

接口标准------服务器------实现的框架

🚀 问题三：FastAPI vs Flask vs Django，区别与优势

我们从 架构、性能、易用性、适用场景 来对比，方便你根据 Java 背景快速理解。

📊 三方对比表

特性	Flask	Django	FastAPI
架构	微框架（Microframework）	全栈框架（Batteries-included）	微框架 + 强大功能
同步/异步	同步为主	同步为主	支持异步（`async/await`）
性能	中等	中等	⭐ 最高（接近 Node.js）
数据验证	手动或 `WTForms`	`Django Forms`	自动 JSON Schema 验证（用 Pydantic）
文档	手动生成 Swagger UI	自动生成文档	⭐ 自动生成 OpenAPI docs（Swagger + ReDoc）
依赖注入	无原生支持	内置	有（通过 `Depends()`）
学习成本	低	高	中等（但有强大 IDE 支持）
适用场景	小型 API、轻量服务	企业级 CMS、复杂业务系统	高性能 API、微服务、数据接口

🔍 深度解析

项目	类比 Java	说明
Flask	`Spring Boot` with minimal starter	轻量，自由度高，适合小项目
Django	`Spring Security` + `Spring Data JPA` + `Thymeleaf`	功能全，自带 ORM、Admin、Auth 等
FastAPI	`Spring WebFlux` + `OpenAPI` + `RxJava`	现代化、异步、自动化文档、类型安全

✅ FastAPI 的核心优势------❤️

1. 自动生成 API 文档（Auto Docs）

内置 Swagger UI 和 ReDoc
不用手写文档，直接访问 http://localhost:8000/docs

🧠 类比：就像你在 Spring Boot 中用 @RestController + @GetMapping，然后自动生成 Springfox 文档。

2. 类型驱动开发（Type Hints + Pydantic）

所有参数都自动验证，把python的弱类型变成了java 的强类型解析
错误提示清晰，防止脏数据进入

python 复制代码

from fastapi import FastAPI
from pydantic import BaseModel

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

app = FastAPI()

@app.post("/items/")
def create_item(item: Item):
    return {"name": item.name, "price": item.price}

🧠 类比：就像 Java 的 @Valid + @RequestBody，但更直观、强类型！

3. 异步支持（async/await）

支持高并发 I/O 操作（数据库、HTTP 请求）
适合做高负载 API

python 复制代码

import asyncio
from fastapi import FastAPI

app = FastAPI()

@app.get("/slow")
async def slow():
    await asyncio.sleep(2)
    return {"message": "Done"}

🧠 类比：就像 Java 的 @Async 或 CompletableFuture，但语法更简洁。

4. 性能媲美 Go / Node.js

使用 Starlette + Uvicorn + Pydantic
在基准测试中，FastAPI 比 Flask 快 5~10 倍
- Starlette 是一个轻量级的ASGI 框架/工具包，非常适合用于构建Python 异步Web 服务

🧠 类比：就像 Spring Boot + Netty 的性能表现

✅ 总结建议

目标	推荐框架
快速上手、做小 API	✅ Flask
企业级项目、带 Admin、Auth	✅ Django
高性能、异步、自动化文档	✅ FastAPI

💡 你现在已经有 Flask 基础，接下来可以尝试：

用 FastAPI 重写一个简单的 API

体验 @app.get("/") + async/await

访问 /docs 查看自动文档

比较性能差异（可以用 wrk 或 ab 测试）

🌟 补充：推荐学习路径

复制代码

Flask (已学) 
   ↓
FastAPI (重点学习) → 适合未来 API 服务
   ↓
Django (可选) → 适合全栈项目

Web进阶------FastAPI

✅ 1. 快速对比：FastAPI vs Flask

特性	Flask	FastAPI
类型提示	❌ 支持有限	✅ 全面支持
自动生成 API 文档	❌ 需要扩展（如 Swagger）	✅ 自动提供 OpenAPI / Swagger / ReDoc
异步支持	❌ 有限	✅ 原生支持异步（async/await）
性能	中等	⚡️ 极高（基于 Starlette + Pydantic）
数据验证	❌ 手动或第三方库	✅ 内置 Pydantic
推荐场景	小型应用、学习	生产级、微服务、API 服务

✅ 2. 快速入门：用 5 分钟启动一个 FastAPI 应用

1. 安装

bash 复制代码

pip install fastapi uvicorn

fastapi：框架核心

uvicorn：ASGI 服务器（类比 Tomcat/Jetty）

2. 创建 `main.py`

python 复制代码

from fastapi import FastAPI
from pydantic import BaseModel
import asyncio

app = FastAPI()

# 1. 定义数据模型（类似 Java POJO）
class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None  # 可选字段

# 2. 路由：GET 请求
@app.get("/")
def read_root():
    return {"message": "Hello World"}

# 3. 路由：POST 请求
@app.post("/items/")
async def create_item(item: Item):  # 自动类型检查 + JSON 解析
    return item

# 4. 路由：路径参数
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

3. 启动服务

bash 复制代码

uvicorn main:app --reload

main:app：模块名:应用对象

--reload：开发模式，代码变化自动重启，热重载

访问：

http://localhost:8000/docs → 自动生成文档（Swagger UI）
http://localhost:8000/redoc → ReDoc 文档

✅ 3. 核心概念（类比Java 风格解释）

Java 概念	FastAPI 对应	说明
`@Controller`	`@app` 路由装饰器	`@app.get()`、`@app.post()`
`@RequestMapping`	`@app.route()`	但 FastAPI 使用更清晰的 `@get`, `@post`
`@RequestBody`	`def func(item: Item)`	参数自动从 JSON 绑定到 Pydantic 模型
`@RequestParam`	`def func(q: str = None)`	查询参数，可选，默认值
`@PathVariable`	`def func(item_id: int)`	路径参数
DTO（Data Transfer Object）	`Pydantic Model`	数据校验 + 序列化
Spring Boot Actuator	FastAPI 自带 `/docs`	文档、健康检查
Spring Validation	Pydantic	字段验证（类型、必填、范围等）
Async IO	`async def`	异步非阻塞，提升性能

✅ 4. 数据模型：Pydantic（类似"DTO"）

Pydantic 是一个用于数据验证和序列化的 Python 模型库

它在 FastAPI 中广泛使用，用于定义请求体、响应体和其他数据模型，提供了强大的类型检查和自动文档生成功能。

只需创建一个继承自 pydantic.BaseModel 的类，并在其中定义字段
所有参数都自动验证，把python的弱类型变成了java 的强类型解析

python 复制代码

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str
    age: int = None  # 可选
    disabled: bool = False

# 自动验证和错误提示
user_data = {
    "id": 1,
    "name": "Alice",
    "email": "alice@example.com"
}

user = User(**user_data)  # ✅ 如果数据合法，创建成功
# 否则 会引发ValidationError异常

🔍 类似 Java 的 @Validated + @NotBlank + @Min(18)，但更简洁！

✅ 5. 异步 API：像写 Spring WebFlux 一样

python 复制代码

from fastapi import FastAPI
import asyncio

app = FastAPI()

@app.get("/slow")
async def slow():
    await asyncio.sleep(2)
    return {"message": "I'm slow!"}

✅ 类比：Spring 的 @Async + CompletableFuture

✅ 6. 错误处理：类似 Java 的异常处理

python 复制代码

from fastapi import FastAPI, HTTPException
from fastapi.responses import JSONResponse

app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id <= 0:
        raise HTTPException(status_code=400, detail="Item ID must be positive")
    return {"item_id": item_id}

✅ 类似 Java 的 throw new IllegalArgumentException("...")

✅ 7. 工程化建议：项目结构（适合团队协作）

复制代码

my_fastapi_project/
├── main.py                  # 主入口
├── app/
│   ├── __init__.py
│   ├── routers/
│   │   ├── users.py         # 用户路由
│   │   └── items.py         # 商品路由
│   ├── dependencies.py      # 依赖注入（类似 Spring @Autowired）
│   └── models.py            # Pydantic 模型
├── schemas/
│   └── user.py              # 数据模型（可选）
├── database/
│   └── db.py                # 数据库连接
└── requirements.txt

示例：`app/routers/users.py`

python 复制代码

from fastapi import APIRouter, Depends, HTTPException
from .models import User

router = APIRouter()

@router.get("/users")
async def get_users():
    return [{"name": "Alice"}, {"name": "Bob"}]

示例：`main.py` 主入口

python 复制代码

from fastapi import FastAPI
from app.routers import users, items

app = FastAPI(title="My API")

app.include_router(users.router)
app.include_router(items.router)

✅ 8. 依赖注入：类似 Spring 的 `@Autowired`

引入了 Depends，使用的时候Depends()

python 复制代码

from fastapi import Depends

# 1. 定义依赖
def get_db():
    return {"db": "connected"}

# 2. 在路由中使用
@app.get("/data")
async def read_data(db=Depends(get_db)):
    return db

✅ 类似：Spring 的 @Autowired + @Bean

Web进阶------LangChain

✅ 1. LangChain 0.1.x vs 1.0：版本演进与主要区别

LangChain 的第一个稳定版本 ，即 LangChain 0.1.0，于 2024 年 1 月 8 日正式发布，这是一个值得庆祝的里程碑，也是 LangChain 项目的一个新的起点

LangChain 的版本号由三个部分组成，即主版本号、次版本号和修订号，分别表示 LangChain 的大的、中等的和小的更新。例如，LangChain 0.1.0 表示 LangChain 的第 0 个主版本，第 1 个次版本，第 0 个修订版本

特性	LangChain 0.1.x（旧版）	LangChain 1.0（新版）
发布时间	2024 年 1 月 8 日	2025年10月23日
核心理念	模块松散，流程不统一	统一、可组合、强类型

🔍 关键总结：

0.1.x → 多个独立类（如 LLMChain, AgentExecutor）

**1.0 → 统一 Runnable 接口，所有组件都是 Runnable，模块重组，代码也得改变

✅ 2. 快速入门 LangChain（1.0）

📦 1. 安装

bash 复制代码

pip install langchain langchain-openai  # 以 OpenAI 为例

💡 你也可以用其他 LLM 提供商，如 Anthropic、Cohere、Claude、Google Vertex AI ，DeepSeek等

🧩 2. 核心概念图谱（类比 Java）

LangChain 概念	类比 Java 开发	说明
`LLM`	`RestTemplate` / `FeignClient`	调用大模型 API
`PromptTemplate`	`String.format()` + `@Value`	动态生成提示词
`Runnable`	`Function<T, R>` / `Supplier<T>`	所有组件都实现此接口
`Chain`	`Service` + `Controller`	逻辑处理链
`Tool`	`@Component` + `@Autowired`	工具函数，用于 Agent
`Memory`	`Session` / `Cache`	记忆历史对话
`LCEL`	Spring Expression Language	链式表达式语法 (`
`Callback`	`Interceptor` / `AOP`	日志、监控、追踪

promet，llm，parser

Conversational(Agent)：用于与用户进行自然对话，并接收用户提出的问题，根据提问内容选择具体使用的处理工具
RetrievalQA(Retriever)：用于从自定义资料集中检索相关内容。
DuckDuckGoSearchRun(tool): 用于访问DuckDuckGoSearch搜索API
Prompts & Structured output parser(ModelIO)：用于定义接收对话的模板以及结构化搜索引擎查询到的结果并生成一个简洁和准确的回答。
SequentialChain(Chain)：用于按照顺序执行以上组件，并将每个组件的输出作为下一个组件的输入
ConversationBufferMemory(Memory)：用于在对话中记住以前的交互置，以便在后续的对话中使用。
StdOutCallbackHandler： 标准输出用于进行日志记录。

🧱 3. 基础组件详解

✅ 3.1 LLM（大语言模型）

使用 OpenAI（最常见）

python 复制代码

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4-turbo", temperature=0.7)

📝 你可以通过 os.getenv("OPENAI_API_KEY") 读取密钥

自定义 LLM 类（高级用法）------invoke()

python 复制代码

from langchain_core.runnables import Runnable

class CustomLLM(Runnable):
    def invoke(self, input: str, config: dict = None):
        # 实现自己的大模型调用逻辑
        return f"Custom response to: {input}"

# 使用
custom_llm = CustomLLM()
result = custom_llm.invoke("Hello")
print(result)

✅ 这样就可以把你的私有模型或本地模型接入 LangChain！

✅ 3.2 提示模板（PromptTemplate）

使用format()进行填入

python 复制代码

from langchain_core.prompts import PromptTemplate

prompt = PromptTemplate.from_template(
    "You are a helpful assistant. Answer the question: {question}"
)

# 生成最终提示
formatted_prompt = prompt.format(question="What is Python?")
print(formatted_prompt)
# 输出: You are a helpful assistant. Answer the question: What is Python?

✅ 支持变量替换，可用于动态生成提示

✅ 3.3 工具（Tools）和工具包（Toolkits）

自定义工具（类似 Java 的 Service）

python 复制代码

from langchain_core.tools import tool
import requests

@tool
def get_weather(city: str) -> str:
    """获取指定城市的天气"""
    url = f"https://api.weather.com/forecast?city={city}"
    response = requests.get(url)
    return response.json()["temperature"] if response.ok else "Error"

工具包（Toolkit）

python 复制代码

from langchain_community.tools import DuckDuckGoSearchRun

search_tool = DuckDuckGoSearchRun()

✅ 工具可以被 Agent 调用，实现"查询互联网"功能

✅ 3.4 消息（Messages）与历史记录（Memory）

消息格式（类似聊天上下文）

消息是LangChain中对话交互的基本单元，分为两类：
- HumanMessage：表示用户输入（如提问或指令）
- AIMessage：表示AI模型的响应

python 复制代码

from langchain_core.messages import HumanMessage, AIMessage

messages = [
    HumanMessage(content="Hello"),
    AIMessage(content="Hi! How can I help?")
]

记忆机制（Memory）

记忆模块用于持久化存储和管理对话历史，常见类型包括：
- ConversationBufferMemory：完整保存所有对话记录
- ConversationBufferWindowMemory：仅保留最近N轮对话
- ConversationSummaryMemory：用LLM摘要压缩长对话

python 复制代码

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
memory.chat_memory.add_user_message("Hello")
memory.chat_memory.add_ai_message("Hi! How can I help?")

保存对话历史供后续调用（如多轮对话上下文）
支持通过memory.load_memory_variables()读取历史

✅ 类似 Session，但持久化更灵活

✅ 3.5 输出解析（Output Parsing）

目标：让模型返回结构化数据（如 JSON）

python 复制代码

from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import PromptTemplate

parser = JsonOutputParser()

prompt = PromptTemplate(
    template="Answer only in JSON format: {question}",
    input_variables=["question"]
)

chain = prompt | llm | parser
result = chain.invoke({"question": "Who is the CEO of Tesla?"})
print(result)
# 输出: {"name": "Elon Musk"}

✅ 避免模型返回自由文本，提升结构化能力

✅ 3.6 回调处理（Callbacks）

用于日志、追踪、调试

python 复制代码

from langchain.callbacks import StdOutCallbackHandler

callbacks = [StdOutCallbackHandler()]

llm.invoke("Hello", callbacks=callbacks)

✅ 可扩展为：LangChainTracer、LangSmithCallbackHandler（企业级追踪）
LangChain 借助 LangSmith 提供了更好的日志、可视化、播放和跟踪功能，以便监控和调试 LLM 应用。LangSmith 是一个基于 Web 的工具，用于可视化和控制 LangChain 的链和代理，能够查看和分析细化到class的输入和输出

✅ 3.7 LCEL（LangChain Expression Language）

用 | 链接模块，像流水线一样执行

就像 unix 的管道机制

示例：一个简单的 LCEL 流程

python 复制代码

from langchain_core.prompts import PromptTemplate
from langchain_core.runnables import RunnableLambda, RunnableSequence

# 1. 提示模板
prompt = PromptTemplate.from_template("Translate this to English: {text}")

# 2. Lambda 函数：转成大写
uppercase = RunnableLambda(lambda x: {"text": x["text"].upper()})

# 3. 链接：先转大写，再翻译
chain = uppercase | prompt | llm

# 执行
result = chain.invoke({"text": "你好世界"})
print(result.content)

RunnableLambda：将普通 Python 函数包装为 LangChain 可执行的组件
RunnableBranch 是 LangChain 中用于根据条件选择不同执行路径的组件
- RunnableBranch 接受多个条件判断对（condition, component）以及一个默认的 fallback 函数
- 每个条件判断对的结构是：(condition, component)，其中：
  - condition 是一个函数，用于判断输入是否满足某个条件。
  - component 是一个可执行的组件（如 RunnableLambda），如果条件满足，则会执行该组件。
  - 如果所有条件都不满足，则执行最后一个 fallback 函数

更复杂的例子：带条件判断

python 复制代码

from langchain_core.runnables import RunnableBranch

branch = RunnableBranch(
    (lambda x: x["text"].startswith("hello"), lambda x: "Hello!"),
    (lambda x: x["text"].startswith("hi"), lambda x: "Hi!"),
    lambda x: "Unknown greeting"
)

result = branch.invoke({"text": "hello world"})

✅ 3. 调用方式区别

invoke()：一次性同步调用，等待完整输出后返回。
stream()：流式异步调用，边生成边返回。就是流式响应！！！
- LangChain会将这些结果作为生成器 逐步返回，开发者可在接收到每个分片（chunk）时进行实时处理或显示
有时我们既想实时输出，又想保存完整结果：

python 复制代码

chunks = []
for chunk in llm.stream("请解释RAG的原理。"):
    print(chunk.content, end="", flush=True)
    chunks.append(chunk.content)

full_output = "".join(chunks)

✅ 4. 项目实战：构建一个智能问答助手

🎯 功能：

接收用户问题
使用 LLM 生成回答
支持简单工具（如搜索）
保留聊天历史

🛠️ 代码结构

python 复制代码

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough, RunnableSequence
from langchain_core.messages import HumanMessage, AIMessage
from langchain_openai import ChatOpenAI
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_core.output_parsers import StrOutputParser

# 1. 初始化 LLM
llm = ChatOpenAI(model="gpt-4-turbo")

# 2. 定义工具
search_tool = DuckDuckGoSearchRun()
wikipedia = WikipediaAPIWrapper()

# 3. 创建提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("human", "{question}")
])

# 4. 构建 LCEL 流程
chain = (
    {
        "question": RunnablePassthrough(),
        "context": RunnableLambda(lambda x: search_tool.invoke(x["question"]))
    }
    | prompt
    | llm
    | StrOutputParser()
)

# 5. 运行
result = chain.invoke({"question": "Who is Elon Musk?"})
print(result)

使用 LangChain 表达式语言（LCEL）构建处理流程：
1. 接收输入问题并原样传递（RunnablePassthrough）
2. 使用搜索工具获取问题相关上下文
3. 将问题和上下文传递给提示模板
4. 将模板输出传递给LLM
5. 最后使用字符串输出解析器
使用LangChain构建一个结合外部搜索的问答系统。
检索到的信息会作为上下文提供给LLM，帮助生成更准确的回答

Python后端开发之旅（二）

Python后端开发之旅（二）

Web 应用开发入门对比------FastAPI & uvicorn

🚀 问题一：FastAPI + uvicorn 是什么？

✅ 简单回答：

🔍 详细解释（类比 Java）

💡 FastAPI 和 Uvicorn 如何协作？

🚀 问题二：ASGI 是什么？

✅ 简单回答：

🔍 详细解释（类比 Java）

⚠️ 为什么需要 ASGI？

📦 常见 ASGI 服务器（类似 Tomcat）

🚀 问题三：FastAPI vs Flask vs Django，区别与优势

📊 三方对比表

🔍 深度解析

✅ FastAPI 的核心优势------❤️

1. 自动生成 API 文档（Auto Docs）

2. 类型驱动开发（Type Hints + Pydantic）

3. 异步支持（async/await）

4. 性能媲美 Go / Node.js

✅ 总结建议

🌟 补充：推荐学习路径

Web进阶------FastAPI

✅ 1. 快速对比：FastAPI vs Flask

✅ 2. 快速入门：用 5 分钟启动一个 FastAPI 应用

1. 安装

2. 创建 main.py

3. 启动服务

✅ 3. 核心概念（类比Java 风格解释）

✅ 4. 数据模型：Pydantic（类似"DTO"）

✅ 5. 异步 API：像写 Spring WebFlux 一样

✅ 6. 错误处理：类似 Java 的异常处理

✅ 7. 工程化建议：项目结构（适合团队协作）

示例：app/routers/users.py

示例：main.py 主入口

✅ 8. 依赖注入：类似 Spring 的 @Autowired

Web进阶------LangChain

✅ 1. LangChain 0.1.x vs 1.0：版本演进与主要区别

✅ 2. 快速入门 LangChain（1.0）

📦 1. 安装

🧩 2. 核心概念图谱（类比 Java）

🧱 3. 基础组件详解

✅ 3.1 LLM（大语言模型）

使用 OpenAI（最常见）

自定义 LLM 类（高级用法）------invoke()

✅ 3.2 提示模板（PromptTemplate）

✅ 3.3 工具（Tools）和工具包（Toolkits）

自定义工具（类似 Java 的 Service）

工具包（Toolkit）

✅ 3.4 消息（Messages）与历史记录（Memory）

消息格式（类似聊天上下文）

记忆机制（Memory）

✅ 3.5 输出解析（Output Parsing）

目标：让模型返回结构化数据（如 JSON）

✅ 3.6 回调处理（Callbacks）

用于日志、追踪、调试

✅ 3.7 LCEL（LangChain Expression Language）

示例：一个简单的 LCEL 流程

更复杂的例子：带条件判断

✅ 3. 调用方式区别

✅ 4. 项目实战：构建一个智能问答助手

🎯 功能：

🛠️ 代码结构

2. 创建 `main.py`

示例：`app/routers/users.py`

示例：`main.py` 主入口

✅ 8. 依赖注入：类似 Spring 的 `@Autowired`