IBM全栈开发【9】：使用SQL和数据库开发Django应用程序

近期在学习IBM全栈应用开发微学士课程，故此记录学习笔记。

1. 数据库入门

1.1. SQL

SQL 全称是 Structured Query Language，是为管理关系数据库中的数据而设计的，对于处理结构化数据非常有用。

数据是由文字、数字和图片组成的事实集合。而数据库是一个数据存储库，提供添加、修改和查询数据的功能。

关系数据库将表格数据存储为相关项目的集合，列中包含项目属性。非关系型数据库提供了一种灵活、可扩展的数据存储和检索方法。

关系数据库是优化存储、检索和处理大量数据的理想选择。

实体-关系模型（Entity-Relationship model）是设计关系数据库的工具。实体变为表、属性变为列。

基本 SQL 语句包括 CREATE TABLE、INSERT、SELECT、UPDATE 和 DELETE。

IBM DB2、SQL Server、MySQL、Oracle Database 和 PostgreSQL 都是有名的关系数据库。

部分有名的云关系数据库包括 RDS、Google Cloud SQL、IBM DB 2 on Cloud、Oracle Cloud 和 SQL Azure。

1.1.1. 用例

OLTP（Online Transaction Processing，在线事务处理）应用程序侧重于高速运行的事务型任务。关系数据库非常适合 OLTP 应用程序，因为它们可以容纳大量用户、支持插入更新或删除少量数据，还支持频繁查询和更新以及快速响应时间。

在数据仓库环境中，关系数据库可针对在线分析处理（或 OLAP）进行优化。在 OLAP 中，历史数据可用于商业智能分析。

物联网解决方案要求速度以及从边缘设备收集和处理数据的能力，这就需要一个轻量级的数据库解决方案。

1.2. RDBMS

DBRM 全称为 Database Management System，也就是数据库管理系统，是一组创建和维护数据库的程序。它允许存储、修改和查询数据库中的信息。

RDBMS 全称是 Rational Database Management System，也就是关系数据库管理系统。这是一种成熟的、文档齐全的技术，具有灵活性、减少冗余、易于备份和灾难恢复，并符合 ACID 标准。

ACID 标准是指数据库管理系统在写入或更新资料的过程中，为保证交易是正确可靠的，所必须具备的四个特性：

• 原子性，或称不可分割性（Atomicity）
• 一致性（Consistency）
• 隔离性（Isolation）
• 持久性（Durability）

1.2.1. 限制

RDBMS 不能很好地处理半结构化或非结构化数据，因此不适合对此类数据进行广泛分析。

要在两个 RDBMS 之间进行迁移，源表和目标表之间的模式和数据类型必须相同。

关系数据库对数据字段的长度有限制，这意味着如果尝试输入的信息超过字段所能容纳的长度，信息将不会被存储。

尽管数据有其局限性和演变性，但在大数据云计算、物联网设备和社交媒体时代，RDBMS 仍然是处理结构化数据的主要技术。

1.3. NoSQL

NoSQL 在过去的文章中有提到过，全称为 Not Only SQL（不只是SQL），有时也指非 SQL，是一种非关系型数据库设计，为数据的存储和检索提供灵活的模式。

NoSQL 数据库有四种常见类型：

• 键值存储
• 基于文档
• 基于列
• 基于图形

1.3.1. 键值存储

键值数据库中的数据以键值对集合的形式存储。键代表数据的一个属性，是唯一的标识符。键和值可以是简单的整数或字符串，也可以是复杂的 JSON 文档。

键值存储非常适用于存储用户会话数据和用户偏好、实时推荐和定向广告以及内存数据缓存。

但是，如果想查询特定数据值的数据、需要数据值之间的关系，或者需要多个唯一键，键值存储可能不是最合适的选择。

Redis、Memcached 和 DynamoDB 就是这类数据库中的一些著名例子。

1.3.2. 基于文档

基于文档的文档数据库将每条记录及其相关数据存储在单个文档中。它们可以对文档集合进行灵活的索引、强大的临时查询和分析。文档数据库适用于电子商务平台、医疗记录、存储、客户关系管理平台和分析平台。

但是如果希望运行复杂的搜索查询和多操作事务，那么基于文档的数据库可能就不是最佳选择。

MongoDB、DocumentDB、CouchDB 和 Cloudant 是一些流行的基于文档的数据库。

1.3.3. 基于列

基于列的模型将数据存储在以数据列而不是行分组的单元格中。

列的逻辑分组，即通常一起访问的列，称为列族。例如，客户的姓名和个人资料信息很可能会一起被访问，但他们的购买历史记录却不会一起被访问，因此客户姓名和个人资料信息数据可以归入一个列族。

由于列数据库将与列相对应的所有单元格存储为连续的磁盘条目，因此访问和搜索数据的速度非常快。对于需要大量写入请求、存储时间序列数据、天气数据和物联网数据的系统来说，列式数据库是个不错的选择。

但是，如果您需要使用复杂的查询或经常改变查询模式，这可能不是最佳选择。

最流行的列数据库是 Cassandra 和 HBase。

1.3.4. 基于图形

基于图形的数据库使用图形模型来表示和存储数据。

它们特别适用于可视化、分析和查找不同数据之间的联系。圆圈是节点，包含数据，箭头代表关系。图形数据库是处理关联数据（即包含大量相互关联关系的数据）的最佳选择。

图形数据库非常适合社交网络、实时产品推荐、网络图、欺诈检测和访问管理。

但如果您想处理大量事务，它可能不是最佳选择，因为图形数据库没有针对大量分析查询进行优化。

Ne04J 和 CosmosDB 是比较流行的图数据库。

1.4. 测验

您正在为一家网上商店建立一个网站。您需要存储产品信息、客户详细信息和订单历史记录。以下哪项最恰当地描述了数据库在这种情况下的作用？

在这种情况下，数据库是相关表格的集合。它提供了一种结构化的方式，将产品信息、客户详情和订单历史记录存储在不同的表格中，从而实现高效管理和数据检索。

以下哪项是 RDBMS 的最大优势？

符合 ACID 标准是 RDBMS 的重要优势之一。ACID 代表原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability），可确保数据事务得到可靠处理。

在图书馆实体-关系数据模型中，图书是 _____ 的一个示例，而图书的书名、版本和出版日期则是 _______ 的示例。

在实体-关系模型中，实体是一个名词（人、地点或事物）。属性是实体的属性或特征。

关于数据库，以下哪些说法是正确的？

数据库是逻辑上连贯的数据集合，具有一定的内在含义。

关系型数据库的主要优势是什么？

关系模型提供了逻辑和物理数据的独立性，允许在不影响底层数据库结构的情况下访问和修改数据。

2. ORM：弥合现实世界与关系模型之间的差距

2.1. Django

Django 是一个可访问的高级开源 Python 网页框架。

Django 采用模型视图控制器 MVC 模式，可帮助开发人员快速高效地构建网络应用程序，从而实现快速开发和代码重用。用户几乎可以用 Django 构建任何网络应用程序，包括内容管理系统（CMS）、社交媒体平台、商业应用程序和新网站。

Django 提供了一系列开箱即用的特性和功能：Django 提供了一个对象关系映射或称 ORM 层，允许使用 Python 类定义数据模型。这使得使用数据库和执行操作变得更加容易。例如查询、插入、更新和删除记录。

Django 有一个内置模板引擎，使开发人员能够将应用程序的业务逻辑与表现逻辑分开。

Django 还提供根据应用程序中的模型自动生成的管理界面。它为管理网站内容提供了友好的用户界面，并可根据具体要求进行定制。Django 提供强大的安全功能，包括防止常见的网络漏洞，如跨站脚本（xss）、跨站请求伪造（CSRF）和 SQL 注入。

它还提供密码散列和用户会话管理机制。Django 内置身份验证和授权机制，允许管理用户账户，包括注册登录和密码管理。

它还提供细粒度的授权控制，以定义用户权限和访问限制。Django 可借助模块（也称为 Django 应用程序或包）进行扩展。这些模块是可重复使用的组件，可以将其集成到 Django 项目中，以添加特定的功能或特性。例如，Django 使用 gettext 模块支持语言本地化，Django 提供第三方软件包，如用于验证码集成的 Django Simple Captcha，它有助于防止表单中的自动僵尸提交，Django 的内置表单模块包括强大的表单。验证逻辑可确保表单数据符合标准。

Django 倡导的架构是每个网络服务器实例独立运行，称为无共享或无状态。该架构中的每个网络服务器实例都能自主处理请求和响应，而无需依赖共享资源或在请求之间维护任何服务器端状态。这使扩展变得容易，无状态使得开发人员可以添加更多应用程序实例，并在不丢失数据的情况下跨模型传输用户体验。

Django 支持各种测试，包括单元测试、集成测试和功能测试。Django 的测试框架包括一个测试运行器，允许开发人员快速运行测试并提供详细的测试报告。它提供各种测试工具、断言和固定装置，以方便编写和执行测试。

由于 Django 是基于 Python 构建的，因此与平台无关，这意味着它可以在许多平台上运行。这种平台独立性得益于 Python 的可移植性和在不同操作系统上的广泛可用性。这使得开发人员可以选择最适合其需求和基础设施的托管平台。Django 应用程序几乎可以在所有云提供商上运行。Django 的平台无关性使得可以根据具体要求和偏好将应用程序部署到各种云平台上。

一些著名的网页应用程序就是使用 Django 构建的。Instagram 是一个分享照片和视频的流行社交媒体平台，最初就是使用 Django 构建的。著名的音乐流媒体平台 Spotify 也使用了 Django 及其基础设施。著名的新闻出版物《华盛顿邮报》也采用了 Django 作为其内容管理系统或 CNS。

1.2. OOAD

面向对象的分析和设计（简称 OOAD）是一种分析和设计软件系统的方法，当系统将使用面向对象的编程语言来开发时，就需要使用这种方法。

在讨论 OOAD 之前，我们先来了解一下 Java 或 C++ 或 Python 等语言中的面向对象编程。OOAD 的核心是对象。对象包含数据，也有规定对象可以采取的行动的行为。

例如，我可以创建一个代表病人的对象。假设病人的名字是 Nia Patel、Nia 需要取消预约。不过，在创建 Nia 之前，我们必须先创建一个病人对象的通用版本。对象的通用版本称为类。接下来，让我们先讨论类，然后再详细讨论 Nia。

类是对象的蓝图或模板，从类中创建特定对象（也称为实例）。 考虑到 Nia 将是病人类的一个实例。类包含对象、通用属性、属性和方法，但只有在创建对象时，也就是代码中所谓的实例化时，这些通用属性才会被设置为特定值。病人类可能有一个名为 LastName 的变量，它是一个属性，但并不指定 LastName 是什么。Lastname 是一个占位符，直到创建了对象并分配了名称。一旦对象被实例化，就可以调用其方法使对象执行某些操作，如预约或取消预约。OOAD 可用于将系统分解为相互交互的对象。这样，多个开发人员就可以同时处理应用程序的不同方面。

1.2.1. ORM

对象关系映射（ORM）工具被广泛应用于现代软件开发中，为面向对象的编程语言和关系数据库之间架起了一座桥梁。ORM 工具提供了一种使用编程语言对象和概念与数据库交互的方便高效的方法，使开发人员无需编写复杂重复的 SQL 查询。

编程语言都有自己的 ORM 工具，可以简化数据库操作和开发流程。

• Django 是一个 Python 网络框架，内置 ORM，提供与数据库交互的高级应用编程接口（API）。Django 提供模型定义、查询构建、数据库迁移和自动查询优化等功能。

• SQLAlchemy 是一个流行的 Python 综合 ORM 库，提供了一个灵活而富有表现力的 API，用于与数据库交互。SQLAlchemy 提供高级和低级 ORM 方法，允许开发人员选择所需的抽象级别。

• web2py 是一个用 Python 编写的开源全栈网络框架，旨在通过提供包括网络服务器、数据库抽象层和基于网络的开发环境在内的一体化解决方案来简化网络应用程序开发。

• Hibernate 广泛用于 Java 应用程序，因为它提供了功能强大、特性丰富的 API，可将 Java 对象映射到关系数据库。Hibernate 支持各种数据库系统，并提供懒加载、缓存和事务管理等高级功能。

• EclipseLink 是另一种流行的 Java 工具。它是一个开源框架，为 Java 与关系数据库的映射提供广泛支持。EclipseLink 支持 Java Persistence API (JPA)、缓存、高级查询功能以及与各种应用服务器的集成等功能。

• Apache OpenJPA 是 JPA 规范的开源实现。它便于将 Java 类映射到关系数据库表，并提供透明的 Java 对象持久性。

• Entity Framework 是微软用于 .NET 应用程序的 ORM 框架。它提供了一个易于使用的 API，用于将 .NET 对象映射到关系数据库。Entity Framework 支持不同的数据库提供商，提供查询功能，并包含代码优先和数据库优先的模型创建方法等功能。

• Dapper 是.NET 的微型操作系统，注重性能和简单性。它为查询数据库提供了轻量级、高效的 API。Dapper 适用于需要直接控制 SQL 查询和执行的场景。

• NHibernate 是 .NET 平台上广泛使用的 ORM 工具。它的灵感来自 Java 的 Hibernate ORM 工具。NHibernate 在 .NET 面向对象编程和关系数据库之间架起了一座桥梁，允许开发人员使用 .NET 对象与数据库交互。

• ActiveRecord 是 Ruby on Rails（一种流行的 Ruby 网络框架）中的默认 ORM。它提供了一种“约定重于配置”的方法，可轻松将 Ruby 对象映射到数据库表。ActiveRecord 提供了模型关联、查询生成和数据库迁移等功能。

• Sequel 是一款灵活、功能丰富的 Ruby ORM 工具，它强调简单性和以 SQL 为中心的方法。Sequel 支持各种数据库系统，提供高级查询功能，并提供插件以实现更多功能。

• DataMapper 注重简洁性、灵活性和易用性。它旨在为在 Ruby 应用程序中使用数据库提供简洁直观的 API。DataMapper 的功能包括灵活的映射、数据抽象、查询和存储库模式。

• Propel 是一款适用于 PHP 的高性能 ORM 工具，专注于代码生成和简化。它采用代码优先的方法，由 PHP 类和对象定义数据库模式。Propel 可生成高效的 SQL 查询，并提供懒加载、急迫加载和缓存等功能。

• CakePHP 包含一个内置的 ORM 组件，为数据库工作提供了一个强大而直观的 API，具有数据库抽象、查询构建和关联管理等功能。

• Eloquent 是流行的 PHP 框架 Laravel 框架提供的默认 ORM。它为定义数据库模型和关系提供了简单明了、表现力丰富的语法。Eloquent 简化了数据库操作，包括查询、数据检索和数据库迁移，并支持不同的数据库引擎。

软件开发人员通常使用数据库作为应用程序的主要数据存储库，因此需要将 SQL 集成到应用程序代码中。SQL 语句必须在应用程序代码中组装，并使用数据库 API 在数据库系统中执行——检索到的数据库行将作为 cursor（一种用于遍历数据库中行的特殊控制数据结构）返回给应用程序代码。

在 Python 中运行 SQL 的例子：

connection = sqlite3.connect('course.db')
cursor = connection.cursor()

insert_statement = 'INSERT INTO data_learner (first_name, last_name, dob, occupation) VALUES ("John", "Doe", "1962-01-01", "Developer");'
cursor.execute(insert_statement)

cursor.execute('SELECT * FROM data_learner')
learner = cursor.fetchone()

与使用表格、行和列来模拟实体的 SQL 不同，面向对象语言使用类和对象来模拟实体。在 OOP 中，Course 实体将被定义为一个类，该类有两个基本属性：name 和 description；一个引用属性，即 learner 列表。

数据操作方法也需要与类属性一起定义。这里我们定义了一个简单的方法：get Learners。Learner 实体也将被定义为一个具有四个属性的类：名、姓、出生日期和职业。我们还将定义一个简单的打印个人资料方法。

connection = sqlite3.connect('course.db')
cursor = connection.cursor()

cursor.execute('SELECT * FROM data_learner')
learner_row = cursor.fetchone()

learner = Learner()
learner.first_name = learner_row['first_name']
learner.last_name = learner_row['last_name']
learner.dob = learner_row['dob']
learner.occupation = learner_row['occupation']

learner.print_profile()

我们已经看到，OOP 和 SQL 的数据建模方式是不同的。OOP 使用类、对象和属性对实体建模，而 SQL 则使用表、行和列对实体建模。最后，OOP 使用方法对数据进行 CRUD，而 SQL 则使用数据操作语言（如 SQL 语句插入、删除和更新）对数据进行 CRUD。

既然我们通常使用 OOP 构建现代应用程序，那么我们是否也可以使用 OOP 而不是 SQL 访问数据库呢？这样，我们就可以坚持使用一种编程范式进行开发。人们发明对象关系映射的主要原因是为了弥合 OOP 与 SQL 之间的差距，使使用 OOP 语言访问数据库成为可能。ORM 库或工具可以将关系数据库中存储的数据映射和传输为行到对象或对象到行。

假设我们有一个由开发人员使用 OOP 创建的 Learner 对象模型。ORM 可以帮助将 Learner 对象转移到 Learner 表中的 Learner 行中，并将其读回 Learner 对象。这就减少了开发人员的工作量，因为他们只需关注对象操作。下面是 ORM 如何以一行代码的形式传输三个表连接的 SQL 查询。

SQL 代码例子：

connection = sqlite3.connect('sample.db')
cursor = connection.cursor()
select_statement = 'SELECT learner.name FROM learner INNER JOIN enrollment ON (learner_id = enrollment.learner_id) INNER JOIN course ON (course_id = enrollment.course_id) WHERE course.name = "Introduction to Python"'

cursor.execute(select_statement)
learners = cursor.fetchall()

ORM 代码例子：

Course.objects.get(name='Introduction to Python').learners.all()

在开发 OOP 应用程序时，只需定义类和创建对象，无需编写 SQL 即可使用数据库。此外还可以使用一个 ORM 接口来管理多个数据库系统，而不必担心 SQL 语法的差异。所有这些优势都将加快应用程序的交付速度。

但是 SQL 和 OOP 仍然是两种不同的语言，具有不同的建模概念，而且 ORM 可能无法将对象映射到数据库表中。此外，由于 ORM 将数据访问逻辑与应用程序代码结合在一起，因此任何数据库变更都需要同时更改应用程序逻辑和数据访问逻辑。由于 ORM 隐藏了实现细节，因此调试可能很困难。ORM 也有可能会降低应用程序的性能：ORM 增加了一个额外的翻译层，但不能保证翻译后的 SQL 语句得到优化。

1.2.2. Django ORM

在 Django ORM 中，每个 Django 模型都映射到一个数据库表。当您创建一个类对象时，它代表一个表行。每个字段代表一个表列。一旦定义了模型类，模式和表格就会自动生成。

class User(models.Model):
    first_name = models.CharField(max_length=30)

例如，我们可以定义一个 User 类，它是 Django 模型的子类。然后，Django 将通过生成 table create 语句并根据类字段创建列，在数据库中创建相应的 User 表。在我们的例子中，将根据 first_name 字段创建 first_name 列。模型中的每个字段都应定义为一个 Field 类。

上面的 Python 代码等同于：

CREATE TABLE data_user
(
    "id" serial NOT NULL PRIMARY KEY,
    "first_name" varchar(30) NOT NULL
)

模型中的每个字段都应定义为 Field 类。Django 会将每个字段映射为列类型。在这里，first_name 被定义为字符字段，将被转换为 varchar，而 dob 是日期字段，将被转换为 date。对于每一列，我们通过在 Django Field 类中指定参数来定义其元数据，如类型和约束条件。例如，对于 first_name 字段，我们使用 max_length 参数指定 varchar 的长度。

class User(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)
    dob = models.DateField()

等同于：

CREATE TABLE data_user
(
    "id" serial NOT NULL PRIMARY KEY,
    "first_name" varchar(30) NOT NULL,
    "last_name" varchar(30) NOT NULL,
    "dob" date NOT NULL
)

接下来，我们为实体之间的关系建模。Django ORM 支持常见的关系，如一对一、多对一和多对多。

我们从一对一关系开始。假设我们有一个 Instructor 和 User ER 图。User 类拥有一些常用字段，如姓名或出生日期，而 Instructor 类拥有一些特殊字段，如是否全职或讲师拥有的学员总数。一个教员只能在一个 User 类中存储基本信息，一个用户只能有一个角色，如 Instructor 或 Learner。

Class: Instructor
is_full_time: boolean
total_learners: int

Class: User
first_name: string
last_name: float
dob: date

将以上 ER 图转换为 Django 模型：

class Instructor(models.Model):
    is_full_time = models.BooleanField()
    total_learners = models.IntegerField()
    user = models.OneToOneField(User)

class User(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)
    dob = models.CharField(max_length=30)

我们将使用 Project 和 Course ER 图来说明 “多对一” 关系。Project 类表示一个课程项目，包含项目名称和成绩等字段。Course 类代表在线课程实体。它有原子字段，如名称和描述。更重要的是，它有一个名为 projects 的集合字段，代表一组课程项目对象。因此，一门课程会有许多课程项目，而一个课程项目只属于一门课程。这是一种典型的多对一关系。要在 Django 中创建模型，我们需要添加一个额外的 Course 字段作为外键。请注意，这不是一对一字段，因为多个项目可能拥有相同的课程字段。

关于“多对多”关系，让我们来看看 Course 和 Learner ER 图。

Class: Course
name: string
description: string
learners: set

Class: Learner
occupation: enum
social_link: URL

为了模拟这种关系，我们在其中一个模型中添加了一个 ManyToManyField。通常，ManyToManyField应放在最常编辑的模型中。例如，Course 可能会随着学习者的添加或删除而每小时被编辑一次，但每个学习者可能每周或每月才注册一次新课程。有时，您可能需要有关模型之间关系的额外信息。

例如，您可能需要学习者和课程之间的注册信息，如注册日期。Django 允许您指定用于管理多对多关系的模型。在我们的例子中，中间模型是 Enrollment 表。它使用 through 参数与 ManyToManyField 关联。

class Course(models.Model):
    name = models.CharField(max_length=30)
    description = models.CharField(max_length=30)
    learners = models.ManyToManyField(Instructor, through='Enrollment')

class Enrollment(models.Model):
    course = models.ForeignKey(...)
    learner = models.ForeignKey(...)
    date_enrolled = models.DateField()

class Learner(models.Model):
    occupation = models.CharField(max_length=20)
    social_link = models.URLField()

Django 中的模型继承就像 Python 中的继承一样。你需要确定父模型是否只是通过子模型才能看到的通用信息的持有者，或者父模型是否应该有自己的表。

1.2.3. CRUD

CRUD 就是喜闻乐见的 增删查改。

Django 模型提供了全面的 CRUD API，无需编写 SQL 查询即可操作对象。让我们回顾一下我们将在示例中使用的在线课程模型。基本 User 模型包含有关 Instructor 和 Learner 模型的通用信息。Instructor 从 User 模型继承而来，拥有 is_full_time 或学习者总数等字段。Learner 也是继承的。它有 occupation 和 social_link 等字段。Course 模型与 Instructor 模型和 Learner 模型都有多对多关系。Course 模型还与 Project 模型有多对一关系。在 Django 模型中，创建一个对象并调用模型的保存方法将其作为记录插入数据库。

course_cloud_app = Course(name='Cloud Application Development with Database', description='Develop and deploy application on cloud')
course_cloud_app.save()

如果创建的对象包含对另一个模型的引用，如外键或多对多字段，则使用相关模型引用来创建关系。

project_orm = Project(name='Object-relational mapping project', grade=0.2, course=course_cloud_app)
project_orm.save()

我们创建了一个 Project 对象，并将其 Course 外键指向我们刚刚创建的 course_cloud_app。将对象及其关系插入数据库后，我们就可以进行查询了。首先，让我们看看如何读取模型的所有对象。这相当于在 SQL 中使用 SELECT * 从表中获取表的所有行。一般来说，要使用 Django Model API 读取对象，需要在模型类上使用 Manager 构建一个 QuerySet。

courses = Course.objects.all()

filter 方法可以有许多查找参数，如大于、小于、包含或为空。这就像 SQL WHERE 子句中的条件用法。查询参数包含字段名称和查询表达式，对于等价检查，查询表达式可以为空，对于其他检查，查询表达式可以用下划线分隔。

part_time_instructors = Instructor.objects.filter(is_full_time=False)

exclude 方法会返回一个与给定查找参数不匹配的新 QuerySet。由于 exclude 和 filter 方法都会返回一个 QuerySet，我们可以进一步追加 exclude 和 filter 方法，形成一个过滤链。这就像在 SQL 的 Where 子句中使用 and 添加多个条件一样。我们可以同时使用 exclude 和 filter 方法查找 Instructor 子集。

filtered_instructors = Instructor.objects.exclude(full_time=False).filter(total_learners__gt=30000).filter(first_name__startswith='J')

filtered_instructors = Instructor.objects.filter(full_time=True, total_learners__gt=30000, first_name__startswith='J')

如果只有一个对象符合您的查询，您可以使用 Get 方法返回该对象。例如，如果我们知道只有一个教员的名字是 John，我们就可以使用带有 first_name 查找参数的 Get 方法来获取教员。

instructor_john = Instructor.objects.get(first_name='John')

更新对象的原始字段。对于我们的学习者对象，我们可以将 dob 字段更改为 1985 年 3 月 16 日，然后使用 save 方法将更改更新到数据库。Django 模型将创建并执行相应的 SQL 更新语句。我们还可以更新相关字段，如外键字段或多对多字段。

learner_john.dob = date(1985,3,16)
learner_john.save()

我们还可以更新相关字段，如外键字段或多对多字段。例如，我们可以更新课程外键字段，使其指向不同的课程。我们还可以 Add 方法将另一位学员添加到课程中。

project_orm.course = course_python
project_orm.save()

要删除数据库中的记录，需要在模型对象或 QuerySet 上调用 Delete 方法。Django ORM 支持不同的 on delete 选项。

project_orm.delete()

Course.objects.filter(name__contains='Python').delete()

3. 全栈 Django 开发

3.1. MVC

MVC 设计模式将应用程序逻辑分为三个部分：

1. 模型访问和操作数据。
2. 视图以各种形式显示数据。
3. 控制器在模型和视图之间进行协调。

Django 的 MVT 模式与 MVC 相似，只是没有控制器，Django 服务器自身会执行控制器的功能。

MVT：Model-View-Template。

3.2. Django

在 Django 中，视图（View）是一个 Python 函数。Django 视图接收网络请求，如 HTTP GET、POST、DELETE 或 UPDATE，并返回网络响应。网络响应可以是字符串、JSON/XML 文件、HTML 页面，也可以是表示客户端或服务器端错误的错误状态。

Django 使用包含静态 HTML 元素和特殊 Python 代码的模板来生成动态网页。可以在 Django 中创建模板来指定数据的展示方式。Django 模板将静态 HTML 元素与描述如何插入动态部分的 Django 模板标记和变量相结合。这些元素共同作用生成一个 HTML 页面，在用户的网络浏览器中呈现。

创建 Django 项目时，Django 会创建一些核心文件：

• manage.py 是用于与 Django 项目交互的命令行界面。
• settings.py 包含 Django 项目的设置和配置。
• urls.py 包含 Django 应用程序的 URL 和路由定义。

可以通过创建一个管理员用户开始构建 Django 管理站点。然后，就可以以超级用户身份登录，并将模型注册到管理员站点，以便对其进行管理。

4. 整合和部署 Django 应用程序

在Django中，类视图必须与URL模式进行映射，几乎就像为基于函数的视图配置URL一样。唯一的区别是你需要指定以下哪一项？

as_view 函数。这是 Django 类视图的一个重要方法，它负责创建一个适合用作视图的实例，并调用其 dispatch 方法。这是在URL配置中使用类视图时需要指定的方法。

在通过登录 HTML 模板从用户处接收用户名和密码时，哪种 HTTP 方法将用户名或密码发送到在线课程登录视图以验证用户？

POST 请求。

Django 提供了一个默认的静态文件应用，它将所有静态文件收集到一个目录中。当你将你的应用部署到生产 Web 服务器时，你可以将所有静态文件移动到这个目录。要做到这一点，有几个步骤。在最后一步，你需要调用什么？

运行 collectstatic 命令。这是 Django 的一个管理命令，用于收集所有应用的静态文件到一个指定的位置，以便在生产环境中使用。

ASGI 是 Django 应用支持的 Web 服务器接口。WSGI 和 ASGI 之间的主要区别是什么？

ASGI 支持异步代码，而 WSGI 适合同步 Web 应用。这是 WSGI（Web 服务器网关接口）和 ASGI（异步服务器网关接口）之间的主要区别。ASGI 是 WSGI 的扩展，它增加了对异步编程的支持，这使得在处理大量并发连接时，可以更有效地利用系统资源。

为了解决 Django 视图的可扩展性和可重用性问题，创建了哪种类型的视图？

基于类的视图。Django 引入了基于类的视图（Class-Based Views），以提供更好的可重用性和可扩展性。基于类的视图允许你通过继承和混入（mixins）来重用和定制视图的行为。

授权是在认证过程的什么时候发生的？

认证之后。在大多数系统中，用户必须首先通过认证（例如，通过提供有效的用户名和密码），然后系统才会进行授权，以确定用户对资源的访问权限。

如果你想在不手动下载和导入的情况下使用 Bootstrap CSS 样式类，你应该怎么做？

在你的 HTML 模板的 head 元素中添加一个链接到最新的 Bootstrap 版本。这样，你就可以在你的网页中直接使用 Bootstrap 的 CSS 样式类，而无需手动下载和导入 Bootstrap。

Django 应用可以有特定于应用的静态文件和外部静态文件。你在哪里定义外部静态文件的目录，以便你可以找到它们？

在 settings.py 文件中的 STATICFILES_DIRS 列表。这是 Django 设置中的一个变量，用于指定包含你的静态文件的额外目录的列表。Django 将在这些目录中查找静态文件。

WSGI 是 Python 用于在 Web 服务器和应用程序之间通信的主要标准。为了使 Django 应用与 WSGI 一起工作，启动项目命令创建了一个默认声明可调用应用程序的文件。这个文件叫什么名字？

wsgi.py。这是 Django 项目中的一个文件，它包含一个可调用的 WSGI 应用。当你使用 Django 的 startproject 命令创建一个新项目时，这个文件会被自动创建。

5. 利用新功能增强在线课程应用程序

5.1. 最终项目概述和方案

您将有机会掌握 Django 技能并将其应用到项目中。您将收到一个在线课程应用程序的模板代码。然后，您将利用在本课程中学到的技能，计划并实施对应用程序的改进；这些改进包括：

1. 创建问题、选择和提交模型
2. 使用管理站点创建带有考试相关模型的新课程对象
3. 更新课程详细信息模板，以显示问题和选项
4. 创建新的考试结果模板，以显示提交结果
5. 创建新的考试结果提交视图
6. 创建一个新视图来显示和评估考试结果

让我们建立一个虚拟环境，其中包含我们需要的所有软件包：

pip install --upgrade distro-info
pip3 install --upgrade pip==23.2.1
pip install virtualenv
virtualenv djangoenv
source djangoenv/bin/activate

pip install -U -r requirements.txt

创建初始迁移并生成数据库模式：

迁移是 Django 将对模型所做的更改（添加字段、删除模型等）传播到数据库模式的方式。迁移主要是自动进行的，但你需要了解何时进行迁移、何时运行迁移以及可能遇到的常见问题。你将使用几条命令与迁移和 Django 处理数据库模式进行交互：

migrate：负责应用和取消应用迁移。
makemigrations：负责根据对模型所做的更改创建新的迁移。
sqlmigrate：用于显示迁移的 SQL 语句。
showmigrations：用于列出项目的迁移及其状态。

python manage.py makemigrations
python manage.py migrate

这次成功运行服务器：

python manage.py runserver

访问 8000/onlinecourse。

5.1.1. 建立新模型

你需要在 onlinecourse/models.py 中创建几个新模型。

Question 模型将保存具有以下特征的考试问题：

• 用于保存课程试题
• 与课程有多对一关系
• 具有问题文本
• 每道题都有一个分数

class Question(models.Model):
    course = models.ForeignKey(Course, on_delete=models.CASCADE)
    content = models.CharField(max_length=200)
    grade = models.IntegerField(default=50)

    def __str__(self):
        return "Question: " + self.content

此外，你还可以在 Question 模型中添加以下函数来计算分数：

def is_get_score(self, selected_ids):
    all_answers = self.choice_set.filter(is_correct=True).count()
    selected_correct = self.choice_set.filter(is_correct=True, id__in=selected_ids).count()
    if all_answers == selected_correct:
        return True
    return False

Choice 模型可保存问题的所有选项：

• 与 Question 模型的多对一关系
• 选项文本
• 表示该选项是否正确

class Choice(models.Model):
    question = models.ForeignKey(Question, on_delete=models.CASCADE)
    content = models.CharField(max_length=200)
    is_correct = models.BooleanField(default=False)

我们为您提供了已注释的 Submission 模型，该模型具有以下特点：

• 与 Exam Submissions 之间的多对一关系，例如，多个考试提交可能属于一个课程注册。
• 与选项或问题的多对多关系。为简单起见，您可以将提交与 Choice 模型相关联。

您需要取消对 Submission 模型的注释，并使用它来关联选定的选择。

class Submission(models.Model):
    enrollment = models.ForeignKey(Enrollment, on_delete=models.CASCADE)
    choices = models.ManyToManyField(Choice)

迁移：

python manage.py makemigrations onlinecourse
python manage.py migrate

5.1.2. 注册模式变更

现在，您将修改 onlinecourse/admin.py，以便使用您创建的新功能。

首先您需要导入 Question、Choice 和 Submission：

from .models import Course, Lesson, Instructor, Learner, Question, Choice, Submission

创建 QuestionInline 和 ChoiceInline 类，这样就可以在管理网站的一个页面上一起编辑它们。

class ChoiceInline(admin.StackedInline):
    model = Choice
    extra = 2

class QuestionInline(admin.StackedInline):
    model = Question
    extra = 2

创建 QuestionAdmin 类：

class QuestionAdmin(admin.ModelAdmin):
    inlines = [ChoiceInline]
    list_display = ['content']

注册新模型后，您可以使用管理网站创建一个包含课程、问题和问题选项的新课程。

admin.site.register(Question, QuestionAdmin)
admin.site.register(Choice)
admin.site.register(Submission)

接着让我们创建一个管理员用户，其详细信息如下：

1. 用户名：admin。
2. 邮箱：留空。
3. 密码：可以使用 p@ssword123。

python manage.py createsuperuser

运行 Django 开发服务器，检查是否可以使用管理站点添加 Question 和 Choice 对象。

5.1.3. 更新课程详细信息模板

现在，您将更新课程详情模板，创建一个包含问题和选项列表的考试部分。一次考试包含多个问题，每个问题都应该有一个以上的正确答案（多选）。

更改将在 templates/onlinecourse/course_details_bootstrap.html 中进行。

如果用户已通过身份验证，则显示带有问题和选项列表的课程考试：

{% if user.is_authenticated %}
</br>
<!-- Remaining code will go here -->
{% endif %}

添加一个开始考试的按钮：

<button class="btn btn-primary btn-block" data-toggle="collapse" data-target="#exam">Start Exam</button>

添加一个可折叠 div：

<div id="exam" class="collapse">
</div>

在表单中添加 Question 逻辑：

<div id="exam" class="collapse">
   <form id="questionform" action="{% url 'onlinecourse:submit' course.id %}" method="POST">
       {% for question in course.question_set.all %}
           <!-- Question UI components will go here -->
       {% endfor %}
   </form>
</div>

添加 Quesion UI：

<div class="card mt-1">
   <div class="card-header"><h5>{{ question.content }}</h5></div>
   {% csrf_token %}
   <div class="form-group">
       <!-- Choices components go here -->
   </div>
</div>

添加 Choices 组件：

{% for choice in question.choice_set.all %}
<div class="form-check">
   <label class="form-check-label">
       <input type="checkbox" name="choice_{{choice.id}}"
              class="form-check-input" id="{{choice.id}}"
              value="{{choice.id}}">{{ choice.content }}
   </label>
</div>
{% endfor %}

5.1.4. 提交评估

由于您已创建了多个新模型，因此现在需要在 views.py 的顶部导入它们。

from .models import Course, Enrollment, Question, Choice, Submission

现在，您将为表单提交创建一个基于函数的视图。创建提交视图 def submit(request,course_id) 来为课程注册创建考试提交记录。您可以根据以下逻辑来实现它：

• 获取当前用户和课程对象，然后获取相关的注册对象
• 参照注册信息创建一个新的提交对象
• 从 HTTP 请求对象中收集所选选项
• 将每个选定的选择对象添加到提交对象中
• 使用提交 ID 重定向到 show_exam_result 视图，以显示考试结果
• 配置 urls.py 以路由新的提交视图

def submit(request, course_id):
    course = get_object_or_404(Course, pk=course_id)
    user = request.user
    enrollment = Enrollment.objects.get(user=user, course=course)
    submission = Submission.objects.create(enrollment=enrollment)
    choices = extract_answers(request)
    submission.choices.set(choices)
    submission_id = submission.id
    return HttpResponseRedirect(reverse(viewname='onlinecourse:exam_result', args=(course_id, submission_id,)))

在 urls.py 中路由提交视图按钮：

path('<int:course_id>/submit/', views.submit, name="submit"),

5.1.5. 评估视图

创建考试结果视图 def show_exam_result(request,course_id,submission_id) 来检查学员是否通过考试以及他们的答题结果。您可以根据以下逻辑实现视图：

• 根据视图参数中的 id 获取课程对象和提交对象
• 从提交记录中获取所选选项的 id
• 检查每个所选选项是否为正确答案
• 将课程中所有问题的分数相加，计算总分
• 将课程、选项和成绩添加到上下文中，以便渲染 HTML 页面
• 配置 urls.py 以路由新的 show_exam_result 视图

def show_exam_result(request, course_id, submission_id):
    context = {}
    course = get_object_or_404(Course, pk=course_id)
    submission = Submission.objects.get(id=submission_id)
    choices = submission.choices.all()
    total_score = 0
    for choice in choices:
        if choice.is_correct:
            total_score += choice.question.grade
    context['course'] = course
    context['grade'] = total_score
    context['choices'] = choices

    return render(request, 'onlinecourse/exam_result_bootstrap.html', context)

5.1.6. 完成考试结果模板以显示考试提交结果

完成用于提交结果的 exam_result_bootstrap.html HTML 模板，该模板应显示学员是否通过考试，并提供总分、每道题的成绩等详细信息。

使用 Bootstrap 对更新后的模板进行样式调整，以符合设计团队的用户界面设计。

通过考试的学员应看到最终分数和祝贺信息：

<b>Congratulations, {{ user.first_name }}!</b> You have passed the exam and completed the course with score {{ grade }}/100

对于考试不及格的学员，应向其显示最终分数和错误选项。应允许学员重考并重新提交：

<b>Failed</b> Sorry, {{ user.first_name }}! You have failed the exam with score {{ grade }}/100

您还必须显示考试成绩，以便学员了解自己的成绩：

{% for question in course.question_set.all %}
<div class="card mt-1">
    <div class="card-header"><h5>{{ question.content }}</h5></div>
    <div class="form-group">
        {% for choice in question.choice_set.all %}
        <div class="form-check">
            {% if choice.is_correct and choice in choices %}
            <div class="text-success">Correct answer: {{ choice.content }}</div>
            {% else %}{% if choice.is_correct and not choice in choices %}
            <div class="text-warning">Not selected: {{ choice.content }}</div>
            {% else %}{% if not choice.is_correct and choice in choices %}
            <div class="text-danger">Wrong answer: {{ choice.content }}</div>
            {% else %}
            <div>{{ choice.content }}</div>
            {% endif %}{% endif %}{% endif %}
        </div>
        {% endfor %}
    </div>
</div>
{% endfor %}