Django初学者入门指南1-初识(译&改)

Django初学者入门指南2-基础知识(译&改)

Django初学者入门指南3-高级概念(译&改)

Django初学者入门指南4-登录认证(译&改)

Django初学者入门指南5-存储数据(译&改)

Django初学者入门指南6-基于类的页面(译&改)

Django初学者入门指南7-部署发布(译&改)

>>原文地址 By Vitor Freitas

简介

欢迎来到Django教程的第二部分！在上一部分中，我们安装了所需的python3.6，并在虚拟环境中运行django1.11，同时也已经创建了我们的第一个项目。接下来，我们将继续在同一个项目中编写代码。

在下一节中，我们讨论将要开发的项目来了解一些背景知识。然后学习Django的基础知识：模型(models)、管理员(admin)、视图(views)、模板(templates)和路由(URLs)。

让我们动起来！

网页面板

不知道大家是不是这样，就我个人而言，通过实际的例子和代码片段可以让我更快地掌握想要学习的内容。我较难通过抽象简单的例子，如Class A、Class B和经典示例foo(bar)，来学习和掌握知识。所以我不打算这么干，在开始学习模型、视图以及其他东西前，让我们花点时间来简单讨论一下我们要开发的这个项目。

如果你有web开发的经验，觉得这部分比较啰嗦的话，可以简单浏览一下插图了解我们要构建的东西，就可以跳到本教程的模型(models)部分。

但如果你是一位web开发新手，那就强烈建议你继续阅读，这将给你讲解关于web应用程序建模和设计的方法，web开发，乃至程序开发，可不仅仅知识编码而已。

用例图

我们的项目是一个论坛，整体思路是通过维护几个版块(board)，它们类似于类别，区分各个版块的不同内容方向。在某一版块里，用户可以通过创建新的主题(topic)来开始新的讨论。在某一主题中，其他用户可以发布、回复帖子(post)来参与讨论。

我们需要找到一种方法来区分普通用户和管理员用户，因为只有管理员才应该创建新的版块。下面是我们的主要用例和每种类型用户的角色的概述：

图 1: 用户权限用例图

类图

我们可以依据用例图来考虑项目的实体(entities)。实体就是是我们将创建的模型，它与我们的Django应用程序将处理的数据密切相关。

为了能够实现上一节中描述的用例，我们至少需要实现以下模型：版块(board)、主题(topic)、帖子(post)和用户(user)。

图 2 : 基本类图

花时间思考模型之间的相互关系也至关重要。图中的实线告诉我们，在主题(topic)中，需要一个字段来标识它属于哪个版块(board)。同样，帖子(post)需要一个字段来表示它属于哪个主题(topic)，这样就可以在讨论中只列出帖子(post)在一个特定的主题(topic)中创建。最后，需要在主题(topic)和帖子(post)中增加字段来记录是谁发起了讨论，这样就可以确定谁在发布回复。

我们还可以给版块(board)与用户(user)模型建立联系，这样就可以确定谁创建了一个特定的版块(board)。但这些信息与应用程序无关。还有其他方法可以跟踪这些信息，稍后我们再进行探讨。

现在我们已经有了基本的类图，必须考虑每个模型将携带什么样的信息。这个过程很容易考虑得过于宽泛，我们试着把注意力集中在重要的点上，仅关注开发所需的信息。后面可以使用迁移(migrations)来改进模型，我们将在下一篇教程中详细介绍这一点。

下图的设计包含了我们现在需要的信息：

图 3: 包含基本关系和基础信息的类图

这个类图强调了模型之间的关系，线条和箭头最终将被转换成字段。

对于Board模型，我们将从两个字段开始：name和description。name字段必须是唯一的，以避免重复的线路板名称。这个description只是为了给大家一个提示，说明这个版块是关于什么的。

Topic模型由四个字段组成：subject，last_update上次更新的时间，用于定义主题排序，starter用于标识发起Topic的User，以及一个名为board的字段，用于定义特定Topic属于哪个Board。

Post模型将有一个message字段，该字段将用于存储帖子回复的文本；一个created_at的时间字段，主要用于在Topic内对Post进行排序；一个updated_at的时间字段，用于记录User何时编辑了某个帖子。与时间字段一样，我们还需要引用User模型：created_by和update_by。

最后是User模型，在类图中，只提到了字段username、password、email和is_superuser标志，这就是现在要使用的全部内容。需要注意的是，我们不需要创建User模型，因为Django已经在contrib包中提供了一个内置的User模型。我们可以直接使用它。

关于类图中的多重性（数字1、0..*，等等），这里简单说明一下：

一个Topic必须与一个（1）Board关联（即不能为空），一个Board可以关联多个Topic或者没有（0..*）。也就是说Board可能没有一个Topic而存在。

版块和主题的一对多关系

一个Topic应该至少有一个Post（主题帖Post），也可以有很多Post（1..*）。一个Post必须与一个Topic（1）关联。

主题和帖子的一对多关系

一个Topic必须有一个且只有一个User关联：主题发起者User（1）。一个User可能有许多或没有Topic（0..*）。

用户和主题的一对多关系

一个Post必须有一个，并且只有一个User与Post的created_by（1）关联。一个User可能创建了许多或没有Post（0..*）。Post还有一个updated_by字段与User关联，多重性0..1表示updated_by字段可能为空（Post未编辑），最多只能关联一个User（最多被1个用户编辑）。

帖子和用户的对应关系

<span id='Figure_4'>
绘制类图的另一种方法是强调字段而不是模型之间的关系：
</span>

图 4: 强调类字段的类图

上面的表示与前面的表示相同，它也更接近于我们将使用Django模型API设计的内容。在这个类图中，我们可以更清楚地看到在Post模型中，关联topic、created_by、updated_by成为模型字段。另一个有趣的地方是，在Topic模型中，我们现在有一个名为posts()的operation（一个类方法）。我们将通过实现一个反向关系来实现这一点，Django将在数据库中自动执行一个查询，返回属于特定Topic的所有Post列表。

类图完成了，这就够了！为了绘制本节中的图表，我使用了StarUML工具。

线框

在花了一些时间设计应用程序模型之后，我喜欢创建一些线框草图来定义需要做的事情，并且对我们的发展方向有一个清晰的了解。

然后基于这些线框，我们可以更深入地了解应用程序中涉及的实体。

<span id='Figure_5'>
首先，我们需要在主页上显示所有的版块Board：
</span>

图 5: 项目首页，显示所有的版块

如果用户点击一个版块Board的链接，比如Django，应该显示出所有主题Topic：

图6 : 版块内容，显示该版块下的所有主题

这里有两个主要功能：用户单击“New topic(新建主题)”按钮创建新主题，或者用户单击某个主题查看或参与讨论。

“New topic(新建主题)”页面：

图7 : “New topic(新建主题)”页面

进入主题后的页面，显示帖子和讨论：

图8 :指定主题下的帖子

如果用户单击“Reply(回复)”按钮，将看到下面的页面，并以时间倒序显示帖子的摘要（最新消息在最上面）：

图9 :回复帖子的页面

要绘制线框，可以使用免费工具draw.io。

模型Models

这些模型基本上是应用程序数据库表的表示。在本节中，我们要做的是创建上一节中建模的类的Django表示：Board、Topic和Post。User模型已经在Django的一个名为auth的内置应用程序中定义，它在INSTALLED APPS配置下的命名空间django.contrib.auth中.

我们将在boards/models.py文件中完成所有的模型工作，(参考 图 4)。完成后的内容如下:

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

class Board(models.Model):
    name = models.CharField(max_length=30, unique=True)
    description = models.CharField(max_length=100)

class Topic(models.Model):
    subject = models.CharField(max_length=255)
    last_updated = models.DateTimeField(auto_now_add=True)
    board = models.ForeignKey(Board, related_name='topics')
    starter = models.ForeignKey(User, related_name='topics')

class Post(models.Model):
    message = models.TextField(max_length=4000)
    topic = models.ForeignKey(Topic, related_name='posts')
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(null=True)
    created_by = models.ForeignKey(User, related_name='posts')
    updated_by = models.ForeignKey(User, null=True, related_name='+')

所有模型都应该是django.db.models.Model的子类。每个类将被转换为database table。每个字段是django.db.models.Field的子类（Django core的定义），并将被转换为database columns。

字段CharField、DateTimeField等都是django.db.models.Field，它们包含在Django core中，随时可以使用。

这里我们只使用CharField、TextField、DateTimeField和ForeignKey字段来定义模型。但是Django提供了各种各样的选项来表示不同类型的数据，比如IntegerField、BooleanField、DecimalField等等，根据实际情况进行定义。

有些字段需要参数，例如CharField。我们应该设置一个max_length。此信息将用于创建database column。Django需要知道database column的大小。Django Forms API还将使用max_length参数来验证用户输入。这个我们后面再探讨。

在Board模型定义中，我们还为name字段设置了参数unique=True，顾名思义，这个字段将在数据库级别强制唯一。

在Post模型中，created_at字段有一个可选参数，auto_now_add设置为True。这将指示Django在创建Post对象时自动设置为当前的日期和时间。

在模型之间创建关系的一种方法是使用ForeignKey字段。它将在模型之间创建链接，并在数据库级别创建适当的关系。ForeignKey字段需要一个位置参数引用与之相关的模型。

例如，在Topic模型中，board字段是Board模型的ForeignKey。它告诉Django一个Topic实例只与一个Board实例相关。related_name参数将用于创建反向关系，其中Board实例将访问属于它的Topic实例列表。

Django会自动创建这种反向关系，related_name是可选的，如果我们不为它设置一个名称，Django将用以下规则生成它：(class_name)_set。例如，在Board模型中，Topic实例将在Topic_set属性下可用。我们把它改名为topics，让它感觉更自然。

在Post模型中，updated_by字段设置related_name='+'。这个设置告诉Django我们不需要这种反向关系，所以Django将会忽略这个反向关系。

下面您可以看到类图和用Django生成模型的源代码之间的关系。绿线表示我们如何处理反向关系。

此时，你可能会问：“主键呢？我应该怎么处理？”如果我们不为模型指定主键，Django将自动生成它。所以这样就可以了。在下一节中，你将更好地了解它是如何工作的。

迁移模型

下一步我们让Django来生成数据库，以供项目的使用。

打开终端，启动虚拟环境，来到manage.py所在的文档目录下，执行下面的命令：

python manage.py makemigrations

你可以看到下面的输出文字：

Migrations for 'boards':
  boards/migrations/0001_initial.py
    - Create model Board
    - Create model Post
    - Create model Topic
    - Add field topic to post
    - Add field updated_by to post

这里的意思是，Django在boards/migrations目录下创建了一个名为0001_initial.py的迁移文件，它描述了应用程序模型的当前状态，下一步Django就会使用这个文件来创建数据库表和列database tables and columns。

迁移文件被转换成SQL语句。如果您熟悉SQL，可以运行以下命令来检查将在数据库中执行的SQL指令：

python manage.py sqlmigrate boards 0001

如果你不熟悉SQL，不用担心。在本教程系列中，我们不会直接使用SQL。所有的工作都将使用Django ORM自动完成，这是一个与数据库通信的抽象层。

下面的命令是将生成的迁移文件应用到数据库中：

python manage.py migrate

接下来你应该会看到如下的输出文字：

Operations to perform:
  Apply all migrations: admin, auth, boards, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying boards.0001_initial... OK
  Applying sessions.0001_initial... OK

因为这是我们首次迁移数据库，migrate命令还应用了Django contrib内置应用程序中的迁移文件，这些文件列在INSTALLED_apps里。

Applying boards.0001_initial... OK指的就是我们前面生成的迁移文件。

好了，数据库准备好了，我们可以继续开发了！

** 注意:** SQLite是一款可以在生产环境直接使用的数据库产品，许多公司的成千上万个产品都是使用的SQLite数据库，如Android和iOS设备、还有主流的网络浏览器、Windows 10、macOS等等。但它并不适用于所有场景，SQLite在大容量网站、写密集应用、巨型数据集、高并发的使用场景中的表现，不如MySQL、PostgreSQL、Oracle等数据库。

我们将在项目开发期间使用SQLite，因为它很方便，而且不需要安装任何其他东西。需要将项目部署到生产环境中时，我们将切换到PostgreSQL，对于简单的网站来说这样就可以了。但对于复杂的网站，最好使用相同的数据库进行开发和生产。

尝试使用Models API

使用Python进行开发的最大优点之一是交互式shell。我一直在用它，这是一种快速的方法，可以用它调试Libraries和APIs功能。

使用manage.py工具可以直接启动shell:

python manage.py shell

这与只需键入python调用交互式控制台非常相似，使用python manage.py shell会自动将我们的项目添加到sys.path并加载Django，这意味着我们可以导入项目的模型和任何其他资源并使用它。

让我们首先引入Board类:

from boards.models import Board

通过下面的代码创建一个Board对象:

board = Board(name='Django', description='This is a board about Django.')

如果需要将该对象的数据存储到数据库中，只需要像下面一样，调用save方法:

board.save()

这个save方法可以创建或者更新对象的数据。我们这里创建Board对象时并未赋值id，Django会自动为它分配一个值，通过下面的方式我们可以查看值:

board.id
1

你同样可以通过这种方式访问该对象的其他属性：

board.name
'Django'

board.description
'This is a board about Django.'

当需要更新对象的属性时，按照下面的方法即可：

board.description = 'Django discussion board.'
board.save()

Django模型类都有一个特殊属性，我们称之为模型管理器(Model Manager)。我们主要在执行查询语句时使用这个属性，可以通过objects属性去访问它。举个例子，我们可以用它来直接创建Board对象：

board = Board.objects.create(name='Python', description='General discussion about Python.')

board.id
2

board.name
'Python'

现在，我们就有两个版块了，可以通过objects来查看所有已经存储在数据库中的版块对象数据：

Board.objects.all()
<QuerySet [<Board: Board object>, <Board: Board object>]>

这个查询结果是一个查询数据集QuerySet，在后面的教程中我们会深入探讨。这个数据集就是在数据库中读取出来的对象列表。这里我们可以看出，数据库中存储了2条版块数据对象，打印的时候输出为对象类型Board object，这是因为我们没有定义和实现Board类的__str__方法。

__str__方法是对象的字符串描述，这里我们可以返回版块的名称。

先让我们离开shell：

exit()

编辑boards应用程序文件目录下的models.py：

class Board(models.Model):
    name = models.CharField(max_length=30, unique=True)
    description = models.CharField(max_length=100)

    def __str__(self):
        return self.name

现在让我们再来试试：

python manage.py shell

from boards.models import Board

Board.objects.all()
<QuerySet [<Board: Django>, <Board: Python>]>

现在看起来更清楚了对吧？

我们可以把QuerySet看成一个列表。比方说需要将列表里的数据枚举出来并逐个打印描述：

boards_list = Board.objects.all()
for board in boards_list:
    print(board.description)

它的输出应该是下面这个：

Django discussion board.
General discussion about Python.

同样的，当我们想用模型管理器(Model Manager)查询某一个对象时，可以使用get方法:

django_board = Board.objects.get(id=1)

django_board.name
'Django'

在使用get方法时一定要注意，如果我们试图获取一个不存在的对象，比如说id=3的版块，它将抛出一个异常boards.models.DoesNotExist：

board = Board.objects.get(id=3)

boards.models.DoesNotExist: Board matching query does not exist.

我们也可以在get方法里使用其他的对象属性进行查询，但最好是可以定位到某一个对象的属性值，否则这个查询方法将返回多个结果可能导致错误。

Board.objects.get(name='Django')
<Board: Django>

也需要注意查询语句是对大小写敏感的case sensitive，通过django你将查找不到你想要的版块：

Board.objects.get(name='django')
boards.models.DoesNotExist: Board matching query does not exist.

模型操作摘要

下面是我们在本节中学习的方法和操作的摘要，以Board模型为参考。大写Board表示类，小写board表示Board模型类的实例（或对象）：

在下一节中，我们将开始编写页面并在HTML页面中显示版块Board。

页面视图(Views),模版(Templates),和静态文件(Static Files)

现在我们的应用已经有一个显示Hello, World!的页面home。

<details>
<summary>原始版本</summary>
原始版本的myproject/urls.py

from django.conf.urls import url
from django.contrib import admin

from boards import views

urlpatterns = [
    url(r'^$', views.home, name='home'),
    url(r'^admin/', admin.site.urls),
]

</details>

修订版本的myproject/urls.py

from django.urls import re_path
from django.contrib import admin

from boards import views

urlpatterns = [
    re_path(r'^$', views.home, name='home'),
    re_path(r'^admin/', admin.site.urls),
]

boards/views.py

from django.http import HttpResponse

def home(request):
    return HttpResponse('Hello, World!')

我们可以将这个页面作为第一个页面来继续开发，图 5设计了首页的样式，在一个表格中展示版块列表和版块的部分信息。

首先要做的就是引入Board模型，并列举出所有的版块对象：

boards/views.py

from django.http import HttpResponse
from .models import Board

def home(request):
    boards = Board.objects.all()
    boards_names = list()

    for board in boards:
        boards_names.append(board.name)

    response_html = '<br>'.join(boards_names)

    return HttpResponse(response_html)

保存后刷新页面你将看到下图所示的样子:

这里就到此为止吧，我们不会像这样渲染HTML。对于这个简单的视图，只需要一个版块对象的列表，然后页面渲染部分就交给Django Template Engine来完成吧。

Django Template Engine(模板引擎)

在项目目录下，与boards同级的位置创建一个名为templates的文件夹:

myproject/
 |-- myproject/
 |    |-- boards/
 |    |-- myproject/
 |    |-- templates/   <-- 是的，放这里!
 |    +-- manage.py
 +-- venv/

在templates目录下，创建一个html文件，取名为home.html:

templates/home.html

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title>Boards</title>
  </head>
  <body>
    <h1>Boards</h1>

    {% for board in boards %}
      {{ board.name }} <br>
    {% endfor %}

  </body>
</html>

在上面的例子中，我们将原始HTML与一些特殊标记{% for ... in ... %}和{{ variable }}混合使用，这是Django模板语言的一部分。上面的示例演示了如何使用for遍历对象列表，{{ board.name }}在HTML模板中读取版块的名称，生成一个动态HTML文档。

在使用这个HTML页面之前，我们必须告诉Django在哪里可以找到应用程序的模板。

打开在myproject目录中的settings.py，搜索TEMPLATES变量并将DIRS键设置为os.path.join(BASE_DIR, 'templates')：

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [
            os.path.join(BASE_DIR, 'templates')
        ],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

这行代码的意思就是将项目位置和/templates拼起来，这样就可以得到templates的完整路径.

我们可以在python shell中进行调试:

python manage.py shell

from django.conf import settings

settings.BASE_DIR
'/Users/vitorfs/Development/myproject'

import os

os.path.join(settings.BASE_DIR, 'templates')
'/Users/vitorfs/Development/myproject/templates'

从上面可以看出，这个方式可以获取到templates文件夹的完整路径.

现在让我们来更新home页面:

boards/views.py

from django.shortcuts import render
from .models import Board

def home(request):
    boards = Board.objects.all()
    return render(request, 'home.html', {'boards': boards})

可以得到下面的页面：

我们再优化HTML模板，添加一个列表：

templates/home.html

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title>Boards</title>
  </head>
  <body>
    <h1>Boards</h1>

    <table border="1">
      <thead>
        <tr>
          <th>Board</th>
          <th>Posts</th>
          <th>Topics</th>
          <th>Last Post</th>
        </tr>
      </thead>
      <tbody>
        {% for board in boards %}
          <tr>
            <td>
              {{ board.name }}<br>
              <small style="color: #888">{{ board.description }}</small>
            </td>
            <td>0</td>
            <td>0</td>
            <td></td>
          </tr>
        {% endfor %}
      </tbody>
    </table>
  </body>
</html>

测试首页(homepage)

测试将始终贯穿这个教程，我们将讨论不同的测试概念和策略。

让我们来创建第一个测试用例，这里将会用到boards应用程序目录下的tests.py文件：

boards/tests.py

from django.core.urlresolvers import reverse
from django.test import TestCase

class HomeTests(TestCase):
    def test_home_view_status_code(self):
        url = reverse('home')
        response = self.client.get(url)
        self.assertEquals(response.status_code, 200)

这是一个简单的测试用例，但是它非常有用。我们测试请求的返回的状态码(status_code)，断言(assertEquals)返回的状态码为200，200表明请求成功(success).

通常我们可以直接在控制台中看到请求返回的状态码(status_code):

如果出现未捕获的异常、语法错误或其他任何情况，Django将返回状态代码500，这意味着Internal Server Error。现在，假设我们的应用程序有100个页面，只使用一个命令为所有视图编写这个简单的测试，就可以测试所有视图是否都返回成功代码，这样用户就不会在任何地方看到任何错误消息。但如果没有自动化测试，我们将需要逐个检查所有页面。

可以通过下面的命令执行Django的测试:

python manage.py test

Creating test database for alias 'default'...
System check identified no issues (0 silenced).
.
----------------------------------------------------------------------
Ran 1 test in 0.041s

OK
Destroying test database for alias 'default'...

现在我们可以测试Django是否为请求的URL返回了正确的view函数。这也是一个有用的测试，因为随着开发的进展，您将看到urls.py模块可以变得非常大和复杂，而URL路由是通过正则匹配定位的，在某些特定情况下可能匹配到目标以外的URL，因此Django最终可能返回错误的view函数。

按下面的方式编写测试用例:

boards/tests.py

from django.core.urlresolvers import reverse
from django.urls import resolve
from django.test import TestCase
from .views import home

class HomeTests(TestCase):
    def test_home_view_status_code(self):
        url = reverse('home')
        response = self.client.get(url)
        self.assertEquals(response.status_code, 200)

    def test_home_url_resolves_home_view(self):
        view = resolve('/')
        self.assertEquals(view.func, home)

在第二个测试方法里，我们使用了resolve方法，Django使用这个方法将url与urls.py中的模块进行匹配。所以这个测试就是保证通过URL/返回的是首页(homepage)。

再测试一次看看:

python manage.py test

Creating test database for alias 'default'...
System check identified no issues (0 silenced).
..
----------------------------------------------------------------------
Ran 2 tests in 0.027s

OK
Destroying test database for alias 'default'...

如果你希望看到更多测试的详细日志，设置verbosity到更高的级别:

python manage.py test --verbosity=2

Creating test database for alias 'default' ('file:memorydb_default?mode=memory&cache=shared')...
Operations to perform:
  Synchronize unmigrated apps: messages, staticfiles
  Apply all migrations: admin, auth, boards, contenttypes, sessions
Synchronizing apps without migrations:
  Creating tables...
    Running deferred SQL...
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying boards.0001_initial... OK
  Applying sessions.0001_initial... OK
System check identified no issues (0 silenced).
test_home_url_resolves_home_view (boards.tests.HomeTests) ... ok
test_home_view_status_code (boards.tests.HomeTests) ... ok

----------------------------------------------------------------------
Ran 2 tests in 0.017s

OK
Destroying test database for alias 'default' ('file:memorydb_default?mode=memory&cache=shared')...

设置verbosity参数会打印出不同程度的日志详情：0表示无输出、1表示正常输出、2表示详细输出。

静态文件(Static Files)配置

静态文件指的是CSS、JavaScripts、字体、图片或我们可以用来生成界面的任何其他资源。

事实上，Django不提供这些文件，除非能在开发过程中为我们提供更多的便利。不过Django提供了一些功能来帮助我们管理静态文件。这些功能由已在INSTALLED_APPS配置中列出的django.contrib.staticfiles应用程序提供。

有这么多的前端组件库可用，没有理由继续使用简陋的HTML文档，我们可以很容易地将bootstrap4添加到我们的项目中。Bootstrap是一个开源工具包，用于使用HTML、CSS和JavaScript进行开发。

在myproject根目录下，与boards、templates、myproject文件夹一起，新建一个名为static的文件夹，在static文件夹中再创建一个名为css的文件夹：

myproject/
 |-- myproject/
 |    |-- boards/
 |    |-- myproject/
 |    |-- templates/
 |    |-- static/       <-- 这里
 |    |    +-- css/     <-- 这里这里！
 |    +-- manage.py
 +-- venv/

打开getbootstrap.com，下载他们的最新Release版本:

下载Compiled CSS and JS版本.

在电脑上打开下载好的bootstrap-4.0.0-beta-dist.zip文件(这里可能是其他更新的版本)，并将css/bootstrap.min.css拷贝到刚刚创建的css目录下:

myproject/
 |-- myproject/
 |    |-- boards/
 |    |-- myproject/
 |    |-- templates/
 |    |-- static/
 |    |    +-- css/
 |    |         +-- bootstrap.min.css    <-- 这里
 |    +-- manage.py
 +-- venv/

下一步就是配置Django项目，让它能够定位到静态文件。打开settings.py文件，在文档最后面，紧跟STATIC_URL添加下面的代码：

STATIC_URL = '/static/'

STATICFILES_DIRS = [
    os.path.join(BASE_DIR, 'static'),
]

还记得吗？跟之前配置TEMPLATES一样。

现在我们需要在我们的html文件中使用这些静态文件(Bootstrap CSS)：

templates/home.html

{% load static %}<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title>Boards</title>
    <link rel="stylesheet" href="{% static 'css/bootstrap.min.css' %}">
  </head>
  <body>
    <!-- body suppressed for brevity ... -->
  </body>
</html>

首先我们在模板最开始加上{% load static %}。

{% static %}这个标签会通过设置文件settings.py去找到资源文件的目录STATIC_URL，在这里就将{% static 'css/bootstrap.min.css' %}表示为/static/css/bootstrap.min.css，最终就是访问到http://127.0.0.1:8000/static/css/bootstrap.min.css。

假如需要将STATIC_URL改为子域名https://static.example.com/，就需要修改配置为STATIC_URL=https://static.example.com/，这样的话{% static 'css/bootstrap.min.css' %}将会访问到https://static.example.com/css/bootstrap.min.css.

如果你还不能理解上面的工作原理，别担心，你只需要记住在需要使用CSS、JavaScript或者图片文件时增加{% static %}标签就可以了。我们会在后面更加详细的谈到这个问题，但现在，所有的配置都搞定了。

刷新链接127.0.0.1:8000，我们就可以看到它的作用：

现在我们来编辑一下HTML模板，使用一些更友好的界面元素：

{% load static %}<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <title>Boards</title>
    <link rel="stylesheet" href="{% static 'css/bootstrap.min.css' %}">
  </head>
  <body>
    <div class="container">
      <ol class="breadcrumb my-4">
        <li class="breadcrumb-item active">Boards</li>
      </ol>
      <table class="table">
        <thead class="thead-inverse">
          <tr>
            <th>Board</th>
            <th>Posts</th>
            <th>Topics</th>
            <th>Last Post</th>
          </tr>
        </thead>
        <tbody>
          {% for board in boards %}
            <tr>
              <td>
                {{ board.name }}
                <small class="text-muted d-block">{{ board.description }}</small>
              </td>
              <td class="align-middle">0</td>
              <td class="align-middle">0</td>
              <td></td>
            </tr>
          {% endfor %}
        </tbody>
      </table>
    </div>
  </body>
</html>

然后再刷新:

到目前为止，我们还是使用交互式控制台(python manage.py shell)来对数据进行维护和管理。但我们需要一个更好的方法。在下一节中，将实现一个管理界面来进行管理。

Django管理模块简介

当创建一个项目时，Django就自动为我们创建了Django Admin应用程序并记录在INSTALLED_APPS下。

举两个用户管理权限的例子：在博客类应用中，作者角色有编写和发布文章的权限；而在电商类网站中，工作人员有创建、编辑、删除产品的权限。

现在，我们先为Django管理员添加版块的管理权限。

首先创建一个超级管理员账户：

python manage.py createsuperuser

按照说明补充信息(可以自行决定信息内容)：

Username (leave blank to use 'vitorfs'): admin
Email address: admin@example.com
Password:
Password (again):
Superuser created successfully.

现在让我们打开网页: http://127.0.0.1:8000/admin/

使用刚刚创建的超级管理员进行登录，输入username和password：

现在已经可以看到默认为我们添加了一些功能，可以配置Users和Groups的权限，稍后我们再对此进行深入讨论。

添加对版块Board的管理功能非常简单，只需要打开boards应用目录下的admin.py文件，添加下面的代码：

boards/admin.py

from django.contrib import admin
from .models import Board

admin.site.register(Board)

保存admin.py文件，点击刷新按钮：

好了，现在我们可以点击Boards去查看在数据库中的版块信息：

如果需要添加一个版块到数据库中，点击Add Board按钮：

然后点击save按钮：

我们可以打开首页http://127.0.0.1:8000来看看是否添加成功:

小结

在本教程中，我们探讨了许多新概念。我们为我们的项目定义了一些需求，创建了第一个模型，迁移了数据库，开始使用模型API。我们创建了第一个视图并编写了一些单元测试。我们还配置了Django模板引擎、静态文件，并将bootstrap4库添加到项目中。最后，我们简要介绍了Django管理接口。

项目的源代码可以在GitHub上找到。项目的当前状态可以在发布标签v0.2-lw下找到。下面的链接将带您找到正确的位置：

https://github.com/sibtc/django-ginners-guide/tree/v0.2-lw

上一节：Django初学者入门指南1-初识(译&改)

下一节：Django初学者入门指南3-高级概念(译&改)