首页 > 脚本专栏 > python > Python Web框架Django高级应用

Python开发从入门到精通：Web框架Django高级应用实战

2026-06-09 10:19:07 作者：程序山海

Django高级功能是指在Django框架基础上提供的高级特性,包括中间件、信号、缓存、表单验证、权限管理等,本文给大家介绍Python开发从入门到精通：Web框架Django高级应用,感兴趣的朋友一起看看吧

一、学习目标与重点

💡 学习目标：掌握Python Web框架Django的高级技巧，包括中间件、信号、缓存、表单验证、权限管理等；学习Django的高级功能；通过实战案例实现高级Web应用。
⚠️ 学习重点：中间件、信号、缓存、表单验证、权限管理、Django高级功能、Web应用实战。

33.1 Django高级功能概述

33.1.1 什么是Django高级功能

Django高级功能是指在Django框架基础上提供的高级特性，包括中间件、信号、缓存、表单验证、权限管理等。这些功能可以帮助开发者更高效地开发复杂的Web应用程序。

33.1.2 高级功能的应用场景

中间件：处理HTTP请求和响应，如身份验证、日志记录等。
信号：实现应用程序各个组件之间的通信。
缓存：提高应用程序的性能，减少数据库查询。
表单验证：验证用户输入的数据。
权限管理：控制用户对资源的访问权限。

33.2 中间件

33.2.1 什么是中间件

中间件是Django框架中的一个组件，用于处理HTTP请求和响应。中间件可以在请求到达视图函数之前或响应返回客户端之前执行特定的操作。

33.2.2 自定义中间件

# myapp/middleware.py
from django.http import HttpResponse
class SimpleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    def __call__(self, request):
        # 请求到达视图函数之前执行的操作
        print("请求到达视图函数之前")
        response = self.get_response(request)
        # 响应返回客户端之前执行的操作
        print("响应返回客户端之前")
        return response

33.2.3 注册中间件

# myproject/settings.py
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'myapp.middleware.SimpleMiddleware',
]

33.3 信号

33.3.1 什么是信号

信号是Django框架中的一个组件，用于实现应用程序各个组件之间的通信。当某个事件发生时，信号会发送一个通知，其他组件可以监听这个通知并执行相应的操作。

33.3.2 内置信号

Django提供了多种内置信号，如：

django.db.models.signals.pre_save：在保存模型之前发送。
django.db.models.signals.post_save：在保存模型之后发送。
django.db.models.signals.pre_delete：在删除模型之前发送。
django.db.models.signals.post_delete：在删除模型之后发送。

33.3.3 自定义信号

# myapp/signals.py
import django.dispatch
# 定义信号
my_signal = django.dispatch.Signal()

33.3.4 发送信号

# myapp/views.py
from myapp.signals import my_signal
def my_view(request):
    # 发送信号
    my_signal.send(sender=my_view, message="Hello, World!")
    return HttpResponse("信号已发送")

33.3.5 接收信号

# myapp/receivers.py
from django.dispatch import receiver
from myapp.signals import my_signal
@receiver(my_signal)
def my_receiver(sender, **kwargs):
    print("收到信号")
    print("发送者：", sender)
    print("参数：", kwargs)

33.3.6 注册信号

# myapp/apps.py
from django.apps import AppConfig
class MyAppConfig(AppConfig):
    name = 'myapp'
    def ready(self):
        import myapp.receivers

33.4 缓存

33.4.1 什么是缓存

缓存是一种提高应用程序性能的技术，通过存储经常访问的数据，减少数据库查询和计算的时间。Django提供了多种缓存后端，如Memcached、Redis等。

33.4.2 配置缓存

# myproject/settings.py
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
    }
}

33.4.3 使用缓存

# myapp/views.py
from django.core.cache import cache
from django.http import HttpResponse
def my_view(request):
    # 从缓存中获取数据
    data = cache.get('my_data')
    if data is None:
        # 缓存未命中，从数据库中获取数据
        data = "Hello, World!"
        # 将数据存入缓存，有效期为60秒
        cache.set('my_data', data, 60)
    return HttpResponse(data)

33.5 表单验证

33.5.1 自定义表单验证

# myapp/forms.py
from django import forms
class MyForm(forms.Form):
    name = forms.CharField(label='姓名', max_length=100)
    email = forms.EmailField(label='邮箱')
    def clean_name(self):
        name = self.cleaned_data['name']
        if len(name) < 2:
            raise forms.ValidationError('姓名长度不能少于2个字符')
        return name
    def clean_email(self):
        email = self.cleaned_data['email']
        if not email.endswith('@example.com'):
            raise forms.ValidationError('邮箱必须以@example.com结尾')
        return email

33.5.2 使用表单验证

# myapp/views.py
from myapp.forms import MyForm
from django.shortcuts import render, redirect
def my_view(request):
    if request.method == 'POST':
        form = MyForm(request.POST)
        if form.is_valid():
            name = form.cleaned_data['name']
            email = form.cleaned_data['email']
            return redirect('success')
    else:
        form = MyForm()
    return render(request, 'myapp/my_form.html', {'form': form})

33.6 权限管理

33.6.1 自定义权限

# myapp/models.py
from django.db import models
from django.contrib.auth.models import Permission
class MyModel(models.Model):
    name = models.CharField(max_length=100)
    class Meta:
        permissions = [
            ('can_view', 'Can view my model'),
            ('can_edit', 'Can edit my model'),
            ('can_delete', 'Can delete my model'),
        ]

33.6.2 分配权限

# myapp/admin.py
from django.contrib import admin
from myapp.models import MyModel
@admin.register(MyModel)
class MyModelAdmin(admin.ModelAdmin):
    list_display = ['name']

33.6.3 检查权限

# myapp/views.py
from myapp.models import MyModel
from django.contrib.auth.decorators import permission_required
from django.shortcuts import render
@permission_required('myapp.can_view')
def my_view(request):
    data = MyModel.objects.all()
    return render(request, 'myapp/my_view.html', {'data': data})

33.7 实战案例：博客系统

33.7.1 需求分析

开发一个博客系统，支持以下功能：

文章的CRUD操作。
文章分类管理。
评论管理。
权限管理。

33.7.2 代码实现

33.7.2.1 数据模型

# myapp/models.py
from django.db import models
from django.contrib.auth.models import User
class Category(models.Model):
    name = models.CharField(max_length=100)
    def __str__(self):
        return self.name
class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    def __str__(self):
        return self.title
class Comment(models.Model):
    article = models.ForeignKey(Article, on_delete=models.CASCADE)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    def __str__(self):
        return f"{self.author.username} - {self.article.title}"

33.7.2.2 序列化器

# myapp/serializers.py
from rest_framework import serializers
from myapp.models import Category, Article, Comment
class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = "__all__"
class ArticleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Article
        fields = "__all__"
class CommentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Comment
        fields = "__all__"

33.7.2.3 视图函数

# myapp/views.py
from rest_framework import viewsets, permissions
from rest_framework.authentication import TokenAuthentication
from myapp.models import Category, Article, Comment
from myapp.serializers import CategorySerializer, ArticleSerializer, CommentSerializer
class CategoryViewSet(viewsets.ModelViewSet):
    queryset = Category.objects.all()
    serializer_class = CategorySerializer
    authentication_classes = [TokenAuthentication]
    permission_classes = [permissions.IsAuthenticated]
class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    authentication_classes = [TokenAuthentication]
    permission_classes = [permissions.IsAuthenticated]
class CommentViewSet(viewsets.ModelViewSet):
    queryset = Comment.objects.all()
    serializer_class = CommentSerializer
    authentication_classes = [TokenAuthentication]
    permission_classes = [permissions.IsAuthenticated]

33.7.2.4 路由配置

# myapp/urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from myapp.views import CategoryViewSet, ArticleViewSet, CommentViewSet
router = DefaultRouter()
router.register(r"categories", CategoryViewSet)
router.register(r"articles", ArticleViewSet)
router.register(r"comments", CommentViewSet)
urlpatterns = [
    path("", include(router.urls)),
]

33.7.2.5 项目路由配置

# myproject/urls.py
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
    path("admin/", admin.site.urls),
    path("api/", include("myapp.urls")),
]

33.7.3 实施过程

安装Django和Django REST framework。
创建项目和应用。
定义数据模型。
编写序列化器。
编写视图函数。
配置路由。
运行应用。

33.7.4 最终效果

通过博客系统，我们可以实现以下功能：

文章的CRUD操作。
文章分类管理。
评论管理。
权限管理。

总结

✅ 本文详细介绍了Python Web框架Django的高级技巧，包括中间件、信号、缓存、表单验证、权限管理等；学习了Django的高级功能；通过实战案例实现了博客系统。
✅ 建议读者在学习过程中多练习，通过编写代码加深对知识点的理解。

到此这篇关于Python开发从入门到精通：Web框架Django高级应用实战的文章就介绍到这了,更多相关Python Web框架Django高级应用内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！