Django知识点总结

因为最近在搞一个Python项目，使用的Django框架。所以快速学习了一下这个web框架。并做一些总结。

Django官网的介绍：Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. Built by experienced developers, it takes care of much of the hassle of web development, so you can focus on writing your app without needing to reinvent the wheel. It's free and open source.

Django是一个高级Python web框架，它鼓励快速开发和清晰、实用的设计。由经验丰富的开发者构建，它处理了许多web开发的繁琐工作，这样你就可以专注于编写你的应用程序，而不需要重新发明轮子。

目录

1.Django项目结构

[2.Django 模型 (Models)](#2.Django 模型 (Models))

[3.Django 视图 (Views)](#3.Django 视图 (Views))

[4.Django 模板 (Templates)](#4.Django 模板 (Templates))

[5.Django 表单 (Forms)](#5.Django 表单 (Forms))

[6. Django URL 配置 (URL Configuration)](#6. Django URL 配置 (URL Configuration))

[7.Django 表单验证 (Form Validation)](#7.Django 表单验证 (Form Validation))

[8.Django 管理界面 (Admin Interface)](#8.Django 管理界面 (Admin Interface))

[9.Django 中间件 (Middleware)](#9.Django 中间件 (Middleware))

[10.Django 信号 (Signals)](#10.Django 信号 (Signals))

[11.Django 表单渲染与提交处理](#11.Django 表单渲染与提交处理)

[12.Django 静态文件和媒体管理](#12.Django 静态文件和媒体管理)

[13.Django 会话 (Sessions)](#13.Django 会话 (Sessions))

[14.Django 认证系统 (Authentication System)](#14.Django 认证系统 (Authentication System))

[15.Django 表单字段 (Form Fields)](#15.Django 表单字段 (Form Fields))

[16.Django 模板标签和过滤器 (Template Tags and Filters)](#16.Django 模板标签和过滤器 (Template Tags and Filters))

[17.Django 模型查询 (Model Queries)](#17.Django 模型查询 (Model Queries))

[18.Django 表单的自定义验证和错误消息](#18.Django 表单的自定义验证和错误消息)

[19.Django 测试框架 (Testing Framework)](#19.Django 测试框架 (Testing Framework))

[20.Django 国际化和本地化 (Internationalization and Localization)](#20.Django 国际化和本地化 (Internationalization and Localization))

21.Django安全性

[22. Django REST framework](#22. Django REST framework)

[23.Django 任务队列](#23.Django 任务队列)

[24.Django 邮件支持](#24.Django 邮件支持)

---

(由于内容太多，所以分成两篇，还有一篇，从25开始)

1.Django项目结构

件	描述
项目	Django 项目的顶级目录。
应用	一个应用是Web应用程序，它执行某项功能，并且可以独立于其他应用运行。
模型	用于定义数据结构（数据库中的表）。
视图	应用逻辑的核心，用于处理HTTP请求并返回HTTP响应。
模板	HTML文件，可以包含变量，用于生成动态的网页内容。
表单	用于创建HTML表单，处理用户输入。
URL分发器	Django URL分发器是URL和视图之间的映射。
设置	Django项目的配置文件。
管理界面	一个自动生成的管理界面，用于管理Django项目中的数据。
信号	Django信号允许某些发送者通知一组接收者发生了某件事情。
表单媒体	表单可能会用到的媒体文件，如CSS或JavaScript文件。

示例：

假设我们有一个博客应用，其结构可能如下：

myblog/

myblog/

init.py

settings.py

urls.py

asgi.py

wsgi.py

blog/

init.py

models.py

tests.py

views.py

admin.py

apps.py

migrations/

templates/

urls.py

manage.py

db.sqlite3

在这个示例中，myblog 是项目的根目录，它包含了一个同名的子目录，这是Django项目的常见布局。blog 是一个应用，它包含了所有的模型、视图、表单和模板等文件。settings.py 包含了项目的配置，urls.py 包含了URL分发器的定义。

2.Django 模型 (Models)

Django的模型用于定义应用程序的数据结构，它们是与数据库表相对应的Python类。

概念	描述
Field	代表数据库中的列，用于定义字段类型和选项。
Model	一个继承自django.db.models.Model的类，代表数据库中的一个表。
Meta	可选的类，用于定义模型的元数据，如排序选项、数据库表名等。
Manager	用于创建查询集的接口，可以自定义以提供额外的查询方法。
QuerySet	模型对象的集合，可以执行数据库查询。
Form	与模型相关联的表单，用于创建和管理用户输入。
Admin	Django管理界面中用于管理模型的接口。
Migrations	数据库迁移，用于在数据库中创建、修改或删除模型的表。

示例：

假设我们有一个博客应用，需要定义一个文章模型：

from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    published_date = models.DateTimeField(auto_now_add=True)
    last_modified = models.DateTimeField(auto_now=True)
    author = models.ForeignKey('auth.User', on_delete=models.CASCADE)

    def __str__(self):
        return self.title

    class Meta:
        ordering = ['-published_date']

这个示例中，Article 是一个模型，它定义了博客文章的数据结构。title、content、published_date 和 last_modified 是字段，分别对应数据库表中的列。author 是一个外键字段，它指向auth.User模型，表示文章的作者。Meta 类用于指定默认的排序方式。

3.Django 视图 (Views)

视图是Django应用的核心，用于处理HTTP请求并返回HTTP响应。视图可以是简单的Python函数，也可以是基于类的视图。

概念	描述
Function-based View (FBV)	基于函数的视图，使用Python函数处理请求。
Class-based View (CBV)	基于类的视图，使用Python类处理请求，提供可重用的视图组件。
HTTP Methods	视图可以处理的HTTP请求方法，如GET、POST、PUT、DELETE等。
Request Object	包含HTTP请求信息的对象，如请求头、请求体等。
Response Object	用于构造HTTP响应的对象，可以包含状态码、内容、头部等。
URLconf	URL配置，用于将URL路径映射到视图函数。
Template Rendering	使用模板生成HTML内容的过程。
Context	传递给模板的上下文数据，用于动态生成网页内容。
Form Handling	表单处理，包括显示表单和处理表单提交。
Generic View	预构建的基于类的视图，适用于常见的Web应用场景。

示例：

以下是一个简单的基于函数的视图，用于返回一个欢迎信息：

from django.http import HttpResponse

def welcome(request):
    name = request.GET.get('name', 'World')
    return HttpResponse(f"Hello, {name}!")

这个示例中，welcome 函数是一个视图，它从GET请求中获取name参数，并返回一个包含问候语的HttpResponse对象。

4.Django 模板 (Templates)

Django模板是一个强大的工具，用于生成动态的HTML内容。模板可以包含变量、标签和过滤器，用于控制页面的内容和显示。

概念	描述
变量	用于在模板中插入上下文数据。
标签	用于执行特定的操作，如循环、条件判断等。
过滤器	对变量进行处理，如格式化日期、转换为大写等。
继承	允许模板继承其他模板，共享布局和重复利用代码。
块	用于在继承的模板中定义可替换的区域。
自定义标签	创建自定义的模板标签，以封装复杂的逻辑。
模板继承	允许模板之间相互继承，实现布局的一致性。
上下文	传递给模板的数据，用于动态生成内容。
模板渲染	Django视图调用模板的过程，将上下文数据插入模板。

示例：以下是一个简单的Django模板示例，它显示一个列表和用户的姓名

<!DOCTYPE html>
<html>
<head>
    <title>My Webpage</title>
</head>
<body>
    <h1>Welcome, {{ user.name }}!</h1>
    <ul>
        {% for item in items %}
            <li>{{ item }}</li>
        {% endfor %}
    </ul>
</body>
</html>

这个示例中，{``{ user.name }} 是一个变量，它将从上下文中获取user对象的name属性。{% for item in items %} 是一个标签，它将遍历上下文中的items列表，并为每个元素生成一个列表项。

5.Django 表单 (Forms)

Django提供了一个强大的表单处理框架，用于创建、验证和处理HTML表单。

概念	描述
Form Class	Django表单类，用于定义表单的结构和验证规则。
Field	表单中的一个字段，对应HTML表单中的一个输入控件。
Widget	用于渲染字段的HTML控件，如文本框、复选框等。
Form Validation	表单提交后，Django将自动进行数据验证。
Bound Field	表单渲染后，每个字段都对应一个Bound Field对象。
Errors	表单验证失败时的错误信息。
Formsets	用于处理多个相同表单的集合。
ModelForm	一个特殊类型的表单，它与Django模型自动关联。
Media	表单可能需要的CSS和JavaScript文件。
Custom Validation	自定义验证方法，用于执行额外的验证逻辑。

示例： 以下是一个使用Django表单创建用户注册表单的示例

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

class UserRegistrationForm(forms.ModelForm):
    password = forms.CharField(widget=forms.PasswordInput)
    confirm_password = forms.CharField(widget=forms.PasswordInput)

    class Meta:
        model = User
        fields = ['username', 'email']

    def clean(self):
        cleaned_data = super().clean()
        password = cleaned_data.get("password")
        confirm_password = cleaned_data.get("confirm_password")

        if password and confirm_password and password != confirm_password:
            self.add_error('confirm_password', "Passwords do not match.")

这个示例中，UserRegistrationForm 是一个继承自ModelForm的表单类，它关联到Django内置的User模型。除了username和email字段外，表单还包括了password和confirm_password字段，用于验证密码是否匹配。

6. Django URL 配置 (URL Configuration)

URL配置是Django应用中用于将URL路径映射到视图函数的机制。

概念	描述
URL Pattern	用于匹配URL的模式，可以是字符串或正则表达式。
URL Resolver	解析器，用于将URL映射到视图。
URL Name	URL的名称，用于在模板和代码中引用特定的URL。
URLconf	URL配置文件，包含URL模式的列表。
Path	用于定义简单URL模式的函数。
Re_path	用于定义基于正则表达式的URL模式的函数。
Include	用于将其他URLconf包含到当前URLconf中。
Namespace	用于组织URL，允许多个应用使用相同的URL名称。
Reverse Resolution	从视图名称和参数解析出URL的过程。
URL Parameters	传递给视图的参数，可以是路径参数或查询参数。

示例：以下是Django项目的URL配置示例

from django.urls import path, include
from myapp.views import home_view, about_view, ArticleListView

urlpatterns = [
    path('', home_view, name='home'),
    path('about/', about_view, name='about'),
    path('articles/', include(('blog.urls', 'blog'), namespace='blog')),
]

这个示例中，path 函数用于定义URL模式，第一个参数是URL路径，第二个参数是视图函数，name 参数为URL提供一个唯一的标识符。include 函数用于将博客应用的URL配置包含到主URL配置中，并指定了一个命名空间blog。

7.Django 表单验证 (Form Validation)

Django表单提供了一套完整的验证机制，确保用户输入的数据符合预期的格式和规则。

概念	描述
内置验证	Django表单字段拥有一套默认的验证规则。
自定义验证	通过覆盖clean_<field_name>方法或使用clean方法来添加自定义验证逻辑。
错误消息	为验证错误提供自定义的错误消息。
必填字段	使用blank=False和null=False来标记必填字段。
字段类型	Django提供多种字段类型，如CharField、IntegerField等，每种类型都有其特定的验证规则。
最大长度/最小长度	使用max_length和min_length参数来限制输入的长度。
选择字段	使用choices参数来限制字段只能从预定义的选项中选择。
正则表达式验证	使用正则表达式来定义复杂的验证规则。
跨站请求伪造保护	Django表单自动提供了CSRF保护。
自定义错误信息	为每个字段的验证错误提供自定义的错误信息。

示例： 以下是自定义表单验证的示例

from django import forms
from django.core.exceptions import ValidationError

class SignupForm(forms.Form):
    username = forms.CharField()
    email = forms.EmailField()

    def clean_username(self):
        username = self.cleaned_data.get('username')
        if len(username) < 4:
            raise ValidationError('Username must be at least 4 characters long.')
        return username

    def clean(self):
        cleaned_data = super().clean()
        username = cleaned_data.get('username')
        email = cleaned_data.get('email')
        if username and User.objects.filter(username=username).exists():
            raise ValidationError('Username is already taken.')
        if email and User.objects.filter(email=email).exists():
            raise ValidationError('Email is already registered.')
        return cleaned_data

这个示例中，SignupForm 表单通过覆盖clean_username方法来确保用户名至少有4个字符。clean方法则用于检查用户名和邮箱是否已经存在。

8.Django 管理界面 (Admin Interface)

Django的管理界面是一个自动生成的基于Web的界面，用于管理Django项目中的数据。

概念	描述
Django Admin	Django提供的管理界面，用于管理数据库中的内容。
ModelAdmin	用于自定义模型在管理界面中的表示方式的类。
AdminSite	管理站点的顶级对象，可以创建自定义的管理界面。
Inlines	在管理界面中，将相关对象以内联形式编辑的方式。
Filters	在管理界面中添加筛选器，方便用户筛选查找数据。
Actions	为管理界面的变更列表页面提供批量操作。
Custom Templates	使用自定义模板来修改管理界面的外观。
User Authentication	管理界面具有用户认证和权限控制。
Modules	管理界面中的模块，通常对应一个模型或一组相关对象。
Views	管理界面提供的各种视图，如列表视图、添加视图、更改视图等。

示例：以下是如何为Article模型自定义管理界面的示例

from django.contrib import admin
from .models import Article

class ArticleAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'published_date')
    list_filter = ('author', 'published_date')
    search_fields = ('title', 'content')

admin.site.register(Article, ArticleAdmin)

这个示例中，ArticleAdmin类定义了Article模型在管理界面中的显示方式。list_display属性定义了列表视图中显示哪些字段，list_filter添加了筛选器，而search_fields允许在管理界面中搜索文章。

9.Django 中间件 (Middleware)

Django中间件提供了一种机制，可以在请求和响应的处理过程中添加自定义的处理逻辑。

概念	描述
请求中间件	在Django处理请求之前运行的中间件。
响应中间件	在Django处理完请求并生成响应之后，发送到浏览器之前运行的中间件。
Middleware Classes	中间件类，需要实现特定的方法来定义中间件的行为。
Middleware Stack	中间件的执行顺序，可以通过设置文件进行配置。
自定义中间件	创建自定义的中间件类以添加特定的功能。
Middleware Signals	Django的信号机制，可以在中间件中使用。
Middleware Security	中间件可以用于提高应用的安全性，如CSRF保护。
Middleware Session	用于处理会话的中间件。
Middleware Process View	用于在视图处理请求之前或之后运行的中间件。
Middleware Exception	用于处理异常的中间件。

示例：以下是创建自定义中间件的示例

class MyCustomMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # 这里可以添加处理逻辑
        response = self.get_response(request)
        return response

    # 可选：处理请求之前
    def process_view(self, request, view_func, view_args, view_kwargs):
        return None  # 或者返回一个HttpResponse对象

    # 可选：处理请求之后
    def process_response(self, request, response):
        return response

这个示例中，MyCustomMiddleware 是一个简单的中间件类，它在请求处理管道中可以插入自定义逻辑。__call__ 方法会在请求处理之前运行，而process_view和process_response方法则分别在视图处理之前和之后运行。

10.Django 信号 (Signals)

Django的信号允许某些发送者通知一组接收者发生了某件事情。这是一种实现解耦的方法，可以在Django的生命周期事件中添加自定义逻辑。

概念	描述
信号	Django中的一种机制，允许在特定事件发生时执行自定义代码。
发送者	触发信号的对象。
接收者	信号的回调函数，定义了当信号发生时要执行的代码。
连接信号	将接收者函数连接到特定信号上的过程。
内置信号	Django提供的一系列内置信号，如post_save、pre_delete等。
自定义信号	创建自定义信号以在特定业务逻辑中使用。
信号调度器	Django内部用于调度信号的组件。
信号参数	信号可以传递给接收者的参数，通常是触发信号的对象。
信号禁用	在某些情况下临时禁用信号。

示例：以下是如何使用Django信号的示例

from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Article

@receiver(post_save, sender=Article)
def update_search_index(sender, instance, **kwargs):
    # 当Article对象被保存后，更新搜索索引
    pass

这个示例中，我们连接了一个名为update_search_index的接收者函数到Article模型的post_save信号上。这意味着每当有一个新的Article对象被保存时，update_search_index函数就会被调用

11.Django 表单渲染与提交处理

Django表单不仅用于收集用户输入，还包括渲染成HTML以及处理表单提交的逻辑。

概念	描述
表单渲染	将表单对象转换成HTML的过程，用于在客户端显示。
表单提交	用户填写表单并发送到服务器的过程。
表单绑定	将提交的数据绑定到表单对象上，以便于进行验证。
表单无效	如果表单验证失败，表单对象会标记为无效，并收集错误信息。
表单有效	如果表单验证通过，表单对象会标记为有效。
错误收集	收集表单中所有字段的验证错误。
表单重渲染	当表单无效时，需要将表单连同错误信息重新渲染给用户。
GET请求与表单	使用GET请求预填充表单数据。
POST请求与表单	使用POST请求提交表单数据。

示例： 以下是如何在Django视图中渲染和处理表单的示例

from django.http import HttpResponse
from django.shortcuts import render
from .forms import ContactForm

def handle_contact_form(request):
    if request.method == 'POST':
        form = ContactForm(request.POST)
        if form.is_valid():
            # 处理有效的表单数据
            form.save()
            return HttpResponse("Thanks for your message!")
    else:
        form = ContactForm()

    return render(request, 'contact.html', {'form': form})

这个示例中，当用户通过POST方法提交表单时，我们创建了一个绑定到请求POST数据的表单对象。如果表单有效，我们处理表单数据并返回一个响应。如果表单无效，我们重新渲染表单，并将表单对象及其错误信息传递给模板。

12.Django 静态文件和媒体管理

在Web开发中，静态文件（如CSS、JavaScript文件）和媒体文件（如图片、视频）是构成用户界面和提供附加内容的重要组成部分。Django提供了管理这些文件的机制。

概念	描述
静态文件	指在Web开发中通常不会频繁改变的文件，如CSS、JavaScript文件。
媒体文件	指用户上传的文件，如图片、文档等。
STATIC_URL	设置静态文件的URL前缀。
STATICFILES_DIRS	在开发过程中，指定额外的目录，Django将这些目录中的文件视为静态文件。
STATIC_ROOT	在生产环境中，指定一个根目录，Django会将所有的静态文件收集到这里。
媒体URL和MEDIA_ROOT	类似于静态文件的设置，但用于媒体文件。
收集静态	使用collectstatic命令将所有静态文件收集到STATIC_ROOT指定的目录下。
管理媒体文件	Django提供了一个管理界面来上传和管理媒体文件。
自定义存储	使用自定义的存储后端来处理静态和媒体文件的存储逻辑。

示例： 以下是如何在Django中设置静态文件和媒体文件的示例

# settings.py

# 指定静态文件的URL前缀和根目录
STATIC_URL = '/static/'
STATICFILES_DIRS = [
    BASE_DIR / "static",  # 开发过程中的静态文件目录
]

# 指定媒体文件的URL前缀和根目录
MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR / "media"  # 媒体文件的文件系统路径

这个示例中，我们设置了静态文件和媒体文件的URL前缀以及它们在开发过程中的目录。在生产环境中，通常会使用像Amazon S3或CDN这样的服务来托管这些文件。

推荐直接放在项目根目录下的static目录，当然也可以改变目录，比如自定义个其他目录(根目录下的common目录下的static目录)

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

STATIC_URL = "/static/"
STATIC_ROOT = os.path.join(BASE_DIR, "static")
STATICFILES_DIRS = [
    os.path.join(BASE_DIR, "common/static"),
]

13.Django 会话 (Sessions)

Django的会话框架提供了一种存储用户会话数据的方法，这些数据可以用来跟踪用户的状态。

概念	描述
会话	存储在服务器端的数据，用于跟踪用户的状态。
会话ID	用于标识用户会话的唯一标识符，通常存储在cookie中。
会话数据	用户会话的相关信息，如用户偏好、购物车内容等。
会话引擎	Django支持的会话后端，如数据库、缓存或文件。
设置会话	在视图或中间件中设置会话数据。
获取会话	从会话中读取数据。
删除会话	清除会话中的数据或结束整个会话。
会话超时	会话的有效期，超时后需要重新登录。
安全会话	使用HTTPS和安全的cookie标志来保护会话数据。

示例：以下是如何在Django中使用会话的示例

def set_session(request):
    request.session['mydata'] = 'This is a test.'

def get_session(request):
    mydata = request.session.get('mydata', 'Default value')
    return HttpResponse(mydata)

def clear_session(request):
    del request.session['mydata']
    return HttpResponse('Session data cleared')

这个示例中，我们展示了如何在视图中设置、获取和删除会话数据。会话数据存储在request.session字典中。

14.Django 认证系统 (Authentication System)

Django提供了一个强大的认证系统，用于管理用户认证、权限和用户组。

概念	描述
用户模型	Django默认使用auth.User模型，也可以自定义用户模型。
认证	验证用户身份的过程。
权限	控制用户对视图、模板或其他资源的访问。
用户组	允许将权限分配给一组用户。
信号	Django认证系统发出的信号，如user_logged_in。
密码管理	Django提供密码散列、密码验证和密码重置功能。
令牌认证	用于API的无状态认证机制。
会话认证	传统的基于cookie的认证机制。
自定义认证	创建自定义的认证后端。
多因素认证	可以集成多因素认证以增加安全性。

示例：以下是如何在Django中实现用户登录和注销的示例

from django.contrib.auth import authenticate, login, logout

def login_view(request):
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            return HttpResponse("You are logged in.")
        else:
            return HttpResponse("Invalid username or password.")
    else:
        return render(request, 'login.html')

def logout_view(request):
    logout(request)
    return HttpResponse("You are logged out.")

这个示例中，login_view函数处理用户登录，通过authenticate函数验证用户凭据，如果成功则使用login函数创建用户会话。logout_view函数使用logout函数结束用户会话。

15.Django 表单字段 (Form Fields)

Django表单框架提供了多种字段类型，用于处理不同类型的用户输入。

概念	描述
CharField	文本框，用于输入较短的文本。
EmailField	邮箱输入框，自动验证输入是否为有效的邮箱地址。
IntegerField	数字输入框，用于输入整数值。
DecimalField	十进制数输入框，用于处理小数值。
DateField	日期选择器，用于选择日期。
DateTimeField	日期和时间选择器，用于选择日期和时间。
ChoiceField	下拉菜单，从预定义的选项中选择一个值。
MultipleChoiceField	多选下拉菜单，允许选择多个值。
BooleanField	复选框，表示布尔值（True/False）。
FileField	文件上传控件，用于上传文件。
ImageField	图片上传控件，继承自FileField，用于上传图片文件。
TypedChoiceField	带类型检查的选项字段，确保选择的值是预期的类型。
SlugField	用于输入简洁的标识符，如URL的一部分。
URLField	输入框，用于输入URL地址，自动进行URL格式验证。

示例： 以下是如何在Django表单中使用不同字段类型的示例

from django import forms

class UserRegistrationForm(forms.Form):
    username = forms.CharField(label='Username', max_length=50)
    email = forms.EmailField(label='Email')
    age = forms.IntegerField(label='Age', min_value=18)
    birthdate = forms.DateField(label='Birth Date')
    password = forms.CharField(label='Password', widget=forms.PasswordInput)
    agree_terms = forms.BooleanField(label='Agree to Terms', required=True)
    favorite_color = forms.ChoiceField(label='Favorite Color', choices=[
        ('red', 'Red'),
        ('blue', 'Blue'),
        ('green', 'Green'),
    ])

这个示例中，我们定义了一个注册表单，包含了不同类型的字段，每个字段都通过forms.Field的相应类来创建。

16.Django 模板标签和过滤器 (Template Tags and Filters)

Django模板系统提供了许多内置的标签和过滤器，用于在模板中执行常见的操作。

概念	描述
标签	用于执行特定的操作，如循环、条件判断等。
过滤器	用于对模板变量进行处理，如格式化、转换等。
自定义标签	创建自定义的模板标签，以封装复杂的逻辑。
自定义过滤器	创建自定义的过滤器，以执行特定的数据转换。
注释标签	在模板中添加注释，这些注释不会在渲染后的页面上显示。
URL标签	用于生成视图的URL，支持命名的URL模式。
循环标签	如for，用于在模板中遍历列表或字典。
条件标签	如if、else，用于在模板中实现条件逻辑。
转义过滤器	对输出进行HTML转义，防止跨站脚本攻击。
日期过滤器	对日期进行格式化。
字符串操作过滤器	如truncate、upper、lower等，用于操作字符串。

示例： 以下是如何在Django模板中使用标签和过滤器的示例

<!-- 使用for标签遍历一个列表 -->
<ul>
  {% for item in items %}
    <li>{{ item.name }}</li>
  {% endfor %}
</ul>

<!-- 使用if标签进行条件判断 -->
<p>{% if user.is_authenticated %}Welcome, {{ user.username }}!{% endif %}</p>

<!-- 使用url标签生成视图的URL -->
<a href="{% url 'home' %}">Home</a>

<!-- 使用过滤器格式化输出 -->
<p>Published on: {{ article.pub_date|date:"F j, Y" }}</p>

<!-- 使用自定义过滤器 -->
<p>Custom filter: {{ some_value|my_custom_filter }}</p>

这个示例中，for标签用于遍历一个名为items的上下文变量，if标签用于判断用户是否已认证，url标签用于生成视图的URL，而date过滤器用于格式化日期。

17.Django 模型查询 (Model Queries)

Django的ORM(Object-Relational Mapping)系统提供了一套强大的查询API，用于从数据库中检索和操作数据。

概念	描述
查询集 (QuerySet)	模型对象的集合，可以执行数据库查询。
筛选 (Filter)	用于筛选特定记录的查询。
排除 (Exclude)	用于排除特定记录的查询。
排序 (Ordering)	用于对查询结果进行排序。
聚合 (Aggregate)	用于执行字段的聚合操作，如求和、平均值等。
F对象	用于引用模型中的字段，常用于更新操作。
Q对象	用于实现复杂的查询。
迭代 (Iterate)	遍历QuerySet以获取模型实例。
计数 (Count)	计算QuerySet中的记录数。
切片 (Slice)	获取QuerySet中的子集。
更新 (Update)	更新数据库中的记录。
删除 (Delete)	从数据库中删除记录。

示例： 以下是如何使用Django模型查询的示例

from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=100)
    published_date = models.DateTimeField()

# 获取所有已发布的文章
published_articles = Article.objects.filter(published_date__lte=timezone.now())

# 获取标题包含"Django"的文章，排除标题为"Hello"的文章
filtered_articles = Article.objects.filter(title__icontains='django').exclude(title='Hello')

# 统计文章数量
article_count = Article.objects.count()

# 更新所有文章的标题
Article.objects.all().update(title='New Title')

# 删除标题为空的文章
Article.objects.filter(title='').delete()

这个示例中展示了如何使用Django的查询API来执行不同的数据库操作。

18.Django 表单的自定义验证和错误消息

Django表单框架允许开发者自定义表单字段的验证逻辑，并为验证失败的情况提供详细的错误消息。

概念	描述
自定义验证方法	在表单或表单字段类中定义额外的验证逻辑。
错误消息	为不同的验证错误指定自定义的错误消息。
错误信息对象	使用ErrorDict和ErrorList来处理表单和字段的错误信息。
跨字段验证	使用cleaned_data来在多个字段之间进行验证。
表单方法	覆盖表单类的方法，如clean、validate等，来添加验证逻辑。

示例：以下是如何在Django表单中实现自定义验证和错误消息的示

from django import forms
from django.core.exceptions import ValidationError

class CustomUserForm(forms.ModelForm):
    username = forms.CharField()
    email = forms.EmailField()

    class Meta:
        model = User
        fields = ['username', 'email']

    def clean_username(self):
        username = self.cleaned_data.get('username')
        if len(username) < 4:
            raise ValidationError('Username must be at least 4 characters long.')
        return username

    def clean(self):
        cleaned_data = super().clean()
        username = cleaned_data.get('username')
        email = cleaned_data.get('email')

        if not username.endswith('@example.com'):
            self.add_error('username', 'Username must end with @example.com')

        if User.objects.filter(email=email).exists():
            self.add_error('email', 'An account with this email already exists.')
        return cleaned_data

这个示例中，我们定义了一个CustomUserForm表单，它在clean_username方法中验证用户名长度，并在clean方法中进行跨字段验证，确保用户名以@example.com结尾，同时检查邮箱是否已存在。

19.Django 测试框架 (Testing Framework)

Django提供了一个强大的测试框架，用于编写和运行自动化测试，以确保应用的正确性和稳定性。

概念	描述
单元测试	对应用中最小的可测试部分进行测试，通常是模型或视图。
功能测试	对整个应用或特定功能进行测试，模拟用户与应用的交互。
测试客户端	Django提供的一个工具，用于模拟浏览器的行为。
测试数据库	Django测试框架支持多种数据库，可以在测试中使用特定的数据库。
断言	用于验证测试结果是否符合预期。
测试标记	用于标记测试用例，如@pytest.mark.django_db。
测试夹具	测试中使用的预设数据和环境配置。
测试覆盖率	衡量测试覆盖了多少代码的指标。
测试套件	一组测试用例的集合。
测试运行器	用于运行测试用例的工具。

示例： 以下是如何在Django中编写单元测试的示例

from django.test import TestCase
from .models import Article

class ArticleModelTest(TestCase):
    def setUp(self):
        # 创建测试夹具数据
        Article.objects.create(title='Test Article', content='This is a test.')

    def test_string_representation(self):
        # 测试模型的字符串表示
        article = Article.objects.get(id=1)
        self.assertEqual(str(article), 'Test Article')

    def test_article_content(self):
        # 测试文章内容
        article = Article.objects.get(id=1)
        self.assertEqual(article.content, 'This is a test.')

    def test_articles_created(self):
        # 测试创建的文章数量
        self.assertEqual(Article.objects.count(), 1)

这个示例中，ArticleModelTest类包含了针对Article模型的多个测试方法。setUp方法会在每个测试方法前运行，用于设置测试夹具。

20.Django 国际化和本地化 (Internationalization and Localization)

Django支持国际化和本地化，使得应用可以轻松地适应不同的语言和地区。

概念	描述
国际化 (Internationalization)	准备一个应用或文档，使其能够无障碍地适应不同的语言和地区，而不做代码级别的改变。
本地化 (Localization)	将国际化的应用或文档，根据特定语言和地区的需要进行调整。
gettext	Django使用的库，用于提取翻译字符串和实现翻译功能。
语言设置	Django支持动态地根据请求设置用户界面的语言。
翻译字符串	需要翻译的文本字符串。
.po 文件	包含翻译的文件，由gettext工具使用。
时区支持	Django支持不同地区的时区设置。
格式化	对日期、时间、数字等进行本地化格式化。
双语支持	应用支持多种语言的输入和显示。

示例： 以下是如何在Django中实现国际化和本地化的示例

1. 在settings.py中启用国际化，并设置默认语言：

USE_I18N = True
LANGUAGE_CODE = 'en-us'
USE_L10N = True  # 启用地区格式化，如日期和数字
TIME_ZONE = 'UTC'

2.使用makemessages命令从代码中提取翻译字符串：

python manage.py makemessages -l es

3. 创建或编辑.po文件，添加翻译：

msgid "Welcome to our site."

msgstr "Bienvenido a nuestro sitio."

4.在模板中使用翻译：

<p>{% trans "Welcome to our site." %}</p>

5. 在视图中动态设置语言：

def set_language(request):
    lang_code = request.GET.get('lang')
    if lang_code:
        request.session[LANGUAGE_SESSION_KEY] = lang_code
    return redirect('home')

这个示例中，我们展示了如何在Django中设置国际化支持，提取翻译字符串，以及如何在模板和视图中使用翻译。

21.Django安全性

Django设计时就考虑了安全性，提供了多种机制来保护Web应用。以下是Django安全性的关键点总结：

安全性特性	描述	示例
CSRF保护	Django自动为每个表单生成CSRF令牌，防止跨站请求伪造攻击。	在模板中使用 {% csrf_token %} 插入CSRF令牌。
XSS保护	Django模板自动转义HTML，防止跨站脚本攻击。	不需要特别操作，模板系统默认转义变量内容。
密码哈希	用户密码使用强哈希算法进行存储，而不是明文。	使用make_password函数创建哈希密码，check_password进行验证。
SQL注入保护	Django ORM自动转义查询参数，防止SQL注入攻击。	使用ORM查询构造器，如Article.objects.filter(pk=1)。
HTTPS强制	可以设置Django来强制使用HTTPS。	在settings.py中设置SECURE_SSL_REDIRECT = True。
用户认证	提供用户认证和权限控制。	使用@login_required装饰器限制视图的访问。
内容安全策略	可以通过设置来增强Web应用的CSP。	在settings.py中设置CSP_DEFAULT_SRC = ("'self'",)。
安全的Cookie	可以设置Cookie为仅通过HTTPS发送。	在settings.py中设置SESSION_COOKIE_SECURE = True。
点击劫持保护	Django提供中间件防止点击劫持攻击。	在settings.py中设置X_FRAME_OPTIONS = 'DENY'。
安全的密码重置	提供安全的密码重置流程，通过邮箱验证。	使用PasswordResetView和PasswordResetConfirmView。
用户权限	可以为用户分配不同的权限。	使用User.has_perm('app.label')检查权限。
用户组	用户可以归属于不同的组，方便权限管理。	使用Group和Group.objects.add()管理用户组。

以下是一些Django安全性特性的具体示例：

1. CSRF保护示例：在HTML模板中，使用Django模板标签来添加CSRF令牌。

<form method="post">
    {% csrf_token %}
    <input type="text" name="username">
    <input type="submit" value="Submit">
</form>

2.密码哈希示例： 使用Django内置的函数来创建和验证哈希密码。

from django.contrib.auth.hashers import make_password, check_password

hashed_password = make_password('mypassword')
# 存储hashed_password到数据库

# 在验证时
password = 'mypassword'
if check_password(password, hashed_password):
    print("Password is correct")
else:
    print("Password is incorrect")

3.HTTPS强制示例：

配置https的步骤：

3.1首先，你需要一个SSL证书。有两种主要类型的SSL证书：

付费证书：从证书颁发机构（CA）购买。

免费证书：可以使用Let's Encrypt，这是一个非营利组织，提供自动化的免费证书。

3.2配置Web服务器以使用SSL

对于Nginx，需要在server块中添加SSL配置。

server {
    listen 443 ssl;
    server_name www.yourdomain.com;

    ssl_certificate /path/to/your/cert.pem;
    ssl_certificate_key /path/to/your/key.pem;

    location / {
        proxy_pass http://unix:/path/to/your/project.sock;
        # 其他配置...
    }
}

3.3. 在项目中启用HTTPS

在settings.py中启用Django的HTTPS安全措施：

# 强制使用HTTPS重定向
SECURE_SSL_REDIRECT = True

# 如果用户已经通过HTTPS访问，则保持会话为HTTPS
SESSION_COOKIE_SECURE = True

# CSRF保护cookie也通过HTTPS发送
CSRF_COOKIE_SECURE = True

# 设置X-XSS-Protection标头
SECURE_BROWSER_XSS_FILTER = True

# 设置X-Content-Type-Options响应头为nosniff
SECURE_CONTENT_TYPE_NOSNIFF = True

# 如果使用Let's Encrypt，可以禁用此设置
SECURE_HSTS_SECONDS = 31536000  # 1 year
SECURE_HSTS_INCLUDE_SUBDOMAINS = True

4. 用户权限示例：限制视图只有拥有特定权限的用户才能访问。

from django.contrib.auth.decorators import permission_required

@permission_required('app.change_article', raise_exception=True)
def edit_article_view(request, article_id):
    # 视图逻辑

通过这些安全特性和示例，Django提供了一个安全的框架，帮助开发者构建安全的Web应用

22. Django REST framework

Django REST framework (DRF) 是一个强大的工具，用于构建Web API，以下是其关键特性的总结：

特性	描述	示例
序列化器 (Serializers)	用于将模型转换为JSON或其他内容类型，以及将输入数据反序列化为模型实例。	serializers.py文件 python class UserSerializer(serializers.ModelSerializer): class Meta: model = User fields = '__all__'
视图 (Views)	提供多种视图类来处理API请求，如列表视图、详情视图等。	views.py文件 python from rest_framework import views class UserListView(views.APIView):
视图集 (Viewsets)	用于简化API视图的创建，特别适合CRUD操作。	views.py文件 python from rest_framework import viewsets class UserViewSet(viewsets.ModelViewSet): queryset = User.objects.all() serializer_class = UserSerializer
路由 (Routing)	基于函数的路由系统，用于定义API的URL结构。	urls.py文件 python urlpatterns = [ path('users/', UserViewSet.as_view({'get': 'list', 'post': 'create'})),]
权限 (Permissions)	控制对API的访问，可以定义自定义权限类。	permissions.py文件 python class IsAdminOrReadOnly(BasePermission): def has_permission(self, request, view): return request.method in ['GET', 'HEAD', 'OPTIONS'] or request.user.is_admin
分页 (Pagination)	支持对API响应进行分页。	在视图或视图集中设置分页：pagination_class = PageNumberPagination
版本控制 (Versioning)	支持API版本的管理。	urls.py文件 python from rest_framework.versioning import NamespaceVersioning urlpatterns = NamespaceVersioning.urlpatterns(pattern)
认证 (Authentication)	提供多种认证方式，如基本认证、令牌认证等。	在视图中设置认证方式：authentication_classes = [SessionAuthentication, TokenAuthentication]
过滤 (Filtering)	支持对查询集进行过滤。	views.py:文件 python from rest_framework import generics class UserList(generics.ListAPIView): queryset = User.objects.all() filter_backends = [filters.SearchFilter] search_fields = ['username', 'email']
**关系 (Relations))	支持对模型关系的序列化。	在序列化器中定义关系：user = serializers.PrimaryKeyRelatedField(many=True)
验证 (Validation)	提供强大的数据验证机制。	在序列化器中使用validate_<field>方法进行自定义验证。
自定义 (Customization)	可以自定义序列化器、视图等组件。	创建自定义的序列化器类和视图类来满足特定的业务需求。

示例：以下是使用Django REST framework创建一个简单的用户API的示例

1.安装Django REST framework

pip install djangorestframework==3.13.1

2.配置Django settings(settings.py)

INSTALLED_APPS = [
    # ...
    'rest_framework',
]

3.创建一个简单的用户序列化器（serializers.py）

from rest_framework import serializers
from django.contrib.auth.models import User

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ('id', 'username', 'email')

4.创建一个视图以列出所有用户（views.py)

from rest_framework import generics
from django.contrib.auth.models import User
from .serializers import UserSerializer

class UserList(generics.ListAPIView):
    queryset = User.objects.all()
    serializer_class = UserSerializer

5.设置URL路由（urls.py)

from django.urls import path
from .views import UserList

urlpatterns = [
    path('users/', UserList.as_view()),
]

6,运行应用

启动Django开发服务器，并在浏览器或Postman中访问 http://localhost:8000/users/ 以查看用户列表。

通过以上步骤，你可以快速构建一个简单的用户API，这只是Django REST framework强大功能的一小部分。

23.Django 任务队列

知识点	描述	Django-Q 示例	Celery 示例
安装	安装任务队列库的必要步骤。	pip install django-q	pip install celery
配置	在settings.py中添加队列相关的配置。	添加到INSTALLED_APPS，配置数据库迁移。	设置Celery相关的配置，如broker_url。
任务定义	创建执行后台任务的函数。	使用标准的Python函数。	使用带有@task装饰器的函数。
任务调度	安排任务在特定时间执行。	使用schedule函数。	使用Celery Beat和定时任务调度。
异步任务	将任务提交到队列进行异步执行。	使用async_task函数。	使用delay方法。
任务执行	任务队列的工作进程执行任务。	使用qcluster命令启动工作进程。	使用celeryd命令启动工作进程。
结果存储	存储任务执行结果。	利用Django模型存储结果。	可以配置多种后端存储结果，如数据库、Redis。
任务重试	失败的任务可以被重试。	提供重试机制和超时设置。	提供重试策略和重试计数。
任务监控和管理	管理和监控任务队列的状态。	通过Django管理界面管理任务。	通常使用Celery自带的监控工具，如Flower。
信号和钩子	在任务执行前后执行额外逻辑。	提供信号如pre_enqueue和pre_execute。	使用Celery的事件和回调机制。
分布式支持	任务分布在多个工作节点上执行。	通过配置多个工作进程实现。	内置支持分布式系统，可以跨多个节点运行任务。
消息代理	中间件用于传递任务消息。	可选，支持多种后端如Redis。	依赖于外部的消息代理，如RabbitMQ或Redis。
定时任务	定时执行任务的能力。	支持cron表达式和固定间隔的调度。	支持复杂的定时任务，通过Celery Beat进行调度。
容错性和持久性	任务在执行过程中的容错处理。	任务持久化到数据库，支持故障转移。	支持任务持久化，具有强大的容错机制。
扩展性	根据需要扩展任务处理能力。	通过增加工作进程和利用多核处理器进行扩展。	通过增加工作节点和使用消息代理进行水平扩展。
文档和社区支持	项目文档的完整性和社区的活跃度。	相对较新的库，文档和社区正在增长。	成熟的库，拥有详尽的文档和活跃的社区支持

示例：给一个django-q的一个完整的示例

在 Django 项目的 settings.py 文件中，添加 django_q 到 INSTALLED_APPS：

INSTALLED_APPS = [
    # ...
    'django_q',
    # ...
]

接着，你可以配置 django-q 使用不同的后端，例如使用默认的数据库后端：

DJANGO_Q = {
    'default': 'django_q.db.models',  # 使用 Django ORM 作为队列后端
    'redis': {
        'BACKEND': 'django_q.backends.redis.RedisBackend',
        'OPTIONS': {
            'host': 'localhost',
            'port': 6379,
            'db': 0,
            'password': '',
        }
    },
    # 可以配置其它后端...
}

使用过程：

1.创建任务

创建一个任务函数，该函数将作为队列任务执行：

from django_q.models import Task, SUCCESS, FAILURE

def my_task():
    # 任务代码
    try:
        # 执行任务
        print("Task is running")
        return SUCCESS
    except Exception as e:
        return FAILURE, str(e)

2. 安排任务

使用 schedule 方法安排任务：

from django_q.models import Task

Task.function(my_task).enqueue()

或者，安排一个定时任务

from django_q.models import Task
from datetime import datetime, timedelta

scheduled_time = datetime.now() + timedelta(seconds=30)
Task.function(my_task).schedule(scheduled_time)

3.运行队列工作者

使用以下命令启动一个队列工作者：

python manage.py qcluster

4.查看任务状态

可以查看任务的状态，例如：

from django_q.models import Task

task = Task.objects.get(id=1)
if task.status == SUCCESS:
    print("Task succeeded!")
else:
    print("Task failed!")

5.重试失败的任务

如果任务失败，可以重试：

task.retry()

6.使用信号

django-q 提供了信号，允许你在任务开始、结束或失败时执行自定义逻辑。

from django_q import signals

def task_started(sender, task, **kwargs):
    print('Task started:', task)

signals.pre_save.connect(task_started)

注意事项：

• 队列工作者需要运行在你的服务器上，以监听并执行任务。
• 根据你的项目需求，可能需要配置多个工作者。
• django-q 也支持 Django 管理命令，如 qinit 初始化数据库、qstop 停止工作者等。

通过使用 django-q，你可以在 Django 应用中轻松地实现后台任务处理，而无需复杂的设置。

24.Django 邮件支持

Django提供了一个强大的邮件支持系统，允许开发者发送电子邮件。以下是Django邮件支持的关键特性和配置的总结表格：

特性	描述	示例
邮件后端	Django支持多种邮件后端，如SMTP、文件系统或内存缓存。	EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
SMTP邮件服务器	配置SMTP服务器的详细信息，包括邮箱地址、密码等。	EMAIL_HOST = 'smtp.example.com'
邮件发送	用于发送邮件的函数。	django.core.mail.send_mail(subject, message, from_email, recipient_list, fail_silently=False)
HTML邮件	发送HTML格式的邮件。	django.core.mail.send_html_mail(subject, message, from_email, recipient_list, html_message=html_content, fail_silently=False)
附件	向邮件添加附件。	django.core.mail.EmailMessage.attach_file(filename)
邮件模板	使用Django模板系统生成邮件内容。	使用django.template.loader.render_to_string生成邮件模板内容
邮件优先级	设置邮件的优先级。	django.core.mail.EmailMessage.priority
邮件头部	自定义邮件的头部信息。	django.core.mail.EmailMessage.extra_headers
邮件队列	Django可以将邮件排队，稍后一起发送以提高性能。	django.core.mail.get_connection().send_messages(emails)
邮件后端设置	配置邮件后端的额外选项，如使用TLS或SSL。	EMAIL_USE_TLS = True
默认从邮箱	设置默认发送邮件的邮箱地址。	EMAIL_HOST_USER = 'user@example.com'
密码	如果SMTP服务器需要认证，设置邮箱的密码。	EMAIL_HOST_PASSWORD = 'yourpassword'
邮件主题和收件人	设置邮件的"主题"和收件人列表。	send_mail('Subject', 'Message', 'from@example.com', ['to@example.com'], fail_silently=False)

示例：

以下是如何使用Django发送邮件的示例：

1. 配置邮件后端 ：在settings.py中配置邮件后端和SMTP服务器信息。

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'smtp.example.com'
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = 'user@example.com'
EMAIL_HOST_PASSWORD = 'yourpassword'

2.发送邮件：在视图或模型中发送邮件。

from django.core.mail import send_mail
from django.template.loader import get_template
from django.utils.html import strip_tags

# 发送简单邮件
send_mail(
    'Subject here',
    'Here is the message.',
    'from@example.com',
    ['to@example.com'],
    fail_silently=False,
)

# 使用模板发送邮件
template = get_template('emails/welcome_email.html')
context = {'name': 'xiaomifeng1010'}
message = template.render(context)
send_mail(
    'Welcome!',
    strip_tags(message),
    'from@example.com',
    ['to@example.com'],
    html_message=message,
)

3. 邮件模板 ：创建一个HTML邮件模板文件welcome_email.html。

<!DOCTYPE html>
<html>
<head>
    <title>Welcome Email</title>
</head>
<body>
    <h1>Hello {{ name }},</h1>
    <p>Welcome to our site!</p>
</body>
</html>

通过以上步骤，你可以在Django应用中实现邮件发送功能。邮件支持对于用户注册、密码重置、通知提醒等场景非常重要。

内容太多，分成了两部分，下一部分主要聚焦于总结Django整合多种认证方式