在前一篇文章中，我们探讨了 Django 的 MVC 架构，尤其是路由和 URL 管理的关键概念。这些概念为我们提供了与用户交互的基础框架，现在，我们将深入到 Django 的数据层，具体地说，我们将学习如何创建 Django 模型。

什么是Django模型？

在 Django 中，模型是应用程序的数据结构，代表数据库中的一个表。每个模型由一个 Python 类定义，类的属性对应于表中的字段。Django 使用这些模型来处理数据库的交互。

例如，假设我们在开发一个图书管理系统，我们可能需要一个模型来表示每一本书的信息。以下是一个简单的 Book 模型示例：

1
2
3
4
5
6
7
8
9

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)  # 书名
    author = models.CharField(max_length=100)  # 作者
    published_date = models.DateField()  # 出版日期
    isbn = models.CharField(max_length=13, unique=True)  # ISBN号
    pages = models.IntegerField()  # 页数
    cover_image = models.ImageField(upload_to='covers/', blank=True, null=True)  # 封面图

在上面的代码中，我们定义了一个叫做 Book 的模型，它有几个字段（或属性）：

• title: 书名，存储为字符字段（CharField）。
• author: 作者，类似存储为字符字段。
• published_date: 出版日期，存储为日期字段（DateField）。
• isbn: 为每本书分配唯一的 ISBN 号。
• pages: 页面数量，以整数形式存储。
• cover_image: 封面图，允许上传图片。

创建模型

1. 在应用程序中定义模型

模型通常在 Django 应用的 models.py 文件中定义。可以根据实际需求创建不同的模型，并为它们添加适当的字段。

2. 数据库字段类型

常用的 Django 字段类型包括：

• CharField: 用于字符类型数据，必须设置 max_length 属性。
• TextField: 用于大文本。
• IntegerField: 存储整型数字。
• DateField: 存储日期。
• ImageField: 上传图片。

3. 验证与约束

可以在字段上添加验证和约束，例如，使用 unique=True 来确保字段的唯一性。其他验证参数包括 blank=False （表示该字段不能为空）和 null=True（允许该字段的值为 NULL）。

4. 自定义方法

在模型中，可以定义一些方法以处理与模型数据相关的操作。例如，添加一个返回书名和作者的字符串表示：

1
2

def __str__(self):
    return f"{self.title} by {self.author}"

通过这样的方式，当我们在 Django 管理后台中查看每本书时，我们会看到更友好的显示格式。

创建数据库迁移

创建和编辑完模型后，接下来需要进行数据库迁移，以便在数据库中生成相应的表。可以通过以下命令生成和应用迁移：

1. 生成迁移：

   1	python manage.py makemigrations

   这会生成一个包含模型变更的迁移文件。

2. 应用迁移：

   1	python manage.py migrate

   这将把生成的迁移应用到数据库中，实际创建表。

小案例：创建一个简单的书籍管理应用

以下是一个完整的案例，演示了如何创建一个简单的书籍管理应用。

1. 首先，在您的 Django 项目中创建一个新应用：

   1	python manage.py startapp library

2. 在 library/models.py 中定义 Book 模型：

   1 2 3 4 5 6 7 8 9 10 11 12

   from django.db import models class Book(models.Model): title = models.CharField(max_length=200) author = models.CharField(max_length=100) published_date = models.DateField() isbn = models.CharField(max_length=13, unique=True) pages = models.IntegerField() cover_image = models.ImageField(upload_to='covers/', blank=True, null=True) def __str__(self): return f"{self.title} by {self.author}"

3. 在 settings.py 中将新应用添加到 INSTALLED_APPS 列表中：

   1 2 3 4

   INSTALLED_APPS = [ # ... other apps ... 'library', ]

4. 生成并应用数据库迁移：

   1 2	python manage.py makemigrations library python manage.py migrate

5. 现在您可以通过 Django 管理后台来添加、编辑和删除书籍了（确保您已经创建了超级用户并设置了管理界面）。

总结

在本篇文章中，我们学习了 Django 模型的创建，包括模型的定义、字段的类型以及如何将模型迁移到数据库。这些都是构建 Django 应用程序的核心组件，并为后续的数据访问和操作奠定了基础。

在接下来的文章中，我们将探讨数据库迁移的详细内容，包括如何管理数据库的版本控制和如何执行数据迁移操作。

在上一篇中，我们讨论了如何在 Django 中创建模型，通过定义类来表示数据库中的表和字段。现在，我们将在此基础上进一步探索如何对这些模型进行数据库迁移。数据库迁移是在 Django 中同步模型和数据库结构的关键步骤。

什么是数据库迁移

数据库迁移是指将模型的变更（如添加、修改或删除字段）应用到数据库中。Django 提供了强大的迁移工具，使得这一过程变得高效和简单。

创建数据库迁移

当你创建或修改模型后，Django 需要知道如何将这些变化应用到数据库。这个过程一般分为以下几步：

1. 创建迁移: 使用命令 makemigrations 生成迁移文件。
2. 应用迁移: 使用命令 migrate 将迁移应用到数据库。

实例：创建迁移

假设在上一篇教程中，我们定义了一个 Book 模型，如下所示：

1
2
3
4
5
6
7

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=50)
    published_date = models.DateField()
    price = models.DecimalField(max_digits=5, decimal_places=2)

接下来，我们希望为 Book 模型添加一个新的字段 isbn，以存储图书的国际标准书号。这一步骤就是我们修改模型的开始。

1
2
3
4
5
6

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=50)
    published_date = models.DateField()
    price = models.DecimalField(max_digits=5, decimal_places=2)
    isbn = models.CharField(max_length=13, unique=True)  # 新添加的字段

生成迁移文件

保存模型后，打开终端并在项目根目录下运行以下命令：

1

python manage.py makemigrations

您将看到类似于以下的输出：

1
2
3

Migrations for 'your_app_name':
  your_app_name/migrations/0002_auto_20230301_1234.py
    - Add field isbn to book

此命令会生成一个迁移文件，记录对模型 Book 结构的改变。

应用迁移

接下来，我们需要将迁移应用到数据库中。运行以下命令：

1

python manage.py migrate

这时，Django 会根据迁移文件，在数据库中添加新字段 isbn。您会看到类似的输出：

1

Applying your_app_name.0002_auto_20230301_1234... OK

如何查看迁移状态

您可以使用以下命令来查看当前的迁移状态：

1

python manage.py showmigrations

这将列出您应用的所有迁移及其状态。

注意事项

• 迁移的顺序: Django 迁移是有顺序的，后续的迁移必须建立在前面的基础上。
• 合并迁移: 当多个迁移文件并行存在时，可能会导致迁移冲突。Django 提供了合并迁移的命令，用于解决这种情况。

清理迁移

在开发过程中，可能会需要重置迁移。在这种情况下，可以删除数据库和迁移文件，然后重新生成迁移。

例如，如果您希望重置 your_app_name 的所有迁移，可以执行以下命令：

1
2
3
4
5
6
7

# 删除迁移文件
rm your_app_name/migrations/0*.py
# 清空数据库
python manage.py flush
# 重新生成迁移
python manage.py makemigrations
python manage.py migrate

总结

在这一部分中，我们学习了如何为 Django 模型创建数据库迁移，并将模型的变化同步到数据库中。通过这个过程，我们可以灵活地管理数据库结构，使其与代码保持一致。

在接下来的教程中，我们将继续讨论与数据库结构管理相关的主题，探索如何管理和维护我们的数据库。

请继续关注《Django 模型之管理数据库结构》。

在上一篇文章中，我们深入探讨了Django模型中的数据库迁移。在这篇文章中，我们将继续前行，学习如何通过Django模型来管理数据库结构。数据库模型是Django应用的核心，它们定义了数据的结构和关系。我们将介绍如何创建、修改以及删除模型，从而有效地管理数据库结构。

创建Django模型

在Django中，模型是一个Python类，通常继承自django.db.models.Model。这些模型类定义了数据库表的结构及其字段。

示例：创建一个简单的模型

假设我们正在开发一个博客系统，我们可能会为每篇文章创建一个模型。以下是一个简单的Article模型的定义：

1
2
3
4
5
6
7
8
9

from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

在这个模型中，我们定义了三种字段：

• title： 文章标题，字符字段，最大长度为200个字符。
• content： 文章内容，文本字段，可以包含更多的文本。
• created_at： 文章创建时间，使用DateTimeField，并自动填充当前时间。

生成数据库迁移

当我们创建了模型后，Django需要生成数据库迁移来创建数据库表：

1

python manage.py makemigrations

此命令会检测到我们模型的变化，并在migrations文件夹中生成一个新的迁移文件。当我们的模型变化时，再次运行此命令以生成相应的迁移。

应用迁移

要应用这些迁移，包括创建我们新的Article表，可以使用以下命令：

1

python manage.py migrate

执行这个命令后，Django会根据生成的迁移文件更新数据库，创建相应的表。

修改Django模型

当我们的需求变化时，我们可能需要修改现有的模型。这可以包括添加新字段、修改字段类型等。假设我们希望给Article模型添加一个author字段，表示文章的作者：

1
2
3
4
5
6
7
8

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    author = models.CharField(max_length=100)  # 新增字段

    def __str__(self):
        return self.title

生成新的迁移

修改完模型后，生成新的迁移文件：

1

python manage.py makemigrations

这会生成一个新的迁移文件以反映我们的更改。然后应用迁移来更新数据库：

1

python manage.py migrate

删除Django模型

如果我们希望删除某个模型，比如说不再需要的Article模型，可以直接删除模型类，然后运行迁移命令：

1

# 从models.py中删除Article模型

之后，运行迁移命令来生成删除该模型的迁移文件：

1

python manage.py makemigrations

再应用迁移以更新数据库：

1

python manage.py migrate

使用Django管理命令

Django提供了一些管理命令（management commands）来帮助我们管理数据库和模型。我们可以使用django-admin工具来列出当前的模型及其状态，比如：

1

python manage.py showmigrations

这个命令可以帮助我们查看所有的迁移及其应用情况。

小结

通过本篇文章，我们学习了如何使用Django模型来管理数据库结构，包括创建、修改和删除模型。我们了解了如何生成和应用迁移，这是将模型变化反映到数据库中的重要步骤。在下一篇文章中，我们将讨论如何创建视图函数来处理请求和返回响应。

通过灵活运用Django的模型功能，我们可以高效地管理应用的数据库结构，为后续的业务逻辑打下坚实的基础。如果在过程中有任何问题，欢迎随时提问！

在本篇教程中，我们将深入讨论Django中的视图函数。视图函数是Django应用的核心部分之一，它负责处理请求并返回响应。通过前几篇的学习，我们已经掌握了如何定义模型并管理数据库结构。接下来，我们将把这些模型与视图连接起来，让我们的应用能够处理用户请求并动态返回数据。

什么是视图函数？

在Django中，视图函数是一个Python函数，它接受Web请求并返回Web响应。视图函数的主要任务是处理业务逻辑，然后将处理的结果返回给用户。

视图函数基本结构

一个基本的视图函数如下所示：

1
2
3
4

from django.http import HttpResponse

def my_view(request):
    return HttpResponse("Hello, World!")

这个函数接收一个request对象，并返回一个简单的HttpResponse，内容为“Hello, World!”。

视图函数的工作流程

视图函数的处理流程通常如下：

1. 接收请求：当用户访问某个URL时，Django会找到与之匹配的视图函数。
2. 处理逻辑：视图函数会根据请求的信息（如URL参数、请求方法等）执行相应的业务逻辑。
3. 返回响应：最后，视图函数会返回一个响应对象，通常是一个HttpResponse或其子类。

案例：创建一个简单的视图函数

我们先创建一个简单的视图，用于展示数据库中所有的书籍。首先，我们假设我们的模型已经定义好了，如下所示：

1
2
3
4
5
6
7
8
9

# models.py
from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)

    def __str__(self):
        return self.title

接下来，我们将创建一个视图函数来展示所有书籍的列表：

1
2
3
4
5
6
7
8

# views.py
from django.http import HttpResponse
from .models import Book

def book_list(request):
    books = Book.objects.all()  # 获取所有书籍
    output = ', '.join([book.title for book in books])  # 将书名连接成字符串
    return HttpResponse("Books: " + output)

在这个示例中，我们定义了一个名为book_list的视图函数，它查询数据库中的所有书籍并将它们的标题作为响应返回。

URL配置

在之前的案例中，我们使用了一个简单的视图函数，但这个函数尚未与URL关联。在下一篇教程中，我们将学习如何配置URL，以便将请求正确地路由到我们的视图函数。通过URL配置，Django能够识别哪些请求应该交给特定的视图处理。

这里我们可以简要介绍一下如何配置URL，以便读者有个基本的了解。我们可以在urls.py中这样配置：

1
2
3
4
5
6
7

# urls.py
from django.urls import path
from .views import book_list

urlpatterns = [
    path('books/', book_list, name='book_list'),
]

这个URL配置表明，当用户访问/books/时，将会调用book_list视图函数。

结论

在本篇中，我们详细介绍了Django中的视图函数。我们学习了如何定义视图函数，处理请求，以及如何与数据库模型相结合。通过简单的案例，我们展示了如何查询数据库并返回结果。

接下来，我们将进一步探讨Django的URL配置，让我们的应用变得更加完整和功能强大。期待在下篇教程中与大家继续深入学习！

在前一篇文章中，我们讨论了Django视图函数，学习了如何创建和使用视图来处理请求并返回响应。接下来，我们将重点了解Django中的URL配置。这是连接用户请求和视图函数的重要环节，通过URL路由，Django能够将特定的URL请求传递给相应的视图。

什么是URL配置？

在Django中，URL配置是指将特定的URL模式映射到相应的视图函数。通过URL配置，Django能够识别用户请求的URL，并调用对应的视图以生成响应。

创建URL配置

在一个Django项目中，我们通常在每个应用的目录中创建一个名为urls.py的文件，以定义应用的URL路由。

示例：基本的URL配置

假设我们创建了一个名为blog的应用，并希望为其添加一些基本的URL路由。我们可以按照以下步骤进行设置：

1. 创建 urls.py 文件：

在blog目录下创建一个名为urls.py的文件。

1
2
3
4
5
6
7
8

# blog/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),  # 首页
    path('post/<int:post_id>/', views.detail, name='detail'),  # 文章详情
]

解析URL配置

在上面的代码中：

• path('')表示将根URL映射到index视图（通常是首页）。
• path('post/<int:post_id>/')使用了URL参数，表示当用户访问/post/1/时，调用detail视图，并将post_id设置为1（整数类型）。

视图函数示例

为了支持以上的URL配置，我们需要在views.py中定义相应的视图函数。以下是一个简单的示例：

1
2
3
4
5
6
7
8

# blog/views.py
from django.http import HttpResponse

def index(request):
    return HttpResponse("Welcome to the Blog!")

def detail(request, post_id):
    return HttpResponse(f"You're looking at post {post_id}.")

将应用的URLs包含到项目的主URL配置中

接下来，我们需要在项目的主urls.py文件中包含blog应用的路由配置。这通常在项目的urls.py文件中进行设置，通常该文件位于项目的根目录下：

1
2
3
4
5
6
7
8

# myproject/urls.py
from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('blog.urls')),  # 包含blog应用的URL
]

在上面的代码中，通过include('blog.urls')将blog应用的URL配置纳入项目中，这意味着所有以/blog/开头的请求都将交由blog应用处理。

URL逆向解析

Django还支持URL的逆向解析，通过名称来访问URL，而不是手动构造URL。这在模板和视图中都非常有用。例如，我们可以在模板中使用命名的URL：

1
2

<a href="{% url 'index' %}">首页</a>
<a href="{% url 'detail' post_id=1 %}">查看文章1</a>

这样做的好处在于，若以后需要改变URL模式，只需修改urls.py即可，使用的地方不需要改动。

总结

在本篇文章中，我们学习了如何在Django中创建和配置URL路由，了解了路径匹配的基本原则，以及如何在视图中接收URL参数。如果没有良好的URL配置，用户将无法正确访问你的视图，这将直接影响到用户体验和网站功能。

下一篇文章中，我们将继续探讨视图与模型的交互，进一步了解如何利用数据库管理数据，并将其展示在视图中。请继续关注！

在上一篇教程中，我们介绍了如何配置Django的URL，这为我们接下来的视图逻辑打下了基础。本篇文章将重点讨论Django视图与模型的交互，帮助你理解如何通过视图来处理数据并与模型进行交互。

理解视图与模型的关系

在Django中，视图是处理HTTP请求和返回HTTP响应的函数或类，而模型则是定义数据结构和数据库交互的类。视图和模型之间的交互是通过Django的ORM（对象关系映射）来实现的。

基本模型

首先，我们需要定义一个模型。假设我们正在创建一个简单的博客应用，其中包含文章（Article）模型。我们可以在models.py中定义如下：

1
2
3
4
5
6
7
8
9

from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

在这个Article模型中，我们定义了三个字段：title，content，和created_at。每当一个新的Article实例被创建时，created_at字段会自动保存创建时间。

创建视图

接下来，我们需要在视图中处理与模型的交互。例如，我们想要显示所有的文章列表。我们可以在views.py中定义一个视图来完成这个任务：

1
2
3
4
5
6

from django.shortcuts import render
from .models import Article

def article_list(request):
    articles = Article.objects.all()  # 从数据库获取所有文章
    return render(request, 'article_list.html', {'articles': articles})

在上面的代码中，我们创建了一个名为article_list的视图。这个视图使用Article.objects.all()方法从数据库中获取所有文章，并将其传递给模板article_list.html。

配置URL

我们需要在urls.py中配置这个视图，以便用户可以访问文章列表页面：

1
2
3
4
5
6

from django.urls import path
from .views import article_list

urlpatterns = [
    path('articles/', article_list, name='article_list'),
]

现在，访问/articles/路径时，会触发article_list视图并显示所有文章。

使用模板展示数据

接下来，我们需要创建一个模板来展示文章的信息。在templates/article_list.html文件中，我们可以这样编写模板：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Article List</title>
</head>
<body>
    <h1>Articles</h1>
    <ul>
        {% for article in articles %}
            <li>
                <h2>{{ article.title }}</h2>
                <p>{{ article.content }}</p>
                <small>Created at {{ article.created_at }}</small>
            </li>
        {% endfor %}
    </ul>
</body>
</html>

在这个模板中，我们使用了Django的模板语言把articles变量中的每一篇文章的标题、内容和创建时间都展示出来。

处理文章的创建

除了展示文章，我们也希望能够创建新的文章。我们可以为此创建一个新的视图和模板。

首先，在views.py中添加一个用于处理文章创建的视图：

1
2
3
4
5
6
7
8
9
10
11
12
13

from django.shortcuts import redirect
from django.http import HttpResponse
from .forms import ArticleForm

def create_article(request):
    if request.method == 'POST':
        form = ArticleForm(request.POST)
        if form.is_valid():
            form.save()  # 保存到数据库
            return redirect('article_list')  # 创建成功，重定向到文章列表
    else:
        form = ArticleForm()
    return render(request, 'create_article.html', {'form': form})

在这个视图中，我们通过ArticleForm来处理表单输入。当接收到POST请求时，我们验证数据并保存到数据库，成功后重定向到文章列表。

创建表单

我们需要创建ArticleForm类，用于处理文章的输入。在forms.py中：

1
2
3
4
5
6
7

from django import forms
from .models import Article

class ArticleForm(forms.ModelForm):
    class Meta:
        model = Article
        fields = ['title', 'content']

这个表单将生成一个用于输入文章标题和内容的表单。

创建文章的模板

创建一个新的模板create_article.html，用于展示文章创建的表单：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Create Article</title>
</head>
<body>
    <h1>Create New Article</h1>
    <form method="post">
        {% csrf_token %}
        {{ form.as_p }}
        <button type="submit">Submit</button>
    </form>
</body>
</html>

注意这里我们使用了{% csrf_token %}来防止跨站请求伪造攻击。

总结

在这一篇中，我们学习了如何通过Django视图和模型进行交互，创建和展示文章列表，以及如何创建新的文章。视图负责处理逻辑，而模型则负责与数据库的交互。在下一篇中，我们将深入了解Django模板语言，通过动态生成HTML来渲染数据。

希望你已经对视图和模型的交互有了清晰的认识，现在你可以开始构建你的应用了！

在上一章节中，我们讨论了Django视图如何与模型进行交互。在这一节中，我们将深入探索Django的模板语言，这将使我们能够在网页上呈现数据，实现动态的用户界面。

什么是Django模板？

Django模板是一个文本文件，通常是HTML格式，但也可以使用其他格式。模板可以包含静态数据（如HTML标记）和动态内容（由Django生成的内容），使用的是Django模板语言（DTL）。

模板语言的主要目的是将您的数据与视图中生成的上下文结合，从而生成动态的网页。它提供了一套简单易用的工具，允许我们使用变量、标签和过滤器来处理和显示数据。

Django模板的基本结构

一个简单的Django模板可能如下所示：

1
2
3
4
5
6
7
8
9
10

<!DOCTYPE html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>{{ header }}</h1>
    <p>{{ content }}</p>
</body>
</html>

在上面的模板中，{{ title }}、{{ header }} 和 {{ content }}都是变量标记，它们可以在视图中定义并传递到模板中。

使用变量

要在Django中使用模板变量，您只需在视图中创建一个上下文字典，并在模板中使用变量标记。以下是一个基本示例：

视图（views.py）

1
2
3
4
5
6
7
8
9

from django.shortcuts import render

def home(request):
    context = {
        'title': '我的Django网站',
        'header': '欢迎来到我的网站',
        'content': '这是一个使用Django创建的简单示例页面。',
    }
    return render(request, 'home.html', context)

模板（home.html）

1
2
3
4
5
6
7
8
9
10

<!DOCTYPE html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>{{ header }}</h1>
    <p>{{ content }}</p>
</body>
</html>

在这个例子中，当用户访问首页时，视图会生成一个上下文并将其传递给模板。模板通过{{ }}语法使用这些变量。

控制结构

Django模板语言提供了一些控制结构，例如if语句和for循环，允许我们根据条件显示内容。

if语句

以下是如何在模板中使用if语句的示例：

1
2
3
4
5

{% if user.is_authenticated %}
    <p>欢迎回来, {{ user.username }}!</p>
{% else %}
    <p>你好，访客！请登录。</p>
{% endif %}

在这个例子中，如果用户已登录，将显示“欢迎回来”，否则显示“你好，访客！”的消息。

for循环

您可以使用for标签遍历列表或字典中的项目：

1
2
3
4
5

<ul>
{% for item in item_list %}
    <li>{{ item }}</li>
{% endfor %}
</ul>

在这个例子中，item_list 是视图中提供的一组数据，模板将遍历列表并为每个项目生成一个列表项。

模板过滤器

Django模板还引入了过滤器，这些是能够修改变量输出的简单函数。过滤器使用管道符号|来应用，如下所示：

1

<p>当前日期：{{ current_date|date:"Y-m-d" }}</p>

在这个例子中，date过滤器将current_date变量格式化为YYYY-MM-DD的格式。

模板继承

模板继承是Django模板系统的一项强大功能。您可以创建一个基础模板，在其上定义页面的通用结构，然后通过子模板来实现特定页面的细节。

基础模板（base.html）

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}网站标题{% endblock %}</title>
</head>
<body>
    <header>
        <h1>我的Django网站</h1>
    </header>
    <div>
        {% block content %} {% endblock %}
    </div>
</body>
</html>

子模板（home.html）

1
2
3
4
5
6
7
8

{% extends "base.html" %}

{% block title %}首页{% endblock %}

{% block content %}
    <h2>欢迎来到首页</h2>
    <p>这里是首页的内容。</p>
{% endblock %}

在这个示例中，home.html继承了base.html，只需定义特定内容的block即可。这大大提高了代码的重用性。

小结

在本篇章中，我们深入探讨了Django模板语言，学习了如何创建动态网页，包括如何使用变量、控制结构和模板继承。这些技能与之前讨论的视图和模型的交互密切相关，因为它们结合在一起，形成了Django应用的核心。

在下一章节中，我们将具体了解如何使用模板渲染动态内容，使您的页面更具互动性和吸引力。让我们准备好开始使用Django模板!

在上一篇中，我们深入探讨了Django模板语言的基本构造与语法。在这一篇中，我们将专注于如何使用Django模板来动态渲染内容。我们会通过具体的案例来展示如何利用模板语言和模板系统来生成HTML页面的内容。

什么是Django模板？

Django模板是用于生成动态HTML的一个强大工具，它通过将数据与模板代码结合，来生成最终显示给用户的网页。模板可以包含HTML标记、模板标签和模板过滤器，使得我们能够灵活地展示内容。

基本示例

假设我们正在构建一个博客应用，我们想要展示一篇博文的标题和内容。在我们的 views.py 中，我们可能会有如下代码：

1
2
3
4
5
6
7
8

from django.shortcuts import render

def post_detail(request, post_id):
    post = {
        'title': 'Django从零开始',
        'content': '这是我们学习Django的第一篇文章。',
    }
    return render(request, 'post_detail.html', {'post': post})

在上面的例子中，我们创建了一个视图 post_detail，它接受 post_id 作为参数，获取对应的博文数据，并将其传递给模板 post_detail.html。

模板文件

接下来，我们需要创建 post_detail.html 模板文件，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{ post.title }}</title>
</head>
<body>
    <h1>{{ post.title }}</h1>
    <p>{{ post.content }}</p>
</body>
</html>

在这个模板中，{{ post.title }}和{{ post.content }} 是模板语言的语法，用于访问并显示我们在视图中传递的博文数据。

使用模板过滤器

Django模板还提供了一些内置的过滤器，可以用来处理数据。例如，我们可以使用 truncatewords 过滤器来限制文本的字数。修改我们的模板如下：

1

<p>{{ post.content|truncatewords:10 }}</p>

这样，模板将只显示博文内容的前10个单词。

使用条件和循环

在实际应用中，处理列表数据是常见的需求。例如，如果我们有多个博文，我们可能会在模板中使用条件和循环来展示每篇博文。我们修改视图返回多个博文：

1
2
3
4
5
6

def post_list(request):
    posts = [
        {'title': 'Django从零开始', 'content': '这是第一篇文章。'},
        {'title': 'Django的高级特性', 'content': '这是第二篇文章。'},
    ]
    return render(request, 'post_list.html', {'posts': posts})

然后，我们在 post_list.html 中使用循环来显示所有博文：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>博文列表</title>
</head>
<body>
    <h1>博文列表</h1>
    <ul>
        {% for post in posts %}
            <li>
                <h2>{{ post.title }}</h2>
                <p>{{ post.content }}</p>
            </li>
        {% empty %}
            <li>没有博文。</li>
        {% endfor %}
    </ul>
</body>
</html>

在这个例子中，我们使用了 {% for post in posts %} 来遍历所有博文。如果 posts 为空，模板会显示“没有博文”。

小结

在本篇中，我们学习了如何使用Django模板来动态生成内容，如何使用模板标签来控制数据的展示，以及如何通过循环和条件来处理复杂的逻辑。这为我们在下一篇的模板继承打下了良好的基础。

在下一篇中，我们将探索Django模板的继承特性，从而实现更高效和可重用的模板结构。通过对当前已学知识的巩固，接下来的学习将会更加深入与完整。请继续关注！

在上一篇教程中，我们探讨了如何使用Django模板来渲染动态内容。了解了如何使用基本的模板语法后，今天我们将学习一个更高级的功能：模板继承。模板继承使得我们可以创建一个基础模板，然后在此基础上扩展子模板，从而实现代码的复用和结构的清晰。

什么是模板继承？

模板继承允许我们定义一个“母模板”，在这个模板中，我们可以定义一些通用的结构（如头部、底部和导航栏），然后其他模板可以“继承”这个母模板，只需实现特定的内容部分。这不仅减少了代码重复，也使得项目结构更加清晰。

基本示例

让我们通过一个简单的案例来理解模板继承的概念。

创建基础模板

首先，我们创建一个名为 base.html 的基础模板。这个模板将包含网站的通用结构，比如头部和尾部。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}网站标题{% endblock %}</title>
</head>
<body>
    <header>
        <h1>我的Django网站</h1>
        <nav>
            <ul>
                <li><a href="/">首页</a></li>
                <li><a href="/about/">关于我们</a></li>
            </ul>
        </nav>
    </header>
    
    <main>
        {% block content %}
        <!-- 子模板内容 -->
        {% endblock %}
    </main>

    <footer>
        <p>© 2023 我的Django网站. 版权所有.</p>
    </footer>
</body>
</html>

在这个模板中，我们定义了头部（header）和底部（footer），并使用了两个block标签，分别是 title 和 content。子模板可以通过这两个模块插入特定的内容。

创建子模板

接下来，我们创建一个名为 index.html 的子模板，它将继承自 base.html。我们在这个子模板中，重写 title 和 content 内容块。

1
2
3
4
5
6
7
8

{% extends 'base.html' %}

{% block title %}首页 - 我的Django网站{% endblock %}

{% block content %}
    <h2>欢迎来到我的网站!</h2>
    <p>这是主页内容。</p>
{% endblock %}

在这个子模板中，使用 {% extends 'base.html' %} 语句来继承父模板。我们根据需要重写了 title 和 content 的内容。

渲染模板

在视图中，我们可以渲染我们的 index.html 子模板。假设我们有如下视图：

1
2
3
4

from django.shortcuts import render

def index(request):
    return render(request, 'index.html')

当用户访问主页时，将会看到基于 base.html 结构的网页，同时显示 index.html 中定义的内容。

其他注意事项

块的可嵌套

模板的 block 可以嵌套。例如，你可以在父模板中定义一个 block，然后在子模板中创建另一个子类用于特定的内容。

处理更复杂的逻辑

对于更复杂的网页，可以考虑使用多个层次的继承。例如，一个基础模板可以作为所有页面的基础模板，一个关于页模板可以从 base.html 继承，然后再次定义内容块。

使用 include 标签

除了模板继承，Django 也允许使用 {% include %} 标签来包含其他HTML文件，可以进一步帮助我们分隔和复用代码。

总结

模板继承是 Django 模板系统的一个强大特性，它可以帮助我们减少重复代码，使得网页结构更加清晰。在这一篇教程中，我们学会了如何创建一个基础模板，并通过子模板进行内容扩展。在下一篇教程中，我们将学习如何使用 Django 创建表单，继续扩展我们的 Django 知识。

希望你能在实际项目中充分利用模板继承的特性来提升开发效率与代码可维护性。如果你对本篇教程有任何疑问或建议，欢迎在下面留言讨论！

在本篇中，我们将深入探索如何在Django中创建表单。Django的表单系统非常强大，能够简化数据收集和验证的过程。接下来，我们将以一个简单的用户注册表单为例，逐步讲解如何创建和使用Django表单。

什么是Django表单

在Django中，表单是用于处理用户输入的工具。通过表单，我们可以轻松收集数据、进行验证并处理提交的数据。Django提供了一个强大的表单框架，这使得表单的创建、验证和渲染变得更加简单。

创建Django表单

要创建一个表单，首先需要在你的应用中定义一个表单类。表单类通常是从django import forms中导入的forms.Form或forms.ModelForm类继承而来。两者的主要区别在于前者用于处理自定义数据，而后者则是与数据库模型相关联的。

1. 创建一个简单的表单类

下面是一个简单的用户注册表单的示例：

1
2
3
4
5
6
7

# forms.py
from django import forms

class UserRegistrationForm(forms.Form):
    username = forms.CharField(max_length=150, required=True, label='用户名')
    email = forms.EmailField(required=True, label='电子邮件')
    password = forms.CharField(widget=forms.PasswordInput, required=True, label='密码')

在上面的代码中，我们定义了一个UserRegistrationForm类，包含三个字段：username、email 和 password。每个字段都有一些属性，例如max_length、required和label。

2. 在视图中使用表单

接下来，我们需要在视图中使用这个表单。我们将创建一个视图以处理用户注册请求。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# views.py
from django.shortcuts import render, redirect
from .forms import UserRegistrationForm

def register(request):
    if request.method == 'POST':
        form = UserRegistrationForm(request.POST)
        if form.is_valid():
            # 处理注册逻辑，比如保存用户数据
            # form.cleaned_data['username']
            # form.cleaned_data['email']
            # form.cleaned_data['password']
            return redirect('success_url')  # 替换为成功后的URL
    else:
        form = UserRegistrationForm()
    
    return render(request, 'register.html', {'form': form})

在这个视图中，我们首先检查请求的方法。如果是POST请求，我们就用request.POST创建一个表单实例，然后使用form.is_valid()来验证数据。如果表单有效，我们可以处理注册逻辑，例如保存用户数据。对于GET请求，我们简单地创建一个新的表单实例。

3. 创建模板来渲染表单

现在，我们需要一个模板来渲染这个表单。以下是一个简单的register.html模板示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<!-- register.html -->
<!DOCTYPE html>
<html>
<head>
    <title>用户注册</title>
</head>
<body>
    <h1>用户注册</h1>
    <form method="post">
        {% csrf_token %}
        {{ form.as_p }}
        <button type="submit">注册</button>
    </form>
</body>
</html>

在这个模板中，我们使用了{{ form.as_p }}来渲染表单字段。这将自动生成各个表单字段的HTML代码。同时，使用{% csrf_token %}来保护表单免受跨站请求伪造攻击。

总结

通过以上步骤，我们创建了一个简单的用户注册表单，并在视图和模板中使用了它。了解了Django表单的创建、渲染以及基本的处理流程，为我们后续的表单验证打下了良好的基础。

在下一篇中，我们将讨论表单验证的内容，解释如何确保用户输入的数据是有效的，并提供错误反馈。这将帮助我们提升用户体验和数据的完整性。请继续关注我们的教程系列，以进一步探索Django的强大表单功能！

在上一篇中，我们学习了如何在Django中创建表单。今天，我们将继续探索如何对这些表单进行验证。在实际开发中，确保用户输入数据的有效性是至关重要的，这可以防止许多潜在的问题并提高用户体验。

表单验证的基本概念

在Django中，表单验证主要依赖于内置的字段验证器。每个字段类型（如 CharField, EmailField, IntegerField 等）都有其默认的验证规则。你可以通过自定义验证方法来扩展这些规则，从而满足更复杂的需求。

验证过程

1. 输入数据：用户在表单中输入数据。
2. 提交数据：通过POST请求将数据发送到服务器。
3. 验证数据：Django会自动调用字段上的验证器。
4. 处理验证结果：如果数据有效，则进行后续处理；否则，返回错误信息给用户。

默认验证器

每个字段都有内置的验证规则。例如：

• CharField 默认要求输入为非空字符串。
• EmailField 要求输入符合电子邮件格式。
• IntegerField 要求输入为数字类型。

自定义验证器

除了默认的验证器，Django还允许你定义自定义验证器，以处理更复杂的逻辑。下面我们来看一个简单的案例，展示如何自定义一个验证器。

案例：用户注册表单验证

假设我们正在创建一个用户注册表单，表单包含用户名、电子邮件和密码字段。我们希望确保用户名是唯一的，并且密码长度至少为8个字符。

首先，我们创建一个表单类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

from django import forms
from django.core.exceptions import ValidationError
from django.contrib.auth.models import User

class UserRegistrationForm(forms.Form):
    username = forms.CharField(max_length=150)
    email = forms.EmailField()
    password = forms.CharField(widget=forms.PasswordInput, min_length=8)

    def clean_username(self):
        username = self.cleaned_data['username']
        if User.objects.filter(username=username).exists():
            raise ValidationError("用户名已存在，请选择其他用户名。")
        return username

    def clean_password(self):
        password = self.cleaned_data['password']
        if len(password) < 8:
            raise ValidationError("密码长度必须至少为8个字符。")
        return password

代码解析

1. 字段定义：我们定义了 username, email 和 password 三个字段。注意 password 字段使用了 PasswordInput 小部件以隐藏输入。
2. 自定义清理方法：
   • clean_username：该方法检查用户名是否唯一。如果用户名已存在，则抛出 ValidationError，并返回错误信息。
   • clean_password：该方法检查密码长度。如果密码少于8个字符，则抛出 ValidationError。

如何使用表单

在Django视图中使用此表单，我们可以处理GET和POST请求：

1
2
3
4
5
6
7
8
9
10
11
12
13

from django.shortcuts import render
from .forms import UserRegistrationForm

def register(request):
    if request.method == 'POST':
        form = UserRegistrationForm(request.POST)
        if form.is_valid():
            # 这里可以保存用户信息到数据库
            return render(request, 'registration_success.html')
    else:
        form = UserRegistrationForm()

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

在这个视图中，我们首先检查请求类型。若是POST请求，验证用户输入；否则渲染空表单。若表单有效，可进行后续处理，例如将用户信息保存到数据库。

错误反馈

当表单验证失败时，你可以在模板中显示错误信息：

1
2
3
4
5
6
7
8

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    {% for error in form.non_field_errors %}
        <div class="error">{{ error }}</div>
    {% endfor %}
    <button type="submit">注册</button>
</form>

使用 {{ form.as_p }} 可以方便地渲染表单字段，同时通过 form.non_field_errors 获取并显示非字段错误信息。

结论

在这一篇中，我们详细探讨了Django中的表单验证，学习了如何使用内置验证器以及自定义验证器来确保用户输入数据的有效性。通过实践案例，我们可以看到，表单验证在提高应用的可靠性和用户体验方面发挥了重要作用。

在接下来的篇章中，我们将讨论如何处理验证通过的表单数据，包括如何将其保存到数据库。请期待下一篇教程！

在上一篇文章中，我们讨论了Django表单的验证，明确了如何设置表单验证规则以及如何使用内置的验证器来保证用户输入的有效性。今天，我们将重点关注如何在Django中处理提交的表单数据。掌握这部分内容将使你能够有效地收集用户输入并进行相应的操作，比如保存到数据库或进一步处理。

处理表单数据的基本步骤

处理表单数据主要包括以下几个步骤：

1. 显示表单：在网页上显示表单。
2. 接收提交的数据：当用户提交表单后，接收用户输入的数据。
3. 验证数据：虽然在上篇文章中已经讨论了验证，但这里我们会再次提到这一点，因为处理表单数据的前提条件是数据的有效性。
4. 处理有效数据：根据验证结果，对有效数据进行处理（如保存到数据库中）。
5. 返回反馈：根据操作结果反馈给用户。

创建表单类

我们先创建一个简单的表单类，以便进行数据处理。假设我们有一个用户反馈的表单，用户可以输入他们的姓名和反馈内容。

1
2
3
4
5
6

# forms.py
from django import forms

class FeedbackForm(forms.Form):
    name = forms.CharField(max_length=100, required=True)
    feedback = forms.CharField(widget=forms.Textarea, required=True)

在上面的例子中，我们使用了 Django 的 forms 模块创建了一个 FeedbackForm 表单类，包含了两个字段：name 和 feedback。

视图函数处理表单数据

接下来，我们需要一个视图函数来处理该表单。当用户访问该页面时，视图需要展示表单；当用户提交表单时，视图需要接收数据并进行处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# views.py
from django.shortcuts import render
from .forms import FeedbackForm
from django.http import HttpResponseRedirect

def feedback_view(request):
    if request.method == 'POST':
        form = FeedbackForm(request.POST)
        if form.is_valid():
            # 处理有效数据
            name = form.cleaned_data['name']
            feedback = form.cleaned_data['feedback']
            # 这里可以将反馈保存到数据库，或者其他处理逻辑
            # 假设保存逻辑已经完成
            print(f"Feedback from {name}: {feedback}")
            return HttpResponseRedirect('/success/')  # 假设有一个成功页面
    else:
        form = FeedbackForm()

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

在上面的代码中，我们检测请求的方法。如果是 POST 请求，说明用户已提交表单，于是我们创建了一个 FeedbackForm 实例，并将 request.POST 传入以获取表单数据。同时，我们调用 form.is_valid() 方法进行验证。

如果表单输入有效，可以通过 form.cleaned_data 获取清洗后的数据。之后，我们可以根据需要，将数据保存到数据库或进行其他处理（在本例中，我们只是简单地打印）。

如果请求方法不是 POST，则创建一个空的表单实例，渲染到模板上。

创建模板

在模板中，我们需要将表单呈现给用户：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<!-- templates/feedback.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Feedback Form</title>
</head>
<body>
    <h1>Feedback</h1>
    <form method="post">
        {% csrf_token %}
        {{ form.as_p }}  <!-- 将表单渲染成段落(s), 这是一种简洁的表示方式 -->
        <button type="submit">Submit</button>
    </form>
</body>
</html>

在模板中，我们使用了 {{ form.as_p }} 来自动渲染表单字段，并且使用了 {% csrf_token %} 来防止跨站请求伪造（CSRF）攻击。

返回反馈给用户

在成功处理完数据后，我们通过 HttpResponseRedirect 重定向到一个成功页面。你可以创建一个简单的成功页面：

1
2
3

# views.py
def success_view(request):
    return render(request, 'success.html')

并在 urls.py 中设置相应的路径。

1
2
3
4
5
6
7
8

# urls.py
from django.urls import path
from .views import feedback_view, success_view

urlpatterns = [
    path('feedback/', feedback_view, name='feedback'),
    path('success/', success_view, name='success'),
]

同时，我们为成功页面创建模板 success.html：

1
2
3
4
5
6
7
8
9
10
11
12

<!-- templates/success.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Success</title>
</head>
<body>
    <h1>Thank you for your feedback!</h1>
    <p>Your feedback has been received.</p>
</body>
</html>

总结

在这一篇中，我们详细介绍了如何在 Django 中处理表单数据，包括显示表单、接收数据、验证数据和处理有效数据等步骤。通过案例的显示，你应该能够更清晰地理解这些流程的实现。

在下一篇文章中，我们将讨论用户认证与权限的内容，重点是如何让用户注册和管理他们的账户。希望你继续关注！