Meta-后端开发笔记-全-

Meta 后端开发笔记（全）

1：课程介绍与概述 🚀

在本节课中，我们将要学习Django Web框架的入门知识，了解课程的整体结构、学习目标以及你将扮演的角色。

概述

Django是一个用Python编写的开源Web框架，用于构建大规模的后端Web应用程序。本课程旨在帮助你整合已有的Python、HTML、CSS和数据库知识，通过Django框架来创建动态的Web应用。

课程背景与目标

你每天进行的许多活动都可以完全在线完成。你可以使用手机、电脑、平板或其他设备上的应用程序来访问网络。在许多Web应用程序中，数据存储在数据库中，这些数据可以通过Python等编程语言在Web服务器上访问。一旦数据被检索出来，就可以使用HTML将其发送到网页内的最终用户。

作为一名有抱负的开发者，你已经具备这些技术的一些知识和技能。现在是时候通过结合这些技能，使用Django框架创建一个动态的Web应用程序来提升你的水平了。

要使用Django，你需要对数据库、Python、HTML和CSS有良好的工作知识。然而，你还需要学习许多新的工具、概念和工作流程。在这个课程介绍中，你可能会遇到许多新术语，但如果在课程期间不能完全理解所有内容，请不要担心。你将更详细地探索这些概念，以及构成Django开发者职责的许多其他任务。

为了辅助你的学习，你将扮演Little Lemon餐厅开发团队中的一名初级开发者的角色。在这个虚构的角色中，你将遇到许多现实世界的场景。通过应用你新获得的知识，你将克服挑战，实施解决方案来完成这些场景。随着你的技能增长，你将专注于框架的工具、它们的使用方法以及为何需要使用它们。

例如，Little Lemon最近推出了其第一个包含HTML、CSS和JavaScript的网站。联合创始人Adrian知道，随着公司的发展，其网站也必须发展。未来，他希望从静态网站过渡到Web应用程序。

主要目标是将所有内容存储在数据库中并提供用户访问。

因此，他要求你的团队使用Django Web框架构建下一个版本。

你的工作是运用你现有的Python、HTML、CSS和数据库知识来探索Django的特性。然后，你将使用该框架构建新Web应用程序的原型。之后，你将向Adrian和开发团队的其余成员展示这个原型。

课程模块介绍

本课程包含五个模块，现在让我简要介绍一下。

模块一：Django入门。你将了解Django以及它为何成为后端开发的流行选择。
模块二：视图（Views）。你将探索视图的概念，以创建向最终用户呈现数据的逻辑。
模块三：模型（Models）。你将深入学习模型。
模块四：模板（Templates）。在熟悉模型后，你将学习如何使用模板。
模块五：毕业项目。最后，你将通过分级评估将新技能付诸实践，创建一个基本的Web应用程序。

现在你对课程结构有了大致了解，让我们更详细地探讨一下这些模块。

模块详解

上一节我们介绍了课程的整体结构，本节中我们来看看每个模块的具体内容。

模块一：Django与Web框架

在第一个模块中，你将了解Web框架的概念。你将学习如何创建一个Django Web应用程序，以及它主要由两个组件构成：项目（projects） 和 应用（apps）。

以下是本模块的关键学习点：

你将学习如何使用特定的命令行工具（命令 django-admin 和 manage.py）来创建和处理项目与应用。
你将运用新获得的技能，在现有项目中以正确的结构创建一个应用。
你将通过扩展Web框架的知识来结束本模块，展示MVC（模型-视图-控制器）模式（在Django中常称为MTV模式）的可重用性，以及Django的项目结构是如何设置以适应这一点的。

模块二：探索视图

在下一个模块中，你将探索视图。你将了解什么是视图以及如何处理基本的HTTP请求。

以下是本模块的关键学习点：

你将发现Django开发者如何使用请求（request）和响应（response）对象进行常见操作。
你将学习如何区分参数，以及它们如何与HTTP方法（如 GET、PUT、POST 和 DELETE）关联。
你将探索使用正则表达式创建不同的URL模式，并将URL映射到视图。
你将列出常见的HTTP错误，并在HTTP视图逻辑和视图级别处理这些错误。
最后，你将了解更多关于Django中基于类的视图，以及如何在项目中重用它们。

模块三：深入模型

在下一个模块中，你将全面探索模型。

以下是本模块的关键学习点：

你将学习如何使用Django管理面板来添加和控制用户及组的权限。
你将探索如何使用查询集API（QuerySet API）与数据库交互。
你将创建一个表单，并使用表单API将数据绑定到对象。
最后，你将学习如何设置MySQL数据库并应用迁移以保持数据最新。

模块四：掌握模板

在下一个模块中，你将全面探索模板。

以下是本模块的关键学习点：

你将学习如何创建模板并使用模板语言创建标记。
然后，你将探索如何使用模板生成HTML。
接下来，你将学习如何将第三方库集成到你的Django应用中。
最后，你将探索Django中的调试和测试。

模块五：毕业项目与实践

在最后一个模块中，你将在进行课程项目之前有机会回顾课程的关键要素。在项目中，你将Little Lemon餐厅创建一个数据驱动的Web应用程序。

学习方法与建议

现在你知道了将要学习的内容，让我们快速了解一下课程将如何交付给你。你的课程中有许多视频，将逐步引导你实现目标。观看、暂停、回放和重看视频，直到你对自己的技能充满信心。

然后，通过查阅课程读物来巩固你的知识，并在课程练习中将你的技能付诸实践。在此过程中，你会遇到几个知识测验，你可以在那里自我检查进度。

你并不是唯一一个考虑成为Django开发者的人，这就是为什么你还会参与课程讨论提示，使你能够与同学联系。这是分享知识、讨论挑战和结交新朋友的好方法。

要在本课程中取得成功，坚持有规律、有纪律的学习方法会很有帮助。你需要认真对待学习，如果可能的话，制定一个学习计划，标明你可以投入参加课程的日期和时间。这是一门在线自定进度的课程，但将你的学习视为定期参加学习机构的活动会很有帮助。

总结

本节课中我们一起学习了Django课程的介绍与概述。本课程为你提供了Django的完整入门，并且是引导你走向后端开发职业生涯的一系列课程的一部分。你了解了课程目标、将扮演的角色、五个核心模块的内容以及成功学习的建议。准备好开始你的Django之旅，为Little Lemon餐厅构建下一代Web应用吧。

2：什么是Django

在本节课中，我们将要学习什么是Django框架，了解其核心概念、优势以及在现实世界中的应用场景。

构建Web应用程序时，开发者和开发团队在代码方面有两种选择。

选择一：自己构建所有功能。选择二：使用一种称为Web应用程序框架的工具。

你可以将Web应用程序框架视为一个工具箱，它包含了应用程序开发所需的所有组件。

通过使用框架，开发者和开发团队可以专注于应用程序的独特功能，而无需花费时间开发所有应用程序共有的通用功能。

以下是使用框架可以避免重复开发的常见功能示例：

用户登录与身份验证的代码。
构建管理仪表盘。

上一节我们了解了框架的基本概念，本节中我们来看看Django框架本身。

本视频将概述Django框架。你将了解Django在现实世界中的应用场景以及使用它的Web应用程序类型。

Django是一个开源的Web开发框架，它使用Python编写，最初是为一家报纸出版商的Web应用程序创建的。因此，它非常适合构建需要处理大量文本内容、媒体文件和高流量的项目。

Django的开源特性促成了其快速发展和广泛采用，这使其能够用于各种各样的Web应用程序。

Django框架允许轻松集成多种工具和语言，并得到其他Python库的支持。

一个Web框架的成功很大程度上取决于其提供健壮、安全、适应性强和可扩展功能的能力。Django满足了所有这些要求，并提供了模板、库和API等特性，这些特性都易于管理和扩展。

除了出版业，Django也是电子商务、医疗保健、金融、交通、旅游、社交媒体等领域的流行选择。

Django的强大之处在于其分离功能的能力，这对于需要使用多个框架创建项目的组织非常有帮助。

例如，开发者可以使用Django创建一个后端框架，该框架可以通过API连接到前端框架。这样，组织就可以自由选择他们喜欢的任何前端框架，例如Meta的React或React Native。

在后端，开发者可以利用Django的强大功能，包括：

用于通知的电子邮件系统。
数据分析工具。
管理仪表盘。
用于在线市场和预订系统的开发工具。

因此，Django框架成为世界各行业领先公司和互联网巨头的选择也就不足为奇了。

这些领域包括机器学习和人工智能、可扩展的Web应用程序、软件即服务应用程序、流媒体平台以及购物、活动管理、新闻和出版等行业。现在让我们更详细地探讨这些领域。

首先是机器学习和人工智能领域。开发者可以使用Django部署机器学习算法，这些算法可以通过API、RPC和WebSocket等方式提供。Django可以处理许多API端点，每个端点可以包含多个ML模型，并且支持这些模型的快速集成和部署。

接下来是可扩展的Web应用程序。Django如此受欢迎的一个重要原因是其易于扩展。许多Web应用程序和科技公司通常从小规模起步，但很快会迅速扩张。例如，构建社交媒体应用的组织。像Meta的Instagram这样的流行社交媒体应用就使用Django来满足不断增长的内存和资源管理需求。可扩展性原则对于用户基数未知的Web应用程序同样有帮助。应用程序扩展能力的一个关键因素是能够为其用户提供快速高效的流量管理。因此，Django在社交媒体、杂志和博客等应用中很受欢迎。

大多数基于Web构建的应用程序都提供某种形式的软件即服务。这可能意味着提供数据存储、应用商店和版本控制系统等服务的平台。例如，Django是云存储应用程序的流行选择，因为它提供了异步视图。这允许应用程序并发运行不同的服务，而不是排队等待完成每项服务，从而显著提高了应用程序的性能。

最后，让我们探讨提供音频和视频流服务的流媒体平台。流媒体平台最近越来越受欢迎，Django经常被用来满足其需求。需要指出的是，Django的应用并不仅限于本视频中提到的服务和行业。

然而，人们普遍认为Django更适合大型项目，因为它提供了良好的容错能力。此外，其开源特性本质上是免费的，大大降低了公司的成本。同时，易于适应、健壮性、支持性的开源社区、全面的文档和安全性也使Django广受欢迎。

归根结底，开发者和组织青睐Django，是因为就像Python一样，它帮助他们避免了重复造轮子。

本节课中我们一起学习了Django框架的概述，以及为什么它在构建Web应用程序时受到青睐。你也了解了Django在现实世界中的应用场景和使用它的Web应用程序类型。

3：Django在现实世界中的应用 🚀

在本节课中，我们将探讨Django框架在现实世界中的实际应用，了解它为何成为最流行的Python Web框架，并比较它与其他框架的差异。

Django简介与核心功能

Django是一个Web框架，它允许你处理来自最终用户的HTTP请求，并最终将内容返回给他们，例如一个HTML页面。Django驱动着用户请求数据或向我们发送数据、我们处理数据并返回更多数据的整个交互过程。

核心交互流程可以用以下伪代码表示：

用户请求 -> Django处理HTTP请求 -> 与数据库交互/处理业务逻辑 -> 返回HTML/数据 -> 用户接收

上一节我们介绍了Web开发的基本概念，本节中我们来看看Django如何具体实现这些功能。

Django的优势与特点

Django是我个人学习的第一个Web框架。我在大学的黑客马拉松和本科研究项目中都使用过它。我使用它的原因是它非常轻量级且易于快速启动。

Django附带了许多工具，这些工具作为框架的一等特性已经内置其中。这意味着框架内部已经包含大量代码，用于执行诸如与数据库交互或处理HTTP请求等任务。

以下是Django内置的一些核心功能：

数据库ORM（对象关系映射）
用户认证系统
管理后台界面
URL路由分发器
模板引擎

Django与Flask的对比

Django和Flask这类框架之间的区别某种程度上是偏好的问题。我会分析你的需求：你是否需要一个非常轻量级的框架，它只接收HTTP请求并返回内容，而不需要数据库管理等功能？如果是，我会选择像Flask这样的框架。

但如果你希望免费获得许多功能，例如，你正在尝试构建一个可能与数据库交互的网站，并且你希望非常快速地创建快速原型或最小可行产品（MVP），那么Django是一个绝佳的选择。

学习Django的挑战与价值

也许Django最大的挑战之一在于它存在学习曲线。它内置了许多不同的工具，需要你学习所有这些不同特性的含义。

我大力倡导学习Django的一个原因是，它能让你接触到我们所谓的全栈开发。这意味着你将学到很多关于如何与数据库交互、如何制作最终返回给用户的前端代码（即用户实际看到的内容），以及显然还有编写Web服务器代码的知识，这些代码将你的后端数据库和前端客户端这两个组件连接起来，Web服务器位于两者之间。这意味着你将全面了解整个软件开发周期是如何运作的。

掌握Django的最佳实践

实际上，我认为提高技能的最佳方法是在实践中学习。这就是为什么我大力支持进行个人项目，即使项目本身对任何人都不是超级有用。我自己也构建了许多无用的项目，仅仅是为了学习不同的框架。随着时间的推移，这实际上使我成为一名更强大的开发者。

我大力倡导在学习课程的同时进行编码实践。原因在于，在软件开发中，如果你被动地观看，知识往往不容易牢固掌握。因此，如果你进行互动式学习，例如学习本课程中的示例并尝试边学边构建，或者进行你自己的个人项目，我认为这将使你的学习更加牢固，同时也更加高效。

总结

本节课中我们一起学习了Django在现实世界中的应用场景、其核心优势、与Flask等轻量级框架的对比，以及学习Django带来的全栈开发视野。掌握Django需要克服一定的学习曲线，但通过动手实践和项目驱动学习，你可以有效地掌握这一强大工具，为成为全面的软件工程师打下坚实基础。

4：项目和应用概述 🏗️

在本节课中，我们将要学习Django框架中两个最核心的组织概念：项目和应用。理解它们之间的关系和结构，是构建任何Django网络应用的基础。

概述：从静态网站到动态应用

学习网络开发时，理解构建一个网站所需的内容很重要。现在你应该已经熟悉网站的基本结构。它包含由HTML构成的网页结构、用于外观样式的CSS以及用于客户端交互的JavaScript。

假设你正在创建一个静态网站，其项目结构可能只需要一些CSS、JavaScript和图片文件夹。

project/
├── css/
├── js/
└── images/

对于简单的静态网站，这种方式可能运行良好。项目结构的目的是以一种易于更新的方式布局文件。

然而，当处理需要更复杂功能的网络应用时，例如需要保持状态或访问和存储数据，事情就需要以不同的方式设置。

为何使用框架：结构与效率

使用框架，开发者可以专注于创建项目特有的功能，而不是重复与构建网络应用相关的编码任务。Django是由遵循最佳实践的开发者创建的。它允许你以结构化的方式设置你的网络应用，以便于开发。

在本视频中，你将学习Django中项目和应用的核心理念，以及它们如何为开发者提供一个工作结构。

动态网络应用的基本要求

在探索Django框架的结构之前，最好充分理解创建一个动态网络应用通常需要什么。这可能涉及处理互联网协议、网络服务器配置以及数据检索或存储。

让我们快速回顾这些概念：

互联网协议：回想一下，HTTP用于获取、发送和渲染网络内容。HTTP在网络开发中至关重要，因为每个操作总是与指向某个URL的HTTP请求相关联。
网络服务器：需要一个网络服务器来获取用户想要的页面，并通过HTTP返回给他们。Django自带其用Python编写的开发服务器。这将为开发者节省大量时间，并避免任何混乱的配置。
数据库：回想一下，网络是无状态的，这意味着它不会为将来参考存储任何东西，因此需要一个数据库来保存和检索与网站相关的数据。例如，每次用户在网站上提交表单时，这些数据都需要被存储，以便以后可以检索和渲染。

现在你已经了解了框架如何为开发者提供一个工作结构，让我们来探索Django项目的结构。

Django项目：整体应用容器 🗂️

在Django中，一个项目代表整个网络应用。Django提供了一组命令，可以自动生成一个项目结构，其中包含与整个网络应用相关的配置和设置。

你将在后面了解更多关于这个项目结构的信息。现在，只需知道它是一种组织你的Python文件和文件夹的方式。这允许开发者专注于代码而不是配置。

Django应用：功能模块化单元 ⚙️

现在你了解了项目，让我们进一步学习应用。在Django中，一个应用是项目的一个子模块。它通常用于实现某些特定目的的功能。

应用可以是自包含的，意味着它们不依赖其他应用来运行。因此，它们可以在许多不同的项目中使用或重用。这很好地引出了“不要重复自己”的DRY原则：一次编写，多次使用。

作为Django的初学者，当你遇到“项目”和“应用”这两个术语时可能会感到困惑。只需记住：一个Django网络应用是一个包含许多应用的项目。

例如，假设你正在创建一个社交媒体应用。在Django中，这个社交媒体应用就是项目，而不同的功能将由不同的应用来代表。因此，你可以为新闻推送、评论、好友列表、用户页面等创建独立的应用。

创建与配置应用

应用是使用 startapp 命令添加的。

python manage.py startapp app_name

与项目类似，Django也会在项目结构内自动生成一个自包含的目录及其相关文件。

为了让Django在项目中识别一个应用，必须将其添加到 INSTALLED_APPS 设置中。

# settings.py
INSTALLED_APPS = [
    ...,
    ‘app_name’,
]

此外，Django应用是一组与框架各个部分交互的代码。Django需要在几个地方与已安装的应用程序交互，这主要是为了配置和内省。这就是为什么应用程序注册表为每个已安装的应用程序在 AppConfig 实例中维护元数据。

应用的组成部分

应用通常包含以下部分的组合：

模型：定义数据结构。
视图：处理业务逻辑。
模板：定义HTML结构。
模板标签：自定义模板功能。
静态文件：如CSS、JavaScript、图片。
URLs：定义路由。
中间件：处理请求/响应全局钩子。

如果你还不理解所有这些术语，请不要担心。你将在本课程后面学习它们。现在，只需知道作为一名开发者，你将花费大量时间与应用打交道，因为它们包含了项目的所有不同部分。

应用设计原则

作为一名开发者，决定项目中什么构成一个应用可能是主观的，你可能会遇到各种应用设计方法。目前，最好认为一个应用应该是功能目标明确的，并且最适合做一件事，且只做一件事。

在本课程中，你将使用一个只包含一个应用的项目。

总结

本节课中，我们一起学习了Django中项目和应用的核心理念。项目是整个网络应用的容器，负责整体配置；而应用是项目内实现特定功能的、可复用的模块化单元。这种结构化的组织方式，遵循了DRY原则，让开发者能够更高效、更清晰地构建复杂的动态网络应用。理解并掌握这种项目-应用的层次关系，是开启Django开发之旅的关键第一步。

5：创建您的第一个项目 🚀

在本节课中，我们将学习如何使用终端和VS Code编辑器创建您的第一个Django项目。您还将学习如何通过安装虚拟环境来设置开发环境，并探索一些用于创建Django项目和启动开发服务器的常用CLI命令。

虚拟环境与开发服务器概述

上一节我们介绍了Django项目和应用程序的概念。本节中，我们来看看如何实际创建一个项目。

如果您是一名处理多个项目的Python开发者，最佳实践是将您的项目隔离在虚拟环境中。您可能想知道为什么需要这样做。Django项目通常规模较大，并且涉及特定依赖项，例如软件包。例如，某个软件包可能依赖于特定版本。您不希望这与其他Python或Django项目发生冲突，因此最好使用虚拟开发环境来隔离您的项目。

虚拟环境是您创建的用于管理依赖项和整个项目的隔离空间。这允许您将解释器、库和脚本等功能隔离并安装到特定项目中。

除了提供的功能外，Django还附带一个集成的开发服务器。这意味着应用程序与客户端具有请求-响应关系。

现在您已经熟悉了虚拟开发环境和开发服务器的概念，让我们探索创建Django项目所涉及的步骤。

以下是创建Django项目的主要步骤：

创建项目目录。
为您的Django应用程序创建虚拟环境。
创建Django项目。
运行Django开发服务器。

详细步骤演示

让我们现在使用VS Code中的一些示例更详细地探索这些步骤。

1. 创建项目目录

项目是一个由设置和数据库信息组成的组织单元。它可以存储在您开发计算机上的任何位置，但作为最佳实践，最好将其保存在包含所有其他Django应用程序的子文件夹中。

首先，从顶部菜单中选择“终端”->“新建终端”以打开新终端。接下来，使用mkdir命令创建一个新目录，并为您的目录命名，例如BuildDjango。

mkdir BuildDjango

然后，使用cd命令进入此目录。

cd BuildDjango

2. 设置虚拟环境

接下来，您需要设置虚拟环境。为此，输入python3 -m venv，然后给出虚拟环境名称，例如tutorial_env。完成后，按回车键。

python3 -m venv tutorial_env

如果您在VS Code中打开目录结构，会注意到生成了一些新文件。

现在您需要激活虚拟环境。输入source和激活路径，即tutorial_env/bin/activate，然后按回车。

source tutorial_env/bin/activate

请注意，终端中的圆括号后缀表示虚拟环境已激活。

3. 安装Django并创建项目

虚拟环境包安装完成后，您就可以安装Django了。使用命令pip3 install django来完成。

pip3 install django

为确保Django已安装，您可以运行命令python3 -m django --version。请注意，当前版本是4.1。

python3 -m django --version

设置完成后，您就可以创建项目了。通过运行Django内置的命令行工具来完成：输入django-admin startproject，然后为项目命名。在本例中，命名为ChessTable。最后，按回车运行命令。

django-admin startproject ChessTable

如果您再次展开目录结构，会注意到ChessTable已创建，并附带支持性的Django特定文件。

4. 启动开发服务器

创建Django项目后，您需要启动开发服务器。在此之前，了解随项目自动创建的manage.py文件很重要。回想一下，manage.py是一个命令行实用程序，其工作方式类似于django-admin命令。因此，您可以用manage.py替换django-admin命令，因为它使用的是项目设置。

要启动开发服务器，您可以使用manage.py命令运行runserver命令。

cd ChessTable
python manage.py runserver

您将在后面了解更多关于如何使用django-admin和manage.py命令的信息。请注意，生成了一个URL。如果您使用的是Mac，可以单击此URL在浏览器窗口中打开它。如果您使用的是Windows，则需要将其复制并粘贴到浏览器中。

请注意，终端为我们提供了按Ctrl+C停止服务器的选项。

重要说明与总结

需要指出的是，虚拟环境和开发服务器本身是广泛的主题，您将在本课程后面了解更多相关内容。如果您愿意，甚至可以省略虚拟环境的使用，但这并不推荐。

本节课中，我们一起学习了如何在Django中创建您的第一个项目，使用了终端、VS Code和Django内置的命令行工具。您掌握了从创建目录、设置虚拟环境、安装Django到最终启动开发服务器的完整流程，为后续的Django开发奠定了基础。

6：Django Admin与Manage.py命令详解 🛠️

在本节课中，我们将要学习Django框架中两个核心的命令行工具：django-admin 和 manage.py。你将了解它们的功能、区别以及如何在项目开发中正确使用它们来执行管理任务。

核心结构与命令回顾

上一节我们介绍了Django项目的核心结构。现在，我们来回顾一下创建和运行一个Django应用的基本流程。

要创建一个Django应用程序，你需要：

为项目创建一个虚拟环境。
创建项目。
运行开发服务器。

你通过运行特定的命令来完成这些步骤，例如使用Django命令行工具执行 startproject 和 runserver。

Django提供了一系列命令，这些命令还会生成一个项目结构，其中包含与整个Web应用程序相关的配置和设置。

两种命令行工具：Django Admin 与 Manage.py

在Django项目中工作时，开发者有两种命令行工具选择来执行任务。

他们可以使用 django-admin 或 manage.py。虽然两者都可以用来执行相同的任务，但存在一些细微差别，你的使用选择将取决于你希望如何开展项目工作。

以下是两种工具的核心概念：

django-admin：这是一个全局命令行工具，在你安装Django时生成。其路径通常位于Django环境目录的 Scripts 文件夹中。
```
# 示例：使用django-admin创建项目
django-admin startproject myproject
```
manage.py：这是一个本地脚本，是 django-admin 的本地版本，位于项目文件夹内。它会设置 DJANGO_SETTINGS_MODULE 环境变量，使其指向你项目的 settings.py 文件。
```
# 示例：使用manage.py运行服务器
python manage.py runserver
```

django-admin 是一个在你安装Django时创建的文件。如果你通过 pip 安装了Django，django-admin 工具应该在你的系统路径上。如果你在系统路径上找不到它，请确保你已经激活了虚拟环境，并在其中使用 pip3 install django 这样的命令安装了Django。

manage.py 是一个每次创建Django项目时自动生成的文件。这个文件特定于项目的虚拟环境。它执行与 django-admin 相同的操作，但还会设置 DJANGO_SETTINGS_MODULE 环境变量以指向你项目的 settings.py。

通常，在单个Django项目上工作时，开发者倾向于使用 manage.py，因为 django-admin 的管理任务也可以用 manage.py 执行。然而，如果你需要在多个Django设置文件之间切换，可以使用带有 --settings 命令行选项的 django-admin 命令。

本视频中的命令行示例为保持一致性使用了 django-admin，但任何示例同样可以使用 manage.py。

关键命令详解

了解了工具的区别后，本节我们来看看两个最常用的命令：startproject 和 runserver。

Startproject 命令

你可能记得使用 startproject 命令来创建一个Django项目。这会在当前目录或给定的目标路径中，为指定的项目名称创建一个Django项目目录结构。

默认情况下，新目录包含 manage.py 文件和一个项目包。这个项目包包含 settings.py 文件和其他文件。

需要注意的是，如果只提供了项目名称，项目目录和项目包都将使用与项目名称相同的名称。此外，项目目录将在当前工作目录中创建。

如果提供了一个可选的目标路径，Django将使用该现有目录作为项目目录，并在其中创建 manage.py 文件和项目包。

一个常见的开发者工作流程是使用句点符号 . 来表示当前工作目录，这样可以避免出现具有相同名称的子目录。

Runserver 命令

回想一下，你使用 runserver 命令来运行一个项目。

此命令在你的本地机器上启动一个轻量级的开发Web服务器。默认情况下，服务器在IP地址 127.0.0.1 的端口 8000 上运行。然而，你可以通过显式传入IP地址和端口号来更改这一点。

# 示例：在指定端口运行服务器
python manage.py runserver 8080
# 或指定IP和端口
python manage.py runserver 0.0.0.0:8000

需要注意的是，如果你以具有普通权限的用户身份运行此脚本（这是推荐的），你可能无法在低端口号上启动端口。这是因为低端口号是为超级用户或root用户保留的。

开发服务器非常适合应用程序开发和测试。然而，Django建议你永远不要在生产环境中使用此服务器，因为它没有经过安全审计或性能测试。

开发服务器会根据需要为每个请求自动重新加载Python代码。你不需要为了代码更改生效而重启服务器。但是，某些操作（如添加文件）不会触发重启，在这些情况下，你必须重启服务器。

总结

本节课中我们一起学习了Django框架中两个核心的命令行工具 django-admin 和 manage.py。我们明确了 django-admin 是全局管理工具，而 manage.py 是项目特定的本地脚本。我们还详细探讨了创建项目的 startproject 命令和启动开发服务器的 runserver 命令的使用方法、注意事项以及它们之间的细微差别。掌握这些工具和命令是高效进行Django开发的基础。

7：创建应用 🚀

在本节课中，我们将学习如何在现有的Django项目中创建一个应用（App）。应用是Django项目的功能模块，我们将创建一个简单的应用，使其能够在网页首页上输出“Hello World”文本。

项目与应用的关系

上一节我们介绍了Django项目的基本结构。本节中我们来看看如何向项目中添加功能模块。

一个Django项目代表整个Web应用程序，而应用则像是项目的子模块，用于提供特定的功能。之前我们已经设置了项目文件夹并在其中创建了虚拟环境。

创建Django应用

以下是创建Django应用的步骤。

首先，在项目目录下，使用startapp命令创建一个新应用。该命令的基本语法如下：

python manage.py startapp <app_label> [destination]

<app_label>：这是应用的唯一名称。
[destination]：这是可选参数，用于指定应用的创建位置。如果不指定，应用将默认创建在当前工作目录中。

例如，要创建一个名为myapp的应用，可以执行：

python manage.py startapp myapp

执行此命令后，项目文件夹内会生成一个名为myapp的新文件夹。该文件夹包含多个文件，如__init__.py、admin.py、models.py、tests.py和views.py。

对于初学者，无需立即理解每个文件的具体作用。关键在于理解概念：通过创建应用来为项目添加不同的功能。由于本项目目前只需在网页上显示文本，因此创建一个应用即可。

理解视图与路由

现在我们已经创建了应用，接下来需要让它能在首页输出文本。这需要用到Django中的两个核心概念：路由（Routes）和视图（Views）。

当用户访问网站首页时，我们希望显示一些文本。在Django中，当用户导航到一个URL时，该URL会被路由到一个称为视图的组件。

目前，你可以将视图简单地理解为Python函数，它负责生成构成网页的内容。视图函数接收一个请求（Request），并返回一个响应（Response）。由于请求和响应通过网络进行，因此会使用HttpRequest和HttpResponse这两个对象。

创建视图函数

首先，我们需要创建视图函数。打开应用文件夹中的views.py文件，你会发现Django已自动生成了一些代码。我们无需修改这些现有代码，只需添加新内容。

在views.py文件中添加以下代码：

from django.http import HttpResponse

def home(request):
    return HttpResponse("Hello World")

第一行：导入HttpResponse类，这是返回HTTP响应所必需的。
home函数：这是一个视图函数，它接收一个request参数，并返回一个包含文本“Hello World”的HttpResponse对象。

需要注意的是，仅仅创建这个返回HTTP响应的函数本身并不会产生任何效果。它只是定义了当用户访问项目首页时需要执行的逻辑。

配置URL路由

为了使视图工作，我们需要将视图函数映射到一个URL。Django项目的URL配置存储在一个名为urls.py的文件中，该文件位于项目目录下。这个文件可以看作是一个映射表，Django用它来确定哪个视图函数与特定的URL相关联。

打开项目目录下的urls.py文件，你会看到Django已经生成了一些默认代码，包括导入语句和一个名为urlpatterns的列表。

我们需要在此文件中添加代码，将首页的URL映射到我们刚刚创建的home视图函数。

在urls.py文件中进行如下修改：

from django.contrib import admin
from django.urls import path
# 导入视图模块
from myapp import views

urlpatterns = [
    path('admin/', admin.site.urls),
    # 添加首页路由映射
    path('', views.home, name='home'),
]

from myapp import views：从我们的应用myapp中导入views模块。
path('', views.home, name='home')：
- ''：这是一个空字符串，代表网站的根路径，即首页。
- views.home：指定当访问根路径时，应调用views.py中的home函数。
- name='home'：为这个URL模式命名，这在后续开发中会很有用。

运行开发服务器并测试

代码配置完成后，保存所有更改。接下来，运行Django开发服务器以查看效果。

在终端中执行以下命令：

python manage.py runserver

服务器启动后，通常会运行在http://127.0.0.1:8000/（即本地主机）。你可能会看到一个关于“未应用迁移（unapplied migrations）”的警告，目前可以暂时忽略，我们将在后续课程中学习如何处理迁移。

现在，在浏览器中访问http://127.0.0.1:8000/，你应该能看到页面上显示“Hello World”文本。这段文本正是由我们的home视图函数返回的HTTP响应。

你可以尝试修改views.py中HttpResponse的文本内容，例如将“Hello World”改为“Hello Django”，保存文件后刷新浏览器页面，内容会立即更新。

总结

本节课中我们一起学习了如何在Django项目中创建应用。我们了解了项目与应用的关系，创建了一个名为myapp的应用，并编写了一个简单的视图函数来向网页输出文本。接着，我们通过配置urls.py文件，将网站的根URL路由到该视图函数，最终在开发服务器上成功运行并看到了结果。

虽然这个视图的内容非常简单，但所有使用Django创建的网页内容，其创建和更新的核心流程都与此相同。掌握了这个基础流程，就为后续学习更复杂的Django功能打下了坚实的基础。

8：什么是Web框架 🧱

在本节课中，我们将要学习什么是Web框架，以及为什么Django是构建后端Web应用程序的热门选择。我们还将探讨三层架构的概念，以理解现代Web应用的基本结构。

作为一名有志于开发新Web项目的开发者，有时可能会对项目的结构方式感到困惑。因此，扎实地理解Web框架及其核心概念至关重要。

什么是Web框架？

Web框架旨在支持开发者构建Web应用程序。其目的是使应用程序开发更容易，并为开发者提供一个清晰的结构，以保持事物有序，并允许进行更改和修改。框架还通过现有代码促进了代码的可重用性。

为什么需要Web框架？

在构建Web应用程序时，理解存在许多不同的部分和组件非常重要。例如，你可以只用一些HTML、CSS和JavaScript构建一个静态网站。然而，假设你想添加电子商务功能，比如一个商店。在这种情况下，你将必须实现诸如用户登录、支付交易、安全性、性能以及处理从Web表单提交的数据等功能。

这将要求你的应用程序分为两部分：前端和后端。前端是用户通过Web浏览器与之交互的网站部分。后端是在Web服务器上运行的部分，通常包含数据库。

因此，如果你的网站需要诸如电子商务、网站用户、支付处理以及存储在数据库中的数据等功能，它很可能需要一个后端。更具体地说，需要一个后端应用程序来管理后端。

选择后端框架

在选择构建后端的框架时，有许多选项可供选择。这些框架都有一个共同的目标：提供功能以创建具有良好结构的Web应用程序。

如果打个比方，你可以将框架视为建造房屋的地基。你总是需要一个坚实的地基，没有它，房子就不会非常稳定。Web框架正是如此。它们提供了一个坚实的构建基础，而Django就是其中最受欢迎的之一。

Django框架简介

Django是一个高级、免费、开源的Python Web框架，鼓励快速开发和简洁实用的设计。它由经验丰富的开发者构建，并处理了许多与Web开发相关的任务，让你可以专注于编写应用程序，而无需重复造轮子。

以下是使用Django框架的一些好处：

速度：Django速度极快，通过减少需要编写的代码量来加速开发过程。这意味着你可以尽可能快地将应用程序从概念变为成品。
功能丰富：Django功能齐全，包含许多开箱即用的功能，可用于处理常见的Web开发任务。这些任务包括用户认证、内容管理、站点地图和RSS订阅等。
安全性：Django非常安全，帮助开发者避免许多常见的安全错误。它提供了一个安全的内部中间件层，保护其免受试图窃取信息的常见攻击。
可扩展性：Django具有高度可扩展性。它允许数据存储在正在使用的服务器之外的其他服务器上，而无需太多配置更改。这提供了灵活性和速度，因此，一些网络上最繁忙的站点都利用了Django快速灵活扩展的能力。

三层架构

现在你已经对什么是Web框架以及为什么Django是应用程序开发的热门选择有了基本了解。让我们通过学习所谓的“三层架构”来探索其结构。

架构指的是软件系统的基本结构。现代应用程序倾向于构建在所谓的“三层架构”中。这是一种基于模块的客户端-服务器架构方法，将应用程序分为三个逻辑部分：表示层、应用层和数据层。

现在，让我们更详细地检查每个部分。

表示层：这是用户主要通过其桌面、笔记本电脑或移动设备上的用户界面与之交互的层。它通常使用UI框架或库（如Meta的React）构建，并通过应用程序接口发送结果与其他层通信。
数据层：通常由数据库服务器组成，用于存储和检索信息。动态网站需要能够存储和检索数据。数据库是最佳选择，因为它将数据存储在表或对象中（取决于数据库的选择）。
应用层：这是连接其他两层的部分。它从表示层获取数据，并将其持久化到数据层。重要的是要注意，这些部分是逻辑上的，而非物理上的。这意味着你可以在同一个Web服务器上运行所有三层。

在本节课中，我们一起学习了Web框架的概念，了解了Django作为后端开发框架的优势，并探讨了构建Web应用程序的三层架构模型。理解这些基础概念是成为一名高效后端开发者的重要一步。

9：MVT架构示例 🏗️

在本节课中，我们将要学习Django框架的核心组织方式——MVT（模型-视图-模板）架构。我们将通过三个循序渐进的示例，了解数据、逻辑和显示是如何在Django项目中分离的，并理解这种分离如何帮助开发者构建大型、可维护的Web应用。

你已经了解到，Django项目可以变得非常庞大。对于一个有抱负的开发者来说，Django项目包含许多活动部件，这很容易让人望而生畏。在本视频中，我将为你提供一个宏观概述，并演示Django如何使用模型、视图和模板（通常称为MVT架构）来组织一个项目。

如果你不能完全理解本视频中的所有概念，请不要担心，因为你很快就会学到它们。相反，请专注于理解在Django框架中，数据、逻辑和显示是相互分离的这一概念。你甚至可以将本视频视为对未来开发者如何在后端开发中使用Django框架的一次预览。

项目结构概览

之前，我创建了一个名为Building_MVT的文件夹。展开它，你会注意到我创建了一个名为tutorial_env的虚拟环境。我还创建了一个名为Chefs_Table的项目，并在该项目中安装了Django。

在Chefs_Table项目内部，请注意我创建了一个名为Little_Lemon的应用。同时，Django已经自动为项目和应用创建了相关的文件。

在演示MVT架构的文件之前，我首先需要更新两个地方的urls.py文件，以便Django能将不同的URL匹配到正确的视图函数。在这些文件中，我已经添加了将调用视图函数的URL。

三个MVT示例

现在，我将通过三个示例来演示MVT架构的概念。第一个示例将只包含视图。接下来是一个包含模型和视图的示例。最后，是一个包含模型、视图和模板的完整示例。

示例一：仅包含视图

让我们从第一个仅包含视图的示例开始。如果你打开views.py文件，会注意到它包含一个Python函数，该函数向运行在本地主机开发服务器上的网页发送一些数据。在这个示例中，返回的数据是文本“Hello World”。

# views.py 中的函数示例
from django.http import HttpResponse

def hello_world(request):
    return HttpResponse("Hello World")

现在让我演示一下。启动开发服务器，在浏览器中打开URL，你会看到文本“Hello World”被显示出来。

好的，让我关闭浏览器窗口并停止服务器。

示例二：模型与视图

对于第二个示例，我对代码做了一些修改，以演示视图如何与模型协同工作。请注意，我在views.py文件中创建了另一个函数。这个函数与模型通信，从数据库表中检索存储的数据，然后动态地将其返回到Web浏览器。

现在，让我们探索模型如何与数据库通信。打开models.py文件，你会注意到这段代码包含一个Python类，它代表数据库中的一个表，而创建的每个变量都像是该表中的一列。

# models.py 中的模型示例
from django.db import models

class MenuItem(models.Model):
    name = models.CharField(max_length=100)
    cuisine_type = models.CharField(max_length=50)
    # ... 其他字段

如果你熟悉关系数据库的概念，可能会好奇这是如何实现的。目前，你只需要知道Django将类中的代码映射到数据库中存储的相应表即可。

好的，让我再次运行服务器。这次，当我访问URL时，输出将显示文本“pasta type of Italian cuisine”。

Django根据URL中发送的数值，动态地从数据库表中获取了文本。这个数值对应于表中的某个条目。目前它的值是1。如果我将它从1改为2，你会注意到浏览器输出了不同的文本。这之所以可能，是因为在views.py文件中创建的逻辑。

示例三：完整的MVT（模型、视图、模板）

对于最后一个示例，我需要修改视图以返回一个模板。我在应用文件夹内创建了这个模板。请注意，如果我展开这个文件夹，里面会有一个名为menucard.html的文件。

该文件包含三个带有基本样式的HTML元素。在这最后一个示例中，除了添加模板和修改views.py文件外，我没有做任何其他更改。

如果我再次打开网页并刷新页面，输出将显示应用了HTML和CSS的样式。

这种格式和样式将应用于我做出更改的所有页面。重要的是要注意，虽然这个输出看起来可能很基础，但其概念非常强大。通过将数据、逻辑和显示分离为M、V和T，开发者可以快速创建大规模的数据驱动应用程序。

MVT架构的优势

MVT架构允许开发者轻松地更新数据库、逻辑代码、呈现方式和样式，以创建动态的Web应用程序。虽然项目文件夹中的文件数量可能看起来令人生畏，但你将在本课程的后续部分中，在需要时探索这些文件。

正如我在视频开头所说，你很快就会更详细地探索这个MVT概念。同样值得记住的是，你已经熟悉将要处理的代码，因为它主要是Python。

总结

在本节课中，我们一起学习了Django如何影响模型、视图和模板（MVT）架构。我们通过三个示例看到了数据（模型）、业务逻辑（视图）和用户界面（模板）是如何分离的。这种分离使得代码更易于维护、测试和扩展，是构建健壮后端应用的基础。记住，MVT是Django高效开发的核心模式。

10：模块总结：介绍Django 🎉

在本节课中，我们将回顾并总结“Django入门”模块所涵盖的核心概念与技能。你将清晰地理解Django是什么、它能解决什么问题，以及如何开始构建一个基础的Django项目。

概述

本模块引导你初步认识了Django这一强大的Web框架。你学习了Django的基本概念、项目与应用程序的结构、管理工具的使用，以及Web框架的核心思想。现在，让我们系统地回顾一下这些关键内容。

Django简介

上一节我们完成了模块学习，本节中我们来看看你首先探索的内容：什么是Django。

你现在能够识别Django所解决的问题，特别是在构建需要处理大量文本内容、媒体文件和高流量的项目时。你也能举出Django在现实世界中的应用实例。

例如，开发者可以使用Django创建一个后端框架，并通过API连接到前端框架。

项目创建过程

接下来，你被引入了项目创建的过程。

你现在可以使用VS Code在Windows或Linux系统上创建一个项目。

项目与应用程序

其次，你学习了项目和应用程序的概念。

你现在应该能够解释项目和应用程序的核心概念。需要强调结构化项目的重要性，这能使你的开发过程更轻松，并让一个默认的Web项目启动并运行。

你还学习了遵循最佳实践以结构化方式开发项目。这包括“不要重复你自己”（DRY）原则。

核心原则：DRY (Don‘t Repeat Yourself) - 编写一次，多次使用。

管理与结构

第三，你探索了管理和结构。

在这一部分，你学习了将Django Admin和manage.py命令作为命令行工具选项，来执行管理任务。你也了解了它们在创建项目和应用程序时是如何被使用的。

你可以阐明项目与应用程序之间的关键区别，以及它们如何协同工作。你还学习了如何在现有项目中创建一个应用程序。

以下是manage.py的一些常用命令：

python manage.py startapp <app_name> - 创建一个新的应用程序。
python manage.py runserver - 启动开发服务器。
python manage.py makemigrations - 创建数据库迁移文件。
python manage.py migrate - 应用数据库迁移。

Web框架

最后，你重点学习了Web框架。

你现在知道，框架旨在支持你构建Web应用程序。它帮助开发团队遵循最佳实践。

你理解到，框架是你构建应用程序的坚实基础。Web框架的目的是使应用程序开发更容易，并为开发者提供一个清晰的结构，以保持事物有序，并允许更改和修改。框架还通过现有代码促进了代码的可重用性。

你学习了构建Web应用程序时存在的不同部分和组件，以及现代应用程序通常使用三层架构构建。

你探索了Django的结构，这些结构处理了许多Web开发任务。这些结构让你可以专注于编写应用程序，而无需重复造轮子。

回想一下使用Django框架的好处，包括速度、功能、安全性和可扩展性。

你还学习了Django如何实现模型-视图-模板（MVT）架构，以及将数据、逻辑和显示分离到MVT中，能够快速创建大规模的数据驱动型Web应用程序。

核心架构：MVT (Model-View-Template)

现在，你可以在优先考虑代码可重用性的同时，展示MVT模式。你学会了在现有的Django项目中创建一个应用程序，其中该应用程序包含一个视图，用于向Web应用程序的主页输出文本。

总结

本节课中我们一起学习了Django开发之旅的精彩开端。你现在熟悉了项目结构与应用程序之间的区别、Django Admin和manage.py命令、MVT框架，以及如何使用正确的结构在现有项目中创建应用程序。做得好！

11：视图

在本节课中，我们将要学习Django框架中的核心概念——视图。我们将了解什么是视图，以及开发者如何使用视图来处理HTTP请求并返回HTTP响应。

静态网站与动态网站

如果你正在构建一个基本的静态网站，你只需要将网站文件上传到Web服务器即可。

然而，如果你正在使用框架构建一个动态网站，你可能需要获取或检索数据并将其渲染到浏览器。这些数据可以是任何内容，例如用户的姓名或信息列表。

在Django中，你使用一种称为“视图”的东西来创建向最终用户呈现数据的逻辑。

什么是Django视图？

在Django中，视图是一个专门设计用于处理Web请求并返回Web响应（例如HTML文档）的函数。

为了演示这一点，让我们通过一个静态文件和一个动态文件的例子来探索HTTP请求-响应场景。

对于一个没有动态内容的静态文件，HTTP请求只需要映射到文件所在的位置并返回该页面进行渲染。由于静态页面不会改变，因此不需要其他操作。

假设页面地址是 littlelemon.com/index.htm。

Web服务器将处理该请求，并返回一个包含 index.htm 页面的响应给浏览器，然后浏览器渲染内容。

你可能还记得，这个过程被称为HTTP请求-响应周期。

然而，如果你想在Django中做同样的事情，你需要编写一个Python函数来创建一个叫做“视图”的东西。

创建视图函数

你在 views.py 文件中创建这个函数并返回HTML。

现在让我们进一步探索这个概念，并逐行分析代码。

首先，从 django.http 模块导入 HttpResponse 类。

接下来，定义一个名为 home 的函数，这被称为视图函数。每个视图函数都将一个HTTP请求对象作为其第一个参数，通常命名为 request。

由于这是一个Python函数，可以定义更多参数并传递参数，你将在本课程后面学到这一点。

需要知道的是，你给视图函数起的名字并不重要。Django不需要以某种特定方式命名函数来识别它。

在这个例子中，它被命名为 home，因为定义一个能清楚表明函数作用的函数名是一种良好实践。

接下来，创建一个变量，并用它来存储一个包含要返回的HTML的字符串。同样，你可以随意命名这个变量。在这个例子中，它被命名为 content。

最后，你需要返回这个包含代码的变量，通过使用 return 语句和 HttpResponse 对象来实现。在 HttpResponse 内部，你放置这个变量。

你还可以在视图函数内部执行其他编程逻辑，例如处理电子邮件和表单的数据、从数据库检索数据、转换数据以及渲染模板。

视图文件与URL映射

需要知道的是，作为最佳实践，你在 views.py 文件中创建视图函数。

理论上，你可以随意命名该文件，但最好将其保持为 views.py，因为这使得在同一项目上工作的其他开发者更容易理解。

重要提示：仅仅创建视图函数不足以使请求-响应工作。视图函数需要映射到一个URL，这样当对该URL发出请求时，视图函数才会被调用。

这个将URL映射到视图函数的过程被称为路由。

设置路由

要设置此路由以将URL映射到视图，你需要在项目应用中创建一个新文件，创建一个名为 urls.py 的新文件。你可能记得项目也有一个同名的文件，你将在后面了解它们之间的区别。

在应用的 urls.py 文件中，首先导入 path 函数。

然后，从应用目录导入 views.py 文件。注意，两个文件在同一目录中，你只需要在 import 语句后放置一个点符号。

接下来，要创建路由并将URL映射到视图，你需要使用变量 urlpatterns 创建一个列表序列。

这个变量被分配给一个列表，该列表包含你想在应用内部创建的URL路径。

urlpatterns 列表可以包含多个路径，每个路径都是使用 path 函数创建的。该函数可以接受参数，其中两个是必需的。

第一个参数是 route，它是一个包含URL模式的字符串。

第二个参数是 view，它包含视图函数的相对路径和名称。

在这个例子中，视图函数是为应用的主页调用的，所以目前 route 被设置为空字符串。

你将在本课程后面学习如何用表示为字符串的URL来填充 route 参数。

总结

本节课中我们一起学习了视图和视图函数，以及开发者如何使用它们来处理HTTP请求并返回HTTP响应。

我们还学习了视图函数通过应用 urls.py 文件中的 path 函数映射到URL。

12：创建视图并映射到URL 🚀

在本节课中，我们将要学习Django中URL配置的核心概念，了解如何将特定的URL地址映射到对应的视图函数，从而在用户访问网站时返回正确的网页内容。我们将从创建视图函数开始，逐步配置项目级和应用级的URL，最终实现一个简单的网页响应。

大多数网站都是Web应用程序。当你在浏览器中输入一个URL地址，或者从搜索引擎点击一个网站链接时，通常会返回一个主页。这个主页是在仅发送了包含域名的URL请求时返回的。

之前的学习中，你已经了解到，为了接受HTTP请求并返回HTTP响应，你需要在views.py文件中创建一个视图函数。这个视图函数随后会被映射到一个URL上。当向该URL发起请求时，视图函数就会被调用。

在本视频中，你将学习Django中的URL配置，以及如何用它来将URL映射到视图。你将探索urls.py这个URL配置文件，并了解为什么它在项目级别和应用级别都存在。最后，你将学习如何使用include()函数来引用应用级别的urls.py文件，从而为你创建的应用设计URL。

在Django中，视图函数所使用的URL配置是在urls.py文件中创建和更新的。Django默认会在项目级别创建一个urls.py文件。但此外，最佳实践是在每个应用级别也创建一个urls.py文件。这样，一个应用的所有相关URL可以集中管理。然而，项目也需要知道每个应用内部使用了哪些URL。

例如，在Django中，当用户请求一个URL时，这个请求首先由项目级别的urls.py文件处理。Django会寻找名为urlpatterns的变量。但是，包含URL映射逻辑的代码位于应用级别。因此，你需要一种方法来告诉Django也去检查应用级别的urls.py文件。你可以通过使用include()函数来实现这一点。

在项目级别的urls.py文件中，你在urlpatterns列表内创建一个新的path()。然后，在path()函数内部，你将应用级别urls.py文件的引用作为view参数传入。这使得项目级别能够访问应用级别的URL。通过使用include()函数，项目级别的urls.py可以继承应用级别的URL配置。稍后，当你处理包含字符串形式URL的路由时，你将更详细地探索这种继承的概念。

现在，让我们打开VS Code，开始编写URL配置的代码。

首先，创建一个项目，并在项目内创建一个名为myapp的应用。为了确保Django应用正在运行，请在终端运行命令python3 manage.py runserver来启动开发服务器。现在，选择URL将Django部署到你的本地主机。

请注意，网页会显示一个“安装成功”的消息。让我们先关闭这个网页并停止服务器。

第一步是打开views.py文件来创建一个视图。使用导入语句，输入from django.http import HttpResponse。接下来，创建一个名为home的函数，并将request对象作为参数传入。然后，返回一个包含字符串的HttpResponse。

让我们以小柠檬餐厅的主页为例。字符串中的消息是：“Welcome to the Little Lemon restaurant.” 我们的目标是当用户打开本地主机的URL时显示这条消息。

以下是创建视图的步骤：

从django.http模块导入HttpResponse类。
定义一个名为home的视图函数，它接受一个request参数。
在函数体内，使用return语句返回一个HttpResponse对象，其内容为欢迎字符串。

代码示例如下：

from django.http import HttpResponse

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/meta-be-dev/img/3aedd0dffb17ca146754e5692fb34ca5_5.png)

def home(request):
    return HttpResponse("Welcome to the Little Lemon restaurant.")

让我们探索显示这条消息的后续步骤。

第一步是在myapp应用内创建一个名为urls.py的文件。请记住，这是应用级别的urls.py文件，项目级别也存在一个同名的文件。

在urls.py文件中，你需要从django.urls导入path函数。这允许你在urlpatterns列表中使用path函数。正是在path函数内部，你将URL映射到其相关的视图函数。

下一步是创建一个名为urlpatterns的序列。在方括号内，你添加path函数，并在括号内传入一个空字符串，后跟视图函数的位置和名称。因为urls.py文件和views.py文件位于同一个文件夹，你只需要提供视图函数所在文件的名称（不带.py扩展名），然后是一个点号和视图函数的名称。

请注意，VS Code在代码中高亮了views这个词。这意味着为了使用views.py文件，必须导入它。因此，输入from . import views并保存文件。重要的是要记住在这个path函数末尾添加一个逗号，以匹配Django执行的解析。

现在，再次保存文件。好的，代码几乎完成了。最后一步是在项目级别设置URL配置。这是因为项目文件不知道视图函数在哪里。

以下是配置应用级URL的步骤：

在应用目录下创建urls.py文件。
从django.urls导入path。
从当前目录导入views模块。
定义urlpatterns列表，使用path()函数将空路径''映射到views.home视图。

代码示例如下：

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home),
]

为了设置此配置，请打开项目的urls.py文件。在path关键字旁边，输入逗号，然后输入include以导入include函数。接下来，在urlpatterns列表内，添加另一个path函数。在括号内传入一个空字符串作为第一个参数。对于第二个参数，使用include()函数来传入应用的urls.py文件位置。再次记住，不要添加.py扩展名。

保存文件并在浏览器中打开本地主机的URL。

成功！消息“Welcome to the Little Lemon restaurant.” 显示出来了。

在本节课中，我们一起学习了Django中的URL配置，以及如何用它来将项目级别的URL映射到应用级别的视图。你掌握了创建视图函数、配置应用级和项目级urls.py文件，并使用include()函数连接它们的关键步骤。通过实践，你成功地在浏览器中显示了自定义的欢迎页面，这是构建Django Web应用的重要基础。

13：创建视图和视图逻辑 🧱

在本节课中，我们将要学习如何创建视图函数，这些函数能够返回文本和HTML标记。我们还将学习如何将这些函数映射到特定的URL，以便最终用户能在网页浏览器中看到它们。

概述

视图是Django应用的核心组件之一，它负责处理用户的请求并返回响应。简单来说，视图就是一个Python函数，它接收一个Web请求，并返回一个Web响应。响应可以是纯文本、HTML页面、JSON数据等。

上一节我们介绍了Django项目和应用的基本结构，本节中我们来看看如何编写具体的视图函数，并让它们通过URL在浏览器中显示出来。

创建返回文本的视图

首先，我们需要在应用的 views.py 文件中创建一个视图函数。这个函数将返回一个简单的“Hello World”文本。

以下是创建此视图的步骤：

打开应用目录下的 views.py 文件。
从 django.http 模块导入 HttpResponse 类。这个类允许我们与服务器进行通信。
定义一个名为 say_hello 的函数，它返回一个包含“Hello World”文本的 HttpResponse 对象。

对应的代码如下：

# 在 views.py 文件中
from django.http import HttpResponse

def say_hello(request):
    return HttpResponse("Hello World")

核心概念：HttpResponse 对象是Django中用于向客户端（浏览器）返回内容的基本方式。其基本公式为：HttpResponse(content=文本或HTML内容)。

将视图映射到URL

仅仅创建视图函数是不够的，Django并不知道当用户访问哪个地址时应该执行这个函数。因此，我们需要在URL配置文件中建立URL与视图函数之间的映射。

以下是配置URL的步骤：

打开项目目录下的 urls.py 文件。
从你的应用模块中导入 views。
在 urlpatterns 列表中添加一个 path()，将特定的URL路径（例如 ‘sayhello/’）与刚才创建的 say_hello 视图函数关联起来。

对应的代码如下：

# 在项目 urls.py 文件中
from django.urls import path
from your_app_name import views # 请将 your_app_name 替换为你的实际应用名

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/meta-be-dev/img/12b4984fa6d6b6f1f248fab190a97fe6_7.png)

urlpatterns = [
    path('sayhello/', views.say_hello, name='say_hello'),
]

核心概念：path() 函数用于定义URL模式。其基本语法为：path(‘路由/’, 视图函数, name=‘路由名称’)。当用户访问 基础URL/sayhello/ 时，Django就会调用 views.say_hello 函数并返回其结果。

配置完成后，运行开发服务器（python manage.py runserver），在浏览器中访问 http://127.0.0.1:8000/sayhello/，你就能看到“Hello World”的页面了。

创建更多视图函数

掌握了基本方法后，我们可以创建更多功能不同的视图。每个视图函数都需要在 views.py 中定义，并在 urls.py 中配置对应的路径。

以下是几个视图函数的示例：

返回欢迎信息：创建一个返回“Welcome to Little Lemon”的视图。
```
def homepage(request):
    return HttpResponse("Welcome to Little Lemon")
```
然后在 urlpatterns 中添加：path(‘homepage/’, views.homepage, name=‘homepage’)。

集成Python功能：创建一个显示当前年份的视图，这需要用到Python的 datetime 模块。
```
import datetime

def display_date(request):
    date_joined = datetime.datetime.now().year
    return HttpResponse(date_joined)
```
对应的URL配置为：path(‘displaydate/’, views.display_date, name=‘display_date’)。

返回HTML内容：视图不仅可以返回纯文本，还可以返回带有HTML标记和简单样式的富文本内容。

def menu(request):
    html_content = “””
    <h1 style=‘color: blue;’>Little Lemon</h1>
    <p>Welcome to our restaurant’s menu page.</p>
    “””
    return HttpResponse(html_content)

对应的URL配置为：path(‘menu/’, views.menu, name=‘menu’)。

访问 http://127.0.0.1:8000/menu/，你将看到一个带有蓝色标题和段落的简单网页。

总结

本节课中我们一起学习了Django视图创建与URL映射的核心流程。

我们首先学习了如何编写一个基础的视图函数，使用 HttpResponse 对象返回文本内容。接着，我们掌握了关键的一步：如何在项目的 urls.py 文件中使用 path() 函数，将特定的URL路径与我们编写的视图函数关联起来，从而使浏览器能够访问到这些内容。

最后，我们通过多个实例进行了实践，包括返回静态文本、集成Python代码动态生成内容，以及返回带有HTML标记和简单样式的响应。虽然目前返回的内容还比较基础，但这为后续学习使用模板（Templates）来构建完整的网页打下了坚实的基础。

记住这个核心流程：编写视图（views.py） -> 配置URL（urls.py） -> 运行服务器访问。祝你接下来的开发之旅顺利！🚀

14：HTTP请求 🔗

在本节课中，我们将要学习HTTP协议的基础知识。HTTP是万维网的核心通信协议，它定义了客户端（如浏览器）与服务器之间如何交换信息。我们将了解HTTP请求和响应的结构、常见的HTTP方法、状态码，以及安全的HTTPS协议。

你是否注意过浏览器地址栏URL旁边的锁形图标？这表示正在使用的是HTTPS，即HTTP的安全版本。HTTP是万维网的核心操作协议。它使你的网页浏览器能够与托管网站的Web服务器进行通信。大多数时候，你浏览网页使用的通信协议就是HTTP。

HTTP的定义与作用 🌐

HTTP代表超文本传输协议。它是一种用于传输Web资源（如HTML文档、图像、样式表和其他文件）的协议。

HTTP是一种基于请求-响应的协议。Web浏览器或客户端向服务器发送HTTP请求，然后Web服务器将HTTP响应发送回浏览器。

HTTP请求的构成 📤

上一节我们介绍了HTTP的基本概念，本节中我们来看看HTTP请求的具体构成。一个HTTP请求由方法、路径、版本和头部组成。

HTTP方法描述了客户端希望执行的操作类型，并将其传达给服务器。主要或最常用的HTTP方法有：GET、POST、PUT和DELETE。

以下是这些方法的详细说明：

GET方法用于从给定服务器检索信息。
POST请求用于向服务器发送数据。
PUT方法用新内容更新Web服务器上现有的资源。
DELETE方法用于删除资源。

路径表示资源在Web服务器上的存储位置。例如，如果你想从网站的某个页面请求一张图片，那么地址栏中的URL就需要包含该文件在Web服务器上的完整路径。

HTTP协议有多个版本，目前最常用的是1.1和2.0版本。

最后是头部。头部包含关于请求以及发出请求的客户端的附加信息。头部可以包含诸如服务器名称、服务器端口、请求方法类型和内容类型等信息。头部的内容可能因特定的客户端和服务器而异，但上述是一些最常见的。

对于某些请求方法（如POST），请求还会包含客户端正在发送的内容主体。

HTTP响应的构成 📥

了解了请求的构成后，我们来看看HTTP响应的格式。HTTP响应的格式与请求格式相似。在头部之后，响应可以选择性地包含一个由响应内容（如HTML文档、图像文件等）组成的消息体。

头部中包含的HTTP状态码指示HTTP请求是否成功完成。状态码的值范围在100到599之间，并按用途分组。状态消息是状态码的文本表示。

在你浏览网页时，是否遇到过显示“404 未找到”或“500 服务器无响应”错误的页面？让我们简要探讨一下这些HTTP状态码及其分组。

状态码分为五组，它们由状态码的第一个数字来划分：

信息响应：100到199。
成功响应：200到299。
重定向消息：300到399。
客户端错误响应：400到499。
服务器错误响应：500到599。

以下是各组状态码的详细说明：

信息响应是服务器发送的临时响应。这些响应是实际响应之前的中间响应。最常见的信息响应是100 Continue，它指示Web客户端应继续请求，或者如果请求已完成则忽略此响应。
成功响应表示请求已被Web服务器成功处理，最常见的成功响应是200 OK。当你成功从网站接收到内容时，你每天都在接收这些响应。“OK”的含义取决于HTTP方法：如果方法是GET，意味着资源已找到并包含在HTTP响应的主体中；如果是POST，意味着资源已成功传输到Web服务器；如果是PUT，意味着资源已成功传输到Web服务器；最后，如果是DELETE，意味着资源已被删除。
重定向响应指示Web客户端，所请求的资源已被移动到不同的路径。最常用的响应代码是301 Moved Permanently（永久移动）和302 Found（临时移动）。重定向消息301和302之间的区别在于，302表示临时重定向，即资源已被临时移动。当Web浏览器收到这些响应时，它们会自动向新路径提交对该资源的请求。
客户端错误响应表示请求包含错误的语法或内容，或者无法被Web服务器处理。让我们探讨一些最常见的响应代码：400 Bad Request用于Web浏览器或客户端向Web服务器提交了错误数据时；401 Unauthorized用于指示用户必须在请求被处理之前登录账户；403 Forbidden用于指示请求有效，但Web服务器拒绝处理它，这通常用于表示用户在Web应用程序中没有足够的权限来执行某项操作；404 Not Found用于指示在Web服务器上未找到请求的资源。
服务器错误响应表示Web服务器在尝试处理请求时发生故障。最常用的代码是500 Internal Server Error，这是一个通用错误状态，表示服务器未能处理请求。

安全的HTTP：HTTPS 🔒

你是否曾在网上购物并需要输入信用卡信息？你肯定不希望别人从HTTP请求中获取这些信息，对吧？这时就必须使用HTTPS。HTTPS是HTTP的安全版本。

它用于两台计算机之间的安全通信，以确保其他人无法看到正在发送和接收的信息。这是通过一种叫做加密的技术实现的。

与HTTP一样，HTTPS中的请求和响应行为方式相同，内容也相同。最大的区别在于，内容在发送之前会被转换成秘密代码。只有另一台计算机才能将这个秘密代码转换回原始内容。如果有人查看这段代码，它将无法被理解。

你每天都在使用HTTPS。这就是你在浏览器URL旁边看到的锁形图标。

总结 📝

本节课中我们一起学习了HTTP协议的核心知识。

首先，HTTP是Web客户端和Web服务器使用的协议。它用于传输HTML文件等Web资源，是网络上任何数据交换的基础。同时请记住，通过使用HTTPS，我们可以安全地发送信息。

请求由客户端（通常是Web浏览器）发送，服务器则用响应进行回复，响应内容可能是一张图片或一个HTML页面。HTTP请求的语法包括方法、路径、版本和头部。

HTTP响应的格式与请求类似，HTTP状态码指示HTTP请求是否成功完成。状态码是一个三位数，对应着代表不同类型结果的分组。

现在，你已经了解了HTTP协议的请求和响应循环是如何工作的，知道了它的方法以及构成HTTP请求的各个要素。做得好！

15：创建请求和响应对象 🚀

在本节课中，我们将要学习Django框架中HTTP请求与响应周期的核心机制。你将了解客户端与服务器如何通过请求和响应对象进行通信，并掌握在Django视图中创建和操作这些对象的基本方法。

请求-响应周期概述

上一节我们介绍了Web应用的基本通信模型。本节中我们来看看Django内部如何处理请求-响应周期。

该周期始于用户在浏览器中输入一个URL。此URL被发送到Web服务器，Django随后在其urls.py文件中寻找匹配项。一旦找到匹配的URL，它就会被映射到对应的视图函数。在视图文件中，视图函数接收HTTP请求并将其封装为一个request对象。视图函数随后定义适当的HTTP响应，并将其作为HTTP response对象发回。此响应由Django处理，最终客户端收到HTTP响应。

在代码中探索请求与响应对象

现在，让我们打开VS Code，探索如何操作Django的请求和响应对象。

首先，打开views.py文件并添加必要的导入语句。接着，创建视图。需要记住的是，Django使用request和response对象在整个系统中传递数据。

HTTP请求和HTTP响应对象的API在Django的django.http模块中定义。你需要在视图函数的逻辑中从这个模块导入并使用HttpRequest和HttpResponse对象。

以下是创建视图函数的步骤：

创建一个名为home的视图函数，并将request对象传递给它。
检查urls.py文件，确保函数名与URL模式列表中的视图函数名称匹配。
回到views.py文件，通过输入request.path来访问request对象中的path属性。
将此属性赋值给一个名为path的变量。需要注意的是，必须修改格式以便在HTTP响应中返回path变量。

下一步是创建带有HTTP响应对象的返回语句。在括号内，传入path参数，然后是内容类型，最后是字符集。

from django.http import HttpResponse

def home(request):
    path = request.path
    return HttpResponse(path, content_type='text/plain', charset='utf-8')

保存文件并在浏览器中打开本地主机URL。输入URL的确切位置，即/main/home。

请注意，路径显示在浏览器的主窗口中，并且其顺序与你在URL模式列表中按下main然后home的顺序相同。

如果你在URL模式列表中移除main并保存文件，可以通过移除路径中的main来配置URL。

注意路径更新为/home。这是因为Django将从应用级别提供的路径拼接到了项目级别的当前路径中。这个例子演示了HTTP响应对象的行为与普通对象类似。

进一步操作响应对象

为了进一步探索，我们可以创建另一个HTTP响应对象并将其赋值给一个变量。

def home(request):
    response = HttpResponse("This works.")
    return response

回到浏览器，刷新页面，注意显示的文本。

需要知道的是，这只是一个如何探索HTTP响应对象的示例。在实际场景中，开发者通常不需要修改HTTP响应对象的结构。

返回请求对象的属性

为了让这个例子更深入，你也可以返回HTTP请求对象的属性。例如，你可以创建变量来存储方案（scheme）、方法（method）、地址（address）、用户代理（user agent）和路径信息（path info）。你可能还记得，元标签（metatags）提供了关于请求对象头部（headers）的信息。

要在浏览器窗口中显示HTTP请求对象的属性，你需要将变量渲染到Python的格式化字符串中。回想一下，在Python中执行字符串格式化，可以使用格式化字符串字面值（f-string）。以一个字符F（大小写均可）开始字符串，并将其放在引号之前。Python表达式则放在花括号{}中。

以下是具体步骤：

在格式化字符串中添加一些HTML标签，并传入你之前创建的变量。
将这个格式化字符串存储在一个名为message的变量中。
最后，使用return语句返回HTTP响应对象，注意将message变量作为第一个参数传递。

def home(request):
    scheme = request.scheme
    method = request.method
    address = request.META['REMOTE_ADDR']
    user_agent = request.META['HTTP_USER_AGENT']
    path_info = request.path_info

    message = f"""
    <p>Scheme: {scheme}</p>
    <p>Method: {method}</p>
    <p>Address: {address}</p>
    <p>User Agent: {user_agent}</p>
    <p>Path Info: {path_info}</p>
    """
    return HttpResponse(message)

现在保存文件。在浏览器中刷新你的URL，注意请求对象的信息显示在浏览器中。

更新请求与响应对象的头部信息

最后需要了解的是，你可以更新HTTP请求和响应对象的头部信息。

为此，创建一个HTTP响应对象并将其赋值给一个名为response的变量。接着，输入response.headers，并使用字典添加一个键为Age、值为20的项。然后，在格式化字符串中传入这个值。

def home(request):
    response = HttpResponse()
    response.headers['Age'] = 20
    message = f"Header 'Age' set to: {response.headers['Age']}"
    return HttpResponse(message)

返回浏览器并刷新页面。注意响应头的内容显示出来，并且Age已作为头部的一部分添加。

实际应用场景

开发者在处理GET和POST方法时会使用请求和响应对象。

这对于创建表单、操作数据库以及处理Django中其他常见数据结构非常有用。

总结

本节课中我们一起学习了如何在Django中使用请求和响应对象。我们了解了请求-响应周期的流程，在代码中创建并操作了HttpRequest和HttpResponse对象，探索了如何访问请求属性、构建响应内容以及修改响应头。这些知识是构建Django Web应用视图层的基础。

16：了解URL 🔗

在本节课中，我们将要学习什么是URL（统一资源定位符），并详细解析构成URL的各个部分。URL是我们在互联网上访问任何资源时使用的地址，理解其结构对于后端开发和网络通信至关重要。

当您从设备访问网络时，可能会点击一个网页链接或输入一个地址。这个地址被称为URL，它链接或指向一个特定的资源或网页。

什么是URL？ 🧩

互联网上的每一个资源都由一个称为统一资源定位符（URL）的地址来定位。每次您点击网页链接或输入网址时，都是在访问一个URL。

URL由多个部分组合而成。其核心组成部分包括：

协议
域名
文件路径
参数

接下来，我们将逐一探索这些部分。

协议（Scheme） 🌐

URL的第一部分是协议，有时也称为方案。

它位于任何URL地址的开头，通常标识为 HTTP 或 HTTPS。

HTTP 这几个字符代表超文本传输协议。该协议决定了数据传输和交换的规则集。

HTTP 和 HTTPS 之间的区别在于安全性，其中的 S 代表安全（Secure）。

HTTP 以纯文本形式发送数据，这可能会暴露发送者的信息。
HTTPS 对所有数据进行加密，这意味着数据不是可读的格式，因此更加安全。

HTTP协议也负责在网络上发送和接收HTML。HTTP及其扩展HTTPS是网络上最广泛使用的协议。

子域名与域名 🏷️

上一节我们介绍了协议，本节中我们来看看子域名和域名。子域名位于域名之前，通常包含主页和其他重要页面。

最常见的子域名是万维网，用 WWW 表示。

需要注意的是，一些浏览器会用符号（例如加密页面的锁形图标）来替换协议和子域名。这样做是为了让URL更易于阅读和理解。

接下来是域名，它由两部分组成：二级域名和顶级域名。

以下是这两部分的简要说明：

二级域名：指一个组织或公司的名称。例如，名为“Little Lemon”的公司的二级域名就是 littlelemon。
顶级域名：位于二级域名之后，是域名的结尾部分。它用于表示您组织所属的国家或类别。例如，.com 地址可以表示商业实体，.org 表示组织，而国家代码（如 .uk）则代表一个国家、主权国家或属地。

文件路径 📁

了解了域名的构成后，让我们来探索文件路径。

文件路径，也称为页面路径，用于引导您找到资源的位置。该资源可以是任何可以通过HTTP传输的文件类型，例如网页文档、图像文件和元数据。

请记住，URL只是一个存储文件的地址。这些文件可以是本地的，也可以是基于网络的（可能位于域之外的外部服务器上）。

本地托管：资源（如图像和网页文件）位于用户的设备或服务器上。
网络托管：资源存在于用户的远程网络服务器或外部服务器上。

例如，Django 4.1版本发布的基于网络的URL，就有一个包含发布年份、月份和日期的特定文件路径。

URL参数（查询字符串） 🔍

URL参数，也称为查询字符串，用于在URL内构建附加信息。

您可以使用URL参数来捕获URL的任何部分，并传递其值以供处理。

查询字符串的格式类似，它以问号 ? 符号开始，并放置在URL路径之后。

它包含以键值对形式表示的参数，这些参数可以出现在URL路径中。

您可以通过在参数之间添加与符号 & 来添加多个参数。

Django可以处理这两种类型的URL，但主要使用URL参数。

URL设计简介 ✨

最后，让我们简要探讨一下URL设计的主题。

URL设计是有目的地创建URL的实践。因此，对于Django开发者来说，理解构成URL的不同部分非常重要。

这有助于定义设计良好的URL，因为网站内容的需求决定了URL将如何构建。

总结 📝

本节课中我们一起学习了什么是URL、构成URL的不同部分以及它们如何工作。您现在了解到，每个URL都是唯一的，它指向网络上特定的资源或页面。

17：映射带参数的URL

在本节课中，我们将要学习如何在Django中定义能够接收参数的URL。你将了解如何从URL中捕获信息，并将其传递给视图函数进行处理，这是构建动态网页功能的基础。

概述

之前，你已经学习了如何使用path函数定义URL结构，并将URL映射到视图函数。有时，开发者需要向视图函数传递信息以进行额外处理。在Django中，开发者可以选择将值作为URL参数传递，将URL本身作为信息来源。本节将详细介绍这一过程。

捕获URL参数

在Django中，你可以通过在定义URL的path函数中使用尖括号来从URL中捕获值。捕获的值可以选择性地包含一种称为“转换器类型”的东西。目前你只需要知道，要捕获一个字符串，可以使用关键字str，后跟一个用于标识该值的名称。然后，在views.py文件中，你可以在request对象之后将此名称作为参数传递给视图函数。

以下是定义带参数URL的基本语法：

path('dishes/<str:dish>', views.menu_items)

其中，str代表路径转换器类型，dish是赋予匹配值的URL参数名称。

实践：创建菜品详情页

让我们通过配置一个URL并向视图函数传递参数来创建一个菜品详情页面。

首先，打开urls.py文件，在urlpatterns列表中添加一个path。在path函数中，将URL定义为dishes/<str:dish>。然后，在views.py文件中创建对应的视图函数。

以下是创建视图函数的步骤：

确保导入HttpResponse对象。
函数声明中，需要在request参数之后传递一个额外的参数，因为我们在urls.py文件中传递了一个参数。
在函数体内，创建一个字典来存储菜品及其描述。

以下是视图函数menu_items的示例代码：

from django.http import HttpResponse

def menu_items(request, dish):
    items = {
        'pasta': '意大利面是一种由面团制成的面食。',
        'falafel': '法拉费是一种由鹰嘴豆或蚕豆制成的中东油炸球。',
        'cheesecake': '芝士蛋糕是一种甜点，由一层或多层组成，最主要的一层是软奶酪。'
    }
    description = items.get(dish, '菜品未找到')
    return HttpResponse(f"<h1>{dish}</h1>" + description)

这段代码的逻辑是：传递给此函数的URL参数值将与字典中的一个键进行匹配，然后将关联的值存储在名为description的变量中。最后，返回一个包含HTML标题的HttpResponse对象，以显示函数参数和关联的描述变量作为纯文本。

保存代码并运行服务器。在浏览器中，在本地主机URL的末尾添加/dishes/pasta。请注意，“pasta”是字典中的一个条目。文本将在浏览器中显示，URL参数作为标题，字典描述作为文本。同样，如果将其修改为/dishes/cheesecake，文本会相应更新。

URL参数的应用场景

定义带参数的URL有广泛的用途。在本例中，视图函数的逻辑是传递一个与字典中描述相匹配的URL参数。

开发者还可以使用URL参数将信息发送到逻辑层进行处理，或作为搜索和排序条件。同样，URL参数可用于获取可与表单、数据模型和其他数据结构一起使用的数据。

例如，你可以使用int路径转换器类型来传递数据库表的主键。一旦主键被发送到视图函数，它就可以获取数据库行及其数据。当你探索Django模型时，你将学习如何做到这一点。

映射带参数的URL对于创建有意义的内容分组也很有用。

总结

本节课中，我们一起学习了如何使用URL参数从URL中检索数据并将其发送到视图函数进行处理。我们还探讨了如何使用尖括号和路径转换器从URL中捕获参数值。这是构建动态、数据驱动的Web应用程序的关键一步。

18：17_URL中的正则表达式 📝

在本节课中，我们将要学习如何在Django中使用正则表达式来定义和验证动态URL模式。正则表达式是一种强大的工具，可以帮助我们精确地匹配URL中的特定模式，从而将请求正确地路由到对应的视图函数。

现在，你应该已经熟悉了在Django中使用参数映射URL的概念。

Django允许你自由设计URL，这是通过使用path函数和路径转换器实现的。例如，创建一个包含动态值的自定义URL。

对于更复杂的匹配需求，你可以使用一种叫做正则表达式的东西来定义自己的路径转换器。在本视频中，你将学习如何使用正则表达式在Django中定义URL模式。

假设你接到一个任务，要为Little Lemon网站创建一个菜单项页面。该页面显示菜单上每个项目的内容。

与其为每个菜单项制作一个单独的页面，你可以定义一个动态的URL结构，将菜单项的ID传递给视图函数。

页面的内容将取决于从URL传递给视图函数的菜单项值。根据URL中传递的ID值，视图函数中的逻辑将决定显示什么类型的数据，例如菜单项名称。

这对开发者的优势在于，他们只需要创建一个页面。开发者无需为每个菜单项创建单独的静态页面，只需创建一个页面，其内容根据URL中传递的值动态更新。

然而，为了确保URL的结构符合视图函数的要求，你需要一种方法来定义和验证URL的值和格式。

为了验证传递给视图函数的URL值是否正确，你可以使用正则表达式。正则表达式（RegEx）是一组指定模式的字符，用于在字符串中搜索或查找模式。

它们是开发者用来执行提取和验证、高级搜索、分组搜索以及查找和替换操作的强大工具。

在Django中，开发者在将动态URL路径发送到关联的视图函数之前，使用正则表达式来定义、提取和验证它们。

本视频重点介绍在Django URL路径中使用正则表达式。但重要的是要知道，正则表达式并非Python或Django所特有。它们在计算机编程和软件开发的各个领域都有许多用途。

正则表达式及其相关字符是通用的，意味着它们在所有编程语言中都是相同的。

上一节我们介绍了正则表达式的基本概念，本节中我们来看看一个具体的代码示例。

让我们从一个包含两个条目的URL模式示例开始探索，这些条目位于urls.py文件中。第一个路径使用常规URL构建，第二个使用正则表达式路径。

让我们逐行分析代码。首先，从django.urls模块导入两个函数：path和re_path。

from django.urls import path, re_path

re_path用于需要包含正则表达式的路径。

在urlpatterns序列内部，有两个条目。这个例子将只探讨传递给这些函数的第一个参数。

请注意，第一个路径包含URL字符串menu-item/10。这个字符串是静态且不可变的，这意味着它没有可能的数值变化，即使格式相同。

例如，如果你输入一个像menu-item/1这样的URL，它将不匹配此路径并映射到视图。结果，将显示404未找到错误消息。

你可以使用re_path函数接受所有这种格式的URL，就像第二个条目那样。

注意字符串开头的r字符。这使它成为一个原始字符串，将反斜杠视为字面字符而非转义字符。

了解了基本语法后，接下来我们看看正则表达式中一些最常见的符号。

以下是正则表达式中一些关键符号的用途：

^：用作字符串开头的锚点。它也可以用于否定。
$：用作字符串结尾的锚点。
[ ]：使用方括号定义字符集，匹配其中存在的任何一个字符。
{ }：使用花括号指定前面字符的确切数量。
( )：使用圆括号对正则表达式的部分进行分组。

现在你已经熟悉了一些字符，可以在正则表达式中使用它们了。让我们重新回顾一下Little Lemon菜单示例中的URL结构。

URL以一个包含单词menu-item的字符串开始。然后是一个正斜杠/，后面跟着用于分组的圆括号( )。括号内是数字0到9出现两次。括号外是另一个正斜杠/，后面跟着美元符号$来结束字符串。

这个正则表达式可接受的字符串可以是menu-item/后跟范围1到99。

正则表达式在创建URL时非常有用，但同时也可能变得非常复杂。对于包含多个特殊字符的正则表达式来说尤其如此。

初学者在学习正则表达式时感到困惑是很常见的。有时一个符号可以用于一个或多个目的，或者同一个符号根据情况可能有不同的行为。

熟悉它们的用法需要一些练习和耐心。

建议从本视频中的示例开始，并利用本课剩余的阅读材料和练习来构建你的知识。

在本节课中，我们一起学习了正则表达式，以及开发者如何使用它们在Django中创建和验证动态URL。如果你想了解更多关于正则表达式的知识，本课末尾的补充阅读材料中有一个链接。

19：错误处理 🛠️

在本节课中，我们将要学习Django中的错误处理。无论进行多少测试或质量保证，应用程序总会以某种形式包含错误。这并不总是直接与错误的代码或语法问题相关。就其本质而言，网络并非总是100%可靠，偶尔会出现问题。作为一名有抱负的开发者，你需要掌握处理这些潜在问题的方法。

HTTP状态码回顾

上一节我们介绍了错误处理的必要性，本节中我们来看看HTTP状态码。你应该已经知道，HTTP响应包含状态码。回顾一下，100系列用于信息提示，200系列表示成功，300系列用于重定向或资源移动，400系列表示错误的请求或授权问题，500系列则表示服务器问题。

虽然看起来需要学习的代码很多，但在处理Web应用程序时，你通常会更频繁地遇到其中一些相同的状态码。

常见的客户端错误响应码

以下是开发者常遇到的一些客户端错误状态码：

400：表示错误的请求。当请求中传递的参数不符合服务器预期时发生。
401：表示用户必须在处理请求前登录账户。
403：表示请求有效，但Web服务器拒绝处理。这通常意味着调用资源的用户没有查看该资源所需的权限。
404：表示在Web服务器上未找到请求的资源。这通常发生在无法在指定文件路径定位资源时。

常见的服务器错误响应码

现在你了解了一些常见的客户端错误响应，让我们来探索一些服务器错误响应。服务器错误响应通常表示Web服务器在处理请求时发生了故障。这可能意味着许多情况。例如，应用程序失败或未运行，或者由于服务器响应时间过长，调用请求的时间限制可能已中止。

服务器错误响应通常使用从500到599的状态码。

你最可能遇到的常见代码是500内部服务器错误，这是一个通用错误状态，表示服务器未能处理请求。

Django中的错误处理视图

现在你已经了解了错误响应，接下来让我们探索Django如何通过引发异常来处理它们。Django通过引发异常来处理所有错误情况，该异常通过你可以配置的错误处理视图来调用。

这些错误处理视图被添加到一个单独的views.py文件中，该文件必须在项目级别创建，以便在整个项目中应用。

用于这些情况的视图由四个变量指定。

它们是：

handler400
handler403
handler404
handler500

自定义错误处理视图

值得注意的是，虽然你可以为项目使用默认值和视图，但有时你可能希望自定义这些视图的外观以符合你网站的风格或主题。通过覆盖默认值可以实现进一步的定制。这些值可以在项目的根URL配置文件中设置。需要知道的是，在任何其他URL配置文件中设置这些变量将不会产生效果。

现在让我们更详细地探讨这些变量，以覆盖其默认值并实现一些自定义视图。

以下是默认的错误处理视图：

handler400：默认情况下，这是错误请求视图。
handler403：默认情况下，这是权限被拒绝视图。
handler404：默认情况下，这是页面未找到视图。
handler500：默认情况下，这是服务器错误视图。

正如你所了解的，也可以实现自定义视图，你很快将学习如何做到这一点。目前，只需知道要实现自定义视图，视图函数需要接受适当的请求参数并返回适当的响应。

使用HTTP响应子类

你使用这些处理程序创建的自定义视图返回不同的HTTP响应子类，这些子类处理不同类型的HTTP响应。

例如：

类 HttpResponseNotFound 的行为类似于 HttpResponse，但使用404状态码。
类 HttpResponseBadRequest 的行为类似于 HttpResponse，但使用400状态码。
类 HttpResponseForbidden 的行为类似于 HttpResponse，但使用403状态码。
类 HttpResponseServerError 的行为类似于 HttpResponse，但使用500状态码。

总结

本节课中我们一起学习了Django中的错误处理。我们回顾了HTTP状态码，探讨了常见的客户端（400， 401， 403， 404）和服务器端（500）错误代码。我们了解了Django如何通过handler400、handler403、handler404和handler500这四个变量来配置错误处理视图，并知道了可以通过自定义视图和特定的HTTP响应子类（如HttpResponseNotFound）来更灵活地处理错误，以提升用户体验。

20：在视图中处理错误 🛠️

在本节课中，我们将学习如何在Django视图中处理错误，并探索如何使用HttpResponseNotFound类创建一个自定义的404错误页面。

概述

浏览网页时，偶尔输入URL或点击链接后，发现找不到目标页面是很常见的。Django在无法匹配URL时会显示一个默认的“页面未找到”错误页，其中包含一些面向开发者的技术信息。然而，通常不希望最终用户看到这类信息。本节将演示如何创建自定义的错误视图，以提供更友好的用户体验。

默认错误页面与调试模式

上一节我们介绍了Django的基本视图处理。本节中我们来看看如何处理错误。首先，让我们了解Django的默认行为。

当Django无法匹配请求的URL时，它会显示一个默认的404错误页面。在开发阶段，Django的调试模式（DEBUG = True）默认开启，此页面会显示详细的错误信息，例如请求方法和URL。

以下是启动开发服务器的命令：

python3 manage.py runserver

在浏览器中打开本地服务器地址（如http://localhost:8000），如果访问一个不存在的URL（例如/home），你将看到默认的错误页面。页面会提示：“你看到此错误是因为在Django设置文件中DEBUG = True。将其改为False，Django将显示标准404页面。”

关闭调试模式

调试是处理代码中错误的过程。为了在生产环境中隐藏技术细节，需要关闭调试模式。

要进行此更改，请打开项目下的settings.py文件，找到DEBUG设置并将其值改为False。

# settings.py
DEBUG = False

此外，必须在ALLOWED_HOSTS设置中添加值。在本例中，添加星号（*）以包含所有可能的主机。

# settings.py
ALLOWED_HOSTS = ['*']

保存文件并刷新浏览器中的网页。现在，你会看到一个不同的页面，显示“未找到，请求的资源在服务器上不存在”，这是一个更简洁的标准404页面。

创建自定义404错误视图

虽然标准页面更简洁，但我们通常希望创建一个与网站品牌一致的自定义错误页面。接下来，我们将创建一个自定义的404错误处理视图。

以下是创建自定义404页面的步骤：

在项目层级创建视图文件：首先，在项目目录下创建一个名为views.py的新文件（如果不存在）。
配置URL：打开项目级的urls.py文件，进行必要的导入并添加URL模式。
指定错误处理器：在urlpatterns列表之外，添加一个变量来指定404错误的处理函数。

让我们看看具体的代码实现。首先，在项目的urls.py文件中进行配置：

# myproject/urls.py
from django.urls import path
from . import views  # 导入项目级的views模块

# 定义URL模式
urlpatterns = [
    # ... 你的其他URL模式 ...
]

# 在urlpatterns之外指定错误处理器
handler404 = views.handler404

接下来，在项目级的views.py文件中创建处理函数：

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

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/meta-be-dev/img/18875dd42af2ab1757b9f334b5f58084_11.png)

def handler404(request, exception):
    return HttpResponse("404错误：页面未找到")

保存文件并返回浏览器，刷新之前显示404错误的页面。现在，页面上将显示我们自定义的消息“404错误：页面未找到”。如果你修改URL为其他随机值，消息保持不变，这是因为handler404会处理所有URL配置文件中未找到的页面。

但是，如果你访问一个在URL配置中明确定义了视图的地址，该视图仍会正常渲染。

使用HttpResponseNotFound类

同样地，就像代码中使用了HttpResponse对象，你也可以使用HttpResponseNotFound。Django中的不同类代表不同的HTTP状态码，HttpResponseNotFound类就代表状态码404（页面未找到）。

修改views.py中函数的返回语句：

# myproject/views.py
from django.http import HttpResponseNotFound

def handler404(request, exception):
    return HttpResponseNotFound("404错误：页面未找到")

保存文件并刷新浏览器。虽然页面上没有可见的变化，但客户端在内部收到了404状态消息。你可以通过浏览器的开发者工具进行验证：右键点击页面，选择“检查”，转到“网络”标签页，然后访问一个不存在的地址（如/home）。刷新页面后，在“网络”标签中点击该请求，你会看到状态为“404 Not Found”。

最佳实践：设计友好的错误页面

通常，开发者会修改返回的字符串，添加一些HTML元素，如标题和返回首页的按钮，以创建更友好、更具引导性的页面。

以下是一个改进的示例：

# myproject/views.py
from django.http import HttpResponseNotFound

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/meta-be-dev/img/18875dd42af2ab1757b9f334b5f58084_24.png)

def handler404(request, exception):
    html_content = """
    <!DOCTYPE html>
    <html>
    <head><title>页面未找到</title></head>
    <body>
        <h1>404 - 页面不存在</h1>
        <p>抱歉，您寻找的页面已丢失在数字海洋中。</p>
        <a href="/"><button>返回首页</button></a>
    </body>
    </html>
    """
    return HttpResponseNotFound(html_content)

通常认为，最佳实践是创建一个易于理解、与网站品牌保持一致并能引导用户返回首页的自定义错误页面。

总结

本节课中我们一起学习了如何使用Django处理视图中的错误。我们探索了如何通过将设置中的DEBUG改为False来切换错误页面显示模式，并详细演示了如何利用handler404和HttpResponseNotFound类来创建自定义的404错误页面，从而为网站用户提供更佳体验。

21：基于类的视图 🧱

概述

在本节课中，我们将要学习Django框架中一个重要的概念——基于类的视图。我们将了解它如何帮助开发者以更清晰、更易于维护的方式组织代码，特别是当项目规模增长时。我们将对比基于函数的视图，并探索面向对象技术（如继承）如何简化视图逻辑。

保持代码整洁与结构化

在项目开发中，以清晰、易用的方式组织代码至关重要。随着项目规模扩大，保持代码的组织性和良好结构对开发者而言是一个挑战。为了帮助克服这些挑战，开发者通常会使用框架和设计模式，例如MVT（模型-视图-模板）模式。

以Django框架为例，你可以使用视图来向最终用户呈现数据。你已经学过，在Django中可以通过创建一个视图函数来响应Web请求，并使用HTTP响应对象返回数据。在后台，框架将HTTP请求传递给这个函数，并期望返回一个HTTP响应。

# 基于函数的视图示例
from django.http import HttpResponse

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/meta-be-dev/img/5e674d5865ec8dad951145d38d3e5359_3.png)

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

虽然这种方式适用于某些场景，但开发者通常需要一个更健壮的解决方案，以便在视图中实现更复杂的应用逻辑。

引入基于类的视图

为了应对上述需求，Django提供了一种称为基于类的视图的功能。

基于类的视图允许你将视图作为对象使用，并提供了基于函数的视图之外的另一种选择。请记住，视图是可调用的，这意味着它可以接收一个请求并返回一个响应。这个过程非常适合HTTP协议。

当处理HTTP时，你需要为不同类型的请求（如GET、POST、PUT、DELETE）使用特定的方法。这些是任何网页的核心CRUD操作。

如果你使用基于函数的视图，你需要在请求方法上执行一些条件逻辑，例如使用if-else语句。

# 基于函数的视图中处理不同HTTP方法
def my_view(request):
    if request.method == 'GET':
        # 处理GET请求的逻辑
        return HttpResponse('GET request')
    elif request.method == 'POST':
        # 处理POST请求的逻辑
        return HttpResponse('POST request')

基于类视图的工作方式

然而，基于类的视图采用了不同的方法。它不使用if-else语句这样的条件分支，而是使用类实例方法来响应HTTP请求。

实例方法是Python类中定义的默认方法，可以访问类的对象或实例。

在基于类的视图中，可以通过为GET和POST请求添加不同的实例方法来简化代码。这些方法将独立地实现视图逻辑。

# 基于类的视图示例
from django.http import HttpResponse
from django.views import View

class MyView(View):
    def get(self, request):
        # 处理GET请求的逻辑
        return HttpResponse('GET request')

    def post(self, request):
        # 处理POST请求的逻辑
        return HttpResponse('POST request')

基于类的视图使用不同的类实例方法来响应HTTP请求，从而取代了在同一函数内使用if语句编写条件分支的方式。

在这种情况下，使用基于类的视图的优势在于，它允许你移除用于检查传入请求方法类型的条件逻辑。这简化了代码并分离了逻辑，使其更易于理解。

利用面向对象技术：Mixin与继承

另一个有用的方面是能够利用面向对象技术，例如Mixin或多重继承，这些技术可以将代码分解为可重用的组件。

在Django中，你可以使用Mixin来扩展基于类的视图的功能。Mixin是基于类的通用视图，与等效的基于函数的视图相比更加灵活。你可以将Mixin视为一种多重继承的形式。

回想一下，继承是面向对象设计（OOP）的核心概念之一。它允许你从一个类派生出另一个类，从而形成一个具有相似属性的类层次结构。

例如，假设你有一个名为Food的类。其他可以继承这个类的类可能是Appetizer、Entree和Dessert。它们都是食物的类型，并且会共享许多共同的属性。

以下是开发者常用的一些核心Mixin：

Create: 用于创建模型实例。
List: 用于列出查询集。
Retrieve: 用于检索模型实例。
Update: 用于更新模型实例。
Delete: 用于删除模型实例。

需要注意的是，在使用Mixin时，它们不能全部一起使用。在某些情况下，过度使用可能会使你的代码更难阅读，因此最好明智地使用它们。

总结

本节课中，我们一起学习了基于类的视图的概念。我们探讨了开发者如何通过使用面向对象技术（如继承的概念，从继承的类创建视图）来简化他们的视图。基于类的视图通过将不同的HTTP方法逻辑分离到独立的实例方法中，提供了更清晰、更模块化的代码结构，并为进一步利用Mixin等高级特性奠定了基础。

22：模块总结：视图 📚

在本节课中，我们将一起回顾“视图”模块的核心内容。我们将总结如何创建视图、处理HTTP请求与响应、配置URL以及进行错误处理等关键知识点。

概述 📖

本模块介绍了Django框架中视图（View）的概念与实现。视图是Web应用的核心，负责处理客户端请求并返回响应。通过学习，你将掌握创建视图函数、配置URL映射、处理不同HTTP方法以及使用基于类的视图等技能。

视图概述 🧠

上一节我们介绍了课程的整体目标，本节中我们来看看视图的基本定义。

视图是处理Web请求并返回Web响应的逻辑单元。它本质上是一个Python函数或方法，包含了处理请求所需的所有业务逻辑。

以下是视图的一些常见用途：

开发动态网站。
处理电子邮件和表单数据。
从数据库检索信息。
转换数据并渲染模板。

在Django中，创建视图后，需要通过路由将其映射到一个URL，这样才能建立起完整的“请求-响应”工作流。

URL配置与最佳实践 ⚙️

理解了视图的基本概念后，我们需要知道如何让用户访问到它，这涉及到URL配置。

你探索了URL配置文件 urls.py 的作用，并学习了如何在项目级和应用级映射视图。使用VS Code等工具可以方便地进行这些配置。

在开发中，遵循最佳实践至关重要。其中，代码复用和 DRY 原则是构建健壮Django项目的基石。DRY代表“Don‘t Repeat Yourself”，旨在减少代码重复。

本节的最后，你创建了视图并为其添加了逻辑，以处理常见的HTTP请求和响应用例。

请求对象与URL映射 🔗

上一节我们介绍了如何配置URL，本节中我们来看看HTTP请求对象以及它与URL的交互。

你首先了解了HTTP请求对象，现在可以演示如何利用它来映射URL、执行常见的CRUD操作，以及通过调用客户端获取信息。

CRUD代表创建、读取、更新和删除，是数据操作的四种基本功能。

随后，你深入学习了如何创建更详细的请求，以及如何将请求和响应对象用于常见操作。

接下来，你探索了URL的构造方式及其如何映射到视图。

你理解了URL命名空间和视图的概念，这本质上就是如何将URL映射到一个名称及其对应的视图。资源将指向相应的用户界面进行渲染。

参数与HTTP方法 📝

URL映射建立后，视图需要处理来自客户端的各种数据，这些数据通常以参数形式传递。

然后，你学习了在Web应用中使用参数的不同选项。

你可以演示参数如何与 GET、PUT、POST 和 DELETE 等操作关联。

以下是三种主要参数类型及其与HTTP方法的典型关联：

路径参数：通常用于GET、PUT、DELETE请求，标识特定资源（如 /users/123/）。
查询参数：通常用于GET请求，传递过滤或排序信息（如 ?search=keyword&page=2）。
请求体参数：通常用于POST、PUT请求，传递创建或更新所需的数据（如表单数据、JSON）。

你还练习了使用URL调度器设置带参数的URL配置。

正则表达式与错误处理 ⚠️

为了更灵活地匹配URL，我们需要使用更强大的工具——正则表达式。

最后，你学习了如何创建URL和视图，并了解了URL中的正则表达式。

你练习了如何创建不同的URL模式，并通过视图函数将URL映射到视图。

在此基础上，你探索了如何处理错误，例如处理HTTP状态响应码（如100、200、400系列消息）。你还发现了如何处理来自服务器的错误响应。

此外，你学会了在处理PUT和POST操作的请求体时，如何在视图中应用错误处理。

基于类的视图 🏗️

为了提升代码的组织性和复用性，Django提供了基于类的视图。

最后，你深入学习了Django中基于类的视图及其在项目中的复用方式。基于类的视图允许你将视图作为对象使用，为基于函数的视图提供了另一种选择。

你还探索了开发者如何通过面向对象技术（如继承的概念）来简化视图，从而从基类创建视图。

你也了解了针对不同HTTP请求使用不同的类实例方法，这取代了在同一个函数内编写条件分支（如使用if-else语句）的方式。

这种方式也移除了条件逻辑，从而简化了代码并分离了关注点，使其更易于理解。

总结 🎯

本节课中我们一起学习了视图模块的核心内容。

你现在已经熟悉了视图，并能使用它创建逻辑，通过处理HTTP请求和返回HTTP响应来向最终用户呈现数据。

你理解了不同的参数类型以及它们如何与HTTP方法关联。

你可以使用正则表达式创建不同的URL模式，并将URL映射到视图。

在整个开发过程中，你已准备好处理HTTP视图逻辑和视图层面的错误。

最后，你也可以在Django中使用基于类的视图，并在整个项目中复用它们。

做得好！

23：模型与CRUD操作

在本节课中，我们将要学习Django框架中模型（Model）的概念，以及如何使用模型类和方法来执行数据库的创建、读取、更新和删除（CRUD）操作。模型是MVT（Model-View-Template）架构模式中的核心组成部分，它充当了数据的单一权威来源。

模型的重要性

如果你正在使用Web框架构建动态应用程序，那么使用数据库进行数据存储是必不可少的。回想一下，表示层是用户与之交互的层，从表示层提交的任何数据都需要被持久化保存，以便后续检索和使用。

例如，如果网站需要用户登录，它就需要跟踪用户是谁以及他们有权查看、编辑和创建哪些数据。解决方案就是使用模型。模型是Django中使用的数据库表的对象等价物，是关于你数据的单一权威信息来源。在本视频中，你将进一步探索MVT架构模式中的模型部分，并学习Django如何使用模型类和方法来执行CRUD操作。

与数据库交互的两种方式

如果你是应用程序后端的开发人员，可以通过以下两种方式之一与数据库交互。

第一种方式是直接在数据库中创建所需的表，然后在你的应用程序中，你需要编写用标准查询语言（SQL）编写的自定义查询来存储和检索数据。

第二种方式是使用框架。你已经了解到，框架旨在通过为开发人员提供一个快速开发的平台来帮助他们，而开发人员可以加速开发的一种方式就是使用模型与数据库交互。

什么是模型？

模型是关于你数据的单一权威信息来源，它包含了你所存储数据的基本字段和行为。通常，每个模型都映射到单个数据库表。模型是Django框架不可或缺的一部分。

现在让我们更详细地探讨一下这个结构。每个模型都是一个继承自 django.db.models.Model 的Python类。模型的每个属性都代表一个数据库字段。

这意味着，你不必为添加和检索数据库记录编写自定义查询，而是可以使用模型来完成。Django为你提供了一个自动生成的数据库访问API，让你可以用Python代码访问数据库。本质上，你可以将模型视为一个Python对象，模型帮助开发人员创建、读取、更新和删除对象，这些操作通常被称为CRUD操作。

从SQL到Django模型

在深入了解这些CRUD操作之前，让我们通过一个创建名为 user 的表的场景来探索，先从SQL语法开始，然后使用Django模型。

你可能还记得，使用SQL在数据库中创建表，你需要使用 CREATE TABLE 语法编写查询。当代码运行时，将创建一个名为 user 的表，包含三个列：id、first_name 和 last_name。

CREATE TABLE user (
    id INT PRIMARY KEY AUTO_INCREMENT,
    first_name VARCHAR(30),
    last_name VARCHAR(30)
);

要在Django中使用模型实现同样的功能，你需要定义一个继承自 django.db.models.Model 的类。

from django.db import models

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

你可能会注意到，类中没有指定ID或主键。这是因为Django会自动添加它。但如有需要，你也可以覆盖它。此时，重要的是要知道，仅仅在Python中定义一个模型类是无法创建数据库表的。要完成这个过程，你需要使用一种叫做“迁移”（migrations）的东西，稍后你将了解更多关于它们如何工作的知识。

使用模型执行CRUD操作

好了，现在你了解了Django中模型的概念，以及它们可以用来替代SQL操作来访问和管理数据。接下来，让我们探索如何使用模型及其关联方法来执行CRUD操作。Django自动提供了所有这些开箱即用的方法，让我们从创建（Create）开始。

创建记录

你可能还记得，在SQL中创建记录需要使用 INSERT 语句。例如，在 user 表中创建一个新用户。

INSERT INTO user (first_name, last_name) VALUES ('John', 'Doe');

在Django中，创建记录需要你从 User 类创建一个新对象，然后使用 save() 函数将其持久化。

new_user = User(first_name='John', last_name='Doe')
new_user.save()

读取记录

在SQL中，要检索信息，你需要使用 SELECT 语句编写SQL查询。例如，从 user 表中检索ID等于1的用户。

SELECT * FROM user WHERE id = 1;

在Django中，你可以使用绑定到 User.objects 的 get() 方法。

user = User.objects.get(id=1)

更新记录

假设你有一个用户表，其中有一个名为John Jones、ID为1的用户，你想将该用户的姓氏更新为Smith。

在SQL中，你使用 UPDATE 语句来更新数据库中的现有记录。

UPDATE user SET last_name = 'Smith' WHERE id = 1;

要在Django中实现相同的结果，你可以使用 get() 和 save() 方法。

user = User.objects.get(id=1)
user.last_name = 'Smith'
user.save()

这段代码的工作原理是检查是否存在ID为1的用户，然后将该用户的姓氏更新为Smith。

删除记录

在SQL中，需要使用 DELETE 语句来删除数据库中的记录。例如，你可以根据ID等于1这样的值来删除用户。

DELETE FROM user WHERE id = 1;

要在Django中实现相同的结果，你可以使用 delete() 方法。

user = User.objects.get(id=1)
user.delete()

需要注意的是，这些只是Django在处理模型时提供的众多方法中的一部分。作为一名有抱负的开发人员，熟悉本视频中提到的这些方法是个好主意。

总结

本节课中我们一起学习了MVT架构模式中的模型部分，以及Django在处理数据库表时如何使用类和方法来执行CRUD操作。模型作为数据的Python对象表示，极大地简化了数据库交互，使开发人员能够更高效地进行后端开发。

24：创建模型 🏗️

在本节课中，我们将学习如何在Django项目中创建数据模型。模型是Django应用的核心，它定义了数据的结构和行为，并直接映射到数据库中的表。

概述

上一节我们介绍了Django模型的基本概念。本节中，我们将通过一个具体的例子，一步步学习如何在models.py文件中创建模型，如何通过Django Shell与模型交互，以及如何对数据进行基本的增删改查操作。

创建模型类

要构建一个模型，需要在models.py文件中编写代码。假设我正在为“小柠檬餐厅”构建一个菜单系统。

首先，我创建一个名为Menu的类，并让它继承自models.Model。

from django.db import models

class Menu(models.Model):

定义模型字段

在类内部，我将创建三个变量作为模型的属性。每个属性都需要指定一个字段类型。

以下是需要定义的字段：

name: 菜品名称。
cuisine: 菜系。
price: 价格。

我为name变量分配一个models.CharField字段，它用于存储中小型字符串。我可以传入max_length参数并设置一个值，例如100。

    name = models.CharField(max_length=100)

对cuisine变量重复相同的过程。

对于price，我使用models.IntegerField字段来存储整数值。注意，这里我不需要传递任何参数。

    cuisine = models.CharField(max_length=100)
    price = models.IntegerField()

至此，模型所需的代码就编写完成了。

注册应用与数据迁移

现在让我尝试访问这个模型。在终端中，我输入命令python manage.py shell并按回车。

我进入了Django的命令行工具。需要知道的是，我不能直接在shell中访问Menu类。首先，我必须从menu_app文件夹内的models.py文件中导入它。

我使用Python的导入命令：from menu_app.models import Menu，然后按回车。注意，我收到了一个错误。

这是因为我没有在settings.py文件的INSTALLED_APPS列表中添加这个应用。所以，我现在打开那个文件，将应用添加到已安装应用列表中。

INSTALLED_APPS = [
    ...
    'menu_app',
]

添加应用后，我需要执行一个叫做“迁移”的操作。暂时不用过于担心这一步，你将在后续课程中详细了解迁移。现在只需知道，这是在Django中操作模型必须运行的命令。

我运行命令：python manage.py makemigrations。注意，它为Menu模型创建了一个迁移文件。如果你查看这个Python文件，可以看到Django内部已经使用内置的SQLite数据库创建了menu表的列结构。

为了完成这一步，我运行另一个迁移命令：python manage.py migrate。

使用Django Shell操作数据

现在，我准备回到shell中操作我创建的Menu模型。让我先清空终端，再次运行python manage.py shell。

进入shell后，我再次导入Menu类。这次没有出现错误。

我现在可以运行命令Menu.objects.all()，它会返回数据库中的所有条目。由于我还没有任何数据，所以返回一个空的查询集。

我将直接使用命令向数据库中添加一个条目：m = Menu.objects.create(name='Pasta', cuisine='Italian', price=10)。注意，我将这个条目赋值给了一个对象m，这样我就可以对这个对象进行操作，例如更新或保存。我按回车，然后保存这个对象。

现在，如果我再次运行命令来返回数据库中的所有条目，会注意到有一个条目在数据库中。

让我快速添加另一个条目，然后再次查看数据库条目。注意，现在有两个对象，但显示的信息不够直观，只显示了菜单对象一和二的名称。

自定义模型显示

Django提供了一种使用“自定义方法”来改变显示方式。例如，我可以使用一个内置的自定义方法__str__来定制字符串表示。

我在Menu类中添加以下方法：

    def __str__(self):
        return self.name + ': ' + self.cuisine

__str__是一个“魔法方法”，用于返回对象的字符串表示。保存文件后，我必须退出shell并重新进入。

再次进入shell后，我可以像在Python文件中一样编写代码。我再次导入Menu类，并运行显示所有条目的命令。注意，现在细节按照我定义的__str__自定义函数打印出来了。

类似地，我可以创建自己的自定义函数以供使用。

更新数据条目

既然我已经演示了如何创建数据库表和添加条目，现在让我演示如何更新条目。

假设我想访问一个条目并更新它。我可以使用get方法并传入主键值2，它指向“Taco”这个条目。然后，我可以将其赋值给我创建的一个名为p的对象。

p = Menu.objects.get(pk=2)

现在，我可以像在常规Python代码中一样访问这个对象内的属性。我输入p.cuisine = 'Mexican'来更新条目。我保存这个更改。

这次当我显示所有条目时，会注意到数值已经更新。

总结

本节课中，我们一起学习了在models.py文件中创建Django模型的全过程。我们定义了模型类及其字段，通过迁移命令将模型同步到数据库，并使用Django Shell进行了数据的创建、查询和更新操作。我们还了解了如何通过__str__方法自定义模型对象的显示方式。虽然也可以通过Django管理后台来查看和更新数据库，但理解代码在内部如何工作同样重要。本视频只是为你展示了如何使用模型的一个例子，你将在后续课程中学习更多关于迁移、管理界面以及使用Django和Python代码可以添加的其他功能。

25：24_迁移 🚀

在本节课中，我们将要学习Django中的迁移。迁移是Django用来记录模型变更，并将这些变更应用到数据库结构（即模式）的一种机制。理解迁移对于管理应用的数据模型变化至关重要。

什么是迁移？🛠️

在Web应用开发中，应用需求会不断变化，开发者的工作就是实现这些变化。一个常见的任务是修改应用的数据模型。在Django中，你可以使用迁移来完成这项工作。

迁移是Django记录对模型所做的更改，并将这些更改实施到数据库模式中的方式。

Django模型与数据库的关系 🔗

Django设计用于与关系型数据库管理系统（如PostgreSQL、MySQL或SQLite）协同工作。在关系型数据库中，数据被组织在表中。

现在你已经知道，可以使用模型来表示存储在数据库中的数据表。使用模型时，Django提供了许多方法，允许你直接从代码中添加、更新和删除数据，而无需编写SQL。这得益于一种称为对象关系映射的技术。

ORM将关系型数据库映射到以Django模型形式表示的对象。模型定义了数据库字段，这些字段对应其关联数据库表中的列。

例如，如果你有一个名为User的模型，它代表一个名为user的表。模型的每个属性在数据库中都有一个列表示。

在Python代码中，如果User类有一个first_name属性，那么表中就会有一个first_name列。

为什么需要迁移？🤔

在应用程序的生命周期中，通常需要对数据库的结构或模式进行更改。例如，初始模型可能需要用额外的属性进行扩展。这意味着从数据库的角度来看，需要添加一个新属性，也就是添加一个新列。

或者，假设你需要执行不同的操作，比如更改列名，甚至删除一个模型。为了使这些操作生效，Django使用了数据库迁移。

迁移与Django模型紧密相连，并以迁移文件的形式存储在每个应用内部的migrations文件夹中。

迁移如何工作？⚙️

让我们通过一个例子来探索迁移的工作原理。假设你想在user表中添加一个名为city的新列。

如果没有像Django提供的ORM，开发者必须登录数据库并运行一条SQL ALTER语句。你可以使用ALTER语句来修改特定表，添加所需类型的列。当语句运行时，user表会更新，增加一个名为city的列。

在Django中，user表是使用模型创建的。模型是数据库中user表的基于类的表示。因此，你不需要编写SQL查询，只需将新属性添加到模型中，然后运行迁移脚本即可实施更改。一旦迁移脚本运行，更改就会被应用。

运行迁移脚本的流程 📝

Django提供了一系列CLI命令，允许你应用迁移。首先，你必须创建一个迁移脚本，然后应用这些迁移。

迁移脚本是一组关于针对数据库创建什么模型的指令。你对模型进行更改，运行迁移文件，Django会处理剩下的事情。你不需要编写任何SQL，因为应用程序会处理一切。

使用迁移而非SQL的优势 🌟

你可能会想，既然像前面的例子那样直接运行SQL查询来更新表看起来很简单，为什么还需要迁移呢？迁移不仅仅是执行SQL命令。它们有助于解决同步问题、进行版本控制和数据库维护。最好将迁移视为数据库模式的版本控制系统。

以下是迁移的一些主要优势：

解决同步问题：使用迁移，可以减少模型定义与数据库内容之间出现同步问题的可能性。在团队协作中，每个开发者通常都有自己的本地数据库副本，以便进行编码和测试。迁移脚本保存在代码仓库中。当团队中的开发者进行更改时，他们会运行迁移脚本，将自己的本地数据库副本更新到最新版本。
版本控制：所有更改都保存在版本控制中，这提供了整个应用程序变更的完整历史记录。开发者还可以利用它来确定添加了哪些更改以及由谁添加。在应用开发中，你能追踪到的应用内变更越多，遇到的问题就越少。替代方案是直接在数据库中运行脚本，这通常问题更多，因为它处于版本控制之外。
易于维护：除了有助于解决同步问题和版本控制外，从代码库维护所有数据库变更也使开发团队的工作更加轻松。他们不必担心直接针对数据库创建SQL查询，也不必担心将这些文件存储在哪里以便其他开发者可以运行它们。

总结 📚

本节课中，我们一起学习了Django中的迁移，以及开发者如何使用它们来对代表数据库模式的模型进行更改。迁移是Django ORM的核心功能，它通过代码来管理数据库模式变更，极大地简化了开发流程，并提供了版本控制和团队协作的优势。

26：使用迁移 🚀

在本节课中，我们将学习如何在Django项目中使用迁移。迁移是Django管理数据库模式变更的核心工具，它允许开发者像管理代码版本一样管理数据库结构的变化。我们将重点掌握两个核心命令：makemigrations 和 migrate，并了解如何查看生成的SQL语句以及回滚迁移。

项目准备

首先，我已经在VS Code中创建了一个Django项目，其中包含一个名为myapp的应用。在models.py文件中，我定义了一个名为MenuItem的模型类。这个类在SQL中等同于一张数据表，它包含三个属性：name、course和year，每个属性都对应一个特定的字段类型。

在开始应用迁移之前，必须确保项目设置已正确配置。具体来说，需要将myapp添加到项目文件夹中settings.py文件内的INSTALLED_APPS列表中。检查确认后，准备工作就完成了。

生成与应用迁移

现在回到models.py文件。应用迁移的第一步是生成迁移文件，这通过运行以下命令完成：

python manage.py makemigrations

执行后，Django会显示一条消息，表明它正在为myapp创建迁移，并会生成一个名为0001_initial.py的迁移文件。这个文件记录了模型MenuItem的初始结构。

生成了迁移文件后，下一步是将其应用到数据库。运行以下命令：

python manage.py migrate

执行此命令后，Django会执行迁移文件中定义的所有SQL操作，从而在数据库中创建相应的表。

理解迁移命令

为了确保理解清晰，我们来区分这两个命令的作用。

makemigrations 命令是Django准备模型变更的方式。它分析模型的当前状态与上一次迁移状态的差异，并生成一个包含这些变更的Python脚本（即迁移文件）。你可以将其理解为生成SQL命令的阶段。

migrate 命令则是执行这些SQL命令的阶段。它读取迁移文件，并将其中的操作（如创建表、修改字段等）应用到实际的数据库中。

例如，执行makemigrations后，可能会在项目根目录生成一个SQLite数据库文件（如db.sqlite3），而migrate命令则负责在这个数据库文件中创建具体的表结构。

运行migrate命令后，会在应用目录下创建一个名为migrations的文件夹，里面保存了所有迁移记录文件。打开第一个迁移文件0001_initial.py，可以看到其中定义了表名、列名以及一个自动生成的主键字段id。

修改模型与生成新迁移

现在我们已经知道如何使用makemigrations和migrate来执行迁移。但如果我想修改模型呢？例如，假设我想将MenuItem模型中的course属性更名为category。

首先，在models.py文件中进行修改并保存。然后，必须再次运行makemigrations命令来为这次变更生成新的迁移文件。

python manage.py makemigrations

Django会检测到字段名的变化，并提示确认：“Was menu_item.course renamed to menu_item.category? (y/N)”。输入y并回车确认。

此时，migrations文件夹中会生成第二个迁移文件（例如0002_rename_course_menu_item_category.py）。打开这个文件，可以看到其中包含了重命名字段的操作代码。

让我们再做一次修改，将name属性改为item_name。保存文件后，再次运行makemigrations命令并确认变更。Django会清晰地描述所做的更改，并生成第三个迁移文件。

查看与回滚迁移

为了查看所有已执行和待执行的迁移，可以使用以下命令：

python manage.py showmigrations

在终端输出中，应用myapp下方会列出所有迁移文件。[X]标记表示该迁移已被应用（即已执行migrate）。由于我们尚未对最新的两次修改执行migrate，因此最后两个迁移文件前没有[X]标记。运行python manage.py migrate后，再次查看，所有迁移前都会显示[X]。

有时，我们可能需要回退到之前的某个迁移状态。这可以通过指定迁移文件名来实现。例如，要回退到0001版本，可以运行：

python manage.py migrate myapp 0001 --plan

--plan标志用于预览回退将执行的操作，而不会实际执行。预览信息会显示将把item_name改回name，category改回course。确认无误后，移除--plan标志再次执行命令即可完成回滚。请注意，回滚操作直接影响数据库，但不会自动修改你的models.py文件。

查看生成的SQL

最后一个有用的命令是sqlmigrate，它可以显示特定迁移文件将生成的原始SQL语句。这对于理解Django在底层做了什么非常有帮助。

python manage.py sqlmigrate myapp 0003

执行后，终端会输出对应的SQL语句。例如，对于第三个迁移（重命名name为item_name），你会看到类似ALTER TABLE ... RENAME COLUMN ...的SQL语句。

对于Django开发者而言，迁移是一个极其强大的工具，它使得对数据模型进行版本控制成为可能，让数据库结构的演进变得安全、可追踪。

总结 📝

本节课中，我们一起学习了Django迁移的核心操作。我们掌握了使用makemigrations命令生成迁移文件，以及使用migrate命令将变更应用到数据库。我们还学习了如何通过修改模型来生成新的迁移，如何使用showmigrations查看迁移状态，以及如何利用migrate命令回滚到特定版本。最后，我们使用sqlmigrate命令探查了Django生成的底层SQL语句，加深了对迁移机制的理解。迁移功能是Django ORM的重要组成部分，能有效管理数据库模式的迭代与变更。

27：变更历史记录 📜

在本节课中，我们将要学习Django迁移（Migrations）如何记录和管理数据模型的变更历史。你将了解迁移文件的结构、Django如何追踪这些变更，以及开发者如何利用这一机制进行模型代码库的版本控制。

概述

迁移在帮助构建数据表以及处理Web应用程序与数据库的交互方面扮演着重要角色。到目前为止，你已经知道开发者可以直接使用模型从代码中查询数据，而无需编写SQL命令。这种方法的一个优势是，Django直接为代码库的变更提供了历史记录。本节视频中，你将学习Django迁移的变更历史，以及开发者如何利用它进行模型代码库的版本控制。

迁移历史的作用

项目中创建的每个模型都提供了其如何被创建、何时被添加以及发生的任何变更的完整历史。

Web应用程序的开发需求往往会以较小的增量频繁变化。

例如，向模型添加额外属性或更改属性名称。此外，有时多个用户会使用多个数据库，迁移确保模式变更能在每个数据库上应用和更新。

在Django中，开发者必须直接在模型中创建变更，然后通过使用迁移脚本来应用迁移。

使用迁移的另一个重要优势是避免重复劳动。一旦你创建了某个模型，为其编写SQL查询来创建对应的数据库是重复性的工作。从模型生成的迁移有助于防止重复劳动，这符合Django的核心原则之一：不要重复你自己（Don‘t Repeat Yourself）。

Django如何追踪变更

你可能会好奇Django如何保存数据库中所有变更的历史。这一切都始于文件结构。迁移文件存储在 migrations 文件夹中。

如果你展开 migrations 文件夹，会注意到在迁移运行后，文件系统会自动更新。

你可以使用 showmigrations 命令来探索迁移的详细信息。

在这个例子中，迁移列在给定的模型下，并带有自动递增的前缀，例如 0001。Django会根据给定迁移中执行的操作或时间戳自动生成文件名。

X 符号表示在创建迁移后应用迁移的状态。这是在执行 makemigrations 命令之后，但在执行 migrate 命令之前。应用迁移后，除非检测到变更，否则Django不会再次对同一数据库应用新的迁移。

在幕后，Django会创建一个名为 django_migrations 的新表来引用迁移文件。

深入 `django_migrations` 表

现在让我们更详细地探索这个表。每次迁移后，都会插入一个新行来追踪变更、关联的应用以及迁移的时间戳。

以下是该表的结构：

第一列是ID：根据在表中的位置自动递增。
第二列是应用（app）：迁移所关联的应用。回想一下，在Django中，一个项目内可以有多个应用程序。
第三列是名称（name）：指的是迁移的文件名。
第四列是时间戳（applied）：迁移被应用的时间。

每次运行迁移脚本时，此表都会用最新的变更进行更新。这也意味着在迁移脚本运行之前会先检查此表。这样做是为了让它知道哪些脚本已经运行，哪些需要被应用。

迁移也可以通过将应用名称放在 makemigrations 命令后来应用到特定的应用。

迁移文件的内容

好了，现在你了解了迁移文件的结构，让我们来探索一下迁移文件的内容。

迁移文件本质上是Python代码。在迁移类内部，通常包含两个重要的序列或列表项：dependencies 和 operations。

dependencies：指的是在此迁移之前必须应用的先前迁移。
operations：指的是在给定迁移中执行的操作。

以下是一些常用的操作：

CreateModel：创建一个模型并生成对应的数据表。
DeleteModel：删除一个模型并删除对应的数据表。
AddField：添加一个数据库列和字段定义（用于新增字段）。
AlterField：修改一个数据库列和字段定义（用于更改字段）。
AddIndex：创建一个数据库索引。

例如，像 DeleteModel 这样的操作会生成相应的SQL查询，例如 DELETE FROM customers;。

总结

在本节课中，我们一起学习了Django迁移的变更历史以及Django如何将其应用于迁移。你也探索了开发者如何利用迁移历史来进行模型代码库的版本控制。理解迁移历史对于管理项目的数据模型演进和团队协作至关重要。

28：使用外键的模型 🔗

在本节课中，我们将学习如何在Django模型中使用外键来建立表与表之间的“一对多”关系。我们将通过为“小柠檬”餐厅构建在线菜单的实例，来理解如何创建关联模型、定义外键字段以及执行相关数据库迁移。

现在，你已经熟悉了创建模型和执行迁移的基础知识。接下来，我们将通过使用“一对多”关系连接另一个模型，来加深你对模型的理解。

理解外键与关系

外键是Django ORM中的一个字段，它代表数据库表中的一个列。你使用它来在数据库的表之间创建关系。

想象一下为“小柠檬”餐厅构建在线菜单的场景。解决方案始于创建一个表来为网页添加菜单项。然而，“小柠檬”是一家提供多种菜系的餐厅，将每个菜品正确归类到其所属的类别需要一些技巧。

为了成功实现这一点，首先需要为“类别”创建另一个模型，并将不同的类别分配给每个菜单项。

创建模型与定义外键

现在，让我们探索如何通过在Django中使用外键来实现“一对多”关系。

我们首先从models.py文件开始。这里需要创建两个模型。第一个模型用于菜单类别，第二个模型用于菜单项。之后，你将在菜单类别中添加子类别，并使用外键来引用这些类别。

需要知道的是，添加这两个模型的方式与独立添加模型的方式相同。

以下是创建模型的具体步骤：

创建菜单类别模型：添加一个名为menu_category_name的属性并保存文件。
创建菜单项模型：创建第二个名为Menu的模型。在此模型内，添加menu_item_name、price和category_id属性。
定义字段类型：为菜单项名称分配一个字符字段，为价格分配一个整数字段。
添加外键：在category_id字段处，使用models.ForeignKey命令来定义外键。

外键内部有两个必需的参数：

第一个参数是要连接到的模型类。
第二个参数是on_delete设置，它定义了当被引用的对象被删除时的行为。在本例中，它被定义为on_delete=models.PROTECT。

此外，还可以添加另一个参数，如default=None。

注册模型与执行迁移

下一步包括更新admin.py文件，添加必要的导入。

接下来是注册模型。请注意，其效用将在后续的Django Admin课程中变得更加明显。目前，请确保更新了应用配置中的settings.py文件。

然后，运行服务器，接着执行迁移操作。

你会注意到输出中包含了两个已迁移的模型。最后，运行命令python3 manage.py migrate。

验证数据库关系

下一步是检查数据库。打开db.sqlite3文件，右键单击并选择“打开数据库”。向下滚动到SQLite资源管理器，选择myapp_menu表。

对于此示例，我们假设数据库中已添加了一些条目。现在，再次打开数据库，在myapp_menucategory表下，ID列出了1、2和3，分别对应意大利菜、希腊菜和土耳其菜。

接着访问myapp_menu表。你会注意到有一个名为category_id_id的第四字段。该字段的ID号与myapp_menucategory表中各自的类别ID相匹配。

例如，希腊沙拉的ID列为2，而在myapp_menucategory表中，类别名称“希腊”的ID也是2。菜单项的ID被引用，并与菜单类别中列出的ID相对应。

优化关系显示

为了让这种关系更直观，我们可以在外键字段中添加另一个属性：related_name='category_name'。

这意味着myapp_menu表现在将列出类别名称，而不是category_id_id。这在再次运行迁移时会很明显。菜单上的类别字段被更改了。

请注意，当选择了on_delete=models.PROTECT时，即使类别表中的任何类别被删除，也不会移除与之关联的菜单项。

总结

本节课中，我们一起学习了如何在Django模型中实现“一对多”关系。我们创建了MenuCategory和Menu两个模型，通过在Menu模型中定义models.ForeignKey字段，将菜单项与其类别关联起来。我们还了解了on_delete参数的作用，并通过数据库验证了这种关联关系。最后，我们使用related_name参数优化了关系的可读性。掌握外键的使用是构建复杂数据关系应用的基础。

29：使用ORM

概述

在本节课中，我们将要学习对象关系映射（ORM）的概念，了解Django如何利用ORM自动生成SQL查询来与数据库交互。我们还将探索查询集API，学习开发者如何使用它来保存和检索数据库中的数据。

什么是对象关系映射（ORM）？

构建Web应用程序时，开发者使用数据库存储数据，并编写SQL查询来获取和操作这些数据。随着应用程序规模和复杂度的增长，SQL查询的数量和复杂度也会相应增加。

为了帮助开发者，Django提供了一个称为对象关系映射（ORM）的功能。ORM能自动创建所需的SQL查询。

对象关系映射是一个抽象层，旨在简化编程语言与数据库之间的交互。它允许程序员使用SQL数据库，而无需编写SQL语句。ORM通过观察数据对象的变化，在内部创建一个结构化映射，为给定的关系数据库生成SQL代码。

查询集（QuerySet）简介

在之前的课程中，你可能已经注意到，为给定模型添加的每一行条目都会创建一个对象。你可能还记得输出结果带有“QuerySet”前缀。

查询集是Django中用于给定模型的此类对象的集合。Django使用查询集从数据库中检索和操作这些对象。

例如，假设你有一个名为Customer的模型。你可以通过运行命令Customer.objects.all()来访问此模型的内容。此命令将输出返回为一个查询集。该列表将包含与数据库中行条目对应的不同对象的条目。

查询集API

对于可以构建的每一个SQL查询，都有一个对应的命令。这些命令是查询集API的一部分。

例如，如果你想在SQL中使用WHERE或LIMIT子句连接多个参数，你可以使用filter函数并将条件作为参数传递给它。

考虑到SQL中可以构建的各种复杂查询，Django提供了多个函数来支持这些操作。根据需要在查询集上运行的逻辑，它们可以分为以下几类：

以下是查询集API方法的分类：

返回新查询集的方法
返回新查询集的运算符
不返回查询集的方法

实践：使用查询集API

现在，让我们打开VS Code，通过一个示例来探索如何使用这些方法与数据库交互。

假设Little Lemon餐厅的管理人员希望跟踪来访的顾客。在Models.py文件中，有一个名为Customer的模型，它包含诸如姓名、预订日期和顾客要求的座位数等属性。该模型已经迁移完成，并且数据库中已包含一些条目。

要查看数据库的内容，请点击SQL Explorer并选择customer表。请注意，数据已显示出来。

数据库中有条目后，在终端中输入python3 manage.py shell打开shell。你可能记得，进入shell后，首先需要从Models.py文件导入Customer类。因此，输入from myapp.models import Customer。

探索不返回查询集的方法

让我们探索一个不运行查询字符串的方法示例。使用Customer.objects.get方法。在括号内，输入一个ID值，例如4。请注意，返回了与ID4对应的顾客姓名。此方法类似于你在SQL中使用的SELECT语句。

探索返回新查询集的方法

接下来，让我们使用filter函数探索返回新查询集的方法。假设你想查找星期六的预订。使用Customer.objects.filter方法，并传递reservation_day等于Saturday的条件。请确保使用双引号，因为你正在处理字符串值。按回车键，注意返回了James和Jacqueline的查询集。filter方法类似于SQL中的WHERE子句。

假设你将日期改为Friday，并添加另一个具有不同条件的filter方法，将条件设置为seats等于4，然后按回车键。注意只返回了一个查询集，因为这是唯一满足两个条件的查询集。使用的AND运算符类似于SQL中使用的AND运算符。此运算符是返回新查询集的查询集API的一部分。

总结

在本节课中，我们一起学习了对象关系映射（ORM）的概念，以及Django如何利用它来创建针对数据库的SQL查询。我们还探索了查询集API，了解了开发者如何使用它来保存和检索数据库中的数据。查询集API是一个广泛的主题，如果你想了解更多，本课末尾提供了一个额外阅读材料的链接。

30：29_表格 📝

在本节课中，我们将要学习Django框架中表单（Forms）的核心概念。表单是Web应用程序收集用户数据的主要方式，例如登录信息、注册详情或购物订单。我们将了解Django如何通过Form类简化表单的创建、渲染和处理，以及如何利用模型（Models）自动生成表单，从而减少潜在的错误。

表单在Web应用中的作用 🌐

绝大多数Web应用程序都需要从最终用户那里收集数据。

这可以是用于登录和身份验证的用户详细信息、新应用程序的注册信息，或是线上购物的订单详情。

回忆一下，Web应用程序使用HTML的<form>标签来构建表单，以收集用户的输入数据。当表单提交时，任何表单元素（如输入框或复选框）都会被发送到服务器进行处理。

基础HTML表单示例 📄

在Django中，最常见的表单提交方式是POST请求，它会将数据放在请求体（POST body）中发送。服务器端代码处理传入的请求并在后端处理数据。

例如，假设你使用HTML创建了一个用于提交姓名的基本表单。

以下是该表单的HTML代码示例：

<form action="/your-name/" method="post">
    <label for="your_name">Your name: </label>
    <input id="your_name" type="text" name="your_name" maxlength="100">
    <input type="submit" value="Submit">
</form>

<label>标签用于显示描述输入内容的文本。
类型为text的<input>元素接受最终用户的输入。在此示例中，它用于存储姓名。
第二个类型为submit的<input>是一个按钮，显示文本“Submit”。当按钮被按下时，将触发action中定义的行为，向/your-name/路径发起POST请求，并由对应的视图（view）处理。
所有这些都定义在表单的action和method属性中。

Django表单类的引入 🛠️

虽然上述过程有效，但在处理大型表单时，代码会变得冗长且复杂。例如，表单可能有许多不同的数据收集方式和条件流程。此外，以这种方式设计表单容易出错，因为每个表单元素的name或id属性都需要与后端代码的期望值匹配。

为了帮助开发者进行表单的创建和处理，Django引入了Form类。在这个类中，你可以定义所有预期会通过请求传递的属性。这意味着你可以使用一个表单类来表示预期的属性，并在HTML中渲染表单元素。

创建Django表单类 🧱

上一节我们介绍了HTML表单的基础，本节中我们来看看如何使用Django的Form类来重构它。

例如，上面的“提交姓名”表单可以通过创建一个类来表示。

让我们逐行分析这段代码：

from django import forms

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/meta-be-dev/img/d0c830a24aedc476197bebac5b62929d_10.png)

class NameForm(forms.Form):
    your_name = forms.CharField(max_length=100)

首先，创建一个名为NameForm的类，它接受一个参数forms.Form。这本质上定义了表单本身的结构。
接着，创建一个名为your_name的变量，它被赋值为forms.CharField，以代表HTML中的文本输入框元素。注意，你还可以通过设置max_length=100来进行一些验证。

最后，当NameForm类被渲染时，它会生成包含相应HTML表单代码的视图。

在模板中渲染表单 🎨

重要的是要知道，Form类本身不包含外层的<form>标签。因此，你需要在模板中添加<form>标签，然后使用模板语法将表单元素附加到里面。

以下是在模板中渲染NameForm的示例：

<form action="/your-name/" method="post">
    {% csrf_token %}
    {{ form }}
    <input type="submit" value="Submit">
</form>

不必过于担心模板（templating）的概念，你很快就会学到它。

对于开发者而言，以这种方式创建表单的优势在于，管理表单的任何变更都变得更加容易。无需担心输入框的name属性是否与服务器端代码匹配，这一切都由Form类完全处理。

面向对象编程的优势 🧠

此外，由于你是在使用类，因此可以获得面向对象编程的所有好处。

例如，你可以将复杂的表单拆分为子类，使其更易于管理。遗憾的是，深入学习这些功能超出了本视频的范围，但了解它们的存在是很好的。

如果你想了解更多，本课末尾提供了额外的阅读材料。

模型表单（Model Forms） 🗃️

最后，让我们探讨一下在Django中结合模型（Models）使用表单。使用POST方法将数据发送到后端后，你需要以某种方式持久化这些数据。

例如，假设你正在为新用户设置站点访问权限。你需要持久化他们的详细信息，如电子邮件和密码，以及一些常规用户信息，如姓名或地址。

幸运的是，开发者可以通过使用模型来解决这个问题。应用程序中的模型将代表存储此信息的数据库表，因此模型本身可以直接转换为Django表单。这很有意义，因为你希望表单映射到你需要持久化的内容。这个功能对于排除任何潜在的问题或错误非常出色。

模型表单的代码通常放在forms.py文件中，并实现模型的结构。你将在本课程后面更详细地学习这两种表单类型。

总结 📚

本节课中我们一起学习了Django中的表单。你了解了Django如何通过Form类自动从类生成HTML元素，从而简化表单开发。你也学习了开发者如何利用模型自动生成表单，以移除潜在的处理错误。掌握这些概念是构建健壮、可维护的Django Web应用程序的关键一步。

31：使用Django表单字段和数据类型 📝

在本节课中，我们将要学习Django中表单字段的使用方法以及如何利用它们来存储正确的数据类型。表单是Web应用从用户处收集数据的关键工具，理解不同的字段类型及其参数对于构建有效且用户友好的表单至关重要。

概述

Web应用通常通过HTML表单从用户那里收集数据，并将这些数据发送到服务器进行处理。在Django中，我们使用Form类来创建和处理表单。表单字段是构建表单的基本单元，它们不仅定义了表单的视觉元素，还决定了后端接收和处理的数据类型。

上一节我们介绍了Django表单的基本概念，本节中我们来看看构成表单的具体字段类型以及如何定制它们。

表单字段类型

以下是Django中一些常用的表单字段类型及其对应的HTML元素：

CharField：接受任何字符串输入。它等同于HTML中的<input type="text">元素。
EmailField：接受符合电子邮件格式的输入。它等同于HTML中的<input type="email">元素。
IntegerField：仅接受整数输入。它等同于HTML中的<input type="number">元素。
ChoiceField：提供多个选项供选择。它等同于HTML中的<select>和<option>元素。
FileField：允许用户选择文件进行上传。它等同于HTML中的<input type="file">元素。

核心字段参数

除了字段类型，我们还可以为字段传递不同的参数来进行定制。虽然具体参数因字段而异，但有几个核心参数是大多数字段都支持的：

required：默认情况下，每个字段都假定为必填项。你可以通过设置required=False来将其改为可选。
label：此参数用于为字段指定一个自定义的标签文本。
initial：可以为特定字段设置初始值。
help_text：用于为字段指定描述性文本，帮助用户理解如何填写。

记住，你构建的每个表单都有不同的数据需求。例如，一个客户反馈表单和一个关于顾客最爱菜单项的调查表单所需的字段就完全不同。了解使用哪种字段类型对于构建有效的表单至关重要。

实践：在代码中探索字段

现在，让我们在VS Code中实际操作，探索用于创建表单的不同字段以及可用的自定义选项。

首先，我们创建一个包含CharField的演示表单。

# forms.py
from django import forms

class DemoForm(forms.Form):
    name = forms.CharField()

在浏览器中查看此表单，你会注意到Django根据定义的属性值自动生成了标签“Name”。如果你更改属性名，表单上的标签也会相应更新。

你可以通过传递参数来进一步编辑表单，例如使用widget参数。以下代码将默认的文本输入框替换为文本区域（textarea）。

name = forms.CharField(widget=forms.Textarea)

刷新页面后，表单会更新为一个更大的文本输入区域。如果你希望文本区域小一些，可以在Textarea小部件中传递attrs参数来指定行数。

name = forms.CharField(widget=forms.Textarea(attrs={'rows': 5}))

保存并刷新后，文本区域将缩小，只显示5行的空间。

总结

本节课中我们一起学习了如何在Django中使用表单字段来存储正确的数据类型。我们介绍了多种字段类型（如CharField、EmailField等）以及用于定制字段的核心参数（如label、required）。我们还通过代码示例实践了如何改变字段的小部件（如将输入框改为文本区域或单选按钮）以优化用户体验。

需要强调的是，这些示例仅展示了Django中可用表单字段和参数的一部分。建议你查阅Django官方文档以了解所有可用选项，这将帮助你创建出更强大、更符合需求的表单。

32：创建表单 📝

概述

在本节课中，我们将学习如何在Django中使用Form类来创建表单。你将了解如何定义表单字段、在模板中渲染表单，并初步探索Django表单的一些内置功能，例如验证。通过构建一个简单的员工打卡表单示例，我们将掌握Django表单开发的基础流程。

表单类简介

上一节我们介绍了Django模型的概念。本节中我们来看看如何使用Django的Form类。开发者使用表单类可以自动从Python类生成HTML表单元素，这极大地简化了表单的创建过程。

创建表单类

首先，我们需要在应用目录下创建一个名为forms.py的文件。我们将为“Little Lemon”网站创建一个表单，允许员工记录他们的上班打卡时间。

以下是创建表单类的步骤：

导入模块
```
from django import forms
```
定义表单类
创建一个继承自forms.Form的类。我们将此类命名为InputForm。
定义表单字段
在类内部，我们将定义四个字段属性：
- first_name 和 last_name: 字符字段，最大长度为200。
- shift: 选择字段，让员工在早班、中班和晚班之间选择。
- time_log: 时间字段，用于记录员工的打卡时间。

以下是forms.py文件的完整代码示例：

from django import forms

# 定义班次选择的元组
SHIFTS = (
    ('morning', 'Morning'),
    ('afternoon', 'Afternoon'),
    ('evening', 'Evening'),
)

class InputForm(forms.Form):
    first_name = forms.CharField(max_length=200)
    last_name = forms.CharField(max_length=200)
    shift = forms.ChoiceField(choices=SHIFTS)
    time_log = forms.TimeField()

创建视图以渲染表单

定义了表单类之后，我们需要创建一个视图来在网页上显示它。这与处理模型视图的过程类似。

以下是创建视图的步骤：

在views.py中导入表单
```
from .forms import InputForm
```
创建视图函数
创建一个名为form_view的视图函数。在函数内部，我们实例化表单类，并将其通过上下文传递给模板。

以下是views.py中视图函数的示例代码：

from django.shortcuts import render
from .forms import InputForm

def form_view(request):
    form = InputForm() # 创建表单实例
    context = {
        "form": form # 将表单实例放入上下文
    }
    return render(request, 'home.html', context) # 渲染模板

创建模板

为了让视图能够显示表单，我们需要创建一个HTML模板。

以下是创建模板的步骤：

在应用目录下创建templates文件夹。
在templates文件夹内创建home.html文件。
在home.html中编写HTML代码来渲染表单。

关键点：

使用POST方法提交表单数据。
包含一个类型为submit的输入按钮。
必须添加{% csrf_token %}标签，这是Django的一种安全机制，用于防止跨站请求伪造攻击。
使用{{ form }}变量来渲染我们传递过来的表单。

以下是home.html的初始代码示例：

<!DOCTYPE html>
<html>
<head>
    <title>Employee Time Log</title>
</head>
<body>
    <form method="post">
        {% csrf_token %}
        {{ form }}
        <input type="submit" value="Submit">
    </form>
</body>
</html>

配置URL与运行服务器

在展示表单之前，我们需要完成最后的配置工作。

以下是需要完成的配置：

更新应用和项目目录下的urls.py文件，将新创建的视图映射到一个URL路径。
确保在项目的settings.py文件中已注册当前应用。
在终端中运行开发服务器：
```
python manage.py runserver
```
在浏览器中访问对应的本地主机URL（例如 http://127.0.0.1:8000/form/）。

成功运行后，你将看到一个包含“First Name”、“Last Name”、“Shift”和“Time Log”字段的基础表单。

定制表单渲染

你可能会注意到，默认渲染的表单没有样式，且所有元素挤在一起。Django提供了简单的方法来调整表单的渲染方式。

使用段落标签渲染

在模板中，你可以通过{{ form.as_p }}来告诉Django将每个表单字段渲染在<p>（段落）标签内。这会使字段垂直排列，更具可读性。

修改home.html中的表单渲染部分：

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <input type="submit" value="Submit">
</form>

刷新页面后，表单元素将逐个垂直显示。

修改字段属性

我们可以在forms.py中为每个字段添加参数来改变其行为。

以下是两个常用的参数示例：

required: 控制字段是否为必填项。默认是True。
```
first_name = forms.CharField(max_length=200, required=False)
```
将required设置为False后，提交表单时该字段可以为空。
help_text: 为字段添加帮助文本，显示在输入框旁边。
```
time_log = forms.TimeField(help_text="Enter the exact time.")
```
这会在时间字段旁显示提示文字“Enter the exact time.”。

添加简单样式

你可以在HTML模板中直接为表单添加内联样式，进行快速美化。

例如，为表单添加背景色：

<form method="post" style="background-color: #f0f0f0; padding: 20px;">
    {% csrf_token %}
    {{ form.as_p }}
    <input type="submit" value="Submit">
</form>

表单验证初探

Django表单内置了基础的验证功能。如果你尝试提交一个包含必填字段但未填写的表单，页面会刷新并提示错误信息（尽管在本示例的视图中我们尚未处理提交逻辑，但基础验证依然存在）。这正是使用Django表单类的一大优势——它自动处理了大量繁琐的验证工作。

总结

本节课中我们一起学习了Django表单创建的核心知识。我们掌握了如何使用forms.Form类定义表单结构，如何在视图中实例化并传递表单到模板，以及如何在HTML模板中渲染表单。我们还探索了通过as_p方法定制渲染、使用required和help_text等参数调整字段属性，以及为表单添加简单样式。虽然本节课没有深入讲解如何处理和保存表单数据，但你已经为后续学习表单数据处理打下了坚实的基础。Django的表单功能强大，能帮助开发者高效、安全地构建Web表单。

33：模型表单 📝

在本节课中，我们将要学习如何使用Django的模型表单（Model Form）。模型表单提供了一种高效的方式，将表单中接收到的数据直接保存到数据库中，从而将模型和表单的功能结合在一起。

到目前为止，在课程中你已经学习了如何使用Django的类实现来创建模型和表单。但是，如果你想将它们结合使用，将表单中输入的数据保存到数据库中，该怎么办呢？Django通过模型表单提供了一种非常高效的方法，它可以将接收到的数据作为响应直接保存到数据库。

模型表单简介

上一节我们介绍了独立的模型和表单。本节中我们来看看如何将它们结合。创建模型表单的过程与创建模型和表单类似。就像模型和表单一样，Django提供了另一个名为ModelForm的辅助类，以帮助更轻松地实现。

让我们举个例子。假设你想为“小乐餐厅”创建一个预订表单。

创建模型表单

以下是创建模型表单的基本步骤：

导入模型：首先，导入你想要与表单绑定的模型。
定义表单类：然后，使用Meta类为其添加实现细节。
实例化表单：最后，创建该表单的一个实例。

请注意，与为表单和模型分别创建单独的类不同，你只需要创建一个继承自ModelForm并实现它的类。由于这个实现涉及将表单数据作为响应发送回来，你还需要在视图内部添加一些关于POST方法的实现细节。

实现步骤详解

现在，让我们详细看看如何实现这一点。

之前，你学习了可以使用Django的Form API来生成静态表单。作为提醒，请注意forms.py文件中的代码，以及它如何用于在浏览器中渲染表单。

基于已有的项目，这次我们来修改表单以使用模型表单。

1. 准备模型

首先，为了简化，移除forms.py中表单的字段属性。由于这是一个模型表单，将内容复制并粘贴到models.py文件中。

接下来，你需要重新配置所有细节，使其与模型的配置代码匹配。注意类名如何从LogForm更改为Logger，这是模型的名称。

代码示例：models.py

from django.db import models

class Logger(models.Model):
    name = models.CharField(max_length=100)
    time = models.TimeField()
    # ... 其他字段定义

2. 创建模型表单类

然后，再次转到forms.py，删除现有内容，并根据已有的模型创建模型表单。

首先，使用from .models import Logger导入模型（Logger是我的模型名称）。接着，输入class LogForm，这是模型表单的名称。这次，在括号内传入ModelForm。

接下来，添加class Meta，后跟模型名称Logger，以及另一个名为fields的属性。与其分配单个字段，不如直接输入值‘__all__’，这将导入该特定模型中的所有字段。

代码示例：forms.py

from django.forms import ModelForm
from .models import Logger

class LogForm(ModelForm):
    class Meta:
        model = Logger
        fields = ‘__all__’

保存此文件。

3. 注册模型到管理后台

接下来，你必须确保为此模型注册到管理后台。转到admin.py并更新详细信息。

代码示例：admin.py

from django.contrib import admin
from .models import Logger

admin.site.register(Logger)

4. 更新视图以处理表单数据

接下来，切换到views.py文件。进入视图后，你会注意到已经有一些基本的配置可以帮助渲染表单。

如果你还记得，表单对象（这次是模型表单）被传递到一个上下文字典中，然后该字典被传递到render函数中。

现在，你必须添加一些代码来帮助接收表单数据并将其发送到模型数据库。

因此，让我们添加一个条件语句，例如if request.method == ‘POST’。接着，添加form = LogForm(request.POST)。这段代码的作用是使用请求对象中的内容更新表单对象。

接下来，检查表单是否有效，如果有效，则使用save()方法保存表单。

代码示例：views.py

from django.shortcuts import render
from .forms import LogForm

def form_view(request):
    if request.method == ‘POST’:
        form = LogForm(request.POST)
        if form.is_valid():
            form.save() # 将数据保存到数据库
    else:
        form = LogForm()
    return render(request, ‘your_template.html’, {‘form’: form})

保存此文件。在表单模板方面，你已经拥有了所需的一切。

运行与测试

运行迁移后，启动服务器。再次转到浏览器并刷新页面。输入姓名“Kyle McGreor”和时间“11:11”。

一旦你按下提交按钮，请注意控制台上记录了POST方法。在左侧面板中，你可以转到数据库，右键单击它，然后单击“打开数据”。在SQLite浏览器中，展开后，单击myapp_logger（这是从模型创建的表的名称）。单击它，你会注意到条目已更新到数据库中。

你可以添加任意数量的条目，每次条目都会被添加到数据库中。

总结

本节课中我们一起学习了如何创建和使用Django模型表单。这是一个关于如何使用模型表单创建表单并将表单数据保存到相应数据库表的示例。通过继承ModelForm类并在Meta类中指定关联的模型和字段，我们可以快速构建出与数据库模型紧密集成的表单，并通过视图中的简单逻辑处理数据验证和保存，极大地提高了开发效率。干得不错！

34：Django管理界面 🛠️

在本节课中，我们将学习如何激活和使用Django框架内置的管理员界面。这个界面允许网站管理员轻松管理应用程序的数据，例如用户、权限和数据库条目，而无需编写额外的代码。

开发Web应用时，大量内容通常存储在某个地方，例如数据库中。因此，为应用程序提供一个管理站点是一项常见任务。

此管理站点的目的是允许特定用户管理和操作应用程序的数据。在本视频中，你将学习如何激活Django的管理界面及其核心功能。

你可能还记得，在讨论URL配置时，管理界面的路径配置默认已在URL配置文件中设置。

现在，假设Little Lemon餐厅的业主要求你将所有网站内容存储在数据库中，以便餐厅员工可以更新。例如，经理可以使用管理站点添加或编辑内容，而这些内容会显示在公开网站上。

对于开发者而言，为每个项目构建这样的站点是繁琐的工作。Django通过自动为站点管理员创建一个统一的管理界面来解决这个问题，用于添加、编辑和删除内容，例如用户、权限和数据库条目。

这个过程是自动化的，因为管理界面直接链接到项目中注册的模型。管理界面通常是大型Web应用的一部分，用于帮助管理员执行某些管理任务。

这些任务包括创建和管理用户、控制访问权限以及组建用户群组。Django读取项目中声明的模型，并根据模型的元数据快速构建一个易于使用的界面。

重要的是要记住，管理站点并非供网站访客使用，而是供站点管理员使用。除了界面，Django另一个强大的功能是提供了一个现成的管理界面，名为Django Admin。

正如你已经学到的，你使用这个命令行工具执行管理任务。Django Admin工具在终端内执行。当你在Django中运行诸如startproject之类的命令时，它默认被启用并分配给项目。

由于管理界面依赖于django.contrib.admin应用，你可以在settings.py文件的INSTALLED_APPS部分找到它，以及其他一些应用。

数据库是构建Web应用的内在组成部分。使用Django和Django Admin提供了一个便捷的方式，通过友好的用户界面访问和修改这些数据库。

在访问此界面之前，你首先需要创建一个管理员用户，以提供必要的凭据。现在让我们探索如何操作，并概览Django管理界面。

首先，你必须创建一个用户。为此，运行命令：

python3 manage.py createsuperuser

接下来，在用户名提示符处，你必须创建一个用户名。例如，输入John并按回车。请注意，如果用户已存在，Django将抛出错误，提示用户名已被占用。

现在，我创建一个名为Adrian的用户并按回车。接着，会出现另一个电子邮件地址的提示。让我们输入Adrian@littlelemon.com并按回车。

然后输入密码并按回车。请注意，由于这不是一个强密码，Django会显示警告，提示密码应更安全。你现在可以忽略此警告，输入y（代表“是”）继续。但需要知道，在实际应用中，密码应足够强并满足安全要求。

创建超级用户后，运行命令启动服务器。并在浏览器中打开默认URL。

接下来，转到分配的路径，在URL后添加/admin并按回车。请注意，Django管理页面加载了一个登录表单，提示你输入用户名和密码。输入你之前创建的用户名和密码，然后点击登录按钮。

登录后，你会看到一个基本界面。第一个选项概述了群组和用户。已经有一个名为Reservations的示例模型，其下方是最近操作列表，目前为空。

你可以选择添加和更改这些配置。例如，如果你转到Reservations模型并点击“更改”，会看到列出了几个条目。你可以选择使用表单直接更新预订数据或添加新条目。你也可以通过点击名称旁边的复选框来删除选定的预订。

如果返回主页，还有其他选项可以添加或修改已存在的用户。例如，如果你点击特定用户，可以更改用户名和密码、个人信息，并将用户分配到某些群组。此外，你可以指定用户拥有的特定权限，这些权限将列在下方。

还有其他附加细节，例如用户的上次登录信息和加入日期。你也可以转到页面顶部，查看用户的历史记录及其所做的更改。

这个工具的实用性可能不会立即显现，但随着课程的深入，你将意识到使用Django管理面板可以通过提供一个易于修改项目内部和模型的界面，为开发者节省大量时间。

在本视频中，你学习了如何启动Django的管理界面站点。你还学习了如何使用它来添加用户、群组、模型和分配权限，这些内容你将在后续课程中进一步学习。做得好！

35：添加组和用户 🧑‍💻

概述

在本节课中，我们将学习如何为Little Lemon餐厅的前台创建一个基础的预订系统。我们将探索如何使用Django的管理后台来注册模型、添加用户和组。

创建基础预订系统

上一节我们了解了课程目标，本节中我们来看看如何开始构建系统。

Little Lemon的员工一直手动在表格上记录预订信息，他们希望找到一种更高效的方式。首先，需要打开models.py文件，该文件已包含一个模型类。

该文件包含一个名为Reservation的类，它有五个属性：

name：顾客姓名。
contact：联系方式。
arrival_time：到达时间。
guest_count：客人数量。
notes：附加备注。

接下来，需要打开settings.py文件，确保应用已添加到INSTALLED_APPS列表中。确认无误后，就可以进行数据迁移，准备创建预订系统了。

创建超级用户并运行服务器

在运行服务器之前，需要先创建一个超级用户。使用以下命令创建：

python manage.py createsuperuser

创建过程中，需要输入用户名（例如admin）、邮箱地址（例如admin@littlelemon.com）和密码。请注意，演示中使用了弱密码，但在生产环境中务必使用强密码。Django会提示密码验证，输入Y后超级用户即创建成功。

最后一步是在运行服务器前注册这个超级用户。现在，可以开始在admin.py文件中进行工作了。

在管理后台注册模型

首先，使用import语句导入Reservation模型。在新的一行，输入以下代码来注册模型：

admin.site.register(Reservation)

保存文件并运行服务器。在浏览器中，访问Django的默认URL并加上/admin路径。页面会加载出一个包含用户名和密码字段的登录表单。

输入之前设置的凭证并点击登录按钮。默认的Django管理页面会加载出来，包含“站点管理”和“我的应用”两个部分。

在“站点管理”部分，可以看到“组”和“用户”的链接。在“我的应用”部分，可以看到之前创建的预订表的链接。点击该链接，会发现目前还没有任何预订记录，这意味着表是空的。

添加和管理预订数据

现在开始创建一些预订记录。点击“添加预订”按钮，会显示一个添加预订的表单。

以下是填写表单的步骤：

输入姓名和电话号码。
对于时间输入，可以点击“现在”来获取当前时间，然后修改其格式。
将预订人数设置为4。
最后，添加备注，例如“我们倾向于户外餐桌”。

点击“保存并添加另一个”按钮。成功消息会显示，并且表单会被重置。可以快速添加另一个预订，输入姓名“Charlotte”、电话号码和时间，将预订人数设置为2，并在备注中填写“我们想要靠窗的座位”。

完成数据添加后，点击“保存”按钮。保存后，会看到创建了两个条目，但它们显示为“Reservation object”。这并没有显示太多关于预订的信息，接下来修复这个问题。

自定义模型对象的显示

回到models.py文件，可以使用__str__方法来覆盖对象的默认字符串表示，并定义自己的显示方式。我们希望这个表示是顾客的姓名。

因此，在Reservation类中添加以下方法：

def __str__(self):
    return self.name

这将显示对象name属性中存储的值。保存文件，然后返回浏览器并刷新网页。

现在，预订对象的名称已根据顾客姓名重新命名。如果点击顾客姓名，网页表单会加载，可以在其中编辑详细信息。还有删除对象和查看版本历史的选项。

现在导航回应用主页，可以看到添加新表或更改当前表的选项。

管理用户和组

接下来探索Django管理后台的用户和组功能。点击主页链接，首先探索“用户”。目前只有一个之前添加的用户。

可以通过点击“添加用户”按钮来添加另一个用户。输入用户名“littlelemon_staff”并添加密码。请注意，如果尝试添加弱密码，Django将不允许。因此，需要添加一个稍强的密码。

点击“保存”按钮，用户即被添加。创建后，可以为用户添加个人信息，如名字、姓氏和电子邮件地址。

在权限部分，可以分配诸如“活跃”、“员工状态”和“超级用户状态”等权限。请记住，具有“员工状态”权限的用户可以访问管理页面。也可以将用户添加到组中，但这超出了本视频的范围，后续课程会学习如何操作。

还可以设置一些特定权限，例如，选择该用户只能查看和更改日志条目。在右侧，可以看到已添加的用户权限。最后，“重要日期”部分会显示最后登录和加入日期。

保存后，再次进入用户页面，会看到名为“Jean”的“littlelemon_staff”用户已被添加。可以根据超级用户状态筛选用户，如果选择此选项，则只显示“admin”超级用户。

可以通过选择“组”链接并点击“添加组”按钮来创建组。在添加组页面，可以分配组名，例如“staff”。然后可以为该组成员分配权限并保存。这允许配置哪些Little Lemon员工可以访问管理面板并进行预订。

在数据库中查看结果

最后，可以在VS Code中使用SQLite Explorer预览表。点击应用下的“reservations”表，然后选择“显示表”。会看到这些条目已在表中更新。这意味着在Django管理后台所做的更改会反映在数据库表中。

总结

本节课中，我们一起学习了如何为Little Lemon餐厅的前台创建一个基础的预订系统。我们探索了如何使用admin.py文件来注册模型，以及如何利用Django管理后台来添加用户和组，从而构建起系统的基础管理功能。

36：用户与模型权限 🔐

在本节课中，我们将要学习Django框架中的用户与模型权限系统。权限是Web应用控制用户能执行哪些操作的核心机制，理解它对于构建安全的应用程序至关重要。

用户分类与权限基础

在大多数应用中，用户被分配了不同的角色，这些角色允许他们执行特定的操作。为了启用这些操作，用户需要被授予相关的权限。

设想以下场景：当你访问一家餐厅时，你不被允许进入厨房。然而，如果你是餐厅员工，你则被允许进入厨房。Web应用程序有一个类似的概念，用于控制哪些用户被允许执行哪些操作，这被称为“权限”。

Django框架内置了一个处理权限的系统。这个认证系统集成了身份验证和授权功能，便于使用。为了让用户执行某个特定操作，他们需要被授予相关的权限。

在深入探讨权限之前，需要明确一点：在Django中，用户可以分为三种类型，即超级用户、员工用户和普通用户。与Django的其他组件类似，Django中的用户也是Python对象。特定的用户类型由用户对象内部设置的特殊属性来定义。

以下是关于这三种分类的详细说明：

超级用户：是系统的顶级用户或管理员。这类用户拥有添加、更改或删除其他用户的权限，并且可以对项目中的所有数据执行操作。
员工用户：被允许访问Django的管理员界面。但是，员工用户不会自动获得在Django管理员中创建、读取、更新和删除数据的权限，这些权限必须被明确授予。请注意，超级用户默认就是员工用户。
普通用户：默认情况下，普通用户无权使用管理站点。用户默认被标记为“活跃”状态。如果认证失败或因某些原因被禁止，用户可能被标记为“非活跃”。

创建用户与设置权限

虽然你可以通过管理员界面创建用户，但也可以通过Django Shell来完成。权限机制由Django的django.contrib.auth应用处理。

你可以使用create_user函数来创建一个新的用户对象。创建用户后，你可以授予用户某种状态，例如使其成为员工。要授予员工状态，需将用户的is_staff属性设置为True。

那么，如何创建超级用户呢？你可以在Django Shell中直接使用命令。系统会提示你为这个超级用户分配密码，随后进行认证。之后，前往管理员界面查看用户列表，新用户就会出现在列表中。请记住，超级用户拥有系统中的所有权限，无论是自定义权限还是Django自动创建的权限。

模型权限

在多个地方都可以启用特定的权限设置，例如针对特定的模型或对象。那么，如何在模型中设置权限呢？

当你在Django应用中创建模型时，Django会自动为该模型创建添加、更改、删除和查看的权限。权限的命名遵循“应用_操作_模型”的模式。其中，“应用”是Django应用的名称，“操作”是add、change、delete或view，“模型”是小写的模型名称。

假设在当前项目中创建了一个名为my_app的Django应用，并且其中声明了一个名为MyModel的模型。现在，你可以应用你新学到的知识了。这个模型的权限会是什么呢？

以下是该模型的权限列表：

my_app.add_mymodel
my_app.change_mymodel
my_app.delete_mymodel
my_app.view_mymodel

在代码中检查权限

在Python代码中，可以检查某个用户是否启用了特定类型的权限。为此，你可以使用has_perm函数，该函数返回True或False。

例如，如果请求用户没有适当的权限，你可以抛出一个PermissionDenied错误，而不是返回正常的HTTP响应。

if not request.user.has_perm('my_app.view_mymodel'):
    from django.core.exceptions import PermissionDenied
    raise PermissionDenied

使用用户组管理权限

为每个用户单独分配权限是一项繁琐的任务，尤其是在用户数量庞大的情况下。幸运的是，Django提供了一个解决方案：你可以通过Django的“组”来管理用户集合的权限，这被证明非常有用。

那么，什么是组呢？在Django中，组是一个权限列表，可以分配给一个或多个用户。一个用户可以属于任意数量的组。回到餐厅的例子，你可能有一个“厨房员工”组和一个“服务员”组。

当你创建或修改用户时，只需选择所需的组，该组中列出的所有权限将自动分配给该用户。需要注意的是，即使用户属于某个组，你仍然可以手动为用户添加额外的权限。

在视图中强制执行权限

上一节我们介绍了如何通过组来批量管理权限，本节中我们来看看如何在视图函数中直接强制执行权限检查。为了在执行视图函数时强制执行权限，你可以使用@permission_required装饰器。

from django.contrib.auth.decorators import permission_required

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/meta-be-dev/img/4517493be5bde69089a93ab4c1c8d42c_5.png)

@permission_required('my_app.change_mymodel')
def my_view(request):
    # 只有拥有 'my_app.change_mymodel' 权限的用户才能执行此视图
    ...

总结

本节课中我们一起学习了Django中的用户与模型权限。你可以在管理员面板或Shell界面中创建用户时为其分配权限。使用“组”是为多个用户启用相似权限集合的一种便捷方式。最后，通过在视图函数上使用@permission_required装饰器，可以有效地在代码层面控制访问权限，从而构建更安全的Web应用。

37：用户与权限管理 🛡️

在本节课中，我们将学习Django框架中用户与权限管理的核心概念。我们将探索如何创建用户、分配权限，以及如何通过Django管理界面和Django Shell两种方式来高效地管理这些功能。

概述

Django内置了一个高效的权限管理系统。它允许你为特定用户或用户组添加或移除权限。管理这些权限主要有两种方式：通过用户友好的Django Admin Web界面，或者通过Django Shell进行编程式操作。

权限系统基础 🔑

上一节我们介绍了Django权限管理的两种方式，本节中我们来看看权限系统本身是如何工作的。

Django的权限系统在django.contrib.auth应用被添加到INSTALLED_APPS设置中后自动启用。它会为每个已安装应用中的Django模型创建四个默认权限。

以下是这四个默认权限：

添加（Add）：创建新对象实例的权限。
更改（Change）：修改现有对象实例的权限。
删除（Delete）：删除对象实例的权限。
查看（View）：查看对象实例的权限。

权限不仅可以按对象类型（模型）设置，还可以针对特定的对象实例进行自定义。通过使用ModelAdmin类提供的方法，可以为同一类型的不同对象实例定制权限。

与之前学习的Admin权限类似，模型特定的权限也可以通过ModelAdmin类进行管理。ModelAdmin类的方法包括has_view_permission、has_add_permission、has_change_permission和has_delete_permission，用于自定义权限逻辑。

通过Django Shell管理权限 💻

了解了权限的基本概念后，接下来我们学习如何在Django Shell中实际操作。

首先，你需要打开一个已导入Django设置的交互式Shell，这允许你直接在项目根目录下工作。

以下是创建用户并查找用户的步骤：

从django.contrib.auth.models导入User模块。
使用User.objects.create_user()方法创建一个新用户，按顺序传入用户名、邮箱和密码参数。
使用User.objects.get()方法，通过用户名定位到刚创建的用户。

创建用户后，下一步就是分配权限。用户对象有两个与权限相关的主要字段：groups和user_permissions。user_permissions字段用于关联一个或多个权限对象。

可以通过调用用户对象上的set()、add()、remove()和clear()方法来授予或移除权限。

让我们探索一个使用add()方法为用户Mario授予权限的例子。在这个场景中，我们将提供一个或多个权限对象。

# 示例：为用户添加修改‘myapp’应用中‘Menu’模型的权限
user.user_permissions.add(permission_object)

需要注意的是，一旦你将django.contrib.auth添加到已安装应用列表，就必须运行migrate命令来实施变更。

当你运行python manage.py migrate时，每个Django模型都会被自动分配上述的默认权限。例如，假设你有一个名为myapp的Django应用，其中包含一个名为MyModel的模型，那么验证添加、更改、删除和查看权限的布尔表达式都将返回True。

除了默认权限，还可以在模型的Meta类中声明自定义权限。

通过Django Admin界面管理权限 🌐

到目前为止，我们已经介绍了如何在Django Shell中修改权限。然而在实践中，使用浏览器中的Django Admin界面来处理权限要容易得多。

让我们探索如何使用Django Admin界面添加和移除权限。基于之前添加组和用户的例子，我们将学习如何使用Django Admin面板为不同用户分配权限。

在浏览器的Admin登录页面，输入现有超级用户的凭据进行登录。

登录Admin面板后，你会看到Groups和Users的选项。在Authentication and Authorization部分，点击Groups链接。

首先要知道，除了现有的staff组，你还可以创建新的组。例如，假设你想添加两个组：第一个用于预订台员工，第二个用于Little Lemon网站管理员。

点击Add group按钮，会加载一个带有添加组表单的新页面。你必须为组命名，在本例中，组名是Reservation Desk。

在权限部分，注意Available permissions表格中有多个选项。假设你想为此组分配针对Reservations模型的权限，你可以选择Can add reservation、Can change reservation等权限，然后点击右箭头按钮将其添加到Chosen permissions表格中。转移完成后，点击Save and add another按钮来创建网站管理员组。

注意，Add group表单会重置，允许你添加另一个组。创建一个名为Admin Users的新组，但这次通过点击Choose all按钮分配所有权限。

所有组创建完成后，点击Save按钮。

现在组已经创建好了，下一步是添加用户。在Authentication and Authorization部分，点击Users链接打开用户页面。

假设你想在此部分创建一个名为Mario的用户（记住，Mario是Little Lemon的店主）。点击Add user按钮，加载一个显示添加用户表单的新网页。

要添加新用户，你必须输入登录凭据：输入Mario作为用户名，然后设置密码。点击Save and add another按钮来添加另一个新用户。第二个用户是Meher，Little Lemon的一名员工。分配密码并点击Save按钮。

注意，当你点击Save按钮时，Django管理界面会立即跳转到可以为你刚创建的用户分配额外信息的页面。

有一个Personal info部分，你可以在其中添加用户的名字、姓氏和电子邮件地址。在Permissions部分，你可以更改权限级别并将用户分配到一个组。

在这个例子中，用户Meher是一名员工，所以让我们保持其Active权限，并同时分配Staff status权限。接下来，将Meher分配到Reservation Desk组。

重要的是要知道，一旦你将用户分配到特定组，该组有权获得的所有权限都会自动分配给该用户。当然，也可以为用户分配额外的独立权限。

当你完成为用户分配组和权限后，按下Save按钮。

接下来，通过在用户表中点击用户名，来为用户Mario添加组和权限。首先，输入用户Mario的个人信息。接着，授予他Superuser状态。使他成为Admin users组的一部分，并保存更改以返回用户页面。

还可以按不同类别筛选用户。在筛选面板中，你可以按员工状态、超级用户状态或他们所属的组（例如Admin users）进行筛选。

最后，在主页上，注意你的最近操作会显示在Recent Actions部分。这个功能允许你快速配置不同的用户并设置他们的权限级别。

总结

在本节课中，我们一起学习了Django中用户与权限管理的核心知识。我们介绍了Django内置的权限系统，包括四种默认权限和自定义权限。我们通过Django Shell演示了如何以编程方式创建用户和分配权限。更重要的是，我们详细探索了如何利用直观的Django Admin界面来添加组、创建用户，以及高效地修改和分配权限。掌握这些技能对于构建安全且可维护的Web应用至关重要。

38：数据库选项 🗄️

在本节课中，我们将要学习如何在Django项目中配置数据库选项，特别是如何从默认的SQLite数据库切换到更强大、可扩展的MySQL数据库。我们将了解不同数据库的特点、配置方法以及相关的安全注意事项。

默认数据库：SQLite

创建Django项目时，默认配置使用SQLite数据库。该配置自动设置在settings.py文件中。这意味着你可以立即开始使用数据库。

SQLite是一个用户友好、零配置的数据库，使用它有许多优点。你无需安装任何东西来支持该数据库，因为它不作为服务器进程运行。这意味着数据库不需要启动、停止，也不需要额外的配置文件。因此，这类数据库适合小型项目或快速原型开发。

假设你正在开发需要快速测试环境的项目，SQLite是一个可靠的选择，因为它不需要运行单独的服务器。

切换到生产级数据库

有时可能需要更可扩展、更健壮的数据库，例如从开发环境迁移到生产环境时。在本视频中，你将学习如何配置数据库选项，以便在Django项目中使用MySQL数据库。

Django支持的数据库

Django支持使用多种数据库，且配置简单。这些数据库包括PostgreSQL、MariaDB、MySQL、Oracle和SQLite。其中，PostgreSQL和MySQL是最常用的。Django提供了支持每种数据库的特性，使其易于连接和使用。

它提供了一种通用的方式来访问不同类型的数据库，通过了解数据库类型来建立连接。在本课中，你将处理最流行和广泛使用的数据库之一：MySQL。

配置MySQL数据库连接

上一节我们介绍了Django支持的多种数据库，本节中我们来看看如何设置与MySQL数据库的连接。

要连接到MySQL数据库，你需要提供数据库运行的地址、端口号以及你想要连接的数据库名称。你还需要一个数据库驱动程序，它负责映射所有模型，并通过模型将Python查询转换为SQL指令。

要使用MySQL，需要安装驱动程序或连接器，即MySQL客户端。

当你连接到数据库时，连接会在每个请求上打开，并保持打开特定时间。连接由CONN_MAX_AGE参数控制，代表连接自动关闭前的特定时间。

要建立连接，你必须在settings.py文件的DATABASES选项下配置参数。默认配置是针对SQLite的。

你也可以使用MySQL的选项文件来存储数据库连接凭据，这将在本课后面学习。凭据可以包括数据库名称、用户名和密码，并存储在单独的配置文件中。在settings.py文件中，MySQL连接引用会在/etc/mysql/目录中查找连接文件。请注意，这不在Django项目内部，这是一种有意的安全措施。

创建数据库与安全

现在你知道了连接到MySQL数据库所需的步骤，让我们来探索数据库的创建过程。虽然Django会根据你的模型通过迁移脚本创建所有表，但初始设置要求你手动创建数据库。

以下是创建数据库时需要注意的要点：

创建数据库需要连接到数据库本身，并拥有足够的权限进行身份验证和授权。
必须记住，要通过分配安全角色和使用强用户名和密码来保证数据库的安全。
存储的数据可能包含最终用户的个人信息，因此保持其私密和安全至关重要。

作为开发者，你需要意识到潜在的安全风险，其中一个重大风险是数据库凭据的安全性。允许他人知道或访问你数据库的用户名和密码可能会带来严重后果。数据库连接凭据仅可在运行Web应用程序的虚拟机或服务器上访问。

总结

本节课中我们一起学习了如何在Django项目中配置数据库选项。我们首先了解了默认的SQLite数据库及其适用场景，然后探讨了切换到MySQL等生产级数据库的必要性和步骤。我们学习了Django支持的多种数据库、配置MySQL连接的具体参数（如地址、端口、驱动），以及手动创建数据库和安全保护凭据的重要性。理解这些内容对于构建可扩展且安全的Web应用至关重要。

39：设置MySQL连接 🗄️

在本节课中，我们将学习如何在Django项目中安装和配置MySQL数据库。你将了解MySQL的特点、安装步骤、数据库连接器的配置，以及如何将MySQL与Django的ORM（对象关系映射器）集成。

概述

Django因其开源特性和丰富的工具集而广受欢迎，这些工具支持轻松扩展和快速开发。MySQL是Django支持的众多数据库之一。数据库有助于存储来自不同来源的数据，这些数据可用于不同目的，例如为网页添加内容。Django开发框架内置了与不同数据库连接的支持。

之前的学习中，你了解到Django使用一种称为对象关系映射器（ORM）的技术。ORM促进了数据库与应用模型之间的数据映射，而无需编写任何SQL查询。MySQL是一个流行的数据库管理系统，可以与Django一起使用，尤其是在处理大量数据负载时。

MySQL的特点回顾

在深入配置之前，让我们快速回顾一下MySQL的一些关键特性：

开源且文档齐全：MySQL是开源的，拥有完善的官方文档和社区支持。
可靠且快速：数据在内存中高效存储，确保了操作的可靠性和速度。
可扩展性强：能够处理从小型到海量的数据量。
安全性高：提供基于加密密码保护的灵活验证安全层。

准备工作：安装数据库

在开始使用模型之前，需要先安装一个数据库。Django默认提供SQLite数据库，无需预先安装。

然而，如果你想使用其他数据库（如MySQL），则必须单独安装并进行配置。

接下来，让我们探索在Django项目中安装和配置MySQL的具体步骤。

步骤一：安装MySQL

要开始将MySQL与Django结合使用，首先确保你的计算机上已安装MySQL。

根据操作系统和用途，你可以使用MySQL官网上提供的不同安装包。本视频中的示例基于Mac OS系统。对于其他操作系统，你可以在本课末尾的补充阅读材料中找到特定的命令。

对于Mac OS，你可以使用如HomeBrew这样的包管理器来管理安装。

首先，输入以下命令来安装MySQL：

brew install mysql

这个命令会安装MySQL数据库。

步骤二：访问MySQL并创建数据库

接下来，进入MySQL以访问数据库。请注意，使用Mac OS时有一些特定的命令。

现在，输入命令连接到MySQL服务器：

mysql -u root -p

其中，-u 指定用户名（这里是 root），-p 表示需要密码。

按回车键后，系统会提示你输入密码。请注意，此处输入的密码需要与MySQL数据库内为root用户设置的密码匹配。

进入MySQL命令行界面后，输入以下命令查看所有数据库：

SHOW DATABASES;

并以分号结束查询。这将生成你的MySQL服务器上所有数据库的列表。

例如，创建一个名为 feedback 的数据库。为此，输入命令：

CREATE DATABASE feedback;

现在，再次运行 SHOW DATABASES; 命令，你会发现列表中包含了刚刚创建的 feedback 数据库。

步骤三：为Django项目创建用户

下一步是为Django项目创建一个专用用户。运行以下命令：

CREATE USER 'admin_django'@'localhost' IDENTIFIED BY 'password';

这里的密码是单词 password。请注意，这个命令可能有其他变体，但这是其中一个简化版本。按回车执行。

接着，输入命令授予该用户对 feedback 数据库的权限：

GRANT ALL PRIVILEGES ON feedback.* TO 'admin_django'@'localhost';

最后的命令是刷新权限，使更改立即生效：

FLUSH PRIVILEGES;

至此，数据库已准备就绪。

步骤四：安装数据库连接器

为了使MySQL数据库能够与Django的ORM交互，需要安装一个数据库连接器。

在本示例中，我们将使用 mysqlclient 库。你也可以使用其他与Django兼容的Python 3数据库连接器库。

现在，退出MySQL命令行界面，输入以下命令安装 mysqlclient：

pip3 install mysqlclient

请注意，你可能需要安装额外的文件，以使这个特定的库在你的操作系统上正常工作。

步骤五：配置Django项目设置

一旦数据库和数据库连接器就位，接下来需要配置Django项目。进入你的项目文件夹，找到 settings.py 文件。Django将在这里引用数据库连接信息。

要使用MySQL，数据库配置需要遵循特定的格式。找到 DATABASES 配置部分，将其替换为MySQL的设置，并将数据库名称改为 feedback。

重要提示：在本例中，数据库名称是 feedback。请始终检查你想要连接到的数据库的实际名称。

配置示例如下：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'feedback',        # 你的数据库名
        'USER': 'admin_django',    # 你创建的用户名
        'PASSWORD': 'password',    # 对应用户的密码
        'HOST': 'localhost',
        'PORT': '3306',
    }
}

将用户替换为 admin_django，密码替换为 password。

步骤六：运行数据库迁移

在可以使用数据库之前，最后一步是运行迁移命令。让我们运行以下两个命令。

首先，创建迁移文件：

python3 manage.py makemigrations

按回车执行。

接着，应用这些迁移到数据库：

python3 manage.py migrate

请注意刚刚执行的迁移列表。然而，由于数据库内还没有任何条目，你对此的视图是有限的。

关于数据库选择的说明

在本课程的大部分内容中，即使没有使用MySQL数据库，了解Django默认安装的SQLite数据库之外还有其他可用替代方案也是有益的。

总结

本节课中，我们一起学习了如何在Django中设置MySQL数据库连接。我们回顾了MySQL的特点，逐步完成了从安装MySQL、创建数据库和用户、安装连接器，到配置Django项目设置并最终运行迁移的整个过程。掌握这些步骤使你能够在需要处理更重数据负载或特定数据库功能时，灵活地将Django项目与强大的MySQL数据库集成。

40：模块总结：模型 🎯

在本节课中，我们将总结关于Django模型模块的核心内容。你将回顾如何创建模型、应用迁移、使用查询集API、处理表单、管理后台以及配置数据库。

模块回顾与技能总结 🏁

上一节我们完成了对模型模块的学习，本节中我们来回顾你获得的关键技能。

你从模型和迁移开始学习。在此部分，你探索了模型、字段、属性和键。你现在能够描述模型与数据库表之间的关系和相似性，并演示如何在Django中创建模型，重点关注不同的属性。

此外，你现在可以总结迁移的概念，以及它们如何通过处理问题和回滚的最佳实践在Web应用中发挥作用。你可以讨论迁移如何通过将SQL与编码分离，为开发团队节省大量时间。无需直接针对数据库创建SQL查询，也无需考虑存储这些文件的位置，以便其他开发人员可以运行它们。

接下来，你探索了对象关系映射（ORM），以及Django如何使用它来创建针对数据库的SQL查询。你还发现了查询集API，以及开发人员如何使用它在数据库中保存和检索数据。

😊

在模型和迁移之后，你学习了模型和表单。你被介绍了Django丰富的表单框架，以及如何操作表单数据来提取和发送信息。你现在能够展示如何设置具有不同数据类型的模型，以及它们如何从标准请求体中映射出来。

你还练习了使用表单API及其一些内置数据类型来创建表单。

接下来，你专注于管理后台。这部分向你介绍了Django管理后台及其一些核心功能。你可以演示如何直接从管理面板创建和管理用户及群组，以提供对Web应用的访问权限。你还学习了权限在视图、模型和控制器级别如何工作，以及如何使用Django管理视图添加它们。最后，你可以设置用户并添加或撤销权限。

最后，你探索了数据库配置。你现在能够展示Django中可用的不同数据库选项，重点是MySQL Lite和MySQL。你练习了设置数据库配置和用于本地开发的SQLite数据库所需的步骤。然后，你了解了设置MySQL数据库的配置选项，并练习了建立MySQL数据库连接并测试其是否正常运行。

😊

核心技能掌握 ✅

你现在已经熟悉了模型。更具体地说，你可以：

创建模型和应用迁移。
使用查询集API与数据库交互。
利用表单API创建表单并将数据绑定到对象。
熟悉Django管理面板，以添加和控制用户及群组的权限。
最后，通过为你的Django应用设置MySQL数据库来结束本模块。

😊

做得好！你在Django开发道路上取得了出色的进展。

41：模板 🧩

在本节课中，我们将要学习 Django 框架中模板的概念与使用方法。模板是生成动态网页内容的核心工具，它允许开发者将静态的 HTML 结构与动态的数据内容分离。

Web 框架通常需要生成动态内容以在网页上呈现。由于 Django 是一个 Web 框架，它提供了一种便捷的方式来动态生成 HTML。

动态内容是指根据上下文、用户行为和偏好而变化的任何数据。

开发者可以利用动态内容和渲染来生成静态的 HTML 代码。

对于开发者而言，最常用的方法是使用模板。

接下来，我们将深入了解如何在 Django 中使用模板，并探索 Django 模板引擎和 Django 模板语言的概念。

什么是模板？📄

模板是基于文本的文档，或者是使用 Django 模板语言标记的 Python 字符串。Django 模板语言简称为 DTL。

模板主要包含两种类型的内容。第一种是静态内容，即网页上不会改变的 HTML 代码。第二种是模板语言，这是一种允许你插入动态数据的语法。

让我们通过一个例子来探索如何使用动态内容创建一个 HTML 标题元素。在这个例子中，变量 dish_name 和 price 被放置在双花括号 {{ }} 内。这些变量代表了动态内容。其余的内容，包括 HTML 标题标签，则是静态的。

示例代码：

<h1>{{ dish_name }} - ${{ price }}</h1>

理解静态部分定义了页面的结构和布局这一点非常重要。

而一个使用 render 函数的视图则负责处理动态内容。

模板的渲染过程 🔄

你可能还记得，render 函数接受三个参数：request、模板路径和一个变量字典。

函数调用示例：

return render(request, ‘template.html‘, {‘dish_name‘: ‘Pizza‘, ‘price‘: 12.99})

当你将字典对象传递给 render 函数时，渲染过程会用上下文中的值替换模板中存在的变量。

虽然你使用模板语言来渲染动态内容，但模板的概念构成了 MVT 架构中的表示层。这有助于实现逻辑分离，因为模板处理的是网页的用户界面逻辑。

需要知道的是，静态 HTML 内部的动态内容是以 Django 能够理解的语法和格式编写的。

Django 模板引擎与语言 ⚙️

Python 是一种动态的、面向对象的编程语言，而 HTML 是一种静态的标记语言。

为了弥合这一差距，Django 利用了 Django 模板引擎和 Django 模板语言。DTL 是用于添加动态内容的语言。

DTL 可以包含嵌入的动态内容，例如 Python 代码和变量，这些内容由模板引擎处理。

DTL 由变量、标签、过滤器和注释等结构组成。

每个结构都有特定的语法，帮助 Django 理解代码逻辑。例如，你可以使用标签和注释来构建一个 for 循环以显示列表项元素。标签映射来自上下文的字典值，并帮助向模板添加逻辑。你将在本课后面学到更多关于这些结构的内容。

此外，Django 还提供了一个用于加载和渲染模板的 API。

模板引擎配置 ⚙️

你在项目目录下的 settings.py 文件中定义模板引擎的配置设置。必须将 APP_DIRS 设置设为 True，这一点很重要。

这个设置告诉 Django 在哪里搜索模板。例如，在项目中每个应用的名为 templates 的子目录内进行搜索。

你还可以在 DIRS 选项内的 directory 设置中添加特定位置，以便 Django 在其中搜索目录。

除了 Django 提供的默认模板引擎，你还可以通过使用一个或多个模板引擎来扩展其功能。

例如，Jinja2 是 Python 中一个流行的模板引擎，你可以在 settings.py 文件中配置添加这些扩展的设置。

例如，你可以更改 Django 的默认环境设置以使用 Jinja2。

模板继承与代码复用 ♻️

现在你了解了模板引擎，让我们探索代码复用的概念。Django 通过使用模板和一种称为“模板继承”的机制来帮助实现代码复用。

模板继承允许开发者构建一个包含网站预期 HTML 元素的基础模板，并定义子模板可以覆盖的块。

一旦定义好，网站的所有页面都可以继承这个基础模板。

这种代码复用性有助于节省开发者的时间和精力，并遵循 DRY（不要重复自己）原则。

例如，你可以创建一个包含网站头部、主体和主要部分 HTML 代码的基础模板。然后，在一个子网页中，你继承这个基础模板并放置页面的特定内容。

将模板文件放置在名为 templates 的文件夹内是一种标准的、最佳实践的做法。

总结 📝

本节课中，我们一起学习了如何在 Django 中使用模板，并探索了 Django 模板引擎和 Django 模板语言的概念。模板是 Django 中一个相当广泛的主题，在本课程的剩余部分，你将学到更多关于它们的知识。

42：创建模板 🧱

在本节课中，我们将要学习如何在Django中创建和使用模板。模板是Django框架中用于渲染动态网页内容的核心组件，它能有效提升代码复用性，并将后端数据与前端HTML分离。

概述

网页设计可能非常耗时，尤其是在使用Django构建Web应用程序时处理动态网页。Django模板为开发者提供了诸多好处，其中一个主要好处是它促进了代码复用，并能渲染动态内容。

在本视频中，你将学习如何使用Django模板和Django模板语言来创建模板。你将探索渲染静态HTML元素的步骤，这些元素可以显示来自Python字典的动态内容。

模板与渲染函数

正如之前所学，在Django中，开发者使用模板来显示动态数据。现在让我们更详细地探讨这一点。

视图函数从某些数据结构（例如连接到我们应用程序的数据库）中检索数据。开发者使用模板和Django模板语言来显示这些动态数据。模板包含静态HTML和由render函数渲染的动态数据。

render函数接受三个参数：request、path和一个变量字典。

让我们现在更详细地探讨一下。

request：代表初始的HTTP请求对象。
path：代表HTML文件相对于模板目录或文件夹的相对路径。
dictionary：包含变量作为键的字典，模板可以使用这些键来显示动态数据。

现在你了解了render函数的结构，让我们看看它如何将数据返回给用户。render函数返回一个字符串，作为HTTP响应对象的一部分，由网页进行渲染。由于这个过程本质上是使用Python代码创建的，因此可以灵活地定义变量并将其传递给模板。

创建模板的步骤

要在Django中创建模板，你可以遵循以下步骤。

以下是创建模板的具体步骤列表：

定义一个返回render函数的视图。
更新urls.py文件中的URL配置。
确保在settings.py中配置了模板和已安装应用的设置。
创建一个HTML页面，使用Django模板语言包含静态HTML和动态数据。
确保将模板页面的名称和字典作为参数传递给render函数。

现在你了解了渲染模板的过程，让我们打开VS Code并进一步探索这些步骤。

实战演练：创建“关于我们”页面

在这个例子中，我将演示如何为Little Lemon网站的“关于我们”页面创建一个模板，该模板使用字典返回HTML内容。

首先，在views.py文件中创建一个视图。第一步是创建一个名为about的视图函数，并将request对象传递给它。接下来，返回一个render函数，并传递request对象，后跟名为about.html的HTML页面，该页面将显示内容。

第二步是确保在项目级别和应用级别的urls.py文件中更新URL配置文件。

代码看起来没问题后，转到settings.py文件，在TEMPLATES设置的DIRS键中添加模板目录。然后需要确保应用已注册。

接下来，你需要创建about.html页面。转到主项目目录并创建一个名为templates的文件夹。现在，右键单击templates文件夹并创建一个名为about.html的文件。

请注意，在about.html文件中，通过键入感叹号并选择第一个选项，VS Code将自动创建基本HTML页面的代码。在<body>标签内，添加带有文本“About”的<h2>标题元素。

保存文件并通过键入python manage.py runserver并按Enter键来运行服务器。在浏览器中访问本地主机URL并在末尾添加/about。

你会注意到，模板是从你在about.html文件中创建的内容渲染出来的。

添加动态内容

现在模板可以工作了，让我们用它来创建一些动态内容。

为此，首先转到views.py文件并创建一个名为about_content的字典。接下来，创建一个键值对，键名为about，值是一个包含Little Lemon网站附加内容的字符串。

现在保存文件。下一步是将字典传递给render函数，以便模板可以访问这个字典对象。

保存文件后，再次返回about.html文件。然后添加一个段落标签<p>，并在其中使用双花括号{{ about }}插入关键字about。这是字典对象内部的键。

现在保存文件，再次转到浏览器并刷新页面。你会注意到页面更新了，并且显示了附加内容。现在，如果你修改字典中的内容，保存并再次刷新页面，内容会自动更新。

添加样式

最后，你可以为HTML添加一些样式，例如背景颜色。

保存文件并刷新网页，页面现在反映了样式更新。

这个例子演示了如何在Django中创建一个HTML模板，其中包含标题内的静态内容和段落内的动态内容。

总结

本节课中，我们一起学习了如何使用Django模板和Django模板语言来创建模板。我们了解了render函数的作用和参数，逐步实践了从创建视图、配置URL、设置模板目录到编写包含动态数据的HTML模板的全过程。通过为Little Lemon网站创建“关于我们”页面的实例，你掌握了将后端Python字典数据传递到前端模板并渲染显示的核心技能。

43：使用模板语言 🧩

概述

在本节课中，我们将要学习Django模板语言（DTL）。DTL是Django用于在HTML标记中嵌入动态数据的关键工具。我们将了解其核心语法，包括变量、标签、过滤器和注释，并学习如何使用它们来分离表示层和应用逻辑，从而创建动态的网页内容。

变量：动态数据的占位符

上一节我们介绍了DTL的基本概念，本节中我们来看看其第一个核心构造：变量。变量用于在模板中插入动态数据。

变量由双花括号 {{ }} 包围。当模板引擎遇到一个变量时，它会计算该变量的值并用结果替换它。

变量可以返回类似字典的对象，将键映射到值。例如，如果上下文中有 {"restaurant_name": "Little Lemon"}，在模板中使用 {{ restaurant_name }} 将渲染为 “Little Lemon”。

同样，您可以使用点符号进行字典属性或列表索引查找。

字典属性查找：{{ my_dict.key }}
列表索引查找：{{ my_list.0 }}

标签：模板中的逻辑控制

了解了变量之后，让我们继续学习标签。标签为模板提供了逻辑控制能力。

标签使用花括号和百分号 {% %} 创建。最常用的标签是控制结构，如 if 条件判断和 for 循环。

if 标签用于根据条件渲染不同的输出。一个典型的用例是检查用户的登录状态。

以下是 if 标签的示例代码：

{% if logged_in %}
    <p>Welcome back!</p>
{% else %}
    <a href="/login">Please log in.</a>
{% endif %}

这段代码检查布尔变量 logged_in 的值。如果为真，页面渲染欢迎语句；如果为假，则渲染登录链接。

另一个常见的工作流程是遍历字典或列表以显示内容。为此，您需要使用 for 循环。

假设您有一个包含餐厅菜单项的简单列表。要静态创建此菜单，您需要为每个菜单项手动编写HTML。而使用模板动态创建，您可以添加一个 for 循环。

以下是 for 循环的示例代码：

<ul>
{% for item in menu_items %}
    <li>{{ item.name }}: ${{ item.price }}</li>
{% endfor %}
</ul>

在这段代码中，变量 item 在迭代过程中会依次引用 menu_items 列表中的每个对象。循环将遍历菜单列表并显示每个菜品的名称和价格。

除了 if 和 for，还有许多其他标签，例如 extends 和 include，您将在后续课程中学习。

过滤器：修改变量的值

现在，让我们来探索过滤器。与标签不同，过滤器可以修改变量的值。

过滤器在变量后使用竖线 | 符号调用。例如，如果您添加一个 upper 过滤器，它会将输入字符串转换为大写。

公式/代码：{{ variable_name|upper }}

过滤器也可以接受参数，例如在使用 date 过滤器时。

公式/代码：{{ a_date_variable|date:"Y-m-d" }}
这个例子传递了年、月、日的格式参数，从而生成指定格式的日期字符串。

注释：用于文档说明

最后，我们来了解一下注释。您可以使用花括号和百分号创建注释，Django会忽略这两个标签之间的所有内容。

注释的语法如下：

{% comment %}
    这里是多行注释。
    这些内容不会在最终页面中渲染。
{% endcomment %}

需要注意的是，开发者使用注释进行文档说明，因为它们不会被渲染到最终页面上。

总结

本节课中我们一起学习了Django模板语言（DTL）的核心组成部分。我们了解到，变量 {{ }} 用于插入数据，标签 {% %} 用于控制逻辑流程（如 if 和 for），过滤器 | 用于格式化或修改变量值，而注释则用于代码说明。开发者经常结合使用标签和过滤器来创建动态的网页内容。掌握DTL是构建灵活、可维护Django应用视图层的基础。

44：Django中的动态模板 🧩

在本节课中，我们将学习如何使用Django模板来返回包含动态数据的网页，具体以展示“小柠檬”餐厅的菜单为例。你将探索如何创建模板，如何从字典中获取数据并将其显示在网页上，以及如何在模板内部使用for循环来遍历字典并展示数据。

概述

上一节我们介绍了Django视图和HTTP响应的基础。本节中，我们来看看如何利用模板系统，将后端数据动态地渲染到HTML页面上，从而创建更丰富、可交互的网页内容。

创建视图与数据字典

首先，打开应用的views.py文件。接下来，创建一个视图函数，它接收request对象作为参数。

在函数内部，通过添加花括号{}来创建一个字典。然后，定义一个键name并为其赋值Greek salad。现在，需要将这个字典赋值给一个变量，我们将其命名为menu_item。

至此，字典的代码已完成。但这次，我们不返回HttpResponse，而是使用render函数。在render函数的括号内，传递三个参数：首先是request对象，然后是HTML文件的名称，最后是包含字典的变量。

可以这样理解：Python字典类似于Web开发中常用的JSON对象。我的代码设置为与menu.html模板文件配合工作，因此现在需要创建这个文件。

以下是创建字典和调用render函数的代码示例：

def menu(request):
    menu_item = {'name': 'Greek salad'}
    return render(request, 'menu.html', {'menu': menu_item})

创建与配置模板

回到项目目录，创建一个名为templates的新文件夹，并在其中创建一个名为menu.html的新文件。打开此文件，编写代码以动态显示字典对象。

为此，首先创建双花括号{{ }}，并在其中传递字典的键，在本例中是name。然后保存文件。

为确保Django能找到menu.html文件，需要打开settings.py文件，在TEMPLATES列表的DIRS选项中添加模板文件夹的名称。同时，需要确保已在INSTALLED_APPS列表中注册了该应用。

最后一步是打开urls.py文件，在urlpatterns列表中添加path函数。然后传递想要映射的URL，例如输入menu/，以及要调用的视图函数名称，即views.menu。

以下是URL配置的示例：

from django.urls import path
from . import views

urlpatterns = [
    path('menu/', views.menu, name='menu'),
]

运行服务器与查看结果

代码准备就绪后，运行服务器并在浏览器中打开对应的URL。导航到菜单页面，你会注意到字典中存储的值显示在了浏览器中。

需要知道的是，字典中保存的值就是将在网页上显示的内容。这是通过在HTML模板中传递字典键来在代码中实现的逻辑。这是一个向网页返回动态内容的例子。如果字典中的值更新，网页上显示的值也会相应更新，并且可以根据需要添加任意多的键值对。

你甚至可以将这些内容包裹在HTML标签中，稍后会学到更多相关内容。至此，你已经知道Django开发者可以使用模板使静态页面动态化。页面布局可以用HTML构建，动态数据则放置在双花括号{{ }}内。双花括号意味着动态内容，这被称为Django模板语言。

使用复杂数据结构与循环

现在让我们进一步扩展这个概念。回到views.py文件，我将用一个包含更多值的对象替换之前的字典。

这个结构稍微复杂一些：注意mains是键，而值是一个字典列表。每个字典内部有两个键值对，键分别是name和price。注意，我已将此对象赋值给一个名为new_menu的变量，该变量被传递到render函数中。

为了在浏览器中显示这些内容，我必须更新menu.html文件中的代码和逻辑。

在menu.html内部，移除现有的代码。接下来，在一组带有双百分号{% %}的单花括号内，我需要使用for循环遍历字典中的每个项。

以下是模板中for循环的示例：

{% for item in mains %}
  {{ item.name }} {{ item.price }}
{% endfor %}

美化输出：结合HTML

虽然代码可以工作，但我希望每个菜单项都显示在新的一行。为此，可以添加一些HTML。回到menu.html，我添加了一些带有内联样式的HTML表格标签。

现在刷新页面，会注意到菜单显示在一个表格中。这样，我应该能够添加另一个字典，并且网页上的内容会动态更新。

回到views.py文件，我添加另一个项目hummus，价格为5。保存文件并刷新页面，可以看到值在网页上被动态更新了。

这就是如何创建编程逻辑并将其应用于模板，以使用Django在网页上渲染动态数据。在这些示例中，我演示了使用字典作为数据源来渲染动态数据。重要的是要知道，数据源也可以是其他东西，比如数据库或API，你很快将学习如何操作。

总结

本节课中，我们一起学习了如何使用模板返回带有动态数据的网页。我们掌握了从创建数据字典、配置模板路径、在模板中引用变量，到使用for循环遍历复杂数据结构并整合HTML美化输出的完整流程。这为构建动态Web应用奠定了坚实的基础。

45：将模型对象映射到模板 📋

在本节课中，我们将学习如何将Django模型对象传递给模板，并利用模板语言动态地展示数据库中的数据。这是创建动态网页内容的核心步骤。

Django广受欢迎的原因之一，是它允许开发者快速创建动态网站内容。只需几个步骤，你就能从数据库中取出数据，编写一些逻辑，然后在浏览器中将其展示给最终用户。

之前你已经学习了如何通过传递给模板的对象，在网页上展示动态数据。本节中，我们将通过向模板传递一个模型对象，为“小柠檬”餐厅创建一个动态菜单。我们还将探索如何使用Django模板语言的for循环来遍历对象并展示其内容。

准备工作：模型回顾

上一节我们介绍了模型的基本概念。现在，我们来看看之前创建的Menu模型。

在models.py文件中，我们创建了一个名为Menu的模型，它包含name和price两个属性。注意，name被设置为字符字段（CharField），而price被设置为整数字段（IntegerField）。我们还创建了一个__str__方法，该方法会使用name属性为对象渲染一个字符串。

from django.db import models

class Menu(models.Model):
    name = models.CharField(max_length=200)
    price = models.IntegerField()

    def __str__(self):
        return self.name

这个方法有助于在Django管理后台进行可视化和识别。在浏览器中打开Django管理后台，可以看到这个模型包含了诸如“鹰嘴豆泥”、“沙拉三明治”等菜单项的数据。

创建视图函数

准备工作就绪后，接下来我们创建视图函数。

在views.py文件中，我创建了另一个名为menu的视图函数。与之前的视频类似，我传入了request对象，但这里需要采取几个不同的步骤。

以下是创建视图的步骤：

首先，从models.py文件中导入Menu模型。
接下来，在函数内部，我需要创建一个包含Menu模型内所有值的对象。为此，我使用Menu.objects.all()方法，并将其赋值给一个名为new_menu的变量。
第三步是创建一个字典。使用你之前学过的类似逻辑，在花括号内，我创建一个名为‘menu’的键，其值就是变量new_menu。这个字典被赋值给另一个变量new_menu_dict。
最后一步是返回一个render函数，它接收三个参数：request对象、模板文件名和刚才创建的字典。

以下是完整的视图函数代码：

from django.shortcuts import render
from .models import Menu  # 从当前目录的models模块导入Menu类

def menu(request):
    # 获取Menu模型中的所有对象
    new_menu = Menu.objects.all()
    # 创建上下文字典，将查询集传递给模板
    new_menu_dict = {‘menu‘: new_menu}
    # 渲染模板并返回响应
    return render(request, ‘menuCard.html‘, new_menu_dict)

屏幕上代码较多，因此我将之前创建的视图函数注释掉。这也能确保不会因两个函数中的某些名称相似而引起正则表达式冲突。

保存文件后，我需要检查urls.py文件中的URL映射。

注意，path函数内的URL被设置为‘menu/‘作为资源定位地址。视图函数menu被指定为要调用的函数。

from django.urls import path
from . import views

urlpatterns = [
    path(‘menu/‘, views.menu, name=‘menu‘),
]

创建模板文件

最后一部分，我需要创建一个与render函数中键入的名称相同的HTML文件：menuCard.html。

在模板文件中，我将访问从字典传递过来的‘menu‘键。

首先，我直接尝试在模板中显示menu变量：

{{ menu }}

保存所有文件后，我打开浏览器，导航到URL ‘/menu/‘ 并按回车。

注意，网页上显示的是一个查询集对象。我希望页面只显示对象中的具体项目，因此需要修改代码。

使用模板语言动态展示数据

回到HTML文件，我需要使用Django模板语言配合条件语句和循环。

以下是修改模板的步骤：

我首先添加一个if条件语句，检查menu中是否有项目。
如果条件为真，我使用一个for循环来遍历menu中的项目。
在循环体内，我使用{{ item.name }}和{{ item.price }}来显示每个项目的名称和价格。
我需要确保使用{% endfor %}来结束for循环。
最后，我添加一个else条件，如果menu对象为空，则显示一些文本。
使用{% endif %}结束if条件。

修改后的模板代码如下：

<!DOCTYPE html>
<html>
<body>
    {% if menu %}
        {% for item in menu %}
            {{ item.name }} : {{ item.price }}
        {% endfor %}
    {% else %}
        <p>No items to display.</p>
    {% endif %}
</body>
</html>

代码看起来没问题。我保存文件并刷新浏览器中的网页。现在，只有对象的名称和价格被动态显示出来。

理解这一点很重要：这些数据是从数据库中获取，并使用模型存储在模型对象中的。然后我遍历该对象以显示每个项目的名称和价格值。

优化显示格式

代码已经可以工作，但我可以通过最后一步来进一步优化：用HTML段落标签包裹动态输出的内容。

<!DOCTYPE html>
<html>
<body>
    {% if menu %}
        {% for item in menu %}
            <p>{{ item.name }} : ${{ item.price }}</p>
        {% endfor %}
    {% else %}
        <p>No items to display.</p>
    {% endif %}
</body>
</html>

如果我保存文件并刷新网页，会注意到现在每个项目都显示在新的一行上。

测试动态更新

最后，为了演示这个动态网页，让我使用Django管理后台向数据库添加另一个项目。

我添加一个名为“Baklava”、价格为10的项目。保存该项目后，我切换到菜单页面并刷新。

注意，内容会自动更新，并显示新添加的项目。

总结 🎯

本节课中，我们一起学习了如何通过从视图向模板传递模型对象来创建动态菜单。你还探索了如何使用Django模板语言的for循环来遍历对象并显示其内容。这个过程涵盖了从数据库获取数据、在视图中处理、最后在模板中动态渲染的完整流程，是Django Web开发的基础。

46：模板继承 🧩

在本节课中，我们将要学习Django中一个非常重要的概念——模板继承。模板继承是遵循“不要重复自己”（DRY）原则的关键实践，它能帮助我们高效地复用网页的公共部分，如页眉和页脚，从而加速用户界面的开发。

概述：为何需要模板继承？

在Django中开发Web应用程序时，需要牢记“不要重复自己”（DRY）这一关键原则。重复，无论是有意还是无意，都可能导致维护问题和逻辑矛盾。每一个独特的概念或数据片段都应该只存在于一个地方。框架应尽可能地从尽可能少的内容中推导出尽可能多的内容。

例如，要为Little Lemon网站的多个页面创建相同的页眉和页脚部分，你可以复制标记代码并多次保存，然后只为每个网页更改相应的标题。但更高效的方法是构建一个包含网站所有公共元素的基础模板，并将它们分配给一个块。这个块随后可以在每个网页上重复使用。

分解页面：理解区块

为了高效地使用模板，将页面分解成多个部分会很有帮助。在Django中，这些部分被称为区块。

以下是大多数网站常见的区块：

页眉：这是第一个区块，通常位于页面顶部。它包含公司名称、Logo以及指向网站不同页面的链接（即导航菜单）。有时还包含用户登录区域。
页脚：这是位于网页底部的区块，包含公司或联系方式的详细信息、导航链接和版权信息。

保持页眉和页脚在所有页面中的外观和位置一致，对于良好的用户界面和积极的用户体验至关重要。这种一致性使用户能够更快、更轻松地在网站中导航。

核心方案：使用模板继承

现在你可能会问，如何将页眉和页脚应用到Little Lemon网站的四个页面上呢？答案就是使用模板继承。

模板继承允许你将内容拆分为独立的组件，然后可以插入和重用这些组件，而无需重复工作。这为你节省了大量时间。请记住，DRY是Django的一个关键原则，而模板继承就是这一原则的绝佳体现。

实现工具：`include` 与 `extends` 标签

了解了模板继承的概念后，让我们来探索实现它所需的两个标签选项：include标签和extends标签。

`include` 标签

基础页面上的HTML标记现在使用include标签来引用包含页眉和页脚部分代码的文件。如果你需要更新这些文件中的任何一个，只需操作一次，而不是在每个页面上都进行修改。

include标签允许你指定一个模板字符串或一个变量，以便为不同的渲染设置条件。例如，假设你想传递一个包含页面名称等信息的对象。为此，你可以在视图的render函数中传递一个字典作为参数，以将变量或对象传递给模板。

为了从页眉文件中访问特定数据（例如页面对象），你需要在include标签内添加额外的属性。添加后，你就可以在页面上的任何地方访问该页面对象了。例如，将页面名称显示为标题元素。重要的是要记住，这个对象是视图中render函数内传递的字典的一部分。

使用include标签的要点：当你使用include标签时，你指示页面渲染这个子模板并包含其HTML。这意味着被包含的模板之间没有共享状态。每个包含都是一个独立的渲染过程。

`extends` 标签

接下来我们看看第二个标签：extends标签。它在语法和用法上与include标签相似，但其目的和功能不同。

extends允许你替换父模板中的块或内容，而include则是包含部分内容。extends创建了一种父子关系，子模板可以覆盖父模板的功能。而include则只是在当前上下文中简单地包含并渲染一个模板。

使用extends标签有两种方式：

使用字符串字面量作为要扩展的父模板的名称。
利用变量的值。一旦变量被求值为字符串，Django就会使用该字符串作为父模板的名称。

示例：
假设你有一个名为header.html的文件，其中包含一个表示为无序列表的导航菜单代码。你可以将header.html的文件内容扩展到一个名为about.html的文件中。这段代码将有效地把header.html的内容添加到about.html的内部内容里。

总结

本节课中，我们一起学习了Django的模板继承。你了解了模板继承如何通过重用内容块（如页眉和页脚）来节省开发时间。这是实践DRY原则、提高代码可维护性和开发效率的核心技术。掌握了这些知识，你应该能够快速开发出Little Lemon网站的四个页面了。

47：使用模板继承 🧩

在本节课中，我们将要学习如何在Django中使用模板继承。模板继承是一种强大的技术，它允许你创建一个基础模板（父模板），其他模板（子模板）可以继承并覆盖其中的特定部分。这有助于保持网站设计的一致性，并减少重复代码。

上一节我们介绍了模板继承的概念，本节中我们来看看如何在Django项目中实际应用 extends 和 include 标签。

项目场景与目标

假设你需要为一家名为“小柠檬”的餐厅设计一个网站。该网站包含三个页面：主页、菜单页和关于页。虽然每个页面的内容不同，但一些基本的样式组件（如页眉、页脚）需要在所有页面上保持一致。此外，你可能希望导航菜单作为页眉的一部分，出现在所有页面上。

我们的目标是使用Django的模板继承功能来实现这个需求。

实施步骤

以下是实现模板继承的具体步骤。

1. 设置视图与URL

首先，你需要在 views.py 文件中设置三个视图函数，分别对应三个页面。

# views.py
from django.shortcuts import render

def home(request):
    return render(request, ‘index.html‘)

def about(request):
    return render(request, ‘about.html‘)

def menu(request):
    return render(request, ‘menu.html‘)

确保在项目级和应用级的 urls.py 文件中配置好URL映射，将相应的URL路径指向这些视图。

接着，更新 settings.py 文件，将你的应用添加到 INSTALLED_APPS 列表中，并配置模板目录 DIRS。

2. 创建模板文件结构

为了使用模板，你需要在项目文件夹下创建一个名为 templates 的文件夹。

当使用模板继承时，通常还会在 templates 文件夹内创建一个名为 partials 的子文件夹，用于存放可复用的模板片段（如页眉、页脚）。

现在，让我们在 templates 文件夹内创建以下文件：

base.html：作为所有页面的基础模板。
index.html：主页模板。
about.html：关于页模板。
menu.html：菜单页模板。

在 partials 文件夹内创建一个文件：

_header.html：页眉模板片段。

3. 编写基础模板 (`base.html`)

基础模板包含了所有页面共有的结构和样式。你可以通过输入 ! 然后按回车来快速生成基本的HTML结构。

<!-- templates/base.html -->
<!DOCTYPE html>
<html lang=“en”>
<head>
    <meta charset=“UTF-8”>
    <title>小柠檬 🍋</title>
    <style>
        body {
            background-color: #f0f8ff; /* 浅蓝色背景 */
        }
    </style>
</head>
<body>
    <main>
        {% block content %}
        <!-- 子模板的内容将在这里被插入 -->
        {% endblock content %}
    </main>
</body>
</html>

代码解释：

{% block content %} 和 {% endblock content %} 定义了一个名为 content 的块。子模板可以覆盖这个块，并填入自己的内容。
我们在 body 标签中添加了背景色样式，这个样式将被所有继承自 base.html 的页面共享。

4. 编写子模板并继承

现在，让我们编辑主页模板 index.html，让它继承基础模板并填充自己的内容。

<!-- templates/index.html -->
{% extends “base.html” %}

{% block content %}
    <h1>欢迎来到小柠檬餐厅！</h1>
    <p>我们提供最新鲜、最美味的柠檬风味菜肴。</p>
    <p>请浏览我们的菜单，了解更多信息。</p>
{% endblock content %}

代码解释：

{% extends “base.html” %} 声明此模板继承自 base.html。
{% block content %} ... {% endblock content %} 覆盖了父模板中同名的 content 块，并提供了主页特有的HTML内容。

对 about.html 和 menu.html 文件重复类似的步骤，填入各自页面的内容。

5. 运行服务器并查看效果

保存所有文件，然后在终端运行开发服务器：

python3 manage.py runserver

在浏览器中访问 http://127.0.0.1:8000/home（或你配置的主页URL）。你会看到主页成功渲染，并且继承了 base.html 中定义的背景色。

为什么背景色生效了？
因为你没有在 index.html 中指定背景色，所以它自动使用了父模板 base.html 中定义的样式。这就是继承的作用：子模板获得了父模板的所有特性，除非它明确覆盖了它们。

同样，访问“关于”页面，你会发现页面结构一致，但内容已变为关于页的信息。

总结一下：base.html 模板在每个页面上渲染，但每个页面独特的 content 块内容会显示在指定的区域。

6. 使用 `include` 标签添加页眉

include 标签用于将另一个模板的内容包含到当前模板中。这非常适合用于添加像页眉、页脚这样的公共组件。

首先，在 _header.html 文件中添加页眉内容并保存。

<!-- templates/partials/_header.html -->
<header>
    <nav>
        <a href=“/home”>主页</a> |
        <a href=“/menu”>菜单</a> |
        <a href=“/about”>关于我们</a>
    </nav>
    <hr>
</header>

然后，修改 base.html 文件，使用 include 标签将页眉包含进来。

<!-- templates/base.html -->
<!DOCTYPE html>
<html lang=“en”>
<head>
    <meta charset=“UTF-8”>
    <title>小柠檬 🍋</title>
    <style>
        body {
            background-color: #f0f8ff;
        }
    </style>
</head>
<body>
    {% include “partials/_header.html” %} <!-- 包含页眉 -->
    <main>
        {% block content %}
        {% endblock content %}
    </main>
</body>
</html>

保存文件并刷新浏览器中的网页。现在，你会看到页眉信息显示在页面的顶部。这个页眉将出现在所有继承自 base.html 的页面上，而不会影响页面的其他信息。

这比将页眉代码单独添加到每个页面要高效得多，后者只会让页眉信息出现在单个页面上。

本节课总结

在本节课中，我们一起学习了如何在Django中使用 include 和 extends 标签来实现模板继承。

extends 标签：用于建立模板间的父子继承关系。子模板可以覆盖父模板中定义的 block。
include 标签：用于将一个模板的渲染结果包含到当前模板中，非常适合复用如页眉、页脚、侧边栏等组件。

掌握这项技能将为你未来的Web开发项目节省大量时间，使你能够更高效地构建和维护具有一致外观的网站。

48：Django应用程序的调试 🐛

在本节课中，我们将要学习如何调试Django应用程序。调试是识别和隔离错误、找到问题根源并部署解决方案的过程。对于由多个相互关联的文件和依赖项组成的Web项目来说，调试可能具有挑战性，但掌握这项技能对于理解应用程序的内部工作原理至关重要。

调试概述与挑战

调试是识别和隔离错误、找到问题根源并部署解决方案的过程。

编程过程中犯错是不可避免的，但在Django这样的Web框架中纠正错误可能尤其困难。

与发生在易于定位的独立文件中的错误不同，Web项目由多个相互关联的文件和依赖项组成，这使得故障排除具有挑战性。

调试需要耐心，但它也有助于更好地理解应用程序的内部工作原理。

常见的错误类型

错误可能以多种形式出现在开发过程的任何阶段。

以下是几种常见的错误类型：

缺少或添加视图。
创建不正确的模板。
缺少导入语句。
无法访问资源，例如模型数据。
甚至在传递给函数的某些属性中缺少逗号。

对于初学者来说，看到错误并不得不进行故障排除可能会令人望而生畏。

虽然观察和实践是克服Django项目中错误的最佳方法，但也有一些工具可以加快项目启动和运行的过程。

Django的默认调试器

你已经知道如何使用提供的内部实现来引发一些错误，但也会出现一些需要处理的意外错误。

Django有一个独特的调试器，以黄色错误页面的形式出现。

你可能还记得在运行服务器后，在本地主机的首页上看到过 DEBUG = True 标志。

Django调试器默认启用，其设置可以在项目的 settings.py 文件中找到和修改。

虽然它是开发过程中的一个有用组件，但Django的开发者建议永远不要在生产环境中使用它。

这是因为它可能会向使用你网站的用户暴露内部文件路径、数据库和项目配置细节。

可以通过将设置更改为 DEBUG = False 来防止这种情况。

# settings.py
DEBUG = False  # 在生产环境中必须设置为 False

第三方调试工具

除了Django提供的默认调试器，正如你所知，Django是用Python编写的，可以轻松集成有助于调试的第三方库。

现在，让我们来探讨几种调试Django应用程序的方法。

调试实践：错误识别

这个例子使用了之前演示的“创建表单”项目。

首先启动开发服务器。

你立即会注意到出现了一个“404页面未找到”错误。

这是因为你尚未配置本地主机的URL。同时，请注意这个错误也会显示在控制台的日志记录器中。

重要的是要知道，默认的Django实现会列出运行命令后Django执行的所有步骤。

现在让我们转到正确的URL。注意控制台底部的日志会更新。

调试实践：Python错误与Django错误

现在打开 forms.py 文件。Python特有的错误很可能出现在控制台日志中。

例如，如果你注释掉 csrf_token 常量并保存文件，会注意到控制台内显示错误日志。会显示一个名称错误，文本内容是“名称 csrf 未定义”。

如果你尝试在浏览器中刷新本地主机的URL，会注意到页面将无法加载。

然而，其他一些错误并不那么明显。例如，移除你在 log_form 函数中传递的导入语句并保存文件。

注意，你在日志中没有得到任何错误。但是，如果你刷新网页，会注意到表单的模板消失了，只剩下使用静态HTML标记呈现的提交按钮。

为了防止这种情况发生，请始终确保你有正确的导入，并且在函数中传递正确的参数。

调试实践：模板与CSRF错误

假设你打开文件 my_template/home.html。在文件中，移除CSRF令牌的代码并保存文件。

如果你转到本地主机的URL并重新加载页面，会注意到表单正确呈现了。

填写表单并按下提交按钮。

会显示一个错误，提示“禁止访问：CSRF验证失败”。这个错误明确指出CSRF令牌缺失，这对故障排除很有帮助。

因此，你可以大致说，黄色页面错误更具体于Django内部的问题，而不是Python代码的问题。

调试实践：分析错误页面

现在假设你再次进入 forms.py 文件，并错误配置了你试图渲染的模板。例如，你将其命名为 home_page.html 并再次保存。

一旦你访问模板页面，就会得到一个错误，例如“模板在特定路径中不存在”。

让我们更详细地检查这个页面。首先，它指定了异常位置，你可以从 get_template 以及它在 FormView 中如何被引发得到提示。

接下来，如果你继续滚动，会看到一个堆栈，称为回溯堆栈。它按顺序包含Python代码，其中有一行被高亮显示，这很可能是错误发生的位置。你还可以将其转换为“复制并粘贴视图”。

当你进行转换时，会得到一个更简洁的界面，列出了所有细节。

你还可以点击“在公共网站上分享此回溯”，点击后会带你到 dpaste.com。这个页面显示方便的剪贴板内容，你可以在不同的论坛上分享。

如果你进一步向下滚动，会看到关于字典的信息，该字典包含所有可用的HTTP头部信息，称为元数据。

继续滚动，你可以在设置中找到详细信息，所有这些信息都可能对调试有帮助。

总结

关于调试，你永远无法采用一种适用于所有情况的方法。随着实践的深入，你遇到的错误数量会慢慢减少。

在处理这些项目时，系统化和耐心的方法是前进的最佳途径。

本节课中，我们一起学习了如何调试Django应用程序，这将在未来你需要对错误进行故障排除时为你提供帮助。

49：Django中的测试 🧪

概述

在本节课中，我们将要学习Django框架中的测试概念。测试是软件开发周期中的重要组成部分，它能确保代码的质量、可靠性和性能。我们将重点了解如何使用Python的unittest模块在Django中进行单元测试。

测试的重要性

测试是软件开发生命周期中的一个重要组成部分。

调试更侧重于消除应用程序的错误和缺陷。

测试则考量质量、可靠性和性能等指标。

它能有效地为开发者节省大量时间。

Django中的测试选项

每种语言和框架都有许多测试选项，开发者会根据项目需求做出适当的选择。

许多测试包和工具都能与Django良好配合。一个流行的方法是单元测试。

你可以使用单元测试来隔离一个函数、类或方法，并只测试那一段代码。

单元测试基础

上一节我们介绍了测试的重要性，本节中我们来看看进行单元测试时需要了解的基础信息。

以下是进行单元测试时需要了解的基础信息：

测试目标：测试针对代码中的细粒度功能，即可测试的最小单元。
测试输出：测试的输出结果将是通过、失败或错误。

在本视频中，你将通过Python的unittest模块示例，学习Django中的测试概念。

Django的测试模块

在Django中，unittest模块采用基于类的方法。

你将测试添加在一个继承自Django测试包中TestCase类的类内部。

假设你编写了一个名为Reservation的模型并想测试它。首先，导入继承自TestCase的测试类，然后导入Reservation模型。

from django.test import TestCase
from .models import Reservation

运行测试

创建测试后，使用命令python3 manage.py test来运行。

此外，你可以添加特定配置来运行特定包内的所有测试，例如：

运行命令：python3 manage.py test reservations。

要运行特定的测试用例，使用命令：python3 manage.py test reservations.tests.ReservationTestCase。

或者，假设你想运行测试用例中的一个特定测试方法，例如一个计算座位数的方法。你可以运行如下命令：python3 manage.py test reservations.tests.ReservationTestCase.test_seat_count。

测试文件组织

了解开发者通常如何组织测试文件很重要。

在小型项目中，开发者通常将测试用例放在特定应用文件夹下创建的一个或多个文件中，并常见地将文件命名为tests.py。

在可能包含多个测试文件的大型项目中，开发者通常使用诸如test_models.py和test_views.py这样的名称。

实践示例：创建单元测试

好了，现在你了解了Django中测试的概念。让我们打开VS Code，探索一个创建单元测试的例子。

之前你学习了如何在Python中使用单元测试来测试代码。在这个例子中，你将探索Django如何将unittest模块与TestCase包结合使用。

让我们探索如何使用测试用例来测试Django应用程序内的模型数据。

请注意，项目已经创建，并且应用配置已在settings.py文件的INSTALLED_APPS列表中设置好。

在这个例子中，你将处理两个文件：models.py和tests.py。在models.py中，你创建一个模型，并将测试代码写在tests.py文件中。

如果这些文件不存在，你可以在myapp目录中创建它们。

第一步：创建模型

首先，在models.py文件中添加一个模型。该模型将记录顾客在Little Lemon网站上进行预订时的名字、姓氏和预订时间。

booking_time字段中的auto_now参数会记录系统的当前时间，并设置为True。

from django.db import models

class Reservation(models.Model):
    first_name = models.CharField(max_length=100)
    last_name = models.CharField(max_length=100)
    booking_time = models.DateTimeField(auto_now=True)

接下来，保存文件并转到tests.py。

第二步：编写测试

请注意，django.test包中的TestCase模块已经被导入。

此外，你必须导入所需的datetime包。

你还必须导入需要使用的模型，即Reservation模型。

下一步是创建一个名为ReservationModelTest的类，并让它继承TestCase。

from django.test import TestCase
from datetime import datetime
from .models import Reservation

class ReservationModelTest(TestCase):

接下来，你添加一个setUpTestData类方法，并在其中传入一个类对象。

setUpTestData是TestCase中存在的一个方法，用于向模型中添加数据。

因此，在这个例子中，为first_name和last_name输入数据。

需要注意的是，由于auto_now参数设置为True，booking_time会自动更新。

    @classmethod
    def setUpTestData(cls):
        cls.reservation = Reservation.objects.create(
            first_name='John',
            last_name='Doe'
        )

接下来，你创建一个名为test_fields的函数，用于检查接收到的名字和姓氏是否为字符串格式。

你使用assert语句来执行检查，以验证名字和姓氏都是字符串数据类型。

    def test_fields(self):
        self.assertIsInstance(self.reservation.first_name, str)
        self.assertIsInstance(self.reservation.last_name, str)

同样，你必须创建另一个名为test_timestamps的函数。在这个函数内部，插入另一个assert语句，例如assertIsInstance。这次，将booking_time与导入的datetime进行比较。

    def test_timestamps(self):
        self.assertIsInstance(self.reservation.booking_time, datetime)

这个步骤的最后一部分是记住添加@classmethod装饰器，因为这是一个类方法。

现在保存文件。

第三步：运行迁移与测试

代码完成后，你现在可以通过在终端中输入python3 manage.py test来运行测试。

按回车键，注意应用程序运行并通过了两个测试。测试的运行由终端中显示的两个点表示。

回到模型中，让我们将其中一个字段从字符串改为整数，看看测试是否会产生不同的结果。

保存文件并再次运行测试。注意，其中一个测试失败了。

此外，显示了一个断言错误，指出你分配的姓氏不是整数类的实例。

断言错误也由字符F.表示，这意味着一个测试失败，另一个测试通过。

如果你熟悉在Python中使用单元测试，请注意其实现方式与你在传统Python代码中找到的类似。

总结

本节课中我们一起学习了Django框架中的测试概念。这个例子演示了如何在Django中实现一个基本测试。

Django作为一个平台和框架非常庞大。因此，重要的是要记住，开发者可以探索许多可用的测试配置和选项。

在本视频中，你通过Python的unittest模块示例，学习了Django中的测试概念。

50：模块总结：模板 📝

在本节课中，我们将回顾模板模块的核心内容。我们将总结Django模板的定义、Django模板语言（DTL）的构成、模板继承的原理，以及调试与测试的基本方法。

模板模块核心要点回顾 🎯

恭喜你完成了模板模块的学习。在本模块中，你学习了如何创建模板，并使用模板语言来生成HTML标记。你还探索了通过调试和测试过程来进行故障排除。

现在，是时候回顾一下关键点了。

什么是Django模板？ 🤔

你从探索模板开始了本模块。完成第一课后，你现在可以阐述Django中的模板是什么，以及在使用逻辑创建HTML结构时，模板如何使你受益。

Django模板是一种将动态数据与静态HTML结构分离的机制。它允许开发者使用特殊的语法在HTML中嵌入变量和逻辑。

Django模板语言（DTL）简介 🔤

你被介绍了Django模板语言，简称DTL。它由变量、标签、过滤器和注释等结构组成。

以下是DTL的核心概念：

变量：使用双花括号 {{ variable_name }} 在模板中输出上下文传递过来的值。
标签：使用花括号和百分号 {% tag_name %} 提供模板逻辑，如循环和条件判断。
```
{% for item in item_list %}
    <li>{{ item.name }}</li>
{% endfor %}
```
过滤器：在变量输出时对其进行修改，使用管道符号 |。
```
{{ title|upper }}
```
注释：使用 {# comment #} 在模板中添加不会被渲染的注释。

然后，你练习了如何创建模板来渲染静态HTML元素，并显示动态内容。

使用模板与变量插值 💻

在第一课之后，你学习了如何使用模板，更具体地说，你探索了如何使用模板语言和变量插值。

变量插值是将上下文中的数据（如从视图传递的模型对象）嵌入到模板指定位置的过程。你现在能够在Django中创建动态模板，并将模型对象映射到模板中。

模板继承与DRY原则 🔄

接下来，你探索了模板继承。通过模板继承，你可以将内容拆分为独立的组件（如页眉、页脚），并在多个HTML页面中重用这些片段。

使用DRY（Don‘t Repeat Yourself）原则可以确保你不会重复工作，提高代码的可维护性。

你了解到模板继承主要使用两个标签：

{% include %} 标签：用于渲染另一个模板。
```
{% include “header.html” %}
```
{% extends %} 标签：用于指定当前模板继承自哪个父模板。它通常使用字符串字面量或变量值。
```
{% extends “base.html” %}
```
这允许你替换父模板中定义的块（{% block content %}）的内容。

调试与测试 🐛

最后，你学习了调试和测试。在这里，你了解了如何调试Django应用程序。

Django有一个独特的调试器，当 DEBUG = True 且发生错误时，它会以黄色错误页面的形式出现。这个默认的错误页面会为开发者显示一些技术信息，但你不希望最终用户访问这类信息。

这可以通过在项目的 settings.py 文件中将设置更改为 DEBUG = False 来防止。

错误可能以多种形式出现在开发过程的任何阶段，包括：忘记添加视图、创建不正确的模板、缺少导入语句、无法访问的资源（如模型数据），甚至在函数中传递属性时缺少逗号。

你还了解到，调试更侧重于消除应用程序的错误和缺陷，而测试则考虑质量、可靠性和性能的度量标准。它有效地为开发者节省了大量时间。

Django中的单元测试 🧪

你知道每种语言和框架都有许多测试选项。在Django中，一个流行的方法是单元测试，你可以用它来隔离一个函数、类或方法，并只测试那一段代码。

在Django中，单元测试模块采用基于类的方法。你可以将测试添加到一个类中，该类继承自Django测试包中的 TestCase 类。

from django.test import TestCase

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/meta-be-dev/img/ae9adc4c04651535f6948e9552e17f81_27.png)

class MyViewTests(TestCase):
    def test_homepage_status_code(self):
        response = self.client.get(‘/‘)
        self.assertEqual(response.status_code， 200)

总结 📋

在本节课中，我们一起回顾了模板模块的核心知识。

你已经完成了本模块的学习，现在对模板已经很熟悉了。你可以创建模板并使用模板语言来生成HTML；你可以使用模板并将第三方库集成到你的Django应用中；你也可以在Django中使用基于类的视图，并在整个项目中重用它们。

做得好！

51：课程回顾与总结 📚

在本节课中，我们将一起回顾Django Web框架课程的核心内容。我们将系统梳理从项目结构、MVT框架的各个组成部分到具体实践操作的关键知识点，帮助你巩固所学，并为接下来的实践项目做好准备。

课程概述

在本课程中，你学习了Django框架的核心原则。现在，让我们花一些时间回顾一下你所学到的关键主题。

Django框架简介 🏁

在开篇课程中，你学习了Django框架的简介。在此介绍中，你了解了开发者如何使用DRY（Don‘t Repeat Yourself）原则来组织代码。你还探索了如何使用MVT（Model-View-Template）框架来确保代码的可重用性。

项目与应用结构 🗂️

上一节我们介绍了Django的基本理念，本节中我们来看看如何构建项目。

你学习了如何在现有的Django项目中使用正确的结构创建一个应用。

接下来，你学习了如何使用Django Admin和manage.py的一些基本命令，并最终区分了应用（App） 和项目（Project） 的结构。

以下是应用与项目结构的关键区别：

项目（Project）：是整个网站的容器，包含全局配置。
应用（App）：是一个专门的功能模块，可以在不同项目中复用。

探索MVT框架：视图（View） 👁️

理解了项目结构后，我们进入到MVT框架的核心部分。你接着探索了MVT框架中的视图（View） 部分。

在这个主题中，你学习了如何创建视图和视图逻辑，以处理基本的HTTP请求。

然后，你学习了URL配置，以及如何将URL映射到视图。

你还研究了如何使用请求（request）和响应（response）对象进行常见操作。

之后，你学习了如何使用正则表达式创建不同的URL模式。

接着，你学习了如何区分参数，以及它们如何与GET、PUT、POST和DELETE等HTTP方法关联。

最后，你探索了如何在HTTP视图逻辑和视图级别处理错误。

探索MVT框架：模型（Model） 🗃️

掌握了视图部分后，我们继续学习MVT框架的另一个支柱。你接着学习了MVT框架中的模型（Model） 部分。

在这个主题中，你学习了如何创建模型。

然后，你了解了迁移（Migrations） 的概念，以及如何使用最佳实践方法应用它们。

你还研究了如何使用查询集API（QuerySet API） 与数据库进行交互。

之后，你学习了如何创建表单，并使用表单API将数据绑定到对象。

接着，你学习了如何使用Django管理面板来添加和控制用户及组的权限。

最后，你探索了如何为你的Django应用设置MySQL数据库。

探索MVT框架：模板（Template） 🎨

数据层和业务逻辑层之后，我们来到展示层。接下来，你探索了MVT框架中的模板（Template） 部分。

在这里，你学习了如何处理模板，并使用模板技术来生成HTML。

你还学习了如何创建模板，并使用Django模板语言（DTL） 来创建标记。

最后，你扩展了这些知识，使用模板继承来创建丰富的模板。

课程总结与实践 🚀

本节课中我们一起回顾了Django Web框架课程的全部核心内容，从DRY原则、MVT架构到具体的视图、模型、模板操作。

你是否确信自己已经掌握了本课程的这些技能？如果答案是肯定的，那么你现在已经准备好将所学知识付诸实践了。

对于课程的评分评估，你需要为“Little Lemon”网站创建菜单页面。

是时候展示你的技能，展示你在课程中学到的东西了。祝你好运。

52：解决方案第1部分：创建菜单页面 🍽️

在本节课中，我们将学习如何完成一个Django项目的评分评估，具体任务是创建一个菜单页面。我们将从定义数据模型开始，逐步完成视图、URL配置和模板的开发，最终在浏览器中展示菜单项。

概述

本节教程将指导你完成Django项目“Little Lemon”中菜单页面的创建。整个过程包括：在models.py中定义菜单模型，在admin.py中注册模型，执行数据库迁移，在Django管理后台添加数据，创建视图函数，配置URL路由，以及编写模板文件来渲染菜单数据。

创建菜单模型

上一节我们完成了项目的基础设置，本节中我们来看看如何定义数据模型。

首先，打开models.py文件，创建一个名为Menu的模型类。确保在模型类内部定义一个__str__方法，以便在Django管理后台中清晰显示对象名称。

from django.db import models

class Menu(models.Model):
    name = models.CharField(max_length=200)
    price = models.DecimalField(max_digits=6, decimal_places=2)
    # ... 可以添加其他字段，如描述、分类等

    def __str__(self):
        return self.name

注册模型到管理后台

模型创建好后，需要将其注册到Django管理后台，以便通过图形界面管理数据。

打开admin.py文件，从models.py中导入Menu模型，并使用admin.site.register()方法进行注册。

from django.contrib import admin
from .models import Menu

admin.site.register(Menu)

执行数据库迁移

模型变更后，需要生成并应用数据库迁移文件，以在数据库中创建对应的表。

在命令行中运行以下命令：

python manage.py makemigrations
python manage.py migrate

配置URL路径

确保项目级和应用级的urls.py文件已正确配置，以便能够访问到我们即将创建的视图。

在管理后台添加菜单内容

现在，我们需要通过Django管理后台为菜单模型添加具体数据。

以下是创建超级用户并登录管理后台的步骤：

在命令行中运行创建超级用户的命令，并按照提示输入信息（例如：用户名 Bisttro admin，邮箱 admin@littlelemon.com，密码 Lemon@786!）。
```
python manage.py createsuperuser
```
启动开发服务器。
```
python manage.py runserver
```
在浏览器中访问 http://localhost:8000/admin，使用刚创建的超级用户凭证登录。
在管理面板中找到名为 restaurant 的应用下的 Menu 模型。
点击“添加菜单”按钮，根据提供的菜单项文本文件（通常在项目资源压缩包中），逐一输入菜单名称和价格等信息并保存。

添加完成后，你可以在菜单列表页面看到所有已添加的菜单项。

创建菜单视图函数

数据准备就绪后，我们需要创建视图函数来处理用户对菜单页面的请求。

打开views.py文件。你会注意到home、about和booking的视图函数已经存在。现在，创建一个名为menu的新视图函数。

from django.shortcuts import render
from .models import Menu

def menu(request):
    # 从数据库获取所有菜单对象
    menu_data = Menu.objects.all()
    # 构建传递给模板的上下文数据
    main_data = {"menu": menu_data}
    # 渲染并返回响应
    return render(request, 'menu.html', main_data)

代码解释：

Menu.objects.all()：这是一个查询集（QuerySet），用于从数据库获取Menu表的所有记录。
main_data：这是一个字典（Dictionary），键"menu"对应的值menu_data将传递给模板。
render(request, 'menu.html', main_data)：这是Django的渲染函数，它接收请求对象、模板文件名和上下文数据，并返回一个HTTP响应。

配置菜单页面的URL路由

视图函数创建后，需要为其配置一个URL路径，这样用户才能通过浏览器访问。

打开应用级的urls.py文件，使用path函数为menu视图添加一条路由。

from django.urls import path
from . import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', views.home, name='home'),
    # ... 其他路径
    path('menu/', views.menu, name='menu'), # 新增菜单路径
]

创建菜单模板

最后一步是创建用于展示菜单的HTML模板。视图函数将数据传递给模板，模板负责将这些数据渲染成用户看到的网页。

在应用目录下的templates文件夹中，创建一个名为menu.html的文件。首先添加基础HTML结构，然后使用Django模板语言（DTL）动态插入数据。

以下是模板内容的关键部分：

{% for item in menu %}
<p>
    {{ item.name }}
    <span>${{ item.price|floatformat:2 }}</span>
</p>
{% endfor %}

模板语言解释：

{% for item in menu %}：这是一个for循环标签，用于遍历从视图传递过来的menu列表。
{{ item.name }} 和 {{ item.price }}：这是变量输出标签，用于显示每个item对象的name和price属性。
|floatformat:2：这是一个过滤器（Filter），用于将价格格式化为保留两位小数。
{% endfor %}：用于结束for循环块。

测试菜单页面

至此，菜单页面的所有代码已完成。让我们运行开发服务器进行测试。

在终端中启动开发服务器（如果尚未启动）。
复制终端中生成的本地URL（通常是 http://127.0.0.1:8000）。
在浏览器地址栏中粘贴该URL并访问网站首页。
在浏览器地址栏中手动追加 /menu 路径（例如 http://127.0.0.1:8000/menu）并访问，你应该能看到列出了所有菜单项及其价格的页面。

总结

本节课中我们一起学习了创建Django菜单页面的完整流程。我们首先在models.py中定义了Menu数据模型，然后在admin.py中注册了该模型。接着，我们执行了数据库迁移，并通过Django管理后台添加了具体的菜单数据。之后，我们创建了menu视图函数来从数据库获取数据，并在urls.py中配置了对应的URL路由。最后，我们编写了menu.html模板文件，使用Django模板语言循环遍历并渲染出所有菜单项。

现在，菜单页面的第一部分已经成功完成。在接下来的部分，我们将继续完善这个项目。

53：解决方案第2部分：创建菜单项页面 🍽️

在本节课中，我们将学习如何为餐厅网站创建一个动态的菜单项详情页面。我们将从更新数据模型开始，逐步完成视图、模板和URL的配置，最终实现点击菜单列表中的项目即可查看其详细信息的功能。

概述

我们将分步完成以下任务：首先更新Menu模型并执行数据库迁移；然后在Django管理后台为菜单项添加描述；接着创建用于显示单个菜单项的视图函数和模板；最后配置URL并测试页面功能。

更新数据模型与迁移

上一节我们完成了菜单列表的展示，本节中我们来看看如何为每个菜单项添加详情页面。首先，我们需要为菜单项模型添加一个description字段。

第一步是打开models.py文件，在Menu模型中更新description属性。

# 在Menu模型中添加description字段
description = models.TextField(max_length=1000, default='')

接下来，在终端中运行命令以执行迁移，将模型的更改应用到数据库。

python manage.py makemigrations
python manage.py migrate

在Django管理后台更新数据

迁移完成后，使用之前创建的超级用户凭证登录Django管理后台，并根据压缩文件中提供的描述信息更新菜单项。

在Django管理面板中，点击来自restaurant应用的Menu模型，以显示菜单项列表。

从列表中选择一个特定的项目进行编辑，并使用压缩文件中提供的详细信息更新其description字段。

为所有菜单项添加描述后，即可进行下一步。

创建视图函数

现在，打开views.py文件，创建一个名为display_menu_item的视图函数。

该函数必须包含两个参数：request和主键pk，其中pk的默认值设置为None。

在函数体内，添加代码以定义视图逻辑。

def display_menu_item(request, pk=None):
    if pk:
        menu_item = Menu.objects.get(pk=pk)
    else:
        menu_item = ''
    return render(request, 'menu_item.html', {'menu_item': menu_item})

使用if条件检查主键pk是否包含值。如果为真，则创建一个变量menu_item，并使用objects.get()方法根据主键从Menu模型中获取对应的菜单项对象。

对于else条件，将一个空字符串赋值给变量menu_item。

最后，从视图中返回render函数，并传递以下参数：request对象、模板名称menu_item.html，以及一个字典对象。该字典以字符串'menu_item'为键，以变量menu_item作为其值。

配置URL路由

完成视图函数后，打开应用级别的urls.py文件，在urlpatterns列表中添加path函数。

在配置新的菜单项页面路径之前，需要先打开menu.html文件，更新代码以添加指向菜单项页面的链接。

选择href属性内的完整字符串，将其替换为指向菜单项页面的动态链接的DTL代码。

<!-- 将硬编码的链接替换为动态URL -->
<a href="{% url 'menu_item' pk=item.pk %}">{{ item.name }}</a>

请注意，不要移除HTML属性字符串的引号。

创建菜单项详情模板

下一步是在名为Restaurant的应用内的templates文件夹中创建一个名为menu_item.html的文件。创建完成后，添加起始代码。

根据注释，使用适当的Django模板语言语法替换匹配的代码。

以下是需要完成的步骤：

首先，添加来自menu_item对象的name属性。

<h2>{{ menu_item.name }}</h2>

接下来，添加来自menu_item对象的description属性。

<p>{{ menu_item.description }}</p>

然后，添加来自menu_item对象的price属性。

<p>Price: ${{ menu_item.price }}</p>

最后，添加代码以显示与菜单项名称一起存储的图片。

<img src="/static/img/{{ menu_item.name }}.jpg" alt="{{ menu_item.name }}">

在进行这些添加时，请确保所有更改都包含在段落标签<p>内。

测试页面功能

现在，保存menu_item.html文件，并确保所有其他文件的更改也已保存。

接下来，添加命令以运行开发服务器。

python manage.py runserver

将本地主机URL粘贴到浏览器中，并在末尾添加/menu文件路径。按回车键，之前显示的相同页面应该会加载，但这次菜单项名称显示为超链接。

点击“Greek Salad”链接，希腊沙拉的菜单项页面就会出现。

请注意，此页面仅包含数据库中为希腊沙拉存储的信息，并显示其名称、描述、价格和图片。

总结

本节课中我们一起学习了如何创建动态的菜单项详情页面。我们首先更新了模型并执行了数据迁移，然后在管理后台填充了数据。接着，我们创建了视图函数来处理单个菜单项的请求，配置了URL路由，并设计了用于展示详情的模板。最后，我们成功测试了从列表页跳转到详情页的完整流程。现在，是时候进入项目的第三部分，开始创建网站的页脚了。

54：解决方案第3部分：如何创建页脚

在本节课中，我们将学习如何为Little Lemon网站创建并集成页脚组件，以及如何测试预订表单的功能并验证数据是否成功存入数据库。

创建页脚模板

上一节我们完成了网站的主体部分，本节中我们来看看如何添加一个统一的页脚。

首先，打开名为 _footer.html 的文件，并将提供给您的代码粘贴进去。

接着，将图片标签（<img>）尖括号内的代码替换为适当的模板代码。例如，将静态路径改为使用Django的静态文件标签。

<!-- 示例：替换图片源 -->
<img src="{% static 'path/to/your/image.png' %}" alt="Logo">

然后，确保移除所有多余的尖括号，并保存文件。

将页脚集成到基础模板

完成页脚文件编辑后，下一步是将其引入到网站的基础布局中。

打开 base.html 文件，找到标记为“footer content”的注释行。

在该注释行的下方，添加 include 标签，并指定 _footer.html 文件的相对路径。

<!-- footer content -->
{% include '_footer.html' %}

保存 base.html 文件，并在浏览器中刷新网页。

现在，页脚内容应该已经成功显示在Little Lemon网站上了。

测试预订表单功能

页脚集成完毕后，是时候进入项目的最后阶段——测试预订表单的功能了。

在Little Lemon网站的导航栏中，点击“预订”按钮。页面将显示一个表单。

以下是需要填写的表单字段：

在“名”和“姓”字段中，输入您的姓名缩写。
填写“客人数量”。
在“评论”框中输入一些备注信息。

填写完毕后，点击“提交”按钮以发送表单数据。

验证数据库存储

表单提交后，我们需要确认数据是否已正确保存到后端数据库。

回到VS Code编辑器，右键点击数据库文件 db.sqlite3，然后选择“打开数据库”。

此时，您会注意到VS Code资源管理器面板底部出现了“SQLite Explorer”选项。

点击“SQLite Explorer”旁边的箭头以展开其内容。

向下滚动，找到名为 restaurant_booking 的数据表，并点击“显示表格”图标。

您将看到，您通过预订表单发送的数据已经存储在了这张数据库表中。

至此，您已成功完成了页脚的创建、集成以及整个表单流程的测试。

课程总结

本节课中我们一起学习了如何创建和集成页脚模板，以及如何测试一个完整的表单功能并验证数据持久化。您掌握了修改HTML模板、使用Django的 include 标签、提交表单数据以及使用VS Code的SQLite Explorer查看数据库记录的关键步骤。

恭喜您完成了Little Lemon餐厅网站项目的这一部分！

😊

55：祝贺与总结 🎉

在本节课中，我们将一起回顾您在Meta后端开发课程中的学习成果，并展望未来的学习路径。您已经完成了这门由Meta提供的课程，通过努力学习和实践，掌握了Django框架开发Web应用的核心技能。

课程回顾与成就

上一节我们介绍了课程的核心内容，本节中我们来看看您已经达成的具体学习目标。

您已经到达了这门Meta后端开发课程的终点。您付出了辛勤的努力，并在此过程中掌握了许多新技能。

您在Django的学习之旅中取得了巨大进步。您现在应该理解了使用Django框架进行Web应用程序开发的基本原理。

您能够通过为“小柠檬”网站创建原型的课程作业，展示部分理论学习成果以及您的实践Django技能集。

掌握的核心技能

以下是您在完成本课程后应具备的能力总结：

设计Django Web应用：您应该能够使用Python、HTML和CSS设计一个Django Web应用程序。
评估交互设计：您应该能够使用设计方法论和最佳实践原则来评估交互设计。
理解HTTP请求/响应周期：您应该能够通过创建视图、路由和模板来描述和实现HTTP请求/响应周期。
构建数据模型：您应该能够描述和构建数据模型，以创建数据库表和动态Web表单。
使用Django模板语言：您应该能够探索Django模板语言，以创建能显示数据库中存储数据的动态网页。
创建与测试应用：您应该能够使用行业标准、最佳实践和指南来创建、共享和测试您的Web应用程序。

课程中的分级评估所衡量的关键技能，证明了您在这些主题上的能力。

下一步计划

这门Django课程为您初步介绍了几个关键领域。您可能意识到自己仍有更多需要学习的内容。

因此，如果您觉得本课程有帮助并希望了解更多，那么为什么不注册下一门课程呢？

无论您是刚起步的技术专业人士、学生还是商业用户，本课程及项目都证明了您对Django框架价值和能力的了解。

最终的作业通过您在Django中的实际技能应用，巩固了您的能力。

但它还有另一个重要的好处。这意味着您拥有一个可以在作品集中引用的真实设计。

这有助于向潜在雇主展示您的技能。它不仅向雇主表明您具有自我驱动力和创新精神，也充分说明了您作为个人的特质以及您新获得的知识。

一旦您完成了所有课程，您将获得Meta后端开发人员证书。

总结与祝福

本节课中我们一起回顾了您在Django课程中的学习历程、掌握的核心技能以及未来的发展方向。

感谢您。能与您一同踏上这段探索之旅是我的荣幸。

祝您未来一切顺利。

56：课程简介 🚀

在本课程中，我们将学习API开发的基础知识。API是现代网络应用的核心，掌握其创建与使用对于开发者至关重要。课程将从基础概念讲起，逐步深入到使用Django REST框架构建实际API项目。

概述

API，即应用程序编程接口，是后端数据的网关。几乎所有现代网络应用都依赖API来工作。例如，当你在手机上查看天气或在线订餐时，你就在使用API来获取其他应用的功能或信息。随着移动技术等的发展，对API的需求也在增长，因此学习创建和使用API对你的开发生涯可能具有不可估量的价值。

课程内容结构

上一节我们概述了API的重要性，本节中我们来看看课程的具体安排。课程内容循序渐进，旨在帮助你从理解概念到动手实践。

以下是课程的主要学习模块：

API与现实世界：首先，你将更深入地了解API在现实世界中的应用场景。
学习准备：你将有机会思考对本课程的期望，了解教学大纲，并掌握在本课程中取得成功的策略。
HTTP/HTTPS 复习：在进入REST API之前，会有一个关于HTTP和HTTPS工作原理的简短复习，包括HTTP方法、请求、响应和状态码。
开发环境配置：你将学习如何设置Visual Studio Code，并使用必要的扩展进行配置。同时，也会学习如何使用像pipenv这样的包管理工具。
REST API 核心概念：关于REST API，你将学习其关键特征、优势、状态和资源类型，以及API的生命周期。
认证与授权：你将学习REST API中的认证原则，以及认证（Authentication）和授权（Authorization）之间的区别。
API设计与组织：你将有机会在创建自己的API时，使用正确的命名约定创建路由，并组织API项目。
Django REST 框架入门：在第二周，你将学习如何安装和设置Django REST框架（DRF）。
创建API端点：随后，你将学习如何使用基于函数和基于类的视图来高效创建API端点。
序列化器：你将丰富关于序列化器的知识，并深入了解如何转换和验证数据。
数据映射与优化：你将学习如何使用反序列化将用户输入映射到数据库模型，以及如何使用节流和缓存来优化和保护你的API。
访问控制与系统健康：在第三周，你将学习如何控制对API的访问，并建立系统以确保其健康运行。
毕业项目与评估：最后，你将有机会完成评分评估，即“小柠檬餐厅API”项目。由于这是同行评审作业，你也将有机会为同学的项目提供反馈。

学习方法与建议

如果你在本视频中遇到新的技术术语，现在不完全理解也没关系。学习过程中的每节课都包含视频内容、阅读材料和测验，会涵盖所有你需要掌握的知识。

本课程包含许多视频，将逐步引导你达成成为开发者的目标。请观看、暂停、回放和重看视频，直到你对自己的技能充满信心。然后，通过查阅课程读物和在课程练习中实践技能来巩固你的知识。

在学习过程中，你会遇到几个知识测验，可以进行自我进度检查。请记住，你并非独自一人考虑开发者的职业道路，因此课程还设计了讨论提示，帮助你与同学建立联系。这是分享知识、讨论困难和拓展开发人脉网络的好方法。

要在这门课程中取得成功，坚持规律和自律的学习方法会很有帮助。虽然这是一门在线的自定进度课程，但你需要认真对待学习，如果可能的话，制定一个包含日期和时间的学习计划，并投入其中。

总结

本节课中我们一起学习了本API开发入门课程的整体框架和目标。本课程为你提供了完整的API开发入门指导，并将引导你走向专业认证和API开发的职业生涯。

请务必也查看此学习路径中的其他课程。期待在你的学习旅程中与你一同努力。

57：API在现实世界中的应用 🚀

在本节课中，我们将学习API（应用程序编程接口）在现实世界中的核心作用、设计理念以及它们如何作为软件组件交互的桥梁。我们将通过Meta软件工程师Selena的分享，了解API设计的关键考量与实际应用。

概述

API设计本身近乎一门艺术，它需要大量的技巧与深思熟虑，以呈现给最终用户。本节将探讨API的本质、设计过程及其在大型产品（如Instagram）中的具体角色。

什么是API？🔧

上一节我们介绍了API的概念，本节中我们来看看它的核心定义与比喻。

API是全栈端到端开发的基石。之所以称之为“基石”，是因为它在描述软件组件如何相互交互方面至关重要。

你可以将API视为最终用户与后端服务之间的中介。一个恰当的比喻是：API如同银行柜员，而后端服务所托管的数据如同银行里的钱。当客户想从银行存取款时，并非直接与钱交互，而是通过柜员（即API）进行沟通。API处理用户与后端服务之间的通信，并告知用户可以访问多少“钱”或数据。

核心公式：

最终用户 <-> [API] <-> 后端服务/数据

每当您打开Instagram应用，您都在与各种API交互。例如：

一组特定的API负责在您的主页信息流中渲染故事、照片和视频。
另一组API在“探索”页面执行相同的渲染功能。
还有API负责处理诸如双击帖子点赞等操作，并通知您的设备将那个小心形图标渲染为红色。

API的设计过程与考量 🤝

理解了API的基本角色后，我们来看看在实际项目中如何设计一个API。

在Meta，API的设计具有明确的目的。例如，目标是设计一个面向用户的产品或功能的API。通常，流程如下：

产品设计：设计师创建产品原型，产品经理提供关于最终产品或服务应达成的高级目标的信息。
工程师协作：实际的API设计是多名工程师（通常是后端和前端工程师）之间达成的一项“握手协议”。他们共同商定API的结构、请求的格式以及响应的格式。

在设计API时，有两点至关重要：

明确最终用户：必须考虑API的最终使用者是谁。
保障安全与完整性：需要考虑哪些人或系统将访问数据及API服务。因此，必须在请求中添加凭证（credentials）形式的安全层，以保护数据的完整性。

核心代码概念（伪代码示例）：

# 一个受保护的API端点示例
@app.route(‘/api/data‘, methods=[‘GET‘])
def get_protected_data():
    user_credentials = request.headers.get(‘Authorization‘) # 从请求头获取凭证
    if validate_credentials(user_credentials): # 验证凭证
        return jsonify(fetch_data()) # 返回数据
    else:
        return jsonify({“error“: “Unauthorized“}), 401 # 返回未授权错误

给开发者的建议 💡

设计API不仅关乎技术，更关乎协作与视野。

我的建议是，以开放的心态对待API设计。请记住，这将是一个涉及多名工程师、可能还包括产品经理和设计师的协作过程。这些人都将非常关心以产品、应用或服务形式呈现的API成果。

即使你在构建一个API，也必须将其组件视为更大整体的一部分。当你的产出能够反映现实世界应用程序中的所见时，其中自有一种美感。因此，尽情享受这个过程，与工程师们一起头脑风暴，共同构想API的目标架构。

总结

本节课中，我们一起学习了API在软件开发生命周期中的核心地位。我们了解到API是连接用户与后端服务的中介，其设计是一个需要明确用户、保障安全并注重团队协作的过程。虽然前方还有许多工作，但坚持学习是值得的，因为理解这些不同组件如何交互至关重要。

58：你对HTTP有什么了解？ 🌐

在本节课中，我们将要学习HTTP和HTTPS的工作原理、HTTP方法、HTTP请求与响应的结构，以及HTTP状态码。这些是构建和管理API的基础知识。

HTTP与HTTPS概述

现在，你已经知道HTTP代表超文本传输协议，并且它是互联网上传输数据最广泛使用的通信协议之一。

在深入更复杂的主题之前，让我们简要回顾一下HTTP和HTTPS。

当你浏览网页、查看图片或提交表单时，你的数据是通过HTTP或其安全版本HTTPS传输的。那么，HTTP和HTTPS的传输分别是如何工作的呢？

HTTP与HTTPS的工作原理

HTTP通信至少需要两个部分：客户端（请求信息）和服务器（响应请求并提供内容）。

HTTPS是HTTP的安全版本，在需要安全性的场景中更为适用。让我们看看它是如何工作的。

使用HTTPS时，客户端的计算机在数据发送到服务器之前会先对其进行加密。服务器随后解密这些来自客户端的数据并进行处理。同时，Web服务器也会对响应数据进行加密，并将加密后的内容发送回你的浏览器。你的浏览器再解密响应并显示内容。

客户端 -> 加密请求 -> 服务器
客户端 <- 加密响应 <- 服务器

由于内容被加密，它更加安全，信息很难被窃取或获取。对于提交信用卡信息等敏感数据，始终建议使用HTTPS以确保数据安全。

HTTP方法

上一节我们介绍了HTTP与HTTPS的基本工作原理，本节中我们来看看HTTP方法。

HTTP方法也被称为HTTP动词。通过HTTP访问内容时，常用的有五种方法。

以下是五种主要的HTTP方法：

GET：用于检索一个资源。
POST：用于向服务器发送数据以创建一条记录。
PUT：用于更新整个资源。
PATCH：用于部分更新一个资源。
DELETE：用于删除一个资源。

HTTP请求

接下来是HTTP请求，它包含了用户浏览器作为编码数据发送的不同类型信息。

一个典型的HTTP请求包括以下部分：

HTTP版本类型：例如，1.1 或 2.0。
URL或路径：请求的目标地址。
HTTP方法：如GET、POST等。
HTTP请求头：包含额外信息。
可选的HTTP请求体：包含发送的数据。

那么，HTTP请求头和请求体具体是什么呢？

当你提交一个表单（例如输入用户名和密码登录网站）时，该数据会作为HTTP请求体传递给Web服务器，其格式可以是原始的JSON字符串或表单URL编码字符串。

另一方面，HTTP请求头是每个HTTP请求的核心部分，它可能包含额外信息，帮助服务器决定如何呈现内容。

以下是HTTP请求头的一些例子：

Cookies：用于状态管理。
User-Agent：标识客户端（如浏览器）类型。
Referer：表示请求来源的页面。

HTTP响应

HTTP请求之后便是HTTP响应，它包含了浏览器用于正确显示响应体内容的信息。

响应包含所请求的资源，同时也包含诸如内容长度、内容类型以及Cookie等头部信息。它还包含ETag（实体标签）和内容最后修改时间。

最后，响应还包含一些特殊的数字代码，称为HTTP状态码。

你一定见过这些HTTP状态码，但可能不知道它们的用途。实际上，它们并非直接面向用户的消息，而是向你的浏览器提供关于资源的额外信息。

例如，如果一切正常，服务器会发送200。你通常不会察觉到这一点，因为它甚至不会显示在你的浏览器中。

或者，如果找不到请求的内容，服务器会以404错误代码响应，这通常会显示在浏览器中，因为没有其他内容可展示。

HTTP状态码详解

上一节我们提到了状态码，本节中我们来详细看看它们的分类和含义。

以下是一系列状态码及其含义的范围：

100 到 199：用于信息性消息。
200 到 299：表示成功的响应。
300 到 399：提供重定向信息。
400 到 499：表示客户端错误响应。
500 到 599：表示服务器错误代码。

服务器错误通常发生在服务器端代码缺乏适当的错误检查、配置不匹配、包依赖不正确等情况。

客户端错误通常发生在客户端发出错误的API请求（请求体信息不足），或客户端请求服务器上不存在的资源时。

但请注意，有时相同的状态码在不同上下文中可能传达不同的信息。例如：

对于GET请求，200状态码意味着找到了内容。
对于PUT请求，同样的200代码意味着数据传输和更新过程成功。
类似地，对于DELETE请求，200状态码意味着资源被成功删除。

一些最常用的状态码包括：200和201、303和304、400、401、403和404，以及500。

随着课程的深入，你将了解更多关于这些状态码的具体含义。

总结

本节课中我们一起学习了HTTP的回顾内容，包括HTTP与HTTPS、HTTP方法、HTTP请求与响应以及HTTP状态码。这些是用于开发可持续和可管理API的基本概念。

59：REST风格 🏗️

在本节课中，我们将要学习什么是REST，以及如何设计符合REST风格的API。我们将了解REST的核心约束、资源的概念，以及这些原则如何帮助你构建易于使用和维护的应用程序接口。

什么是REST？

现在你已经复习了HTTP和HTTPS，可以开始学习REST了。但首先，你需要知道什么是REST。换句话说，是什么让API变得“RESTful”。

API，即应用程序编程接口，是访问后端数据的网关。它允许你轻松访问和修改这些数据。而REST是一种为你的项目设计API的架构风格。它在开发者中非常流行，因为它比其他架构风格更容易开发和实现。对你有利的是，它的学习曲线并不陡峭，你可以在短时间内创建可用于生产环境的API。但不要操之过急，你现在还不会创建API。相反，你首先要学习REST的基础知识。

REST API的核心约束

REST API为你提供了一种与服务器通信并访问驱动应用程序数据的简便方式。但一个API只有在符合某些约束条件时才是RESTful的。我们来逐一审视它们。

它必须采用客户端-服务器架构。REST API始终是无状态的，并且应该是可缓存的。它应该是分层的，具有统一的接口，并且可能还包括“按需代码”，但这是可选的。

以下是每个约束的详细说明：

客户端-服务器架构

API应使用客户端-服务器架构。应该有一个提供资源的服务器，以及一个消费这些资源的客户端。

无状态性

REST API是无状态的。这意味着服务器不包含任何发出调用的API客户端的状态。因此，如果没有适当的用户信息，服务器无法识别是谁在发出请求，或者他们之前请求的数据是什么。实际上，状态只保存在客户端机器上，而不是服务器上。这会影响你应该在API端点或URL路径中包含什么内容，但这一点稍后会详细说明。

可缓存性

API也应该是可缓存的。这意味着响应可以被Web浏览器、服务器或任何系统保存。这种缓存过程有助于减少服务器负载，因为它可以从缓存中使用API结果，而不是每次都向服务器发出实际请求。

分层系统

“分层”意味着整个系统架构可以被拆分或解耦成多个层，并且你应该能够在任何时候添加或移除一个层。下图将使这种分层更容易理解。

一个RESTful API系统的层可以包括防火墙、负载均衡器、Web服务器和数据库。

统一接口

接下来我们看看统一接口的约束。这在目前听起来可能有点令人困惑，但它意味着系统应该提供一个统一的通信系统来访问资源。例如，每个资源都应该有唯一的URL。还应该有一种统一的方式来修改资源，或者根据API结果（以标准的XML或JSON格式表示）对资源进行进一步处理。

按需代码

最后，“按需代码”意味着API可能会传递一些业务逻辑或代码，客户端可以运行这些代码来进一步改善响应结果。

为了理解这个“按需代码”功能，请考虑以下脚本标签，它从小柠檬餐厅的某个API端点加载一些JavaScript代码。一旦加载，这个脚本可以显示当天的任何特色菜单项。

目前，这六个约束只是理论上的。不要让它们把你搞糊涂。一旦你开始开发自己的API，这些术语对你来说就会变得清晰。

理解资源

接下来，让我们关注资源。资源是每个REST API的核心部分，因此熟悉API如何呈现资源对你来说很重要。

假设小柠檬餐厅有一个移动应用程序，顾客和经理都可以使用。经理可以使用该应用程序获取订单和顾客的信息，而顾客则使用该应用程序浏览菜单和下单。为了支持这些功能，应用程序使用不同的API从服务器获取数据，并且在每种情况下，资源类型都会不同。让我们探讨几个例子。

以下是几个API调用及其返回的资源类型示例：

获取所有订单：如果经理想查看所有订单，应用程序会调用API littlelemon.com/orders 并显示结果。这种情况下的资源类型是订单对象列表。
获取特定订单：如果经理想查看特定订单（例如ID为16的订单）的更详细信息，应用程序会调用API littlelemon.com/orders/16。资源类型是订单对象。
获取订单的顾客信息：要查看是谁下的订单，应用程序会进行一个带有额外过滤器 /customer 的API调用。这会检索该订单顾客的所有详细信息。这种情况下的资源类型是顾客对象。
获取订单的菜单项：假设经理想查看订单16包含哪些菜单项，应用程序会进行一个API调用，将 /customer 替换为 /menu-items。结果中只会显示订单16的菜单项。这次的资源类型是菜单项对象。

另一方面，如果顾客想浏览菜单，应用程序会使用另一个API littlelemon.com/menu-items。虽然资源类型也是菜单项对象，但返回的将是餐厅所有可用的菜单项。

但有时，资源类型是相同的，尽管结果可以被过滤得更具体。让我们探讨最后一个API来理解这一点。这次，顾客想浏览特定类别（比如开胃菜）的食品。应用程序会添加 ?category=appetizers。请注意，端点与之前的API相同，但它将输出过滤为仅限开胃菜。然而，资源仍然是菜单项对象。

重温无状态约束

现在你已经探索了几个API资源的例子，让我们重新审视REST API的无状态约束。

你需要记住，服务器总是只呈现你所请求的内容。它不记得之前发生的任何事情。例如，如果经理检索了订单16的信息，然后想查看订单16的菜单项，你不能仅仅向端点 /menu-items 发送一个后续的HTTP请求，因为这个API将返回所有菜单项，而不仅仅是订单16的菜单项。服务器不记得你之前的调用是针对特定订单的。

如果你想获取特定订单号的菜单项，你需要明确地向服务器提供该订单号，如 orders/16/menu-items。简单来说，这就是无状态的含义。服务器无法自动识别客户端。API调用必须包含更多关于用户的信息，但你将在课程后面学到更多相关内容。

总结

本节课中，我们一起学习了如何通过遵循一些关键约束来创建REST API。我们还学习了REST API的核心部分，如资源类型。这些约定将帮助你构建易于使用和维护的API。但是，关于如何优化你的API还有很多需要学习，例如使用正确的命名约定，这些内容将在接下来的视频中介绍。

60：API命名约定 🏷️

在本节课中，我们将要学习如何为API端点（Endpoint）设计清晰、有效的命名。良好的命名约定不仅能帮助开发者快速理解API的用途，还能提升项目的长期可维护性。

概述

API端点是服务器与应用程序交互的桥梁，它决定了服务器将发送哪些数据。一个精心设计的端点不仅能准确传递数据，还能通过其名称清晰地传达其目的，这对开发者和项目本身都至关重要。

命名格式规范

上一节我们介绍了API端点的重要性，本节中我们来看看命名的具体格式规范。

你的REST API的统一资源标识符（URI），也称为端点或URL路径，是用户加载页面时首先注意到的事物之一。第一印象至关重要，因此API的命名约定非常重要。

以下是关于命名格式的核心要点：

使用小写字母和连字符：API端点应始终使用小写字母，并使用连字符（-）分隔多个单词。
- 示例：/orders（正确），而非 /Orders（错误）。
避免不当的命名风格：使用下划线（蛇形命名法）、首字母大写或驼峰命名法来分隔单词并非最佳实践，因为这会使名称难以阅读和理解。
变量的表示方法：有一个例外情况。如果你的API接受一个变量，例如用户ID或订单ID，应使用驼峰命名法表示，并用花括号 {} 包裹。
- 示例：/orders/{orderId}

此外，应始终尝试在API名称中使用清晰、简洁且有意义的词语，使其易于立即理解。

使用斜杠表示层级关系

接下来，我们探讨如何使用斜杠来组织API结构。

如果你的项目包含相关的对象，应在API URI中使用正斜杠（/）来指示它们之间的层级关系。

以下是指示层级关系的示例：

在餐厅API项目中，一个客户可以拥有包含订单项的订单。
在图书馆API中，图书馆可以拥有由作者撰写的书籍。

为了获取特定书籍的作者，你可以使用API端点：/library/books/{bookId}/author。
为了获取特定作者撰写的所有书籍，你可以使用作者ID并添加 /books：/library/authors/{authorId}/books。

请注意，在这些API URI中，客户与订单、书籍与作者之间的关系都是通过正斜杠来指示的。

使用名词表示资源

另一个重要的命名约定是，你的API应始终使用名词来表示它正在处理的资源。

一个返回书籍集合或单本书籍的API应使用名词，例如 books 或 books/{bookId}。
同样，要获取一本书的价格，应使用名词：books/{bookId}/price。

使用动词的API端点（如 getAllBooks 或 getUser/{userId}）是不良API命名的例子。这是因为在REST API中，端点应始终用名词表示，而不是动词。

像 users/{userId}/delete 或 orders/{orderId}/save 这样的API端点也是错误的，因为它们使用HTTP请求作为动词来指示API执行的操作。

请记住，你应该发送一个HTTP DELETE请求到 users/{userId} 来删除用户。
你应该发送一个HTTP PUT或PATCH请求到 orders/{orderId} 来更新订单。

应避免使用标准的CRUD操作名称（如 create、read、update 或 delete）作为端点，原因有二：

这些端点所代表的资源应该是名词。
应使用适当的HTTP请求（如 GET、POST、PUT 或 DELETE）与这些端点结合，以执行必要的操作。

避免使用文件扩展名

接下来需要考虑的是，是否应在API中使用文件名。

餐厅API项目可以将API结果返回为XML和JSON数据。那么问题来了，能否将端点设计为 /orders/{orderId}.json 来获取JSON数据，或者 /orders/{orderId}.xml 来获取XML数据？

答案是否定的，你绝不应该在API中使用文件扩展名。

为了解决这个问题，你应该将预期的数据格式作为查询字符串参数来接受。

因此，如果你希望输出为JSON格式，可以在API端点后添加 ?format=json。
对于XML，你可以在末尾使用 ?format=xml。

类似地，要提供JavaScript文件的压缩版本或源代码版本，你可以使用像 /assets/js/jquery/3.6.0/min 或 /assets/js/moment/2.29.4/original 这样的API端点。

使用查询参数进行过滤

但是，如果你需要过滤集合或执行搜索呢？例如，Little Lemon餐厅的菜单上有很多项目，但你只对开胃菜感兴趣。

为了过滤结果，你应始终将数据作为查询字符串参数接受。在URL中，问号 ? 之后发送的所有内容都是查询字符串。

请记住，API端点 /menu-items 返回所有菜单项，但要只获取开胃菜，你应该将类别名称作为 ?category=appetizer 传递给端点。

因此，如果你设计可以这种方式过滤的API，你团队中的其他开发者就会知道，要获取主菜或甜点的列表，他们可以将端点更改为 ?category=main 或 ?category=dessert。

这就是良好且一致的API命名策略的魅力所在。

避免使用尾部斜杠

另一个最佳实践是，当你与团队或公众共享API端点时，绝不应在API端点末尾添加尾部斜杠。

这意味着，以正斜杠结尾的API名称（如 /orders/{orderId}/）是不良实践。/sports/basketball/teams/ 末尾有另一个正斜杠也是如此。

只需在不带尾部斜杠的情况下结束API即可。

总结

本节课中我们一起学习了API端点命名的最佳实践。

如果你想成为一名熟练的后端开发者，就需要关注你的端点，并确保使用设计良好且用户友好的API。

让我们回顾一下本视频中讨论的最佳实践：

使用小写URI格式。
使用正斜杠指示层级关系。
对资源名称使用名词。
避免使用文件扩展名。
使用查询参数指定数据类型。
不要使用尾部斜杠。
始终遵循一致的命名策略和标准API命名约定。

精心选择的API端点名称可以通过让其他开发者更容易使用你的API，来显著改善整个项目。现在，你已经掌握了创建优秀API端点名称的方法。

61：面向API开发的基本工具 🛠️

在本节课中，我们将学习如何利用几种命令行和图形界面工具来高效地测试与调试API。掌握这些工具将帮助您更快地开发并提升开发能力。

概述

作为一名开发者，若想高效工作，就需要合适的工具。例如，一个智能的代码编辑器可以帮助您更快地开发。本节视频将介绍几种可用于测试API的命令行和图形界面工具，并演示如何在Insomnia中进行实际测试。这些工具都是跨平台的，可在Windows、Mac OS和Linux上使用。在本课程中，您将频繁使用其中一些工具（如Insomnia），因此现在了解它们非常重要。

命令行工具：cURL

首先介绍的是cURL，这是一个广为人知的工具，允许开发者从命令行发起HTTP调用。它适用于所有主流操作系统，但没有图形界面。

要使用cURL，只需在Windows中打开PowerShell，或在Linux/Mac中打开终端，输入curl并回车即可。

cURL可以轻松发送HTTP GET请求。例如，只需在curl命令后加上API的URI。以下命令会向Postman Echo服务（一个用于显示请求头和请求体的服务）发送一个HTTP GET请求，这对于测试API调用非常有用。

curl https://postman-echo.com/get

对于POST请求，操作略有不同。这次需要使用-d参数添加请求体，并使用-X参数指定HTTP方法为POST。

curl -X POST -d "key=value" https://postman-echo.com/post

图形界面工具：Postman

接下来是Postman，它提供了跨平台的桌面工具和一个网页版本，拥有先进的图形界面，使得API的测试和调试变得简单。Postman是一个强大的API开发工具，使用它可以减少在API细节上的纠缠，从而将更多时间用于构建完美的API。您可以访问其官网和附加资源以获取更多信息。

图形界面工具：Insomnia Rest Client

另一个重要工具是Insomnia Rest Client，这是一个功能强大的REST API客户端，用于存储、组织和执行REST API请求。Insomnia是免费的、跨平台的，并且拥有非常用户友好的界面。您可以从本课末尾附加资源中提供的链接下载并安装适合您操作系统的Insomnia。请注意，Insomnia目前只有桌面版本。

在本课程的其余部分，您将使用Insomnia来测试和与您构建的API进行交互。下面我们来看看如何使用它。

开始使用Insomnia

Insomnia是测试API的绝佳工具。所有请求都将保存在一个“请求集合”中。要开始使用，请点击右上角的“创建”按钮，然后选择“请求集合”。为其命名（例如“第一个集合”），然后点击“创建”。

现在，您进入了一个空的集合。要创建第一个API请求，请点击左侧边栏的加号图标，然后选择“HTTP请求”。在Mac上也可以按Command + N，在Windows和Linux上按Ctrl + N。

您可以双击默认的请求名称“New Request”，将其更改为更具个人特色的名称，例如“第一个请求”。

在中间区域顶部显示“GET”的地方，点击并选择您的请求将要使用的HTTP方法类型。目前先保持为GET。在旁边的文本框中，写入您的API URL，例如：https://httpbin.org/get?project=LittleLemon。

HTTPBin.org是一个免费服务，允许您试验不同类型的HTTP方法。当您调用这些API时，它会将您发送的内容回显出来。

现在，点击右侧的“发送”按钮，您将看到HTTPBin返回了您发送的相同查询参数，在您的例子中就是project=LittleLemon。

创建POST请求

这次，让我们尝试创建一个新的HTTP POST请求。为此，点击左侧边栏的加号图标，选择“HTTP请求”。请求创建后，双击其名称并赋予一个新名称，例如“第二个请求”。

现在点击HTTP方法下拉菜单，选择“POST”。这次在URL字段中添加：https://httpbin.org/post。

您已经知道，HTTP POST请求接受表单数据或JSON数据作为参数。在Insomnia中，您可以轻松地为POST请求输入数据：点击“Body”选项卡，然后选择“Form URL Encoded”或“JSON”。

在这个参数窗口中，您可以以一种易于使用和组织的方式列出所有参数。在左侧写入参数名，在右侧写入值。在参数字段中写入project，值写为Little Lemon。

现在，点击“发送”按钮以显示输出。您可以创建任意数量的请求，并随时返回进行测试。

总结

在本节课中，我们一起学习了cURL、Postman和Insomnia等出色的工具，您可以使用它们来创建和测试您的API。掌握这些工具是成为一名高效后端开发者的重要一步。

62：使用Pipenv创建Django项目 🐍

在本节课中，我们将学习如何使用Pipenv工具来创建一个Django项目，并配置虚拟环境。我们还将了解如何在Visual Studio Code的集成终端中使用这个虚拟环境。

概述

你已经安装了最新版本的Python、Visual Studio Code以及所有必要的扩展，同时也安装了Pipenv。本节将指导你完成在虚拟环境中设置新Django项目的全过程。

创建项目目录

首先，创建一个名为LittleLemon的项目目录。

mkdir LittleLemon
cd LittleLemon

使用Pipenv安装Django

进入项目目录后，在终端窗口中输入以下命令来安装Django：

pipenv install django

Pipenv在为你设置Django和创建虚拟环境时，会显示大量信息。

激活虚拟环境并创建Django项目

你可以通过以下命令激活Pipenv创建的虚拟环境：

pipenv shell

此命令将为你的项目在虚拟环境中开启一个新的shell会话。

接着，你可以使用Django管理工具在此目录下创建一个新的Django项目。执行以下命令：

django-admin startproject littlelemon .

创建Django应用

现在，新的Django项目已经设置完成，是时候为你的API项目创建一个新的Django应用了。使用以下命令创建应用：

python manage.py startapp LittleLemonAPI

很好，Django应用已经创建完成，包含了所有必要的迁移文件和配置。

运行Django开发服务器

接下来，要运行Django服务器，请输入：

python manage.py runserver

默认情况下，服务器将在8000端口运行。你可以在浏览器中通过访问127.0.0.1:8000来访问Django服务器。

在本课程的后续部分，此地址将被称为本地主机URL。如果你想使用不同的端口号运行，可以输入python manage.py runserver 9000。

在VS Code中集成虚拟环境

上一节我们完成了项目的创建和运行，本节中我们来看看如何在VS Code中集成虚拟环境，以便在集成终端中执行命令。

在VS Code中打开你的项目目录，然后通过“查看”菜单或按Ctrl+Shift+P（Windows）或Cmd+Shift+P（Mac）来访问命令面板。

选择“Python: Select Interpreter”，然后选择Pipenv为你创建的解释器。你可以通过项目目录的名称找到它。这是一个重要的步骤，请确保不要跳过。

现在，从“终端”菜单在VS Code中打开终端。你会注意到，VS Code已经激活了Pipenv为你的项目创建的虚拟环境。

现在，你可以在此终端中无任何问题地运行所有命令，例如python manage.py runserver。

你还可以通过点击加号图标打开任意多个终端会话，并在此终端选项卡之间切换。

总结

本节课中，我们一起学习了如何使用Pipenv在虚拟环境中创建Django项目，以及如何在VS Code的集成终端中运行不同的命令。现在，你已经准备好开始使用Django开发API了。

1：课程简介

概述

在本节课中，我们将要学习Meta后端开发专业证书课程的整体介绍。我们将了解课程的目标、你将学到的核心技能、课程结构以及完成课程后能获得的职业机会。

数字空间是一个充满连接与机遇的世界。以此刻为例，正是网络使你能够注册这个课程项目，并有机会向Meta的开发者们学习他们的个人经验。当你完成这个专业证书课程后，你将能够成为数字体验的创造者。连接正在进化，你也是如此。

你可能完全没有技术背景，这没关系。即使你没有任何经验，这个项目也能让你在一年内做好就业准备。

课程如何帮助你为职业做好准备

上一节我们了解了课程的入门门槛，本节中我们来看看这个专业证书如何帮助你为像Meta这样的组织的工作做好准备。

后端开发专业证书将帮助你构建后端开发职位所需的就业技能，同时获得来自Meta工程师的Meta认证。你将学习他们如何协作创建和测试高性能的网站与应用程序。你还将与其他有抱负的后端开发者讨论有趣的话题，并完成一系列编码练习以提升你的技能。

课程结构与核心学习内容

了解了课程目标后，接下来我们看看课程的具体结构和核心学习内容。按顺序完成证书中的所有课程非常重要，因为每门课程都将建立在你已掌握的技能之上。

虽然我们为每门课程提供了建议的学习计划，但整个项目完全是自定进度的，这意味着你可以自由管理自己的时间。

以下是你在课程中将学习到的核心技能：

Python编程：你将学习如何使用Python进行编程，这是世界上最流行的编程语言之一。
数据库操作：你将学习如何查询数据库，并将其数据呈现在界面上。
API开发：你将学习如何构建安全的API，以实现应用程序之间的相互连接。
前后端集成：你将学习使用Django框架来连接Web应用的前端与后端。

毕业项目与协作工具

掌握了核心开发技能后，你将有机会通过一个综合项目来应用它们。在你的最终项目中，你将创建一个具有功能集成的Web应用程序，该程序采用最佳实践的后端架构进行设计和开发，以作为你求职时的展示作品。

你也将准备好与其他开发者协作，因为你将学会使用Git和GitHub进行版本控制。如果你希望独立工作或在较小的团队中工作，也无需担心，我们同样为你准备了云计算基础知识的课程。

求职准备与职业支持

在学习了所有技术技能后，课程的最后阶段将帮助你为求职面试做好准备。在最后一门课程中，你将练习面试技巧、完善简历，并应对一些通常在技术职位面试中出现的常见编码挑战。

完成整个项目后，你将获得Meta职业项目板的访问权限。这是一个连接了超过200家雇主的求职平台，这些雇主承诺通过Meta证书项目寻找人才。谁知道你最终会走向何方？无论未来的连接形式如何，你都将成为其中的创造者。

总结

本节课中，我们一起学习了Meta后端开发专业证书课程的全面介绍。我们了解了课程旨在帮助零基础的学员在一年内做好就业准备，涵盖了从Python编程、数据库操作、API开发到使用Django框架的核心技能。课程以自定进度的方式展开，包含一个综合性的毕业项目，并最终指导你进行求职准备，提供专属的职业平台支持。现在，让我们开始学习吧。

2：1_课程简介

在本节课中，我们将要学习Meta后端开发专业证书课程的整体介绍。课程将概述互联网如何运作，并引导你从零开始学习构建网站和Web应用所需的核心技术与工具。

概述：互联网与Web开发

你每天进行的许多活动都可以完全在线完成。你可以使用手机、电脑、平板或其他设备上的应用程序访问网络，执行购物、预订酒店以及与朋友和同事聊天等任务。

随着远程工作日益普及，你可以在家中舒适地工作、与同事互动并保持高效。这一切的实现，依赖于互联网基础设施、技术以及构建你所使用应用程序的专业人员的技能。需要说明的是，当你遇到“app”这个术语时，它可能指手机上的应用程序，也可能指在网站上或以其他在线方式运行的Web应用程序。

课程内容概览

上一节我们了解了互联网的普遍性，本节中我们来看看本课程将具体涵盖哪些内容。

从模块1开始，你将学习互联网的工作原理，包括对网页、Web服务器和Web浏览器的探索。你将了解它们各自是什么，以及它们在将互联网呈现给你时所扮演的角色。

你还将获得使用HTML、CSS和JavaScript等核心互联网技术的实践机会。你将学习开发者如何将这些技术结合起来，构建功能性和交互性的网站与Web应用程序。

随着课程的深入，你将探索专业开发者使用的一些工具，并学习使用最佳实践和标准进行编码的基础知识。

以下是开发者常用工具的一个例子：

你将学习如何使用网页浏览器内置的开发者工具。
你将学习使用被称为集成开发环境（IDE）的行业标准软件进行编码。专业人士使用IDE来更高效地编写代码。

在模块2中，你将通过HTML5和CSS的介绍开启编码之旅。你将学习这两种语言的基础知识，以及它们如何相互配合来布局和样式化网页上的元素。这包括文本、图像和视频等多媒体元素。

此外，为了确保你的网页对所有人都可访问，你将学习如何进行Web无障碍编码。

在模块3中，你将学习开发者如何使用框架和库。本模块将重点介绍响应式设计。你将学习如何实现Bootstrap库，使网页无论使用何种类型的设备都能提供出色的浏览体验。

你还将了解用户界面（UI）设计，以及如何使用常见的UI组件，并通过灵活的Bootstrap网格系统来定位它们。

接下来，你将接触React——一个免费开源的JavaScript库，开发者用它基于UI组件来构建用户界面。然后，你将了解静态内容与动态内容的区别，以及使用单页应用程序的好处。

说到内容，在模块4中，你将有机会通过编辑你自己的个人传记网页来实践新学到的技能。

学习路径与建议

上一节我们介绍了课程的技术模块，本节中我们来了解如何有效地完成这门课程。

总而言之，本课程为你提供了Web开发的入门介绍。它是一个引导你走向软件开发职业的系列课程的一部分。你的课程中有许多视频，将逐步引导你实现这个目标。

观看、暂停、回放并重新观看视频，直到你对自己的技能充满信心。然后，通过查阅课程阅读材料来巩固你的知识，并在课程练习中将你的技能付诸实践。

在学习过程中，你会遇到几个知识测验，可以用于自我检查进度。

考虑成为Web开发者的并非只有你一人，课程中的讨论提示使你能够与同学建立联系。这是分享知识、讨论困难和结交新朋友的好方法。

为了在课程中取得成功，你应该尝试为你的学习计划制定一个时间表。理想情况下，为自己设定一个固定的学习时段和时长。

你可能在本视频中遇到了许多新的技术词汇和术语。如果你现在不能完全理解所有这些术语，请不要担心。随着课程的推进，一切都会变得更加清晰。

总结

本节课中我们一起学习了Meta后端开发课程的总体介绍。我们了解了课程将如何从互联网基础讲起，逐步深入到HTML、CSS、JavaScript、响应式设计、Bootstrap、React等核心Web技术，并强调了实践、社区互动和制定学习计划的重要性。现在，你已经为开启Web开发之旅做好了准备。

3：前端、后端和全栈开发人员角色

概述

在本节课中，我们将要学习网站和应用开发中的三种核心角色：前端开发人员、后端开发人员以及全栈开发人员。我们将了解他们的职责、所需技能以及彼此之间的区别，帮助你找到适合自己的发展方向。

当你在餐厅用餐时，通常会有许多厨师在不同的区域准备你的餐点。同样地，对于你每天使用的网站和应用程序，也有许多不同的角色参与其中，共同将这些项目交付给用户。

如果你去查阅一份高薪IT工作的列表，Web开发人员的角色肯定会名列前茅，并且理由充分。如果没有开发人员在我们设备上创建、架构和维护我们每天使用的技术，我们生活的数字世界将不复存在。

然而，对于有志成为开发人员的人来说，理解与Web开发相关的一些术语可能会令人困惑。为你找到合适的领域，将取决于你对Web开发人员的角色、职责和技术的更深入理解。

前端开发人员 👨‍💻

上一节我们介绍了Web开发中的不同角色，本节中我们来看看前端开发人员。

前端开发人员负责处理网站或Web应用中用户将与之交互的所有部分。这可以包括样式、颜色、按钮、菜单，或者用户在点击、滑动和与网站交互时的用户体验。

前端开发人员的技能可能有所不同，但他们始终会专注于三项核心技术：HTML、CSS和JavaScript。

以下是前端开发的一个典型任务示例：

假设你是一名前端开发人员，被分配了在网站主页上添加新闻通讯注册选项的任务。在这种情况下，你会使用HTML来构建显示元素，例如供用户输入电子邮件地址的输入区域，以及点击发送的按钮。

然后，你可以使用CSS来定位、着色和设计这些元素在页面上的样式。

最后，你可以使用JavaScript来处理用户点击按钮时的活动。这可能是检查电子邮件地址是否有效，然后将该电子邮件地址发送到网站，以便存储在新闻通讯成员列表中。

虽然HTML和CSS技能至关重要，但最关键的技能通常是JavaScript。它是前端技术的核心动力。这主要是因为它的多功能性，以及它与强大的库和框架（例如Meta的React）相结合的事实。这些工具可用于构建快速、安全且高度可扩展的、以丰富用户界面为驱动的企业网站和Web应用。

前端开发人员的薪资具有竞争力，并可能根据经验而有所不同。通常，前端开发人员的职位会面向初级、中级和高级专业人士开放。对于有志成为开发人员的人来说，这是一个很好的入门领域。通过展示一些核心概念和技能的基础演示，以及一个引人注目的作品集样本，就有可能进入初级职位的就业市场。

后端开发人员 🖥️

了解了前端开发人员后，我们接下来看看后端开发人员的工作。

后端开发人员负责处理网站或Web应用中最终用户看不到的部分。这些活动发生在幕后，特别是在Web服务器上、数据库中或在构建架构时。

后端开发人员负责在用户请求信息时，或网站需要与Web架构的另一部分进行通信以进行处理时，创建和维护功能。例如，执行账户登录或使用信用卡完成在线购买。后端开发人员将促进网站与数据库中存储内容的交互。

因此，后端开发需要不同的语言、技能和工具。虽然这些可能有所不同，但它们通常包括与后端编程语言、数据库管理系统和Web服务器相关的知识。

后端开发人员的薪资与前端开发人员相似，取决于经验。尽管如此，在某些情况下，薪资可能会更高，特别是对于入门级和高级职位。这是因为开始学习后端技术需要更多的设置、配置、资源和一般的基础结构知识。这与前端形成对比，在前端，你仅使用一个Web浏览器就可以开始学习一些元素。

通往后端开发的道路通常比较漫长，因为你必须精通前端技术的需求。这可能包括互联网、网络和服务器的内部工作原理。对于有志成为开发人员的人来说，首先从前端开始，然后在获得专业知识后再转向后端，这是相当常见的。

全栈开发人员 🌐

前面我们分别探讨了前端和后端，现在我们来认识一下结合两者的全栈开发人员。

全栈开发人员是指能够同样熟练地处理前端和后端技术的人。全栈开发人员在Web开发项目周期的所有领域都拥有技能和知识。例如，他们在网站或Web应用的规划、架构、设计、开发、部署和维护方面拥有相关的专业知识。

全栈开发人员的职位通常处于更高级别的水平。要成为一名全栈开发人员，需要花费一些时间来获取知识、专业经验和技能。因此，该领域的职位需求很高，并且是IT行业中薪酬最高的工作之一。

总结

本节课中，我们一起学习了Web开发中的三种主要角色。前端开发人员专注于用户直接看到和交互的部分，主要使用HTML、CSS和JavaScript。后端开发人员则负责幕后的服务器、数据库和业务逻辑，使用如Python、Java等后端语言和数据库技术。而全栈开发人员则兼具前端和后端的技能，能够处理整个开发流程。理解这些角色的区别和联系，将帮助你明确自己的学习路径和职业目标。

4：后端开发人员的一天 👩‍💻

在本节课中，我们将跟随Meta的后端工程师Grace Ebo，了解后端开发人员的日常工作内容、核心职责以及所需技能。你将明白后端开发如何支撑起我们每天使用的流畅应用体验。

你是否曾好奇，你的应用程序为何加载如此迅速，或者为何持续滚动时信息能即时返回？我们的工作，就是构建这些响应迅捷的程序和架构解决方案，确保应用运行良好且高效。

我叫Grace Ebo，是Meta的一名后端工程师。我的工作是构建解决方案，帮助我们的产品在巨大规模下高效、可靠地运行。我希望你能对后端工程师的职责及其为团队带来的独特价值有更多了解。

我们的平台拥有超过30亿用户。一个常被提及的问题是：我们如何确保能够支持所有使用平台的用户，同时避免网站崩溃或让程序应用变得异常缓慢？对我而言，最酷的部分之一就是优化，探索如何让用户体验更快，如何突破极限，持续为用户创造更高效、更优质的体验。

日常工作流程 📅

上一节我们了解了后端工作的宏观目标，本节中我们来看看后端工程师一天的具体工作流程。

在补充能量（吃些东西）之后，我通常会开始一天的工作。首先，我会进行代码审查。

以下是代码审查的主要目的：

查看同事的代码，思考如何支持他们。
检查代码中是否有优秀之处，或需要修改的地方，以帮助他们将代码部署到生产环境。

代码审查之后，我通常会参加一些会议。这些会议通常围绕项目进展更新或我们可能开展的新项目进行讨论。

会议结束后，我便开始编码，进入工作状态。

最有成就感的时刻 💡

在介绍了日常工作后，我们来看看工作中最具挑战和成就感的方面。

我一天中最有收获的部分，是能够为某个困扰我数日的问题找到潜在的解决方案。在Meta，我们确实会遇到一些非常复杂的问题，有时甚至觉得它们不可能解决。但这正是突破极限的魅力所在：我们能否让系统更快？响应更迅捷？能否让它对我们的客户端和工程师更友好？

我有时会梦到潜在的代码优化方案。然后，当灵光乍现的时刻到来，我会想：“这个方案可行！就是它了。”接着我将其写入代码，运行，然后——成功了！它确实有效，并且帮助实现了我在笔记上设定的目标。

技术栈与软技能 ⚙️

解决了复杂问题固然令人兴奋，但实现这些方案离不开具体的技术工具和协作能力。

从技术层面讲，我使用Python和Java。具体使用哪种语言更多取决于项目需求，以及哪种能更轻松地帮助我达成目标，因为不同的编程语言各有其优缺点。

然而，你可能没有完全意识到的是，软技能甚至更为必要。例如沟通能力：你如何做到倾听——不只是为了回应而听，而是真正为了理解而听。当你听到与自己不同的观点时，尤其是在当前分布式远程办公的世界里，这项技能变得愈发重要。

团队协作模式 🤝

技术实现离不开团队合作，后端工程师需要与不同角色的同事紧密配合。

我与前端工程师和全栈工程师以多种方式合作。例如，在我的团队中，我们通常会有一个产品构想。然后，我们会根据不同的平台和用例进行分工。

作为一名后端工程师，我的职责是构建所谓的数据模式（Schema）和系统架构（Architecture），定义我们应该如何使用这些数据。

这是一个双向的过程。有时，客户端或前端工程师会提出需求，例如：“我们实际上需要数据以这种方式组织，或者需要不同的结构。”基于此，我可以进行更新、修改或优化，以确保客户端工程师也能更高效地工作。

最终，我们希望确保为用户构建的产品是精心设计、高效且可扩展的，能够持续服务多年。

持续学习与成长 🌱

从职业生涯的第一年到第五年甚至第十年，总会有你不了解的新事物。这始终是一个学习新知识、持续扩展技能储备（双关语，也指代码仓库）的机会，也是一个接触不同技术、获得成长机会，让事物在不同公司变得更优化或更具扩展性的过程。

市场始终存在需求：我们如何扩展系统？如何让响应更迅捷？如何让运行更高效？正是你和你现在所做的工作，将在未来助力实现这些目标。

总结 📝

本节课中，我们一起学习了后端开发人员的一天。我们了解到，后端工程师的核心工作是构建高效、可靠、可扩展的系统架构以支撑海量用户。其日常工作包括代码审查、会议、编码和解决复杂技术问题。成功不仅需要掌握如Python或Java等技术栈，更需要沟通、倾听与协作等软技能。后端开发是一个需要与前端等角色紧密配合、并保持持续学习以应对不断变化的技术挑战的领域。

posted @ 2026-03-29 09:19 绝不原创的飞龙阅读(3) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

Meta-后端开发笔记-全-

Meta 后端开发笔记（全）

1：课程介绍与概述 🚀

概述

课程背景与目标

课程模块介绍

模块详解

模块一：Django与Web框架

模块二：探索视图

模块三：深入模型

模块四：掌握模板

模块五：毕业项目与实践

学习方法与建议

总结

2：什么是Django

3：Django在现实世界中的应用 🚀

Django简介与核心功能

Django的优势与特点

Django与Flask的对比

学习Django的挑战与价值

掌握Django的最佳实践

总结

4：项目和应用概述 🏗️

概述：从静态网站到动态应用

为何使用框架：结构与效率

动态网络应用的基本要求

Django项目：整体应用容器 🗂️

Django应用：功能模块化单元 ⚙️

创建与配置应用

应用的组成部分

应用设计原则

总结

5：创建您的第一个项目 🚀

虚拟环境与开发服务器概述

详细步骤演示

1. 创建项目目录

2. 设置虚拟环境

3. 安装Django并创建项目

4. 启动开发服务器

重要说明与总结

6：Django Admin与Manage.py命令详解 🛠️

核心结构与命令回顾

两种命令行工具：Django Admin 与 Manage.py

关键命令详解

Startproject 命令

Runserver 命令

总结

7：创建应用 🚀

项目与应用的关系

创建Django应用

理解视图与路由

创建视图函数

配置URL路由

运行开发服务器并测试

总结

8：什么是Web框架 🧱

什么是Web框架？

为什么需要Web框架？

选择后端框架

Django框架简介

三层架构

9：MVT架构示例 🏗️

项目结构概览

三个MVT示例

示例一：仅包含视图

示例二：模型与视图

示例三：完整的MVT（模型、视图、模板）

MVT架构的优势

总结

10：模块总结：介绍Django 🎉

概述

Django简介

项目创建过程

项目与应用程序

管理与结构

Web框架

总结

11：视图