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

从零开始学 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 "<h1>Hello Flask! 这是我的第一个Web应用</h1>" 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/<int:user_id>") 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("/<int:todo_id>", 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 "<h1>Flask蓝图示例：待办事项API</h1>" 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/<int:todo_id>", 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/<int:todo_id>", 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/<int:todo_id>", 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/<int:article_id>/", views.article_detail, name="article_detail"), # 创建文章 path("articles/create/", views.create_article, name="create_article"), # 编辑文章 path("articles/<int:article_id>/edit/", views.edit_article, name="edit_article"), ] 

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

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

<!-- blog/templates/blog/article_list.html --> <!DOCTYPE html> <html lang="zh-CN"> <head> <meta charset="UTF-8"> <title>我的博客 - 文章列表</title> <style> .container { width: 80%; margin: 0 auto; } .article-item { margin: 20px 0; padding: 20px; border: 1px solid #eee; border-radius: 8px; } .nav { margin: 20px 0; display: flex; justify-content: space-between; } .btn { padding: 8px 16px; background: #007bff; color: white; text-decoration: none; border-radius: 4px; } .btn-secondary { background: #6c757d; } </style> </head> <body> <div> <div> <h1>我的博客</h1> <div> {% if user.is_authenticated %} <span>欢迎，{{ user.username }}！</span> <a href="{% url 'create_article' %}">发布文章</a> <a href="{% url 'logout' %}">退出登录</a> {% else %} <a href="{% url 'login' %}">登录</a> <a href="{% url 'register' %}">注册</a> {% endif %} </div> </div> <hr> <div> {% for article in articles %} <div> <h2><a href="{% url 'article_detail' article.id %}">{{ article.title }}</a></h2> <p>作者：{{ article.author.username }} | 发布时间：{{ article.create_time|date:"Y-m-d H:i:s" }}</p> <p>{{ article.content|truncatechars:200 }}</p> <a href="{% url 'article_detail' article.id %}">查看详情</a> </div> {% empty %} <p>暂无已发布的文章</p> {% endfor %} </div> </div> </body> </html> 

步骤 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 <!DOCTYPE html> <html lang="zh-CN"> <head> <meta charset="UTF-8"> <title>用户注册</title> </head> <body> <div> <h1>用户注册</h1> <form method="post"> {% csrf_token %} {{ form.as_p }} <button type="submit">注册</button> </form> </div> </body> </html> 

运行与使用说明

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

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

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

核心亮点

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 应用的安全性、可扩展性与稳定性。