【Python】Python常用技术框架详解与应用指南

Python作为一门简洁而强大的编程语言，其成功很大程度上归功于丰富的框架生态系统。这些框架为开发者提供了预构建的模块和工具，大大提高了开发效率。本文将系统介绍Python各个领域的常用技术框架，帮助开发者根据项目需求选择合适的框架。

一、Web开发框架

（一）Django - 全栈开发之王

简介：Django是Python最受欢迎的全栈Web框架，采用”电池包含”的设计理念。 1

核心特性：

• 内置ORM（对象关系映射）
• 自动化管理后台
• 用户认证系统
• 表单处理
• 国际化支持
• 安全性保障（CSRF、XSS防护）

适用场景：

• 大型复杂Web应用
• 内容管理系统
• 电商平台
• 企业级应用

代码示例：

# Django视图示例
from django.shortcuts import render
from django.http import HttpResponse
from .models import Article

def article_list(request):
    articles = Article.objects.all()
    return render(request, 'articles/list.html', {'articles': articles})

def article_detail(request, article_id):
    article = Article.objects.get(id=article_id)
    return render(request, 'articles/detail.html', {'article': article})

（二）Flask - 轻量级冠军

简介：Flask是一个轻量级的微框架，以其简洁性和灵活性著称。 1

核心特性：

• 最小化核心
• 高度可扩展
• 灵活的路由系统
• 模板引擎（Jinja2）
• 会话管理
• 蓝图（Blueprint）支持

适用场景：

• 小型到中型Web应用
• 微服务架构
• API开发
• 原型开发

代码示例：

# Flask应用示例
from flask import Flask, render_template, request, jsonify

app = Flask(__name__)

@app.route('/')
def home():
    return render_template('index.html')

@app.route('/api/users', methods=['GET', 'POST'])
def users():
    if request.method == 'GET':
        return jsonify({'users': get_all_users()})
    elif request.method == 'POST':
        user_data = request.get_json()
        return jsonify(create_user(user_data))

if __name__ == '__main__':
    app.run(debug=True)

（三）FastAPI - API开发新星

简介：FastAPI是一个现代、高性能的Web框架，专为构建API而设计。 5

核心特性：

• 基于Python类型提示
• 自动生成API文档（OpenAPI/Swagger）
• 异步支持
• 高性能（基于Starlette和Pydantic）
• 数据验证
• 现代Python特性支持

适用场景：

• RESTful API开发
• GraphQL端点
• 高性能应用
• 实时数据处理
• 微服务架构

代码示例：

# FastAPI应用示例
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional

app = FastAPI(title="用户管理API", version="1.0.0")

class User(BaseModel):
    id: Optional[int] = None
    name: str
    email: str
    age: int

@app.get("/users", response_model=List[User])
async def get_users():
    return await fetch_users_from_db()

@app.post("/users", response_model=User)
async def create_user(user: User):
    if await user_exists(user.email):
        raise HTTPException(status_code=400, detail="用户已存在")
    return await save_user(user)

@app.get("/users/{user_id}", response_model=User)
async def get_user(user_id: int):
    user = await fetch_user_by_id(user_id)
    if not user:
        raise HTTPException(status_code=404, detail="用户未找到")
    return user

（四）其他Web框架

Pyramid：

• 高度灵活和模块化设计
• 适合大型复杂项目
• 企业和政府部门青睐 1

Tornado：

• 专注于实时应用
• 异步网络库
• 适合WebSocket和长连接

Bottle：

• 单文件微框架
• 零依赖
• 适合小型项目和学习

二、数据科学与分析框架

（一）NumPy - 科学计算基础

简介：NumPy是Python科学计算的基础库，提供多维数组对象和相关工具。

核心特性：

• 高性能多维数组（ndarray）
• 广播机制
• 线性代数运算
• 傅里叶变换
• 随机数生成

代码示例：

import numpy as np

# 创建数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(f"数组形状: {arr.shape}")
print(f"数组类型: {arr.dtype}")

# 数学运算
result = np.sqrt(arr) * 2
print(f"运算结果:\n{result}")

# 统计函数
print(f"平均值: {np.mean(arr)}")
print(f"标准差: {np.std(arr)}")

（二）Pandas - 数据处理利器

简介：Pandas是强大的数据分析和操作库，提供数据结构和数据分析工具。

核心特性：

• DataFrame和Series数据结构
• 数据清洗和转换
• 数据合并和连接
• 时间序列分析
• 文件I/O（CSV、Excel、JSON等）

代码示例：

import pandas as pd

# 创建DataFrame
data = {
    '姓名': ['张三', '李四', '王五'],
    '年龄': [25, 30, 35],
    '城市': ['北京', '上海', '广州'],
    '薪资': [8000, 12000, 15000]
}
df = pd.DataFrame(data)

# 数据分析
print(f"平均年龄: {df['年龄'].mean()}")
print(f"薪资统计:\n{df['薪资'].describe()}")

# 数据筛选
high_salary = df[df['薪资'] > 10000]
print(f"高薪员工:\n{high_salary}")

# 数据分组
city_stats = df.groupby('城市')['薪资'].mean()
print(f"各城市平均薪资:\n{city_stats}")

（三）Matplotlib - 数据可视化

简介：Matplotlib是Python最基础的绘图库，提供类似MATLAB的绘图接口。

代码示例：

import matplotlib.pyplot as plt
import numpy as np

# 创建数据
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# 绘制图形
plt.figure(figsize=(10, 6))
plt.plot(x, y1, label='sin(x)', linewidth=2)
plt.plot(x, y2, label='cos(x)', linewidth=2)
plt.xlabel('X轴')
plt.ylabel('Y轴')
plt.title('三角函数图像')
plt.legend()
plt.grid(True)
plt.show()

（四）Seaborn - 统计可视化

简介：基于Matplotlib的统计数据可视化库，提供更美观的默认样式。

代码示例：

import seaborn as sns
import matplotlib.pyplot as plt

# 加载示例数据
tips = sns.load_dataset('tips')

# 创建多种图表
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

# 散点图
sns.scatterplot(data=tips, x='total_bill', y='tip', hue='day', ax=axes[0,0])
axes[0,0].set_title('账单与小费关系')

# 箱线图
sns.boxplot(data=tips, x='day', y='total_bill', ax=axes[0,1])
axes[0,1].set_title('各天账单分布')

# 热力图
corr_matrix = tips.select_dtypes(include=[np.number]).corr()
sns.heatmap(corr_matrix, annot=True, ax=axes[1,0])
axes[1,0].set_title('相关性热力图')

# 分布图
sns.histplot(data=tips, x='total_bill', hue='sex', ax=axes[1,1])
axes[1,1].set_title('账单分布（按性别）')

plt.tight_layout()
plt.show()

三、机器学习框架

（一）Scikit-learn - 经典机器学习

简介：Scikit-learn是Python最受欢迎的机器学习库，提供各种经典算法实现。

核心特性：

• 分类、回归、聚类算法
• 数据预处理工具
• 模型选择和评估
• 降维技术
• 特征工程

代码示例：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# 加载数据
iris = load_iris()
X, y = iris.data, iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 训练模型
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# 预测和评估
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"准确率: {accuracy:.3f}")
print(f"分类报告:\n{classification_report(y_test, y_pred, target_names=iris.target_names)}")

# 特征重要性
feature_importance = model.feature_importances_
for i, importance in enumerate(feature_importance):
    print(f"{iris.feature_names[i]}: {importance:.3f}")

（二）TensorFlow - 深度学习平台

简介：Google开发的开源深度学习框架，支持从研究到生产的完整机器学习工作流。

核心特性：

• 灵活的架构
• 分布式训练
• 移动和边缘部署
• TensorBoard可视化
• Keras高级API

代码示例：

import tensorflow as tf
from tensorflow import keras
import numpy as np

# 加载MNIST数据集
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# 数据预处理
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# 构建模型
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation='softmax')
])

# 编译模型
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 训练模型
history = model.fit(x_train, y_train,
                    epochs=5,
                    validation_split=0.1,
                    verbose=1)

# 评估模型
test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=0)
print(f"测试准确率: {test_accuracy:.3f}")

（三）PyTorch - 动态深度学习

简介：Facebook开发的深度学习框架，以动态计算图和易用性著称。 1

核心特性：

• 动态计算图
• 自动微分
• GPU加速
• 丰富的预训练模型
• 研究友好的设计

代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# 创建简单的神经网络
class SimpleNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)
        self.dropout = nn.Dropout(0.2)
    
    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.dropout(x)
        x = self.fc2(x)
        return x

# 创建模型实例
model = SimpleNet(input_size=784, hidden_size=128, output_size=10)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练循环示例
def train_epoch(model, dataloader, criterion, optimizer):
    model.train()
    total_loss = 0
    for batch_idx, (data, target) in enumerate(dataloader):
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    return total_loss / len(dataloader)

四、GUI开发框架

（一）Tkinter - 内置GUI库

简介：Python标准库中的GUI工具包，基于Tcl/Tk。

代码示例：

import tkinter as tk
from tkinter import ttk, messagebox

class SimpleApp:
    def __init__(self, root):
        self.root = root
        self.root.title("简单应用")
        self.root.geometry("400x300")
        
        # 创建界面元素
        self.create_widgets()
    
    def create_widgets(self):
        # 标签
        label = ttk.Label(self.root, text="请输入您的姓名:")
        label.pack(pady=10)
        
        # 输入框
        self.entry = ttk.Entry(self.root, width=30)
        self.entry.pack(pady=5)
        
        # 按钮
        button = ttk.Button(self.root, text="问候", command=self.greet)
        button.pack(pady=10)
        
        # 文本区域
        self.text_area = tk.Text(self.root, height=10, width=40)
        self.text_area.pack(pady=10)
    
    def greet(self):
        name = self.entry.get()
        if name:
            greeting = f"你好, {name}!\n"
            self.text_area.insert(tk.END, greeting)
        else:
            messagebox.showwarning("警告", "请输入姓名")

if __name__ == "__main__":
    root = tk.Tk()
    app = SimpleApp(root)
    root.mainloop()

（二）PyQt/PySide - 专业GUI开发

简介：基于Qt的Python绑定，提供专业级GUI开发能力。

代码示例：

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QPushButton, QLabel, QLineEdit
from PyQt5.QtCore import Qt

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("PyQt示例")
        self.setGeometry(100, 100, 400, 300)
        
        # 创建中央部件
        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        
        # 创建布局
        layout = QVBoxLayout()
        central_widget.setLayout(layout)
        
        # 添加控件
        self.label = QLabel("点击按钮开始")
        self.label.setAlignment(Qt.AlignCenter)
        layout.addWidget(self.label)
        
        self.line_edit = QLineEdit()
        self.line_edit.setPlaceholderText("输入文本...")
        layout.addWidget(self.line_edit)
        
        button = QPushButton("更新标签")
        button.clicked.connect(self.update_label)
        layout.addWidget(button)
    
    def update_label(self):
        text = self.line_edit.text()
        if text:
            self.label.setText(f"您输入了: {text}")
        else:
            self.label.setText("请输入一些文本")

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

五、网络爬虫框架

（一）Requests - HTTP库

简介：优雅简洁的HTTP库，是Python进行HTTP请求的首选。

代码示例：

import requests
import json
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

# 创建会话并配置重试策略
session = requests.Session()
retry_strategy = Retry(
    total=3,
    backoff_factor=1,
    status_forcelist=[429, 500, 502, 503, 504]
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("http://", adapter)
session.mount("https://", adapter)

# 发送GET请求
response = session.get('https://api.github.com/users/octocat')
if response.status_code == 200:
    user_data = response.json()
    print(f"用户名: {user_data['login']}")
    print(f"公开仓库数: {user_data['public_repos']}")
else:
    print(f"请求失败: {response.status_code}")

# 发送POST请求
post_data = {
    'title': '测试文章',
    'content': '这是一篇测试文章的内容'
}
headers = {'Content-Type': 'application/json'}
response = session.post('https://httpbin.org/post', 
                       data=json.dumps(post_data), 
                       headers=headers)
print(f"POST响应: {response.status_code}")

（二）Scrapy - 专业爬虫框架

简介：强大的爬虫框架，提供完整的爬虫解决方案。

代码示例：

import scrapy
from scrapy.crawler import CrawlerProcess

class QuotesSpider(scrapy.Spider):
    name = 'quotes'
    start_urls = ['http://quotes.toscrape.com']
    
    def parse(self, response):
        # 提取引言
        quotes = response.css('div.quote')
        for quote in quotes:
            yield {
                'text': quote.css('span.text::text').get(),
                'author': quote.css('small.author::text').get(),
                'tags': quote.css('div.tags a.tag::text').getall()
            }
        
        # 跟踪下一页链接
        next_page = response.css('li.next a::attr(href)').get()
        if next_page is not None:
            yield response.follow(next_page, self.parse)

# 运行爬虫
if __name__ == "__main__":
    process = CrawlerProcess({
        'USER_AGENT': 'quotes-spider',
        'FEEDS': {
            'quotes.json': {'format': 'json'},
        },
    })
    process.crawl(QuotesSpider)
    process.start()

（三）BeautifulSoup - HTML解析

简介：用于解析HTML和XML文档的库，提供简单的API。

代码示例：

import requests
from bs4 import BeautifulSoup
import csv

def scrape_news(url):
    """爬取新闻标题和链接"""
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    
    response = requests.get(url, headers=headers)
    soup = BeautifulSoup(response.content, 'html.parser')
    
    # 查找新闻条目
    news_items = []
    articles = soup.find_all('article', class_='news-item')
    
    for article in articles:
        title_element = article.find('h2')
        link_element = article.find('a')
        
        if title_element and link_element:
            title = title_element.get_text(strip=True)
            link = link_element.get('href')
            
            news_items.append({
                'title': title,
                'link': link
            })
    
    return news_items

# 保存到CSV文件
def save_to_csv(news_items, filename):
    with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
        fieldnames = ['title', 'link']
        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
        
        writer.writeheader()
        for item in news_items:
            writer.writerow(item)

# 使用示例
if __name__ == "__main__":
    url = "https://example-news-site.com"
    news = scrape_news(url)
    save_to_csv(news, 'news.csv')
    print(f"爬取了 {len(news)} 条新闻")

六、测试框架

（一）pytest - 现代测试框架

简介：功能丰富的测试框架，支持简单的单元测试到复杂的功能测试。

代码示例：

import pytest
from unittest.mock import Mock, patch

# 被测试的类
class Calculator:
    def add(self, a, b):
        return a + b
    
    def divide(self, a, b):
        if b == 0:
            raise ValueError("除数不能为零")
        return a / b
    
    def get_data_from_api(self, url):
        # 模拟API调用
        import requests
        response = requests.get(url)
        return response.json()

# 测试类
class TestCalculator:
    def setup_method(self):
        """每个测试方法前执行"""
        self.calc = Calculator()
    
    def test_add_positive_numbers(self):
        """测试正数相加"""
        result = self.calc.add(2, 3)
        assert result == 5
    
    def test_add_negative_numbers(self):
        """测试负数相加"""
        result = self.calc.add(-2, -3)
        assert result == -5
    
    def test_divide_normal(self):
        """测试正常除法"""
        result = self.calc.divide(10, 2)
        assert result == 5.0
    
    def test_divide_by_zero(self):
        """测试除零异常"""
        with pytest.raises(ValueError, match="除数不能为零"):
            self.calc.divide(10, 0)
    
    @pytest.mark.parametrize("a,b,expected", [
        (1, 2, 3),
        (0, 0, 0),
        (-1, 1, 0),
        (100, 200, 300)
    ])
    def test_add_parametrized(self, a, b, expected):
        """参数化测试"""
        result = self.calc.add(a, b)
        assert result == expected
    
    @patch('requests.get')
    def test_get_data_from_api(self, mock_get):
        """测试API调用（使用Mock）"""
        # 设置Mock返回值
        mock_response = Mock()
        mock_response.json.return_value = {'data': 'test'}
        mock_get.return_value = mock_response
        
        # 执行测试
        result = self.calc.get_data_from_api('http://test.com')
        
        # 验证结果
        assert result == {'data': 'test'}
        mock_get.assert_called_once_with('http://test.com')

# Fixture示例
@pytest.fixture
def sample_data():
    """提供测试数据"""
    return {
        'users': [
            {'id': 1, 'name': '张三'},
            {'id': 2, 'name': '李四'}
        ]
    }

def test_user_data(sample_data):
    """使用fixture的测试"""
    users = sample_data['users']
    assert len(users) == 2
    assert users[0]['name'] == '张三'

（二）unittest - 标准测试框架

简介：Python标准库中的测试框架，基于xUnit架构。

代码示例：

import unittest
from unittest.mock import patch, MagicMock

class TestStringMethods(unittest.TestCase):
    
    def setUp(self):
        """每个测试方法前执行"""
        self.test_string = "hello world"
    
    def tearDown(self):
        """每个测试方法后执行"""
        pass
    
    def test_upper(self):
        """测试字符串大写"""
        self.assertEqual(self.test_string.upper(), 'HELLO WORLD')
    
    def test_isupper(self):
        """测试是否为大写"""
        self.assertFalse(self.test_string.isupper())
        self.assertTrue('HELLO'.isupper())
    
    def test_split(self):
        """测试字符串分割"""
        result = self.test_string.split()
        self.assertEqual(result, ['hello', 'world'])
        
        # 测试分割器
        with self.assertRaises(TypeError):
            self.test_string.split(2)

if __name__ == '__main__':
    unittest.main()

七、异步编程框架

（一）asyncio - 异步I/O

简介：Python标准库中的异步编程框架。

代码示例：

import asyncio
import aiohttp
import time

async def fetch_url(session, url):
    """异步获取URL内容"""
    try:
        async with session.get(url) as response:
            return await response.text()
    except Exception as e:
        return f"Error fetching {url}: {str(e)}"

async def fetch_multiple_urls(urls):
    """并发获取多个URL"""
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results

async def main():
    """主函数"""
    urls = [
        'https://httpbin.org/delay/1',
        'https://httpbin.org/delay/2',
        'https://httpbin.org/delay/1',
    ]
    
    start_time = time.time()
    results = await fetch_multiple_urls(urls)
    end_time = time.time()
    
    print(f"获取 {len(urls)} 个URL耗时: {end_time - start_time:.2f} 秒")
    for i, result in enumerate(results):
        print(f"URL {i+1} 结果长度: {len(result)} 字符")

# 运行异步程序
if __name__ == "__main__":
    asyncio.run(main())

八、框架选择指南

（一）Web开发框架选择

项目类型	推荐框架	理由
大型企业应用	Django	功能完整，生态成熟
微服务/API	FastAPI	高性能，现代化设计
小型项目	Flask	轻量级，灵活性高
实时应用	Tornado	异步支持，WebSocket

（二）数据科学框架选择

应用场景	推荐框架	理由
数据分析	Pandas + NumPy	功能强大，易用性好
机器学习	Scikit-learn	算法丰富，文档完善
深度学习	PyTorch/TensorFlow	社区活跃，工具完善
数据可视化	Matplotlib + Seaborn	功能全面，样式美观

（三）选择建议

1. 项目规模：大型项目选择功能完整的框架，小型项目选择轻量级框架
2. 性能要求：高性能需求选择FastAPI、Tornado等
3. 团队经验：考虑团队对框架的熟悉程度
4. 社区支持：选择社区活跃、文档完善的框架
5. 长期维护：考虑框架的发展前景和维护状况

九、最佳实践

（一）框架使用原则

1. 合适原则：根据项目需求选择合适的框架
2. 简单原则：优先选择简单易用的解决方案
3. 标准原则：遵循框架的最佳实践和约定
4. 测试原则：编写充分的测试代码
5. 文档原则：维护清晰的项目文档

（二）性能优化建议

1. 合理使用缓存：Redis、Memcached等
2. 数据库优化：索引、查询优化
3. 异步处理：使用异步框架处理I/O密集型任务
4. 代码优化：避免不必要的计算和内存占用
5. 监控调优：使用性能监控工具

（三）安全考虑

1. 输入验证：严格验证用户输入
2. 权限控制：实现适当的访问控制
3. 数据加密：敏感数据加密存储和传输
4. 依赖管理：定期更新依赖包，修复安全漏洞
5. 日志审计：记录关键操作日志

十、学习路径建议

（一）初学者路径

1. 基础语法：掌握Python基础语法
2. 标准库：熟悉常用标准库
3. Web开发：从Flask开始学习Web开发
4. 数据处理：学习NumPy和Pandas
5. 项目实践：完成小型项目

（二）进阶路径

1. 深入框架：深入学习Django或FastAPI
2. 数据科学：学习机器学习和数据可视化
3. 异步编程：掌握asyncio和异步框架
4. 测试开发：学习测试驱动开发
5. 部署运维：学习容器化和云部署

（三）专业化方向

1. Web全栈：Django + Vue.js/React
2. 数据科学：Pandas + Scikit-learn + Jupyter
3. AI/ML：TensorFlow/PyTorch + MLOps
4. DevOps：自动化测试 + CI/CD
5. 爬虫开发：Scrapy + 分布式爬虫

总结

Python丰富的框架生态系统为不同领域的开发提供了强大支持。从Web开发的Django、Flask、FastAPI，到数据科学的NumPy、Pandas、Scikit-learn，再到深度学习的TensorFlow、PyTorch，每个框架都有其独特的优势和适用场景。 4

选择合适的框架需要综合考虑项目需求、团队经验、性能要求和长期维护等因素。通过系统学习和实践这些框架，开发者可以构建高质量、高性能的Python应用程序。

随着技术的不断发展，Python框架生态也在持续演进。保持学习热情，关注新技术趋势，是每个Python开发者持续成长的关键。

参考资料

1. The Most Popular Python Frameworks in 2024：https://codeanywhere.com/blog/the-most-popular-python-frameworks-in-2024 1
2. 2024年顶级Python REST API框架：https://www.explinks.com/blog/2024-年顶级-python-rest-api-框架/ 2
3. Top 10 Python Frameworks for Web Development：https://blog.projecthelena.com/blog/top-10-python-frameworks-web-development-2024/ 3
4. Top Python Frameworks for Web Development in 2025：https://www.techtootalk.com/article/top-python-frameworks-for-web-development-in-2025 4
5. Which Is the Best Python Web Framework：https://blog.jetbrains.com/pycharm/2025/02/django-flask-fastapi/ 5