赵走x博客 - 开发者的网上家园

5、模型与数据库

资源编号:76308 Tango with Django Python Web 热度：72

说到数据库，你往往会想到结构化查询语言（Structured Query Language，SQL），这是从数据库中查询所需数据的常用工具。然而在 Django 中，查询底层数据库这项操作由对象关系映射器（Object Relational Mapper，ORM）负责。在 ORM 中，存储在一个数据库表中的数据封装为一个模型。模型则是描述数据库表中数据的 Python 对象。Django 不直接通过 SQL 查询数据库，而是使用相应的 Python 模型对象操纵。

说到数据库，你往往会想到结构化查询语言（Structured Query Language，SQL），这是从数据库 中查询所需数据的常用工具。然而在 Django 中，查询底层数据库这项操作由对象关系映射器 （Object Relational Mapper，ORM）负责。在 ORM 中，存储在一个数据库表中的数据封装为一个 模型。模型则是描述数据库表中数据的 Python 对象。Django 不直接通过 SQL 查询数据库，而是 使用相应的 Python 模型对象操纵。

本章介绍使用 Django 及其 ORM 管理数据的基础知识。你会发现，通过 ORM 添加、修改和删除 底层数据库中的数据特别简单，而且把数据库中的数据检索出来提供给 Web 浏览器使用也十分方 便。

# 5.1 Rango 的要求

学习新知识之前，先回顾一下 Rango 应用对数据的要求。详细要求参见前文，这里只简要列出客 户的要求。

❏ Rango 其实是个网页目录，全是指向其他网站的链接。

❏ 网页有分类，一个分类中有一系列链接。第 1 章说过，我们假定这是一对多关系，如下面 的实体-关系图所示。

❏ 分类有名称，要记录查看次数和点赞次数。

❏ 网页有标题和 URL，要记录访问次数。

![bs64](https://img.handsomemark.com/2020/02/13/a8a93ebe-4e71-11ea-8525-0242ac140002.png)

图 5-1：两个主要实体之间的 ER 图

# 5.2 设置数据库

创建模型之前要设置数据库。新建项目时，Django 已经自动在 settings.py 模块中添加了 DATABASES 变量，其值类似下面这样：
```
DATABASES = {
		'default': {
				'ENGINE': 'django.db.backends.sqlite3',
				'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
				}
		}
```

对 Rango 应用来说，使用默认值基本就行了。可以看到，default 数据库由一个轻量级数据库引 擎驱动，即 SQLite（见 ENGINE 键）。NAME 键的值是数据库文件的路径，默认为 Django 项目根目 录中的 db.sqlite3。

>Git 提示
如果你使用 Git，很可能想把数据库文件纳入版本控制。这可不是个好主意，因为如果你与 别人协作的话，它们说不定会修改数据库，这会导致无穷尽的冲突。
正确的做法是把 db.sqlite3 添加到 .gitignore 文件中，在提交和推送时排除数据库文件。*.pyc 和设备专用的文件也应该忽略。

Django 数据库框架支持多种不同的数据库引擎，例如 PostgresSQL、MySQL 和微软的 SQL Server。使用这些数据库引擎时，可以使用 USER、PASSWORD、HOST 和 PORT 等键配置。
本书不说明如何使用其他数据库引擎，如果想了解这方面的知识，请到网上查找资源。可以 从 [Django 文档](https://docs.djangoproject.com/en/1.9/ref/databases/#storage-engines "Django 文档")开始。

SQLite 足够说明 Django ORM 的功能了。如果你的应用大受欢迎、流量激增，或许应该考虑 换用更可靠的数据库后端。

# 5.3 创建模型

在 settings.py 模块中配置好数据库之后，下面创建 Rango 应用所需的两个数据模型。Django 应用 的模型保存在应用目录中的 models.py 模块里。因此，Rango 应用的模型保存在 rango/models.py 文件中。

我们要定义两个类，一个类对应一个模型。这两个类都要继承基类 django.db.models.Model，分 别表示分类和网页。参照下述代码片段定义 Category 和 Page 模型。
```
from django.db import models

# Create your models here.

class Category(models.Model):
    name = models.CharField(max_length=128, unique=True)

def __str__(self):  # Python 2 还要定义 __unicode__
        return self.name

class Page(models.Model):
    category = models.ForeignKey(Category)
    title = models.CharField(max_length=128)
    url = models.URLField()
    views = models.IntegerField(default=0)

def __str__(self):  # Python 2 还要定义 __unicode__
        return self.title

```

>`__str__() vs. __unicode__()`
在 Python 中，`__str_()` 和` __unicode__() `方法生成类的字符串表示形式（类似于 Java 中的 toString() 方法）。在 Python 2.x 中，`__str__() `方法以 ASCII 格式表示字符串；如果需要 支持 Unicode，还要实现 `__unicode__()` 方法。 在 Python 3.x 中，字符串默认就支持 Unicode，因此只需实现 `__str__()` 方法。

定义模型时，要指定字段及其类型，并提供必须或可选的参数。默认情况下，每个模型都有一个 自增整数字段，名为 id。这个字段自动分配，用作主键。 Django 内置的字段类型无所不包。下面介绍其中最常用的几个：

❏ CharField：存储字符数据（如字符串）的字段。max_length 参数指定最多可存储的字符 数。
❏ URLField：类似于 CharField，不过是专用于存储 URL 的。也可指定 max_length 参数。
❏ IntegerField：存储整数。
❏ DateField：存储 Python datetime.date 对象。

>其他字段类型
Django 提供的全部字段类型，以及各自必须和可选的参数说明，参见 [Django 文档](https://docs.djangoproject.com/es/1.9/ref/models/fields/#model-field-types "Django 文档")。

每个字段都可指定 unique 参数，设为 True 时，字段的值在模型对应的底层数据库表中必须是唯 一的。看一下前面定义的 Category 模型。name 字段设为唯一的了，这表明每个分类的名称必须是 唯一的。这也意味着，可以把 name 字段用作主键。 此外，各字段还可指定其他参数，例如通过 default='value' 设定默认值，指定字段的值可以为 空（null=True）或者不可以为空（null=False）。 为了建立模型之间的关系，Django 提供了三个字段类型，分别是：

❏ ForeignKey：用于建立[一对多关系](https://en.wikipedia.org/wiki/One-to-many_(data_model) "一对多关系")。
❏ OneToOneField：用于建立[一对一关系](https://en.wikipedia.org/wiki/One-to-one_(data_model) "一对一关系")。 
❏ ManyToManyField：用于建立[多对多关系](https://en.wikipedia.org/wiki/Many-to-many_(data_model) "多对多关系")。

在我们定义的模型中，Page 模型中的 category 字段是 ForeignKey 类型。我们在字段的构造方法 中指定，与 Category 模型建立一对多关系。

最后，建议实现` __str__()` 和（或`）__unicode__() `方法。如果不实现，使用 print 打印对象时将 显示` <Category: Category object>`，这对调试没什么帮助；如果实现的话，打印“Python”分类时 将显示 `<Category: Python>`。这两个方法在管理界面中也用得到，因为 Django 会在管理后台中显 示对象的字符串表示形式。

# 5.4 创建和迁移数据库

在 models.py 中定义好模型之后，可以让 Django 施展魔法，在底层数据库中创建表了。为此， Django 提供了迁移工具，让它帮助我们设置和更新数据库，体现模型的改动。例如，添加新字段 后可以使用迁移工具更新数据库。

### 设置

首先，数据库必须预置，即创建数据库及相关的表。请打开终端或命令提示符，进入项目的根目 录（manage.py 文件所在的目录），执行下述命令。注意，你看到的输出可能与这里不一样。
```
$ python manage.py migrate

Operations to perform:

Apply all migrations: admin, contenttypes, auth, sessions Running migrations:

Rendering model states... DONE 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 sessions.0001_initial... OK
```

执行这个命令后，项目中安装的所有应用都会更新各自的数据库表。这个命令执行完毕后，Django 项目的根目录中会出现 db.sqlite3 文件。

然后，创建一个超级用户（superuser），用于管理数据库。执行下述命令：

$ python manage.py createsuperuser

这个超级用户在本章后面将用于访问 Django 管理界面。请根据提示输入用户名、电子邮件地址和 密码。别忘了记下超级用户的用户名和密码。

### 创建和更新模型/表

每次修改应用的模型都要通过 manage.py 中的 makemigrations 命令登记改动。在 Django 项目的根 目录中执行下述命令，指明目标为 rango 应用：
```
$ python manage.py makemigrations rango

Migrations for 'rango':

0001_initial.py:

- Create model Category

- Create model Page
```
上述命令执行完毕后，rango/migrations 目录中会出现一个 Python 脚本，名为 0001_initial.py。这 个脚本中包含此次迁移创建数据库模式所需的一切信息。

>检查底层 SQL
如果想查看 Django ORM 为某个迁移执行的底层 SQL，可以执行下述命令：
```
$ python manage.py sqlmigrate rango 0001
```
这里，rango 是应用的名称，0001 是想查看 SQL 代码的迁移。这样做能更好地理解数据库层 具体做了哪些操作，例如创建了什么表。你可能会发现其中包含复杂的数据库模式，比如建 立多对多关系时会创建额外的表。

创建好迁移后，要提交到数据库。为此要再次执行 migrate 命令。
```
$ python manage.py migrate
Operations to perform:

Apply all migrations: admin, rango, contenttypes, auth, sessions Running migrations:

Rendering model states... DONE Applying rango.0001_initial... OK
```
输出表明在数据库中创建了所需的表。

不过，你可能注意到了，根据客户对 Rango 提出的要求，Category 模型还缺少一些字段。别担 心，后面会再次通过迁移加上。

# 5.5 Django 模型和 shell

暂不介绍 Django 管理界面，先来看看 Django shell。这个工具对调试十分有用，可以直接与 Django 模型交互。下面说明如何在 shell 中创建 Category 实例。

为了打开 shell，我们要再次在项目的根目录中运行 manage.py 脚本。执行下述命令：
```
$ python manage.py shell
```
这个命令启动 Python 解释器，并加载项目的设置。在这个 shell 中可以与模型交互，具体方法参 见下述终端会话中的演示。留意笔者加上的注释，了解各命令的作用。注意，Django 1.9 和 1.10 返回的结果稍有不同，下述示例都给出了，并在注释中做了说明。
```
# 从 Rango 应用中导入 Category 模型 
>>> from rango.models import Category

# 显示目前的所有分类 
>>> print(Category.objects.all()) 
# 下述输出分别针对 Django 1.9 和 Django 1.10 
# 意思是一样的，都表示还未定义分类 [] 
# Django 1.9 的输出：一个空列表 <QuerySet []> 
# Django 1.10 的输出：一个空 QuerySet 对象

# 创建一个分类对象，存入数据库

>>> c = Category(name="Test")

>>> c.save()

# 再次列出所有分类对象 >>> print(Category.objects.all())

# 下述输出分别针对 Django 1.9 和 Django 1.10 
# 两个输出中都有测试分类 
[<Category: Test>] # Django 1.9 
<QuerySet [<Category: Test>] # Django 1.10

# 退出 Django shell 
>>> quit()
```

这里，我们先导入要操纵的模型。然后打印现有的全部分类。因为底层的 category 表是空的，所 以返回一个空列表。之后，我们创建并保存了一个 Category 对象，然后再次打印所有分类。这一 次打印发现有个新分类。注意，第二次打印显示了分类的名称，这是` __str__()` 或` __unicode__() `方法的功劳。

以上只是简单演示，除此之外，在 Django shell 中可以执行的操作还有很多。如果你还没阅 读 Django 官方教程的[第二部分](https://docs.djangoproject.com/en/1.9/intro/tutorial02/ "第二部分")，现在是个好时机，请留意在 shell 中与模型交互的更多方 法。顺便看一下 Django 文档中列出的[模型操作命令](https://docs.djangoproject.com/en/1.9/ref/django-admin/#available-commands "模型操作命令")。

# 5.6 配置管理界面

Django 广受欢迎的一个功能是内置的 Web 管理界面，在这里你可以浏览、标记和删除模型实例 表示的数据。本节将做些设置，让你在管理界面中查看 Rango 应用的两个模型。

相关的设置很简单。在项目的 settings.py 模块中你可能注意到了，有个预装的应用是 django.contrib.admin（在 INSTALLED_APPS 列表中）。此外，在项目的 urls.py 模块中有个匹配 admin/ 的 URL 模式（在 urlpattern 中）。

其实，使用默认的设置基本就行了。执行下述命令，启动 Django 开发服务器：
```
$ python manage.py runserver
```
然后打开 Web 浏览器，访问 http://127.0.0.1:8000/admin/ 。你会看到登录界面。使用创建超级用户 时提供的凭据登录。登录后会看到类似图 5-2 所示的界面。

![bs64](https://img.handsomemark.com/2020/02/13/4ec59d1e-4e73-11ea-8934-0242ac140002.png)
图 5-2：Django 管理界面，没有 Rango 应用的模型

看起来不错，但是没有 Rango 应用的 Category 和 Page 模型。为了显示这两个模型，我们要给 Django 一些提示。

打开 rango/admin.py 文件，注册想在管理界面显示的类。下述代码注册 Category 和 Page 两个 类。
```
from django.contrib import admin 
from rango.models import Category, Page

admin.site.register(Category) 
admin.site.register(Page)
```
如果以后添加更多模型，只需再调用 admin.site.register() 方法。

改好之后，重启 Django 开发服务器，然后再次访问 http://127.0.0.1:8000/admin/ 。现在能看到 Category 和 Page 模型了，如图 5-3 所示。

![bs64](https://img.handsomemark.com/2020/02/13/674f53c0-4e73-11ea-b2bd-0242ac140002.png)
图 5-3：Django 管理界面中显示了 Rango 应用的模型

点击“Rango”区下的 Categorys 链接试试。你应该会看到前面在 Django shell 中创建的 Test 分类。

用户也在 Django 管理界面中管理，在“Authentication and Authorisation”区。你可以创建、修 改和删除用户账户，还可以赋予用户不同的权限等级。

发现没有，管理界面中有拼写错误（应该是 Categories，而不是 Categorys）？为了修正这 个错误，可以在模型定义中添加嵌套的 Meta 类，在里面声明 verbose_name_plural 属性。下 面是修改后的 Category 模型。Meta 类有很多作用，详情参见 [Django 文档](https://docs.djangoproject.com/en/1.9/topics/db/models/#meta-options "Django 文档")。

```
class Category(models.Model):
    name = models.CharField(max_length=128, unique=True)

class Meta:
        verbose_name_plural='Categories'

def __str__(self):  # Python 2 还要定义 __unicode__
        return self.name
```

不难看出，admin.py 差不多是 Rango 应用中内容最少的模块。其实，在这个模块中能以多种 方式定制管理界面。如果感兴趣，请阅读 Django 文档。

# 5.7 编写一个填充脚本

把测试数据输入数据库是件麻烦事。很多开发者选择随机按键，输入虚假的测试数据，例如 wTFzmN00bz7。与其这样，不如编写一个脚本，把真实可信的数据自动填充到数据库中。如此一 来，演示或测试应用时，你将看到合理的示例。而且，部署应用或者与同事分享时，你自己和同 事无需自己动手输入示例数据。鉴于此，最好编写一个填充脚本。

下面为 Rango 应用编写一个填充脚本。在 Django 项目的根目录中新建一个 Python 文件，命名为 populate_rango.py，写入下述代码：

```
import os

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'tango_with_django_project.settings')

import django

django.setup()

from rango.models import Category, Page

def populate():
    # 首先创建一些字典，列出想添加到各分类的网页
    # 然后创建一个嵌套字典，设置各分类
    # 这么做看起来不易理解，但是便于迭代，方便为模型添加数据
    python_pages = [
        {"title": "Official Python Tutorial", "url": "http://docs.python.org/2/tutorial/"},
        {"title": "How to Think like a Computer Scientist", "url": "http://www.greenteapress.com/thinkpython/"},
        {"title": "Learn Python in 10 Minutes", "url": "http://www.korokithakis.net/tutorials/python/"}]

django_pages = [
        {"title": "Official Django Tutorial", "url": "https://docs.djangoproject.com/en/1.9/intro/tutorial01/"},
        {"title": "Django Rocks", "url": "http://www.djangorocks.com/"},
        {"title": "How to Tango with Django", "url": "http://www.tangowithdjango.com/"}]

other_pages = [
        {"title": "Bottle", "url": "http://bottlepy.org/docs/dev/"},
        {"title": "Flask", "url": "http://flask.pocoo.org"}]

cats = {"Python": {"pages": python_pages},
            "Django": {"pages": django_pages}, "Other Frameworks": {"pages": other_pages}}

def add_cat(name):
        c = Category.objects.get_or_create(name=name)[0]
        c.save()
        return c

def add_page(cat, title, url, views=0):
        p = Page.objects.get_or_create(category=cat, title=title)[0]
        p.url = url
        p.views = views
        p.save()
        return p

# 如果想添加更多分类或网页，添加到前面的字典中即可

# 下述代码迭代 cats 字典，添加各分类，并把相关的网页添加到分类中
    # 如果使用的是 Python 2.x，要使用 cats.iteritems() 迭代
    # 迭代字典的正确方式参见 # http://docs.quantifiedcode.com/python-anti-patterns/readability/
    for cat, cat_data in cats.items():
        print("cat:",cat)
        c = add_cat(cats)

for p in cat_data['pages']:
            add_page(c, p['title'], p['url'])

# 打印添加的分类
    for c in Category.objects.all():
        for p in Page.objects.filter(category=c):
            print("-{0}-{1}".format(c, p))

# 从这开始执行
if __name__ == '__main__':
    print("Starting Rango population script...")
    populate()

```

看着代码很多，其实就是对模块后部定义的` add_page()` 和 `add_cat()` 两个函数的调用。上述代码 从模块的底部开始执行，即第 71 和 72 行。这是因为在此之前是函数定义，并未调用，因此也就 未执行。解释器遇到第 70 行的` if __name__ == '__main__'` 时调用 populate() 函数。

>`__name__ == '__main__' `是什么意思？
`__name__ == '__main__' `是个有用的技巧，既让 Python 模块作为可重用的模块，也让其作为 独立的 Python 脚本。可重用的模块是指可以导入其他模块（例如通过 import 语句），而独 立的 Python 脚本可以在终端或命令提示符中执行（python module.py）。
因此，`if __name__ == '__main__'` 条件语句中的代码仅在作为独立的 Python 脚本运行时才 执行。如果作为模块导入，那一段代码不执行，因为导入做是为了访问模块中的类或函数。

导入 Django 模型之前要导入 django，并把环境变量 DJANGO_SETTINGS_MODULE 设为项目的设 置文件，然后调用 django.setup()，导入 Django 项目的设置（第 1-6 行）。

如果缺少这重要的一步，导入模型时会抛出异常，这是因为所需的 Django 基础设施未初始 化。鉴于此，我们在第 7 行才导入 Category 和 Page 模型。

第 47-50 行的 for 循环负责不断调用 add_cat() 和 add_page() 函数。这两个函数的作用分别是创 建分类和网页。populate() 函数会记录创建了哪些分类。我们在第 48 行把分类存储在局部变量 c 中，因为创建 Page 对象时要引用 Category 对象。调用 add_cat() 和 add_page() 函数后， populate() 迭代所有 Category 和相应的 Page 对象，把它们的名称显示在终端中。

在上述填充脚本中，我们使用便利的 get_or_create() 方法创建模型实例。由于我们不想创 建重复的记录，因此使用 get_or_create() 方法检查数据库中有没有要创建的记录；如果没 有，创建指定的记录；否则，返回那个模型实例的引用。

这个辅助方法能避免我们编写大量重复的代码。既然有这样的方法存在，何必自己动手检查 呢！

get_or_create() 方法返回一个元组 (object, created)。第一个元素是数据库中不存在记录

时创建的模型实例引用。这个模型实例使用传给 get_or_create() 方法的参数创建，例如上 例中的 category、title、url 和 views。如果数据库中存在相应的记录，get_or_create() 方 法返回那个记录。created 是布尔值，get_or_create() 创建模型实例时值为 True。

了解这些之后我们便知道 get_or_create() 后面的 [0] 表示只返回对象引用。与很多其他编程语言数据结构一样，Python 元组中的元素从零开始编号。

保存文件，在终端把当前工作目录切换到 Django 项目的根目录，然后执行 python populate_rango.py 命令。你应该会看到类似下面的输出，在不同的电脑中添加分类的顺序可能有 所不同。
```
$ python populate_rango.py

Starting Rango population script...

- Python - Official Python Tutorial

- Python - How to Think like a Computer Scientist

- Python - Learn Python in 10 Minutes

- Django - Official Django Tutorial

- Django - Django Rocks

- Django - How to Tango with Django

- Other Frameworks - Bottle

- Other Frameworks - Flask
```
然后，确认填充脚本确实把数据填充进数据库中了。重启 Django 开发服务器，访问管理界面 （http://127.0.0.1:8000/admin/ ），检查有没有新的分类和网页出现。点击“Pages”，有没有看到所 有网页，如下图所示？

![bs64](https://img.handsomemark.com/2020/02/13/253ea282-4e74-11ea-ba18-0242ac140002.png)
图 5-4：Django 管理页面中显示着填充脚本添加的网页

# 5.8 基本流程

我们已经学习了 Django ORM 的核心概念，现在是时候总结一下了。为了便于参考，笔者把整个 过程分成了几部分。如果以后你想回顾这个过程，可以随时翻阅这一节。 设置数据库 新建项目后应该告诉 Django 你想用什么数据库（settings.py 模块中的 DATABASES 设置）。此外， 还可以在 admin.py 模块中注册模型，以便在管理界面中管理。 添加模型 添加模型的过程可以分为以下 5 步。

➊ 首先在 Django 应用的 models.py 文件中定义模型。
➋ 更新 admin.py，注册新增的模型。 
➌ 生成迁移：python manage.py makemigrations <app_name>。 
➍ 运行迁移：python manage.py migrate。在数据库中创建模型所需的表和字段。
➎ 创建或编辑填充脚本。

有时你可能想删除数据库，重头再来。具体步骤如下。注意，本书使用的是 SQLite 数据库，此外 Django 还支持其他数据库引擎。

➊ 如果 Django 开发服务器正在运行，停止。

➋ 如果使用的是 SQLite 数据库，删除 Django 项目根目录中的 db.sqlite3 文件。这个文件与 manage.py 脚本位于同一级目录中。

➌ 如果修改过应用的模型，执行 python manage.py makemigrations <app_name> 命令，记得把 <app_name> 替换成 Django 应用的名称（例如 rango。）如果未修改模型，跳过这一步。

➍ 执行 python manage.py migrate 命令，新建数据库文件（使用 SQLite 的话），并创建数据 库表。

➎ 执行 python manage.py createsuperuser 命令，创建一个超级用户。

➏ 最后，运行填充脚本，在新数据库中插入可信的测试数据。

![bs64](https://img.handsomemark.com/2020/02/13/509b99c6-4e74-11ea-83b5-0242ac140002.png)
图 5-5：更新后的管理界面，Page 模型页面显示有网页的分类和 URL