从零开始学 Python：Web 后端开发全实战（核心框架 + 2 大业务场景）

在 Web 开发领域，Python 凭借简洁的语法、丰富的生态框架，成为后端开发的热门选择。无论是轻量级快速开发的Flask、全栈一站式解决方案的Django，还是高性能异步的FastAPI，都能满足不同规模、不同场景的 Web 后端需求。

本文将从 Python Web 后端的核心框架入手，详细讲解Flask（轻量级快速开发）、Django（全栈企业级开发），以及配套技术（SQLAlchemy、MySQL、Redis）的核心用法，再通过 2 个落地实战场景（Flask 搭建待办事项 API、Django 开发博客系统），帮你从零基础掌握 Python Web 后端开发，实现从 “框架入门” 到 “项目落地” 的跨越。

一、Web 后端核心框架与配套技术

Python Web 生态成熟，框架和配套工具各司其职，覆盖从快速原型到企业级项目的全流程需求，其中Flask、Django、FastAPI是最主流的三大后端框架。

前置条件：安装核心依赖

# 安装核心框架与配套技术
pip install flask django fastapi uvicorn sqlalchemy pymysql redis python-dotenv

1.1 Flask：轻量级灵活框架

Flask是一款微框架（Micro Framework），核心只提供路由、请求 / 响应处理、模板渲染等基础功能，无强制依赖，可通过扩展插件（Flask-SQLAlchemy、Flask-JWT）灵活扩展功能，适合快速开发小型项目、API 接口、原型验证。

核心特性与基础用法

1.1.1 最小化 Flask 应用（Hello World）

# app.py
from flask import Flask

# 初始化Flask应用实例
app = Flask(__name__)

# 定义路由：绑定URL与视图函数
@app.route("/")
def hello_world():
    """根路径视图函数，返回响应内容"""
    return "
Hello Flask! 这是我的第一个Web应用
"

if __name__ == "__main__":
    # 启动开发服务器，debug=True开启调试模式（开发环境专用）
    app.run(debug=True, host="0.0.0.0", port=5000)

运行命令：python app.py，访问 http://localhost:5000 即可看到响应结果。

1.1.2 核心功能：路由、请求 / 响应处理

Flask 的核心是处理 HTTP 请求与响应，支持GET、POST、PUT、DELETE等常用请求方法，可轻松获取请求参数、返回 JSON 数据。

# app.py
from flask import Flask, request, jsonify

app = Flask(__name__)

# 1. 带参数的路由（URL路径参数）
@app.route("/user/")
def get_user(user_id):
    """获取用户信息，URL参数限定为整数类型"""
    return jsonify({
        "code": 200,
        "message": "success",
        "data": {"user_id": user_id, "username": f"user_{user_id}"}
    })

# 2. 处理不同HTTP请求方法（GET获取/POST创建）
@app.route("/todo", methods=["GET", "POST"])
def todo_operation():
    """待办事项操作：GET查询，POST创建"""
    if request.method == "GET":
        # 获取GET请求查询参数（如：/todo?page=1&size=10）
        page = request.args.get("page", 1, type=int)
        size = request.args.get("size", 10, type=int)
        return jsonify({
            "code": 200,
            "message": "查询成功",
            "data": {"page": page, "size": size, "todos": []}
        })
    
    elif request.method == "POST":
        # 获取POST请求体（JSON格式）
        todo_data = request.get_json()  # 要求请求头Content-Type: application/json
        if not todo_data or not todo_data.get("title"):
            return jsonify({"code": 400, "message": "标题不能为空"}), 400
        
        # 模拟创建待办事项
        todo = {
            "id": 1,
            "title": todo_data["title"],
            "content": todo_data.get("content", ""),
            "status": "pending"
        }
        return jsonify({"code": 201, "message": "创建成功", "data": todo}), 201

if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=5000)

1.1.3 进阶功能：蓝图（Blueprint）- 模块化拆分

当项目规模扩大时，单一文件会变得臃肿，Flask 的蓝图（Blueprint） 支持将功能模块拆分，实现路由隔离、代码解耦，是 Flask 项目模块化的核心方案。

步骤 1：拆分蓝图模块（创建todo模块）

# 创建目录结构
# ├── app.py
# └── todos
#     ├── __init__.py
#     └── views.py

# todos/views.py
from flask import Blueprint, jsonify, request

# 1. 创建蓝图实例，指定蓝图名称与URL前缀
todo_bp = Blueprint("todo", __name__, url_prefix="/api/todos")

# 2. 蓝图中定义路由（URL自动拼接前缀：/api/todos + /）
@todo_bp.route("/", methods=["GET"])
def get_all_todos():
    """查询所有待办事项"""
    return jsonify({
        "code": 200,
        "message": "查询成功",
        "data": [{"id": 1, "title": "学习Flask", "status": "pending"}]
    })

@todo_bp.route("/", methods=["GET", "PUT", "DELETE"])
def todo_detail(todo_id):
    """待办事项详情：查询、更新、删除"""
    if request.method == "GET":
        return jsonify({
            "code": 200,
            "message": "查询成功",
            "data": {"id": todo_id, "title": "学习Flask", "status": "pending"}
        })
    elif request.method == "PUT":
        todo_data = request.get_json()
        return jsonify({
            "code": 200,
            "message": "更新成功",
            "data": {"id": todo_id, **todo_data}
        })
    elif request.method == "DELETE":
        return jsonify({"code": 200, "message": "删除成功"}), 200

步骤 2：在主应用中注册蓝图

# app.py
from flask import Flask
from todos.views import todo_bp

app = Flask(__name__)

# 注册蓝图（将todo模块挂载到主应用）
app.register_blueprint(todo_bp)

@app.route("/")
def index():
    return "
Flask蓝图示例：待办事项API
"

if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=5000)

运行后可访问蓝图路由：http://localhost:5000/api/todos，实现了模块的解耦与复用。

1.2 Django：全栈式企业级框架

Django是一款全栈框架（Full-Stack Framework），遵循 “电池已内置” 的设计理念，提供了 ORM 数据库操作、Admin 后台管理、表单验证、权限管理、中间件等一站式功能，无需额外整合第三方插件即可快速搭建企业级 Web 应用，适合开发博客、电商、管理系统等复杂项目。

核心特性

1. ORM（对象关系映射）：无需编写原生 SQL，通过 Python 类操作数据库，支持多种数据库（MySQL、PostgreSQL 等）；
2. Admin 后台：自动生成数据管理后台，无需手动开发 CRUD 操作；
3. 认证与权限：内置用户注册、登录、权限控制功能；
4. 中间件：处理请求 / 响应的全局钩子，支持日志、认证、跨域等全局功能；
5. URL 路由分发：支持复杂的路由配置与反向解析。

基础用法：快速搭建 Django 项目

步骤 1：创建 Django 项目与应用

# 1. 创建Django项目（blog_project为项目名）
django-admin startproject blog_project

# 2. 进入项目目录
cd blog_project

# 3. 创建应用（blog为应用名，对应具体业务模块）
python manage.py startapp blog

步骤 2：配置项目（blog_project/settings.py）

# 1. 注册应用（将blog应用添加到INSTALLED_APPS）
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog',  # 注册自定义应用
]

# 2. 配置数据库（默认SQLite，改为MySQL）
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'blog_db',  # 数据库名（需提前创建）
        'USER': 'root',  # 数据库用户名
        'PASSWORD': 'your_mysql_password',  # 数据库密码
        'HOST': 'localhost',  # 数据库地址
        'PORT': '3306',  # 数据库端口
        'CHARSET': 'utf8mb4',
    }
}

# 3. 配置中文与时区
LANGUAGE_CODE = 'zh-hans'
TIME_ZONE = 'Asia/Shanghai'
USE_I18N = True
USE_TZ = False

步骤 3：定义 ORM 模型（blog/models.py）

Django 的 ORM 通过Model类映射数据库表，无需手动创建表结构，通过迁移命令自动生成。

from django.db import models
from django.contrib.auth.models import User

class Article(models.Model):
    """文章模型"""
    title = models.CharField(max_length=200, verbose_name="文章标题")
    content = models.TextField(verbose_name="文章内容")
    author = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name="作者")
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")
    is_published = models.BooleanField(default=True, verbose_name="是否发布")

    class Meta:
        verbose_name = "文章"
        verbose_name_plural = "文章"
        ordering = ["-create_time"]  # 按创建时间倒序排列

    def __str__(self):
        return self.title

class Comment(models.Model):
    """评论模型"""
    article = models.ForeignKey(Article, on_delete=models.CASCADE, verbose_name="关联文章")
    user = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name="评论用户")
    content = models.CharField(max_length=500, verbose_name="评论内容")
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="评论时间")

    class Meta:
        verbose_name = "评论"
        verbose_name_plural = "评论"
        ordering = ["-create_time"]

    def __str__(self):
        return f"{self.user.username} 对 {self.article.title} 的评论"

步骤 4：数据库迁移与创建超级用户

# 1. 生成迁移文件（记录模型的变更）
python manage.py makemigrations

# 2. 执行迁移（创建/更新数据库表）
python manage.py migrate

# 3. 创建超级用户（用于登录Admin后台）
python manage.py createsuperuser

步骤 5：注册模型到 Admin 后台（blog/admin.py）

Django Admin 自动生成数据管理后台，注册模型后即可实现对数据的 CRUD 操作。

from django.contrib import admin
from .models import Article, Comment

# 注册文章模型
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
    # 后台列表显示字段
    list_display = ["title", "author", "create_time", "is_published"]
    # 搜索字段
    search_fields = ["title", "content"]
    # 筛选字段
    list_filter = ["is_published", "create_time"]

# 注册评论模型
@admin.register(Comment)
class CommentAdmin(admin.ModelAdmin):
    list_display = ["article", "user", "content", "create_time"]
    search_fields = ["content"]
    list_filter = ["create_time"]

步骤 6：启动 Django 开发服务器

python manage.py runserver 0.0.0.0:8000

访问 http://localhost:8000/admin，使用超级用户账号登录，即可看到已注册的文章和评论模型，实现可视化数据管理。

1.3 配套技术：ORM、数据库、缓存

1.3.1 SQLAlchemy：通用 ORM 框架

SQLAlchemy是一款独立于框架的通用 ORM 框架，支持多种数据库，提供了灵活的 SQL 操作方式，既可以使用 ORM 面向对象操作，也可以编写原生 SQL，常与Flask搭配使用（Flask-SQLAlchemy是其封装扩展）。

核心用法示例（Flask 整合 SQLAlchemy）：

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime

app = Flask(__name__)

# 配置数据库连接（SQLite，无需额外安装数据库）
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///todo.db"
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False

# 初始化SQLAlchemy
db = SQLAlchemy(app)

# 定义Todo模型
class Todo(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    content = db.Column(db.Text, nullable=True)
    status = db.Column(db.String(20), default="pending")
    create_time = db.Column(db.DateTime, default=datetime.now)

    def to_dict(self):
        """模型转字典，用于返回JSON数据"""
        return {
            "id": self.id,
            "title": self.title,
            "content": self.content,
            "status": self.status,
            "create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S")
        }

# 创建数据库表（在应用上下文中执行）
with app.app_context():
    db.create_all()

# 新增待办事项
@app.route("/todo/add", methods=["POST"])
def add_todo():
    from flask import request, jsonify
    data = request.get_json()
    new_todo = Todo(title=data["title"], content=data.get("content"))
    db.session.add(new_todo)
    db.session.commit()
    return jsonify({"code": 201, "message": "创建成功", "data": new_todo.to_dict()})

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

1.3.2 MySQL：关系型数据库

MySQL 是开源免费的关系型数据库，是 Web 后端开发的主流选择，Django 和 Flask 都能轻松整合。使用前需安装 MySQL 服务，并创建对应的数据库（如上述 Django 示例中的blog_db）。

1.3.3 Redis：高性能缓存

Redis 是一款高性能的键值对缓存数据库，支持多种数据结构（字符串、哈希、列表等），常用于缓存热点数据、存储会话信息、实现限流等，可大幅提升 Web 应用的响应速度。

核心用法示例（Python 操作 Redis）：

import redis

# 连接Redis（默认本地localhost:6379，无密码）
r = redis.Redis(host="localhost", port=6379, db=0, decode_responses=True)

# 1. 存储字符串（缓存热点数据）
r.set("todo:1:title", "学习Redis", ex=3600)  # ex=3600，过期时间1小时

# 2. 获取缓存数据
title = r.get("todo:1:title")
print(f"缓存数据：{title}")

# 3. 存储哈希数据（缓存用户信息）
r.hset("user:1001", mapping={"username": "张三", "age": 25})

# 4. 获取哈希数据
user_info = r.hgetall("user:1001")
print(f"用户信息：{user_info}")

1.3.4 FastAPI：高性能异步框架

FastAPI是一款基于 Python 异步语法（async/await）的高性能 Web 框架，支持自动生成 API 文档、数据验证、类型提示，性能接近 Node.js 和 Go，是构建高性能 API 接口的首选框架，尤其适合高并发场景。

最小化 FastAPI 示例：

from fastapi import FastAPI
from pydantic import BaseModel

# 初始化FastAPI应用
app = FastAPI(title="待办事项API", version="1.0.0")

# 定义数据模型（自动数据验证）
class TodoCreate(BaseModel):
    title: str
    content: str | None = None

# 定义路由
@app.get("/")
async def root():
    """异步视图函数"""
    return {"message": "Hello FastAPI"}

@app.post("/todos")
async def create_todo(todo: TodoCreate):
    """创建待办事项（自动验证请求数据）"""
    return {
        "code": 201,
        "message": "创建成功",
        "data": todo.dict()
    }

if __name__ == "__main__":
    import uvicorn
    # 启动FastAPI服务器
    uvicorn.run(app, host="0.0.0.0", port=8000)

运行后访问 http://localhost:8000/docs，可看到自动生成的交互式 API 文档，支持直接调试接口。

二、Web 实战场景 1：Flask 搭建「待办事项」API（增删改查）

场景需求

使用 Flask 搭建一套完整的待办事项（Todo）RESTful API，支持核心增删改查（CRUD）操作，整合 SQLAlchemy 操作数据库，实现数据的持久化存储，接口返回标准化 JSON 格式。

完整实现代码

步骤 1：项目目录结构

todo_api/
├── app.py          # 主应用入口
├── config.py       # 配置文件
└── todo.db         # SQLite数据库文件（自动生成）

步骤 2：配置文件（config.py）

# 数据库配置
SQLALCHEMY_DATABASE_URI = "sqlite:///todo.db"
SQLALCHEMY_TRACK_MODIFICATIONS = False
DEBUG = True

步骤 3：主应用实现（app.py）

from flask import Flask, jsonify, request
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
import config

# 1. 初始化Flask应用与SQLAlchemy
app = Flask(__name__)
app.config.from_object(config)
db = SQLAlchemy(app)

# 2. 定义Todo模型（ORM映射数据库表）
class Todo(db.Model):
    __tablename__ = "todos"

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    title = db.Column(db.String(200), nullable=False, comment="待办事项标题")
    content = db.Column(db.Text, nullable=True, comment="待办事项内容")
    status = db.Column(db.String(20), default="pending", comment="状态：pending/finished")
    create_time = db.Column(db.DateTime, default=datetime.now, comment="创建时间")
    update_time = db.Column(db.DateTime, default=datetime.now, onupdate=datetime.now, comment="更新时间")

    def to_dict(self):
        """模型对象转换为字典，用于接口返回"""
        return {
            "id": self.id,
            "title": self.title,
            "content": self.content,
            "status": self.status,
            "create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S"),
            "update_time": self.update_time.strftime("%Y-%m-%d %H:%M:%S")
        }

# 3. 创建数据库表（应用上下文内执行）
with app.app_context():
    db.create_all()

# 4. 定义标准化响应函数
def standard_response(code, message, data=None):
    """返回标准化JSON响应"""
    response = {
        "code": code,
        "message": message
    }
    if data is not None:
        response["data"] = data
    return jsonify(response)

# 5. 待办事项API：增删改查
@app.route("/api/todos", methods=["GET"])
def get_all_todos():
    """查询所有待办事项（支持状态筛选）"""
    # 获取查询参数
    status = request.args.get("status")
    # 构建查询条件
    query = Todo.query
    if status:
        query = query.filter_by(status=status)
    # 执行查询并排序
    todos = query.order_by(Todo.create_time.desc()).all()
    # 转换为字典列表
    todo_list = [todo.to_dict() for todo in todos]
    return standard_response(200, "查询成功", todo_list)

@app.route("/api/todos/", methods=["GET"])
def get_todo_detail(todo_id):
    """查询单个待办事项详情"""
    todo = Todo.query.get(todo_id)
    if not todo:
        return standard_response(404, "待办事项不存在")
    return standard_response(200, "查询成功", todo.to_dict())

@app.route("/api/todos", methods=["POST"])
def create_todo():
    """创建新的待办事项"""
    # 获取请求体数据
    request_data = request.get_json()
    if not request_data:
        return standard_response(400, "请求数据不能为空")
    # 验证必要字段
    title = request_data.get("title")
    if not title or len(title) == 0:
        return standard_response(400, "待办事项标题不能为空")
    # 创建待办事项
    new_todo = Todo(
        title=title,
        content=request_data.get("content"),
        status=request_data.get("status", "pending")
    )
    # 提交数据库
    try:
        db.session.add(new_todo)
        db.session.commit()
        return standard_response(201, "创建成功", new_todo.to_dict())
    except Exception as e:
        db.session.rollback()
        return standard_response(500, f"创建失败：{str(e)}")

@app.route("/api/todos/", methods=["PUT"])
def update_todo(todo_id):
    """更新待办事项"""
    todo = Todo.query.get(todo_id)
    if not todo:
        return standard_response(404, "待办事项不存在")
    # 获取请求体数据
    request_data = request.get_json()
    if not request_data:
        return standard_response(400, "请求数据不能为空")
    # 更新字段
    if "title" in request_data:
        todo.title = request_data["title"]
    if "content" in request_data:
        todo.content = request_data["content"]
    if "status" in request_data:
        todo.status = request_data["status"]
    # 提交数据库
    try:
        db.session.commit()
        return standard_response(200, "更新成功", todo.to_dict())
    except Exception as e:
        db.session.rollback()
        return standard_response(500, f"更新失败：{str(e)}")

@app.route("/api/todos/", methods=["DELETE"])
def delete_todo(todo_id):
    """删除待办事项"""
    todo = Todo.query.get(todo_id)
    if not todo:
        return standard_response(404, "待办事项不存在")
    # 提交数据库
    try:
        db.session.delete(todo)
        db.session.commit()
        return standard_response(200, "删除成功")
    except Exception as e:
        db.session.rollback()
        return standard_response(500, f"删除失败：{str(e)}")

# 6. 启动应用
if __name__ == "__main__":
    app.run(debug=config.DEBUG, host="0.0.0.0", port=5000)

使用说明与接口测试

1. 运行脚本：python app.py，启动 Flask 服务器；
2. 接口测试工具：可使用 Postman、curl 或浏览器插件，接口前缀为/api/todos；
3. 核心接口示例：
   • 创建待办事项：POST http://localhost:5000/api/todos，请求体 JSON：{"title": "学习Flask API", "content": "完成增删改查"}；
   • 查询所有待办事项：GET http://localhost:5000/api/todos；
   • 更新待办事项：PUT http://localhost:5000/api/todos/1，请求体 JSON：{"status": "finished"}；
   • 删除待办事项：DELETE http://localhost:5000/api/todos/1；
4. 数据持久化：所有操作都会保存到todo.db SQLite 数据库中，重启服务器后数据不会丢失。

核心亮点

1. 接口遵循 RESTful 规范，支持标准 HTTP 方法，返回格式统一；
2. 整合 SQLAlchemy 实现数据持久化，支持事务回滚，保证数据安全；
3. 包含数据验证与异常处理，提升接口的健壮性；
4. 代码结构清晰，便于后续扩展（如添加分页、缓存、权限控制）。

三、Web 实战场景 2：Django 开发博客系统（用户注册、文章发布、评论功能）

场景需求

使用 Django 开发一套简易博客系统，实现核心功能：「用户注册 / 登录」、「文章发布 / 编辑 / 展示」、「文章评论」，利用 Django 内置的认证系统、ORM、模板引擎，快速搭建全栈 Web 应用。

完整实现步骤与代码

步骤 1：项目初始化与配置（已在前文基础上扩展）

1.1 项目目录结构

blog_project/
├── blog/                  # 博客核心应用
│   ├── admin.py           # Admin后台配置
│   ├── apps.py
│   ├── forms.py           # 表单验证（新增）
│   ├── migrations/        # 数据库迁移文件
│   ├── models.py          # ORM模型
│   ├── templates/         # 模板文件（新增）
│   │   └── blog/
│   │       ├── article_list.html
│   │       ├── article_detail.html
│   │       ├── create_article.html
│   │       └── comment.html
│   ├── tests.py
│   ├── urls.py            # 应用路由（新增）
│   └── views.py           # 视图函数
├── blog_project/          # 项目配置
│   ├── asgi.py
│   ├── settings.py        # 项目配置
│   ├── urls.py            # 项目路由
│   └── wsgi.py
└── manage.py

1.2 配置项目路由（blog_project/urls.py）

from django.contrib import admin
from django.urls import path, include
from django.views.generic import RedirectView

urlpatterns = [
    path('admin/', admin.site.urls),
    # 重定向根路径到博客应用
    path('', RedirectView.as_view(pattern_name='article_list')),
    # 包含博客应用路由
    path('blog/', include('blog.urls')),
    # 包含Django内置认证路由（登录、注册、退出）
    path('accounts/', include('django.contrib.auth.urls')),
]

步骤 2：编写表单验证（blog/forms.py）

Django 表单用于前端数据验证与页面渲染，简化用户输入处理。

from django import forms
from .models import Article, Comment

class ArticleForm(forms.ModelForm):
    """文章发布/编辑表单"""
    class Meta:
        model = Article
        fields = ["title", "content", "is_published"]
        # 自定义表单控件属性
        widgets = {
            "title": forms.TextInput(attrs={"class": "form-control", "placeholder": "输入文章标题"}),
            "content": forms.Textarea(attrs={"class": "form-control", "rows": 10, "placeholder": "输入文章内容"}),
            "is_published": forms.CheckboxInput(attrs={"class": "form-check-input"}),
        }

class CommentForm(forms.ModelForm):
    """评论表单"""
    class Meta:
        model = Comment
        fields = ["content"]
        widgets = {
            "content": forms.TextInput(attrs={"class": "form-control", "placeholder": "输入你的评论"}),
        }
        labels = {
            "content": "",  # 隐藏标签
        }

步骤 3：编写视图函数（blog/views.py）

视图函数处理用户请求，实现业务逻辑，返回页面或数据。

from django.shortcuts import render, get_object_or_404, redirect
from django.contrib.auth.decorators import login_required
from django.contrib import messages
from .models import Article, Comment
from .forms import ArticleForm, CommentForm

# 1. 文章列表页
def article_list(request):
    """展示所有已发布的文章"""
    articles = Article.objects.filter(is_published=True).order_by("-create_time")
    context = {"articles": articles}
    return render(request, "blog/article_list.html", context)

# 2. 文章详情页
def article_detail(request, article_id):
    """展示文章详情与评论"""
    article = get_object_or_404(Article, id=article_id, is_published=True)
    comments = article.comment_set.all().order_by("-create_time")
    comment_form = CommentForm()

    # 处理评论提交
    if request.method == "POST" and request.user.is_authenticated:
        comment_form = CommentForm(request.POST)
        if comment_form.is_valid():
            new_comment = comment_form.save(commit=False)
            new_comment.article = article
            new_comment.user = request.user
            new_comment.save()
            messages.success(request, "评论提交成功！")
            return redirect("article_detail", article_id=article.id)

    context = {
        "article": article,
        "comments": comments,
        "comment_form": comment_form
    }
    return render(request, "blog/article_detail.html", context)

# 3. 创建文章（需登录）
@login_required(login_url="/accounts/login/")
def create_article(request):
    """发布新文章"""
    if request.method == "POST":
        form = ArticleForm(request.POST)
        if form.is_valid():
            article = form.save(commit=False)
            article.author = request.user  # 关联当前登录用户为作者
            article.save()
            messages.success(request, "文章发布成功！")
            return redirect("article_detail", article_id=article.id)
    else:
        form = ArticleForm()

    context = {"form": form}
    return render(request, "blog/create_article.html", context)

# 4. 编辑文章（需登录且为文章作者）
@login_required(login_url="/accounts/login/")
def edit_article(request, article_id):
    """编辑已发布的文章"""
    article = get_object_or_404(Article, id=article_id)

    # 验证是否为文章作者
    if article.author != request.user:
        messages.error(request, "你没有权限编辑这篇文章！")
        return redirect("article_list")

    if request.method == "POST":
        form = ArticleForm(request.POST, instance=article)
        if form.is_valid():
            form.save()
            messages.success(request, "文章更新成功！")
            return redirect("article_detail", article_id=article.id)
    else:
        form = ArticleForm(instance=article)

    context = {"form": form, "article": article}
    return render(request, "blog/create_article.html", context)

步骤 4：配置应用路由（blog/urls.py）

from django.urls import path
from . import views

urlpatterns = [
    # 文章列表
    path("articles/", views.article_list, name="article_list"),
    # 文章详情
    path("articles//", views.article_detail, name="article_detail"),
    # 创建文章
    path("articles/create/", views.create_article, name="create_article"),
    # 编辑文章
    path("articles//edit/", views.edit_article, name="edit_article"),
]

步骤 5：编写 HTML 模板（以article_list.html为例）

Django 模板引擎支持变量渲染、循环、条件判断，快速构建动态页面。

    
    
    


    

        

            
我的博客
            

                {% if user.is_authenticated %}
                    欢迎，{{ user.username }}！
                    发布文章
                    退出登录
                {% else %}
                    登录
                    注册
                {% endif %}
            
        

        


        

            {% for article in articles %}
                

                    
{{ article.title }}
                    
作者：{{ article.author.username }} | 发布时间：{{ article.create_time|date:"Y-m-d H:i:s" }}
                    
{{ article.content|truncatechars:200 }}
                    查看详情
                
            {% empty %}
                
暂无已发布的文章
            {% endfor %}
        
    

步骤 6：扩展用户注册功能（Django 内置认证无注册视图，需自定义）

# blog/views.py 新增注册视图
from django.contrib.auth.forms import UserCreationForm
from django.views.generic import CreateView
from django.urls import reverse_lazy

class RegisterView(CreateView):
    """用户注册视图"""
    form_class = UserCreationForm
    template_name = "registration/register.html"
    success_url = reverse_lazy("login")

# blog/urls.py 新增注册路由
path("register/", RegisterView.as_view(), name="register"),

# 新建模板 registration/register.html



    
    


    

        
用户注册
        
    

运行与使用说明

1. 数据库迁移与启动服务器：

   python manage.py makemigrations
   python manage.py migrate
   python manage.py runserver 0.0.0.0:8000
   

2. 功能访问：
   • 博客首页：http://localhost:8000，展示所有已发布文章；
   • 用户注册：http://localhost:8000/accounts/register/；
   • 用户登录：http://localhost:8000/accounts/login/；
   • 发布文章：登录后点击「发布文章」，填写标题与内容提交；
   • 文章详情与评论：点击文章标题进入详情页，登录后可提交评论；
3. Admin 后台：http://localhost:8000/admin，可管理文章、评论、用户。

核心亮点

1. 利用 Django 内置认证系统，快速实现用户注册 / 登录 / 退出，无需手动处理密码加密；
2. ORM 模型关联用户、文章、评论，实现数据的关联查询与存储；
3. 表单验证简化前端数据处理，提升应用的安全性；
4. 模板引擎实现动态页面渲染，代码复用性高；
5. 权限控制：仅文章作者可编辑文章，未登录用户无法发布 / 评论，保证应用安全。

四、总结

本文系统讲解了 Python Web 后端开发的核心框架与 2 个落地实战场景，核心要点总结如下：

1. 核心框架选型：
   • Flask：轻量级、灵活，适合小型项目、API 接口、原型验证，可通过扩展插件丰富功能；
   • Django：全栈式、企业级，内置 ORM、Admin、认证系统，适合复杂项目、管理系统，开发效率高；
   • FastAPI：高性能、异步，支持自动 API 文档，适合高并发、高性能 API 场景；
2. 配套技术：SQLAlchemy（通用 ORM）、MySQL（关系型数据库）、Redis（缓存）是 Web 后端开发的必备工具，可大幅提升应用的性能与可维护性；
3. 实战场景落地：
   • Flask 待办事项 API：掌握 RESTful 接口设计、数据持久化、异常处理，是后端 API 开发的基础；
   • Django 博客系统：掌握全栈 Web 应用开发流程，利用 Django 内置功能快速实现核心业务，降低开发成本；
4. 进阶方向：后续可学习接口权限认证（JWT）、跨域处理、文件上传、分布式部署、容器化（Docker），进一步提升 Web 应用的安全性、可扩展性与稳定性。