From f8e1365037f61e42bc81d0a490352e1d822dc567 Mon Sep 17 00:00:00 2001 From: Jason Lee Date: Sat, 4 Jun 2022 20:20:36 +0800 Subject: [PATCH 1/2] AutoCorrect files/zh-cn/learn/{l,p,s,t}* --- .../learning_and_getting_help/index.html | 24 +- files/zh-cn/learn/performance/css/index.html | 12 +- files/zh-cn/learn/performance/index.html | 12 +- .../perceived_performance/index.html | 12 +- .../web_performance_basics/index.html | 14 +- .../configuring_server_mime_types/index.html | 56 ++--- .../server-side/django/admin_site/index.html | 54 ++--- .../django/authentication/index.html | 68 +++--- .../server-side/django/deployment/index.html | 126 +++++----- .../django/development_environment/index.html | 182 +++++++-------- .../django/django_assessment_blog/index.html | 42 ++-- .../learn/server-side/django/forms/index.html | 80 +++---- .../django/generic_views/index.html | 84 +++---- .../server-side/django/home_page/index.html | 92 ++++---- .../zh-cn/learn/server-side/django/index.html | 42 ++-- .../django/introduction/index.html | 130 +++++------ .../server-side/django/models/index.html | 70 +++--- .../server-side/django/sessions/index.html | 40 ++-- .../django/skeleton_website/index.html | 108 ++++----- .../server-side/django/testing/index.html | 72 +++--- .../tutorial_local_library_website/index.html | 28 +-- .../web_application_security/index.html | 80 +++---- .../express_nodejs/deployment/index.html | 146 ++++++------ .../development_environment/index.html | 16 +- .../author_detail_page/index.html | 8 +- .../author_list_page/index.html | 8 +- .../book_detail_page/index.html | 10 +- .../displaying_data/book_list_page/index.html | 8 +- .../index.html | 10 +- .../bookinstance_list_page/index.html | 10 +- .../date_formatting_using_moment/index.html | 12 +- .../flow_control_using_async/index.html | 14 +- .../genre_detail_page/index.html | 12 +- .../displaying_data/home_page/index.html | 20 +- .../express_nodejs/displaying_data/index.html | 22 +- .../locallibrary_base_template/index.html | 8 +- .../template_primer/index.html | 22 +- .../forms/create_author_form/index.html | 18 +- .../forms/create_book_form/index.html | 12 +- .../forms/create_bookinstance_form/index.html | 8 +- .../forms/create_genre_form/index.html | 24 +- .../forms/delete_author_form/index.html | 20 +- .../express_nodejs/forms/index.html | 72 +++--- .../forms/update_book_form/index.html | 8 +- .../server-side/express_nodejs/index.html | 34 +-- .../express_nodejs/introduction/index.html | 38 +-- .../express_nodejs/mongoose/index.html | 32 +-- .../express_nodejs/routes/index.html | 8 +- .../skeleton_website/index.html | 28 +-- .../tutorial_local_library_website/index.html | 10 +- .../client-server_overview/index.html | 126 +++++----- .../learn/server-side/first_steps/index.html | 20 +- .../first_steps/introduction/index.html | 50 ++-- .../first_steps/web_frameworks/index.html | 120 +++++----- .../first_steps/website_security/index.html | 80 +++---- files/zh-cn/learn/server-side/index.html | 6 +- .../index.html | 124 +++++----- .../introduction/index.html | 38 +-- .../main_features/index.html | 6 +- .../react_getting_started/index.html | 108 ++++----- .../vue_first_component/index.html | 94 ++++---- .../vue_getting_started/index.html | 58 ++--- .../vue_methods_events_models/index.html | 50 ++-- .../vue_rendering_lists/index.html | 30 +-- .../vue_resources/index.html | 32 +-- .../vue_styling/index.html | 58 ++--- .../accessibility/index.html | 186 +++++++-------- .../automated_testing/index.html | 28 +-- .../html_and_css/index.html | 110 ++++----- .../cross_browser_testing/index.html | 18 +- .../introduction/index.html | 62 ++--- .../javascript/index.html | 20 +- .../testing_strategies/index.html | 98 ++++---- .../index.html | 216 +++++++++--------- .../learn/tools_and_testing/github/index.html | 32 +-- .../zh-cn/learn/tools_and_testing/index.html | 14 +- .../command_line/index.html | 188 +++++++-------- .../index.html | 10 +- .../overview/index.html | 76 +++--- 79 files changed, 2062 insertions(+), 2062 deletions(-) diff --git a/files/zh-cn/learn/learning_and_getting_help/index.html b/files/zh-cn/learn/learning_and_getting_help/index.html index c9dddb73510533..0283de1e274a9f 100644 --- a/files/zh-cn/learn/learning_and_getting_help/index.html +++ b/files/zh-cn/learn/learning_and_getting_help/index.html @@ -33,7 +33,7 @@

不同的学习方法

  1. 知道如何使用工具 A 解决问题 A。
  2. 知道如何用工具 B 解决问题 B。
    3. -
  3. 不知道如何解决问题 C 。
    4. +
  4. 不知道如何解决问题 C。

假设您一直专注于问题 C，然后感到沮丧，因为您无法思考如何解决它。但是，在散步获得新鲜空气后，你可能会发现，当你的头脑徘徊，你突然使工具 A 和工具 B 之间的连接，并意识到你可以使用它们一起解决问题 C！它并不总是这么简单，但它也令人惊讶的是多少次，这确实发生了。这也凸显了在电脑前学习时定期休息的重要性。

@@ -44,7 +44,7 @@

不同的学习材料

文本文章

-

你会发现很多书面文章在网上教你有关网页设计。例如，像本课程的多数课程一样。有些文章将是教程，教你某种技术或重要概念（如"学习如何创建视频播放器"或"学习CSS框模型"），有些文章将是参考材料，允许您查找您可能忘记的细节（如"CSS属性的语法是什么"？background

+

你会发现很多书面文章在网上教你有关网页设计。例如，像本课程的多数课程一样。有些文章将是教程，教你某种技术或重要概念（如"学习如何创建视频播放器"或"学习 CSS 框模型"），有些文章将是参考材料，允许您查找您可能忘记的细节（如"CSS 属性的语法是什么"？background

MDN Web 文档对这两种类型都非常好 - 您当前位于的区域非常适合学习技术和概念，我们还有几个巨大的参考部分，允许您查找任何您不记得的语法。

@@ -60,7 +60,7 @@

视频资料

交互式的代码演练场

-

你可能是那种喜欢简单指令的人，更喜欢直接开始操纵代码。这也是一种合理的方法，一些学习网站倾向于采用这种方法。例如像 Codecademy 这类网站中, 教程主要由交互式代码编辑器组成，您必须直接编写代码并查看是否达到了预期的结果。

+

你可能是那种喜欢简单指令的人，更喜欢直接开始操纵代码。这也是一种合理的方法，一些学习网站倾向于采用这种方法。例如像 Codecademy 这类网站中，教程主要由交互式代码编辑器组成，您必须直接编写代码并查看是否达到了预期的结果。

许多 MDN Web 文档参考页面中也提供了交互式的示例，您可以在其中更改代码，并查看实时结果的变化。在你的计算机上或者在像 JSBin、Codepen 或 Glitch 这样的在线代码编辑器中创建自己的代码示例也是可以的。事实上，当你在学习时，你会被要求去做这些事情本身就是属于课堂的一部分！

@@ -122,7 +122,7 @@

我每周需要投入多

一旦你知道你需要做什么，以及你认为需要多长时间，你就可以开始写一个计划来实现你的目标。它可以简单到：

-

“我需要花 500 个小时来学习我需要知道的东西，我有一年的时间来学习。如果我假设有两周的假期，我打算每周为此学习 10 个小时(在晚上和周末有空的时候)，所以我会这样安排时间。”

+

“我需要花 500 个小时来学习我需要知道的东西，我有一年的时间来学习。如果我假设有两周的假期，我打算每周为此学习 10 个小时 (在晚上和周末有空的时候)，所以我会这样安排时间。”

当然，你能在这上面花多少时间取决于你的情况。如果你在学校，那么你有比其他有工作和孩子要养活的人地情况更多的空闲时间。如果不是，实现目标仍然是可能的，但你必须现实清楚地知道实现目标最快需要多长。

@@ -148,9 +148,9 @@

保持动力

@@ -191,7 +191,7 @@

学习并认知模式

正如我们之前所说，web 设计/编程主要是关于问题解决和模式。一旦你写下了你需要做什么来解决一个特定的问题，你就可以开始弄清楚用什么技术特性来解决它了。例如，专业的 web 开发人员已经创建了很多水平导航菜单，所以他们会立即开始考虑这样的解决方案：

-

创建一个水平导航栏菜单经常利用到列表，比如:

+

创建一个水平导航栏菜单经常利用到列表，比如：

<ul>
   <li>First menu item</li>
@@ -207,7 +207,7 @@ 
学习并认知模式

   display: flex;
 }
-

接着删除不必要的间距和要点， 我们可以这样做：

+

接着删除不必要的间距和要点，我们可以这样做：

ul {
   list-style-type: none;
@@ -220,7 +220,7 @@ 
学习并认知模式

 
 
当你找到这些问题的解决方案时，写下你所做的事情，并在某个文件目录中保留一些少量的代码示例，这样你就可以回顾以前的工作了。

 
-
另外， 网络上有 开发者工具，它使您可以查看用在 web 上构建任何网站的代码。如果你手头没有解决方案，一个好的研究方法是在网络某处地方找到具有类似功能的网站，并找出它们是如何做到的。

+
另外，网络上有 开发者工具，它使您可以查看用在 web 上构建任何网站的代码。如果你手头没有解决方案，一个好的研究方法是在网络某处地方找到具有类似功能的网站，并找出它们是如何做到的。

 
 

 
注: 请注意，上面我们讨论了我们首先要解决的问题，然后是用来解决这个问题的技术。这几乎总是最好的方法--不要从一个你看起来很酷但陌生的新技术开始，然后试着把它塞进用例中。

@@ -251,7 +251,7 @@ 
高效的网络搜索

 
    
  
  • 如果你想了解更多关于响应式网页设计的信息，你可以搜索”响应式网页设计”。
    • 
  
  • 如果你想了解更多关于某项特定技术功能的信息，像 HTML 元素，CSS 属性，或者 JavaScript 方法，你应该直接搜索功能的名称。<video>background-coloropacityDate.setTime()
    • 
- 
  • 如果您正在寻找一些更具体的信息，您可以添加其他关键字作为补充，例如 "<video> element autoplay attribute"， 或者 "Date.setTime parameters"。
    • 
+ 
  • 如果您正在寻找一些更具体的信息，您可以添加其他关键字作为补充，例如 "<video> element autoplay attribute"，或者 "Date.setTime parameters"。
    • 
 

 
 
如果你想搜索一些没有那么明显的专业术语的东西，你需要考虑最有可能搜索到想要的东西是什么。

@@ -285,11 +285,11 @@ 
使用 MDN

 
 
在 MDN 的这一部分中，我们提供了关于 web 开发基础知识的大部分问题的答案。如果你陷入困境，最好重新阅读相关文章，看看你是否遗漏了什么。

 
-
如果你不确定该读哪篇文章，那么尝试在 MDN 中搜索一些相关的关键字（如上所述），或者尝试一般的网络搜索。要在 MDN 上搜索，你可以使用网站内置的搜索功能，或者使用你最喜欢的搜索引擎，在搜索词前面加上 “MDN”。例如，“mdn responsive web design“ 或者 ”mdn background-color“。

+
如果你不确定该读哪篇文章，那么尝试在 MDN 中搜索一些相关的关键字（如上所述），或者尝试一般的网络搜索。要在 MDN 上搜索，你可以使用网站内置的搜索功能，或者使用你最喜欢的搜索引擎，在搜索词前面加上“MDN”。例如，“mdn responsive web design“或者”mdn background-color“。

 
 
其他在线资源

 
-
我们在之前已经提到了 Stack Overflow， 但在这里还有其他在线资源可以提供帮助。

+
我们在之前已经提到了 Stack Overflow，但在这里还有其他在线资源可以提供帮助。

 
 
找到一个社区是件好事，如果你试图帮助别人回答他们的问题，也可以自己在上面提出问题，你会得到很多尊重。其他好论坛包括：

 
diff --git a/files/zh-cn/learn/performance/css/index.html b/files/zh-cn/learn/performance/css/index.html
index 36e587b0794ff6..17abde06d6907d 100644
--- a/files/zh-cn/learn/performance/css/index.html
+++ b/files/zh-cn/learn/performance/css/index.html
@@ -3,21 +3,21 @@
 slug: Learn/Performance/CSS
 translation_of: Learn/Performance/CSS
 ---
-
页面在样式没有渲染完毕的情况下被绘制，在样式渲染完毕后又被刷新，这大概是很糟糕的用户体验。因此，除非浏览器知道当前不需要 该 CSS，否则 该 CSS将阻止渲染。浏览器只会在下载 CSS 和构建 CSSOM之后绘制页面。浏览器遵循特定的渲染路径：绘制 paint 仅在布局 layout之后进行，布局 layout 则在创建渲染树 render tree 之后进行，创建渲染树则需要在DOM和CSSOM 树解析完成后进行。为了优化CSSOM的构造，请删除不必要的样式，对 CSS 进行最小化，压缩和缓存，并将页面加载时不需要的CSS拆分为其他文件，以减少CSS渲染阻塞。

+
页面在样式没有渲染完毕的情况下被绘制，在样式渲染完毕后又被刷新，这大概是很糟糕的用户体验。因此，除非浏览器知道当前不需要 该 CSS，否则 该 CSS 将阻止渲染。浏览器只会在下载 CSS 和构建 CSSOM 之后绘制页面。浏览器遵循特定的渲染路径：绘制 paint 仅在布局 layout 之后进行，布局 layout 则在创建渲染树 render tree 之后进行，创建渲染树则需要在 DOM 和 CSSOM 树解析完成后进行。为了优化 CSSOM 的构造，请删除不必要的样式，对 CSS 进行最小化，压缩和缓存，并将页面加载时不需要的 CSS 拆分为其他文件，以减少 CSS 渲染阻塞。

 
 
阻塞渲染优化

 
-
CSS 可以使用媒体查询将样式应用在特定条件下。媒体查询对于响应式 Web 设计非常重要，可以帮助我们优化关键渲染路径。浏览器会阻塞渲染，直到它解析完全部的样式，但不会阻塞渲染它认为不会使用的样式，例如打印样式表。通过基于媒体查询将CSS分成多个文件，可以防止在下载未使用的CSS期间阻止渲染。为了创建非阻塞 CSS 链接，将不会立即使用的样式（例如打印样式）移动到单独的文件中，将 <link> 添加到 HTML 中，并添加媒体查询，在这种情况下说明它是打印样式表。

+
CSS 可以使用媒体查询将样式应用在特定条件下。媒体查询对于响应式 Web 设计非常重要，可以帮助我们优化关键渲染路径。浏览器会阻塞渲染，直到它解析完全部的样式，但不会阻塞渲染它认为不会使用的样式，例如打印样式表。通过基于媒体查询将 CSS 分成多个文件，可以防止在下载未使用的 CSS 期间阻止渲染。为了创建非阻塞 CSS 链接，将不会立即使用的样式（例如打印样式）移动到单独的文件中，将 <link> 添加到 HTML 中，并添加媒体查询，在这种情况下说明它是打印样式表。

 
 
<link rel="stylesheet" href="styles.css"> <!-- blocking -->
 <link rel="stylesheet" href="print.css" media="print"> <!-- not blocking -->
 <link rel="stylesheet" href="mobile.css" media="screen and (max-width: 480px)"> <!-- not blocking on large screens -->

 
-
默认情况下，浏览器假设每个指定的样式表都是阻塞渲染的。通过添加 media属性附加媒体查询，告诉浏览器何时应用样式表。当浏览器看到一个它知道只会用于特定场景的样式表时，它仍会下载样式，但不会阻塞渲染。通过将 CSS 分成多个文件，主要的 阻塞渲染 文件（本例中为 styles.css）的大小变得更小，从而减少了渲染被阻塞的时间。

+
默认情况下，浏览器假设每个指定的样式表都是阻塞渲染的。通过添加 media 属性附加媒体查询，告诉浏览器何时应用样式表。当浏览器看到一个它知道只会用于特定场景的样式表时，它仍会下载样式，但不会阻塞渲染。通过将 CSS 分成多个文件，主要的 阻塞渲染 文件（本例中为 styles.css）的大小变得更小，从而减少了渲染被阻塞的时间。

 
-
在GPU 上呈现动画

+
在 GPU 上呈现动画

 
-
浏览器针对处理CSS动画和不会很好地触发重排（因此也导致重新绘制）的动画属性进行了优化。为了提高性能，可以将被动画化的节点从主线程移到GPU上。将导致合成的属性包括 3D transforms (transform: translateZ(), rotate3d()，etc.)，animating transform 和 opacity, position: fixed，will-change，和 filter。一些元素，例如 <video>, <canvas> 和 <iframe>，也位于各自的图层上。 将元素提升为图层（也称为合成）时，动画转换属性将在GPU中完成，从而改善性能，尤其是在移动设备上。

+
浏览器针对处理 CSS 动画和不会很好地触发重排（因此也导致重新绘制）的动画属性进行了优化。为了提高性能，可以将被动画化的节点从主线程移到 GPU 上。将导致合成的属性包括 3D transforms (transform: translateZ(), rotate3d()，etc.)，animating transform 和 opacity, position: fixed，will-change，和 filter。一些元素，例如 <video>, <canvas> 和 <iframe>，也位于各自的图层上。 将元素提升为图层（也称为合成）时，动画转换属性将在 GPU 中完成，从而改善性能，尤其是在移动设备上。

 
 
will-change 属性

 
@@ -39,4 +39,4 @@ 
font-display 属性

 
 
contain 属性

 
-
CSS的 contain属性允许作者指示元素及其内容尽可能独立于文档树的其余部分。 这允许浏览器针对DOM的有限区域而不是整个页面重新计算布局，样式，绘画，大小或它们的任意组合。

+
CSS 的 contain属性允许作者指示元素及其内容尽可能独立于文档树的其余部分。这允许浏览器针对 DOM 的有限区域而不是整个页面重新计算布局，样式，绘画，大小或它们的任意组合。

diff --git a/files/zh-cn/learn/performance/index.html b/files/zh-cn/learn/performance/index.html
index d40e90da92b5a0..961d923b361dca 100644
--- a/files/zh-cn/learn/performance/index.html
+++ b/files/zh-cn/learn/performance/index.html
@@ -5,23 +5,23 @@
 ---
 
{{LearnSidebar}}

 
-
构建一个网站需要HTML、CSS和JavaScript。为了构建人们需要的、能吸引和留住用户的网站和应用，你需要创建一个良好的用户体验。良好用户体验的一部分是确保内容能够快速加载并响应用户交互。这就是所谓的web性能，在这个模块中，你将会学到构建性能良好的网站所需要的知识。

+
构建一个网站需要 HTML、CSS 和 JavaScript。为了构建人们需要的、能吸引和留住用户的网站和应用，你需要创建一个良好的用户体验。良好用户体验的一部分是确保内容能够快速加载并响应用户交互。这就是所谓的web 性能，在这个模块中，你将会学到构建性能良好的网站所需要的知识。

 
 
给初学者的学习材料的剩下部分主要关注于如何尽量提高性能和易用性等网络体验。但是，也需要特别关注这些话题，确保你熟悉他们。

 
 
学习方法

 
-
虽然了解HTML，CSS和Javascript是实现许多网页性能提升建议的必要条件，但了解如何构建应用却不是理解和衡量网页性能的必要先决条件。即便如此我们仍建议在通读此模块之前，你至少要过一遍我们的网页编程入门模块，对网页发展有一个基本认识。

+
虽然了解 HTML，CSS 和 Javascript 是实现许多网页性能提升建议的必要条件，但了解如何构建应用却不是理解和衡量网页性能的必要先决条件。即便如此我们仍建议在通读此模块之前，你至少要过一遍我们的网页编程入门模块，对网页发展有一个基本认识。

 
 
更深入进行以下主题也很有必要，这些模块包括

 
 
    
- 
  • HTML入门 
    • 
- 
  • CSS初步 
    • 
- 
  • Javascript初步 
    • 
+ 
  • HTML 入门 
    • 
+ 
  • CSS 初步 
    • 
+ 
  • Javascript 初步 
    • 
 

 
-
当你通读了这个部分之后，你或许特别想深入了解网页性能——你可以 在我们的主MDN网页性能章节找到更多教学，包括性能API的概览，测试和分析工具 ，以及性能瓶颈问题。

+
当你通读了这个部分之后，你或许特别想深入了解网页性能——你可以 在我们的主 MDN 网页性能章节找到更多教学，包括性能 API 的概览，测试和分析工具，以及性能瓶颈问题。

 
 
Introductory modules

 
diff --git a/files/zh-cn/learn/performance/perceived_performance/index.html b/files/zh-cn/learn/performance/perceived_performance/index.html
index 5ec25d2a29683d..621bf29de1e699 100644
--- a/files/zh-cn/learn/performance/perceived_performance/index.html
+++ b/files/zh-cn/learn/performance/perceived_performance/index.html
@@ -11,7 +11,7 @@
 
 
{{PreviousMenuNext("Learn/Performance/what_is_web_performance", "Learn/Performance/Measuring_performance", "Learn/Performance")}}

 
-
感知性能 是用户对网站速度的感受。 用户如何看待性能与任何客观统计数据一样重要，甚至更重要，但它是主观的，并且不易测量。感知性能是用户视角，而不是指标。

+
感知性能 是用户对网站速度的感受。用户如何看待性能与任何客观统计数据一样重要，甚至更重要，但它是主观的，并且不易测量。感知性能是用户视角，而不是指标。

 
 
本文简要介绍了感知性能，着眼于用户的感知，以及可以使用哪些客观工具来衡量这类主观因素。

 
@@ -23,7 +23,7 @@
   
   
    目标
-   基本了解用户对Web性能的看法。
+   基本了解用户对 Web 性能的看法。
   
  
 
@@ -58,13 +58,13 @@ 
提升感知性能

 
 
最小化初始加载

 
-
要提升可感知性能，请最小化页面初始加载。 换句话说，首先下载将实际显示的所有内容，但仅下载实际使用的内容，然后下载其余内容。 因为最终要下载所有资源，所以实际上资源总量并没有改善——实际上还需要增加一些代码。但因为暂不需要的资源被延后加载了，所以用户并不会感知资源量的增加，而会感受到页面加载更快了。 

+
要提升可感知性能，请最小化页面初始加载。换句话说，首先下载将实际显示的所有内容，但仅下载实际使用的内容，然后下载其余内容。因为最终要下载所有资源，所以实际上资源总量并没有改善——实际上还需要增加一些代码。但因为暂不需要的资源被延后加载了，所以用户并不会感知资源量的增加，而会感受到页面加载更快了。 

 
-
为了最大程度地减少初始加载资源，请从内容中分离交互式功能，以便优先加载初始化时所需的可见内容——文本、样式和图像。 延迟加载其余资源。

+
为了最大程度地减少初始加载资源，请从内容中分离交互式功能，以便优先加载初始化时所需的可见内容——文本、样式和图像。延迟加载其余资源。

 
 
不要加载初始页面未使用或看不到的图像或脚本，而在页面可用后延时加载，或在需要使用时按需加载。 在初始页面加载之后加载其他资源可提高感知性能。 在初始请求中加载基本数据，并仅根据需要逐步加载功能部件和数据，有助于改善低带宽和低规格硬件的体验。

 
-
此外，您应该优化需加载的资源。 图片和视频应以最佳格式、压缩后的大小和正确尺寸进行投放。

+
此外，您应该优化需加载的资源。图片和视频应以最佳格式、压缩后的大小和正确尺寸进行投放。

 
 
防止内容跳转和其他重排

 
@@ -84,7 +84,7 @@ 
交互类元素是可交互的

 
 
使任务启动器显得更具交互性

 
-
在按下按键而不是等待按键弹起时发出请求，可以使感知的内容加载减少200毫秒。在 KEYUP 后添加一个有趣但不显眼的200毫秒动画，甚至可以再降低200毫秒的加载感知。 您并没有节省400毫秒的时间，但是用户直到真正等待内容时，才感觉到他们在等待内容。

+
在按下按键而不是等待按键弹起时发出请求，可以使感知的内容加载减少 200 毫秒。在 KEYUP 后添加一个有趣但不显眼的 200 毫秒动画，甚至可以再降低 200 毫秒的加载感知。您并没有节省 400 毫秒的时间，但是用户直到真正等待内容时，才感觉到他们在等待内容。

 
 
总结

 
diff --git a/files/zh-cn/learn/performance/web_performance_basics/index.html b/files/zh-cn/learn/performance/web_performance_basics/index.html
index 4689bfa18a8de9..0044e4b81cc87e 100644
--- a/files/zh-cn/learn/performance/web_performance_basics/index.html
+++ b/files/zh-cn/learn/performance/web_performance_basics/index.html
@@ -3,20 +3,20 @@
 slug: learn/Performance/Web_Performance_Basics
 translation_of: Learn/Performance/Web_Performance_Basics
 ---
-
有很多的理由告诉你为什么你的网站需要尽可能好的性能。下面是关于最佳实践，工具，API以及链接的简明介绍，它为每个主题提供了更多的信息。意识到对用户来说什么是真正重要的也至关重要，他可能不是绝对意义上的时间而是用户感知的时间。

+
有很多的理由告诉你为什么你的网站需要尽可能好的性能。下面是关于最佳实践，工具，API 以及链接的简明介绍，它为每个主题提供了更多的信息。意识到对用户来说什么是真正重要的也至关重要，他可能不是绝对意义上的时间而是用户感知的时间。

 
 
最佳实践

 
 
    
  
  • 从学习浏览器的关键渲染路径开始。了解这些会帮助你通晓如何提升浏览器的性能。
    • 
  
  • 使用resource hints例如rel=preconnect, rel=dns-prefetch, rel=prefetch, and rel=preload
    • 
- 
  • 压缩Js代码至最小。只为当前页面加载需要使用到的js代码
    • 
+ 
  • 压缩 Js 代码至最小。只为当前页面加载需要使用到的 js 代码
    • 
  
  • CSS性能因素 
    • 
- 
  • 在你的服务器（或者CDN）上使用 HTTP/2协议
    • 
- 
  •  使用CDN托管静态资源，这样可以显著减少加载时间
    • 
+ 
  • 在你的服务器（或者 CDN）上使用 HTTP/2协议
    • 
+ 
  •  使用 CDN 托管静态资源，这样可以显著减少加载时间
    • 
  
  •  使用gzip, Brotli 或者 Zopfli压缩您的资源
    • 
- 
  •  图片优化（如果可以，尽可能使用css动画或者svg）
    • 
- 
  •  在超出应用视口范围的部分使用懒加载，如果你这么做了，为SEO制定一个后备计划（例如为bot traffic 渲染整个页面）
    • 
+ 
  •  图片优化（如果可以，尽可能使用 css 动画或者 svg）
    • 
+ 
  •  在超出应用视口范围的部分使用懒加载，如果你这么做了，为 SEO 制定一个后备计划（例如为 bot traffic 渲染整个页面）
    • 
 

 
 
工具

@@ -24,7 +24,7 @@ 
工具

 
    
  
  • 学习使用Firefox Dev Tools来分析您的网站。
    • 
  
  • Pagespeed Insights 可以分析您的页面并且给出一些通用的建议来提升网站性能。
    • 
- 
  • Lighthouse 可以给您一份有关您网站的包括性能，SEO和可访问性等多个方面的详细分类。
    • 
+ 
  • Lighthouse 可以给您一份有关您网站的包括性能，SEO 和可访问性等多个方面的详细分类。
    • 
  
  • 使用 Webpagetest.org检测页面在不同真实设备类型和地点时候的速度。trics.
    • 
  
  • 定义一个 绩效预算 （performance budget）。
    • 
 

diff --git a/files/zh-cn/learn/server-side/configuring_server_mime_types/index.html b/files/zh-cn/learn/server-side/configuring_server_mime_types/index.html
index 8fa29cf3ce8afb..f11b4dca042fab 100644
--- a/files/zh-cn/learn/server-side/configuring_server_mime_types/index.html
+++ b/files/zh-cn/learn/server-side/configuring_server_mime_types/index.html
@@ -8,11 +8,11 @@
 ---
 
Background

 
-
默认情况下，许多web服务器会为那些未知内容类型的文件配置一个默认MIME类型text/plain 或者application/octet-stream 。当一种新的内容类型被创造或者被添加到web服务器上，web管理者在添加它到web服务器配置中可能会失败。主要原因是用户使用Gecko-based 的浏览器，而这种浏览器只相信由web服务器和web应用所发布的MIME类型

+
默认情况下，许多 web 服务器会为那些未知内容类型的文件配置一个默认 MIME 类型text/plain 或者application/octet-stream 。当一种新的内容类型被创造或者被添加到 web 服务器上，web 管理者在添加它到 web 服务器配置中可能会失败。主要原因是用户使用 Gecko-based 的浏览器，而这种浏览器只相信由 web 服务器和 web 应用所发布的 MIME 类型

 
 
What are MIME types?

 
-
MIME类型描述了邮件或者web服务器或者web应用中的媒体内容的类型，其目的是为了指导web浏览器对媒体内容的处理和表现。MIME类型的示例如下：

+
MIME 类型描述了邮件或者 web 服务器或者 web 应用中的媒体内容的类型，其目的是为了指导 web 浏览器对媒体内容的处理和表现。MIME 类型的示例如下：

 
 
    
  
  • text/html  对于一般网页
    • 
@@ -26,71 +26,71 @@ 
    What are MIME type
 
 
    Technical Background
    
 
-
    完整的MIME类型列表可在 IANA | MIME Media Types 查看.
    
+
    完整的 MIME 类型列表可在 IANA | MIME Media Types 查看。
    
 
-
    在HTTP specification 中定义了能够描述在web中使用的媒体类型的MIME超集。
    
+
    在HTTP specification 中定义了能够描述在 web 中使用的媒体类型的 MIME 超集。
    
 
 
    Why are correct MIME types important?
    
 
-
    Example of an incorrect MIME type result 假如web服务器或者应用报告内容的MIME类型不正确，根据HTTP规范，或许发起人想要处理和显示内容通过他所规定的MIME类型，因此web浏览器无法采取任何措施。
    
+
    Example of an incorrect MIME type result 假如 web 服务器或者应用报告内容的 MIME 类型不正确，根据 HTTP 规范，或许发起人想要处理和显示内容通过他所规定的 MIME 类型，因此 web 浏览器无法采取任何措施。
    
 
-
    对于某些浏览器，例如IE，它尝试允许web服务器对于错误配置通过其源码猜测它可能的正确MIME类型。
    
+
    对于某些浏览器，例如 IE，它尝试允许 web 服务器对于错误配置通过其源码猜测它可能的正确 MIME 类型。
    
 
-
    这种做法将会避免许多由web管理员他们的错误。因为当内容的MIME类型错误，IE将会用可能正确的MIME类型来继续处理内容。例如你设置一个img的类型为text/plain ,IE可能会设置它为正确的MIME类型images/*
    
+
    这种做法将会避免许多由 web 管理员他们的错误。因为当内容的 MIME 类型错误，IE 将会用可能正确的 MIME 类型来继续处理内容。例如你设置一个img的类型为text/plain ,IE 可能会设置它为正确的 MIME 类型images/*
    
 
-
    出于安全原因，使用正确的MIME类型的服务内容也是重要的； 恶意内容可能会影响用户的计算机，假装它是一个安全类型文档，实际上不是。
    
+
    出于安全原因，使用正确的 MIME 类型的服务内容也是重要的；恶意内容可能会影响用户的计算机，假装它是一个安全类型文档，实际上不是。
    
 
 
    
-
    注意: 从历史角度, 只要HTML文档请求处理CSS文件 ，Firefox 能够正常加载CSS即使它设置了错误的MIME类型。处于安全原因, {{ gecko("2.0") }} 对于从请求文档不同来源加载的样式表，将不再这样做。如果CSS来自于不同来源，你必须设置它的正确MIME类型 (text/css).
    
+
    注意： 从历史角度，只要 HTML 文档请求处理 CSS 文件，Firefox 能够正常加载 CSS 即使它设置了错误的 MIME 类型。处于安全原因，{{ gecko("2.0") }} 对于从请求文档不同来源加载的样式表，将不再这样做。如果 CSS 来自于不同来源，你必须设置它的正确 MIME 类型 (text/css).
    
 
-
    Gecko 1.9.1.11 (Firefox 3.5.11) 和 Gecko 1.9.2.5 (Firefox 3.6.5) 同样实施这种安全措施，但是提高它的实用性。如果样式表中的第一行看起来是一个很好的CSS构造，则存在允许加载的临时启发式算法。在Firefox 4中已经删除了启发式，您必须正确设置text/css 的MIME类型，才能够识别CSS。
    
+
    Gecko 1.9.1.11 (Firefox 3.5.11) 和 Gecko 1.9.2.5 (Firefox 3.6.5) 同样实施这种安全措施，但是提高它的实用性。如果样式表中的第一行看起来是一个很好的 CSS 构造，则存在允许加载的临时启发式算法。在 Firefox 4 中已经删除了启发式，您必须正确设置text/css 的 MIME 类型，才能够识别 CSS。
    
 
    
 
 
    为何浏览器不应该猜测 MIME 类型
    
 
-
    除了违返了HTTP规范，让浏览器去猜测正确的MIME类型是一个差劲的策略。原因如下
    
+
    除了违返了 HTTP 规范，让浏览器去猜测正确的 MIME 类型是一个差劲的策略。原因如下
    
 
 
    失去控制
    
 
-
    假如浏览器忽略报告的MIME类型，web管理员和用户不在对内容如何进行处理有发言权了。
    
+
    假如浏览器忽略报告的 MIME 类型，web 管理员和用户不在对内容如何进行处理有发言权了。
    
 
-
    例如，面对web开发员的网址可能希望发送某些实例HTML文档，同时通希望能够以 text/html或者 text/plain 的MIME类型进行数据的处理和显示 或者 作为一个源代码。如果浏览器猜测它的正确MIME类型为 text/html 那么开发员不在有权利进行选择了。
    
+
    例如，面对 web 开发员的网址可能希望发送某些实例 HTML 文档，同时通希望能够以 text/html或者 text/plain 的 MIME 类型进行数据的处理和显示 或者 作为一个源代码。如果浏览器猜测它的正确 MIME 类型为 text/html 那么开发员不在有权利进行选择了。
    
 
 
    安全性
    
 
-
    一些内容类型，例如可执行程序，本质上是不安全的。原因是经过规范化的MIME类型都有经过严格规定浏览器如何对这类类型的文件进行操作。一个可执行程序不能够在用户的电脑浏览器上执行，但可以通过弹出会话询问是否下载这个文件
    
+
    一些内容类型，例如可执行程序，本质上是不安全的。原因是经过规范化的 MIME 类型都有经过严格规定浏览器如何对这类类型的文件进行操作。一个可执行程序不能够在用户的电脑浏览器上执行，但可以通过弹出会话询问是否下载这个文件
    
 
-
    MIME类型猜测导致IE浏览器的安全漏洞（通过利用IE能够将错误的MIME类型 修改为正确的类型）。这绕过了正常的下载对话框，导致InternetExplorer猜测内容是可执行程序，然后在用户的计算机上运行。
    
+
    MIME 类型猜测导致 IE 浏览器的安全漏洞（通过利用 IE 能够将错误的 MIME 类型 修改为正确的类型）。这绕过了正常的下载对话框，导致 InternetExplorer 猜测内容是可执行程序，然后在用户的计算机上运行。
    
 
 
    如何确定服务器发送内容的 MIME 类型
    
 
-
    通过开发者工具的 ContentType 查看MIME类型。
    
+
    通过开发者工具的 ContentType 查看 MIME 类型。
    
 
-
    根据标准，通过一个 meta 标签来设置MIME类型 例如 <meta http-equiv="Content-Type" content="text/html"> 当包含{{HTTPHeader("Content-Type")}} 时则忽略 meta 标签
    
+
    根据标准，通过一个 meta 标签来设置 MIME 类型 例如 <meta http-equiv="Content-Type" content="text/html"> 当包含{{HTTPHeader("Content-Type")}} 时则忽略 meta 标签
    
 
 
 
 
    如何为你的内容确定正确的 MIME 类型
    
 
-
    这里有几种方法来确定文件的正确MIME类型
    
+
    这里有几种方法来确定文件的正确 MIME 类型
    
 
 
      
- 
    1. 如果你的内容是通过供应商软件应用创建的，那么你可以阅读供应商文档确认不同媒体文件的MIME值
      2. 
- 
    2. 通过查看完整的MIME类型表 IANA | MIME Media Types registry 
      3. 
- 
    3. 如果使用插件netscape gecko显示媒体类型，请安装插件，然后查看“帮助”>“关于插件”菜单，以查看哪些MIME类型与媒体类型相关联。
      4. 
- 
    4. 搜索文件扩展名 FILExt 或者File extensions reference ，确认扩展名和哪种类型的MIME相关联
      5. 
+ 
    5. 如果你的内容是通过供应商软件应用创建的，那么你可以阅读供应商文档确认不同媒体文件的 MIME 值
      6. 
+ 
    6. 通过查看完整的 MIME 类型表 IANA | MIME Media Types registry 
      7. 
+ 
    7. 如果使用插件 netscape gecko 显示媒体类型，请安装插件，然后查看“帮助”>“关于插件”菜单，以查看哪些 MIME 类型与媒体类型相关联。
      8. 
+ 
    8. 搜索文件扩展名 FILExt 或者File extensions reference ，确认扩展名和哪种类型的 MIME 相关联
      9. 
 
    
 
-
    如何设置服务器以发送正确的MIME类型
    
+
    如何设置服务器以发送正确的 MIME 类型
    
 
-
    基本的方法是配置你的服务器发送正确的HTTP ContentType类型给每个文档
    
+
    基本的方法是配置你的服务器发送正确的 HTTP ContentType类型给每个文档
    
 
 
      
- 
    • 如果您正在使用Apache Web服务器，只需将此示例.htaccess文件复制到包含要使用正确MIME类型发送的文件的目录中。 如果你有一个完整的文件子目录，只需将文件放在父目录中；您不需要将它放在每个子目录中。
      • 
- 
    • 如果您使用的是Microsoft IIS, 请参阅IANA | MIME Media Types registry这篇文章。
      • 
- 
    • 如果您使用服务器端脚本生成内容，通常可以在脚本顶部附近添加一行。 您可以从Perl，PHP，ASP或Java提供HTML以外的内容 - 只需相应地更改MIME类型即可。
+ 
    • 如果您正在使用 Apache Web 服务器，只需将此示例.htaccess 文件复制到包含要使用正确 MIME 类型发送的文件的目录中。如果你有一个完整的文件子目录，只需将文件放在父目录中；您不需要将它放在每个子目录中。
      • 
+ 
    • 如果您使用的是 Microsoft IIS, 请参阅IANA | MIME Media Types registry这篇文章。
      • 
+ 
    • 如果您使用服务器端脚本生成内容，通常可以在脚本顶部附近添加一行。您可以从 Perl，PHP，ASP 或 Java 提供 HTML 以外的内容 - 只需相应地更改 MIME 类型即可。
   
        
-   
      • 对于 Perl CGI，你应该在文档其他行之前输出 print "Content-Type: text/html\n\n";。如果您正在使用CGI模块, 你可以使用 print $cgi->header('text/html');  代替, 其中 $cgi 是对CGI实例的引用。
        • 
+   
      • 对于 Perl CGI，你应该在文档其他行之前输出 print "Content-Type: text/html\n\n";。如果您正在使用 CGI 模块，你可以使用 print $cgi->header('text/html');  代替，其中 $cgi 是对 CGI 实例的引用。
        • 
    
      • 对于 PHP，你应该在文档其他行之前输出 header('Content-Type: text/html');。
        • 
    
      • 对于 ASP, 你应该在文档其他行之前输出response.ContentType = "text/html";。
        • 
    
      • 对于 Java servlet, 你需要在doGet 或 doPost 方法之前输出response.setContentType("text/html"); ，其中 response 是对 HttpServletResponse的引用。
        • 
diff --git a/files/zh-cn/learn/server-side/django/admin_site/index.html b/files/zh-cn/learn/server-side/django/admin_site/index.html
index 0be09f634a4d01..19b80c4b240203 100644
--- a/files/zh-cn/learn/server-side/django/admin_site/index.html
+++ b/files/zh-cn/learn/server-side/django/admin_site/index.html
@@ -8,16 +8,16 @@
 
 
        {{PreviousMenuNext("Learn/Server-side/Django/Models", "Learn/Server-side/Django/Home_page", "Learn/Server-side/Django")}}
        
 
-
        好了，我们已经为本地图书馆网站 LocalLibrary 创建了模型，我们接下来使用 Django 管理站点去添加 一些 “真“书数据。首先我们展示如何用管理站点注册模型，然后展示如何登录和创建一些数据。本文最后，我们介绍你可以进一步改进管理站点的建议。
        
+
        好了，我们已经为本地图书馆网站 LocalLibrary 创建了模型，我们接下来使用 Django 管理站点去添加 一些“真“书数据。首先我们展示如何用管理站点注册模型，然后展示如何登录和创建一些数据。本文最后，我们介绍你可以进一步改进管理站点的建议。
        
 
 
-   
+   
-   
+   
@@ -27,15 +27,15 @@
 
 
        综述
        
 
-
        Django管理应用程序可以使用您的模型自动构建可用于创建，查看，更新和删除记录的站点区域。这可以在开发过程中节省大量的时间，从而很容易测试您的模型，并了解您是否拥有正确的数据。根据网站的类型，管理应用程序也可用于管理生产中的数据。Django项目建议仅用于内部数据管理（即仅供管理员或组织内部人员使用），因为以模型为中心的方法不一定是所有用户最好的界面，并且暴露了大量不必要的细节关于模型。
        
+
        Django 管理应用程序可以使用您的模型自动构建可用于创建，查看，更新和删除记录的站点区域。这可以在开发过程中节省大量的时间，从而很容易测试您的模型，并了解您是否拥有正确的数据。根据网站的类型，管理应用程序也可用于管理生产中的数据。Django 项目建议仅用于内部数据管理（即仅供管理员或组织内部人员使用），因为以模型为中心的方法不一定是所有用户最好的界面，并且暴露了大量不必要的细节关于模型。
        
 
-
        创建基础项目时，自动完成所有将您的网站中的管理应用程序包含在内的配置文件 （有关所需实际依赖关系的信息  (如有需要请看 Django docs here). 其结果是，你必须做你的模型添加到管理应用程序是  注册  他们。在本文末尾，我们将简要介绍如何进一步配置管理区域以更好地显示我们的模型数据。
        
+
        创建基础项目时，自动完成所有将您的网站中的管理应用程序包含在内的配置文件（有关所需实际依赖关系的信息  (如有需要请看 Django docs here). 其结果是，你必须做你的模型添加到管理应用程序是  注册  他们。在本文末尾，我们将简要介绍如何进一步配置管理区域以更好地显示我们的模型数据。
        注册模型后，我们将展示如何创建一个新的“超级用户”，登录到该网站，并创建一些书籍，作者，书籍实例和流派。这些将有助于测试我们将在下一个教程中开始创建的视图和模板。
        注册模型
        
 
-
        首先，在目录应用程序(/locallibrary/catalog/admin.py)中打开 admin.py 。此时此刻它看起来像这样—注意它已经导入了django.contrib.admin：
        
+
        首先，在目录应用程序 (/locallibrary/catalog/admin.py) 中打开 admin.py 。此时此刻它看起来像这样—注意它已经导入了 django.contrib.admin：
        from django.contrib import admin
 
@@ -52,7 +52,7 @@ 
        注册模型
        
 admin.site.register(BookInstance)
 
        
 
-
        注意: 如果你接受创建模型以表示书籍的自然语言的挑战(see the models tutorial article), 导入并注册。
        
+
        注意: 如果你接受创建模型以表示书籍的自然语言的挑战 (see the models tutorial article), 导入并注册。
        这是在网站上注册模型或多模型的简单方法，管理站点是高度可定制的，我们将进一步讨论注册模型的其他方式。
        
 
@@ -86,14 +86,14 @@ 
        登入并使用该网站
        Admin Site - Book Add
        
-
        注意: 在这里，我们希望你花费一点时间添加一些书，作者，类型（如: 幻想）到你的应用。确保每个作者和类型都包含几本不同的书籍（这会是你的列表和详细视图在文章系列中后期使用时更有趣）。
        
+
        注意: 在这里，我们希望你花费一点时间添加一些书，作者，类型（如：幻想）到你的应用。确保每个作者和类型都包含几本不同的书籍（这会是你的列表和详细视图在文章系列中后期使用时更有趣）。
        
 
        我们完成添加书籍，在顶部标签中，点击 Home 链接将回到主管理页面。然后点击 Books 链接显示当前书籍的列表（或其他链接之一，以查看其他型号列表）。现在你已经添加了几本书，列表可能与下面的截图类似。显示每本书的标题；这是书模型 __str__() 方法返回的值，在上一文章中提到。
        Admin Site - List of book objects
        
 
-
        从该列表中，您可以通过选中不需要的图书旁边的复选框来删除图书，从“ 操作”下拉列表中选择“ 删除”操作  ，然后按Go按钮。您也可以通过按下ADD BOOK按钮添加新书。
        
+
        从该列表中，您可以通过选中不需要的图书旁边的复选框来删除图书，从“操作”下拉列表中选择“删除”操作  ，然后按 Go 按钮。您也可以通过按下 ADD BOOK 按钮添加新书。
        您可以通过在链接中选择其名称来编辑书籍。一本书的编辑页面如下所示，与“添加”页面几乎相同。主要的区别是页面标题（更改书）和添加  删除，历史和VIEW ON SITE按钮（最后一个按钮出现，因为我们定义了get_absolute_url()我们的模型中的  方法）。
        
 
@@ -101,13 +101,13 @@ 
        登入并使用该网站
        现在回到主页（使用主页链接的导航痕迹），然后查看作者  和类型  列表 - 您应该已经有很多创建从添加新书，但可以自由添加一些更多。
        
 
-
        你不会有任何书籍实例，因为这些不是从图书创建的（虽然你可以从 BookInstance - 创建一个书  - 这是ForeignKey字段的性质）。返回主页，然后按关联的添加按钮显示下面的添加书实例屏幕。请注意，全球唯一的ID，可用于单独标识库中单书的副本。
        
+
        你不会有任何书籍实例，因为这些不是从图书创建的（虽然你可以从 BookInstance - 创建一个书  - 这是 ForeignKey 字段的性质）。返回主页，然后按关联的添加按钮显示下面的添加书实例屏幕。请注意，全球唯一的 ID，可用于单独标识库中单书的副本。
        Admin Site - BookInstance Add
        为你的书创建一些记录。将状态设置为可用于至少一些记录，并为其他记录贷款。如果状态 不可 用，则还设置未来到期日期。
        
 
-
        而已！您现在已经学会了如何 设置和使用管理站点。您还创建书的记录，BookInstance，Genre，和Author 我们就可以一次我们创造我们自己的观点和模板使用。
        
+
        而已！您现在已经学会了如何 设置和使用管理站点。您还创建书的记录，BookInstance，Genre，和 Author 我们就可以一次我们创造我们自己的观点和模板使用。
        高级配置
        
 
@@ -122,7 +122,7 @@ 
        高级配置
        你可以进一步自定义界面，使它更容易使用，你可以改进的一些想法：
          
- 
        • 视图列表:
+ 
        • 视图列表：
   
            
    
          • 添加每个记录显示的其他字段/信息
            • 
    
          • 添加过滤器以根据日期或某些其他选择值（例如图书货款状态）选择列出哪些记录。
            • 
@@ -137,7 +137,7 @@ 
            高级配置
            
  
 
          
 
-
          在本节中，我们将看一些改进本地图书馆界面的更改，其中包括添加更多信息Book和Author 模型列表，以及改进编辑视图的布局。我们不会改变 Language 和 Genre 模拟演示，因为它们只有一个字段，所以这样没有真正的好处。
          
+
          在本节中，我们将看一些改进本地图书馆界面的更改，其中包括添加更多信息 Book 和 Author 模型列表，以及改进编辑视图的布局。我们不会改变 Language 和 Genre 模拟演示，因为它们只有一个字段，所以这样没有真正的好处。
          
 
 
          你可以 在The Django Admin site 中找到所以管理员网站自定义选项的完整参考。
          
 
@@ -145,7 +145,7 @@ 
          注册 一个 ModelAdmin 类
          
 
 
          在管理界面去改变一个模型的展示方式，当你定义了 ModelAdmin 类（描述布局）和将其注册到模型中。
          
 
-
          让我们开始作者模型。打开 admin.py 在目录应用程序(/locallibrary/catalog/admin.py)。注释你的原始注册（前缀为#）在 Author 模型
          
+
          让我们开始作者模型。打开 admin.py 在目录应用程序 (/locallibrary/catalog/admin.py)。注释你的原始注册（前缀为#）在 Author 模型
          
 
 
          # admin.site.register(Author)
          
 
@@ -179,7 +179,7 @@ 
          注册 一个 ModelAdmin 类
          
     pass
 
 
-
          可以看到我们现在 的 类都是空的 （“pass”），所以管理操作并不会改变，我们现在对这些类进行扩展，以定义我们针对模型的管理行为。
          
+
          可以看到我们现在 的 类都是空的（“pass”），所以管理操作并不会改变，我们现在对这些类进行扩展，以定义我们针对模型的管理行为。
          
 
 
          配置列表视图
          
 
@@ -195,19 +195,19 @@ 
          配置列表视图
          
 
 
          Admin Site - Improved Author List
          
 
-
          对于我们的Book模型，我们将另外显示author和genre。这author是一个ForeignKey字段（一对多）的关系，所以将由__str()__相关记录的值表示。用BookAdmin下面的版本替换课程。
          
+
          对于我们的 Book 模型，我们将另外显示author和genre。这 author 是一个ForeignKey字段（一对多）的关系，所以将由__str()__相关记录的值表示。用BookAdmin下面的版本替换课程。
          
 
 
          class BookAdmin(admin.ModelAdmin):
     list_display = ('title', 'author', 'display_genre')
 
          
 
-
          不幸的是，我们不能直接指定 list_display 中的 genre 字段， 因为它是一个ManyToManyField （Django可以防止这种情况，因为在这样做时会有大量的数据库访问“成本”）。相反，我们将定义一个 display_genre 函数来获取信息作为一个字符串（这是我们上面调用的函数;下面我们将定义它）。
          
+
          不幸的是，我们不能直接指定 list_display 中的 genre 字段，因为它是一个ManyToManyField （Django 可以防止这种情况，因为在这样做时会有大量的数据库访问“成本”）。相反，我们将定义一个 display_genre 函数来获取信息作为一个字符串（这是我们上面调用的函数;下面我们将定义它）。
          
 
 
          
-
          注意：在genre这里获取可能不是一个好主意，因为数据库操作的“成本”。我们向您展示了如何在模型中调用函数的其他原因非常有用 - 例如在列表中的每个项目旁边添加一个“ 删除”链接。
          
+
          注意：在genre这里获取可能不是一个好主意，因为数据库操作的“成本”。我们向您展示了如何在模型中调用函数的其他原因非常有用 - 例如在列表中的每个项目旁边添加一个“删除”链接。
          
 
          
 
-
          将以下代码添加到Book模型（models.py）中。这将从 genre字段的前三个值（如果存在）创建一个字符串，并创建一个short_description可以在此方法的管理站点中使用的字符串。
          
+
          将以下代码添加到 Book 模型（models.py）中。这将从 genre 字段的前三个值（如果存在）创建一个字符串，并创建一个short_description可以在此方法的管理站点中使用的字符串。
          
 
 
              def display_genre(self):
         """
@@ -221,10 +221,10 @@ 
          配置列表视图
          
 
 
          Admin Site - Improved Book List
          
 
-
          该Genre模型（和Language模式，如果你定义一个）都有一个单一的领域，所以没有一点为他们创造更多的显示领域的附加模型。
          
+
          该 Genre 模型（和 Language 模式，如果你定义一个）都有一个单一的领域，所以没有一点为他们创造更多的显示领域的附加模型。
          
 
 
          
-
          注意：值得更新BookInstance模型列表，至少显示状态和预期的返回日期。我们已经补充说，作为本文末尾的挑战！
          
+
          注意：值得更新 BookInstance 模型列表，至少显示状态和预期的返回日期。我们已经补充说，作为本文末尾的挑战！
          
 
          
 
 
          添加列表过滤器
          
@@ -244,7 +244,7 @@ 
          整理细节视图布局
          
 
          默认情况下，详细视图按照其在模型中声明的顺序垂直排列所有字段。您可以更改声明的顺序，哪些字段显示（或排除），区段是否用于组织信息，字段是水平还是垂直显示，甚至是管理窗体中使用的编辑窗口小部件。
          
 
 
          
-
          注意：LocalLibrary模型比较简单，因此我们不需要更改布局; 不管怎样，我们会做一些改变，只是为了向你展示如何。
          
+
          注意：LocalLibrary 模型比较简单，因此我们不需要更改布局; 不管怎样，我们会做一些改变，只是为了向你展示如何。
          
 
          
 
 
          控制哪些字段被显示和布局
          
@@ -285,7 +285,7 @@ 
          剖切细节视图
          
         }),
     )
          
 
-
          每个部分都有自己的标题（或者None如果你不想要一个标题）和字典中的一个相关的元组 - 描述的格式很复杂，但是如果你看上面的代码片段，那么它们很容易理解。
          
+
          每个部分都有自己的标题（或者 None 如果你不想要一个标题）和字典中的一个相关的元组 - 描述的格式很复杂，但是如果你看上面的代码片段，那么它们很容易理解。
          
 
 
          重新启动并导航到书籍实例视图; 表格应如下所示：
          
 
@@ -295,7 +295,7 @@ 
          关联记录的内联编辑
          
 
 
          有时，可以同时添加关联记录是有意义的。例如，将书籍信息和有关您在同一详细信息页面上的特定副本的信息同时显示可能是有意义的。
          
 
-
          你可以通过声明 inlines, 类型 TabularInline (水平布局 ) or StackedInline (垂直布局 ，就像默认布局)这样做. 您可以通过在您的以下的粗体中添加以下行，将内容中的BookInstance信息添加到我们的Book详细信息中BookAdmin：
          
+
          你可以通过声明 inlines, 类型 TabularInline (水平布局 ) or StackedInline (垂直布局，就像默认布局) 这样做。您可以通过在您的以下的粗体中添加以下行，将内容中的BookInstance信息添加到我们的 Book 详细信息中BookAdmin：
          
 
 
          class BooksInstanceInline(admin.TabularInline):
     model = BookInstance
@@ -313,15 +313,15 @@ 
          关联记录的内联编辑
          
 
          在这种情况下，我们所做的就是声明我们的tablular内联类，它只是从内联模型添加所有字段。您可以为布局指定各种附加信息，包括要显示的字段，其顺序，是否只读等。（有关详细信息，请参阅  TabularInline ). 
          
 
 
          
-
          注意：这个功能有一些痛苦的限制！在上面的屏幕截图中，我们有三个现有的书籍实例，其次是新的书籍实例的三个占位符（看起来非常相似！）。默认情况下没有备用书实例会更好，只需使用“ 添加另一个书”实例链接添加它们，或者可以BookInstance从这里列出作为不可读的链接。第一个选项可以通过extra在BookInstanceInline模型中将属性设置为0 来完成，自己尝试一下。
          
+
          注意：这个功能有一些痛苦的限制！在上面的屏幕截图中，我们有三个现有的书籍实例，其次是新的书籍实例的三个占位符（看起来非常相似！）。默认情况下没有备用书实例会更好，只需使用“添加另一个书”实例链接添加它们，或者可以BookInstance从这里列出作为不可读的链接。第一个选项可以通过extra在BookInstanceInline模型中将属性设置为 0 来完成，自己尝试一下。
          
 
          
 
 
          挑战自己
          
 
 
          我们在本节学到了很多东西，所以现在是时候尝试一些事情了。
          
 
-
          1. 对于  BookInstance列表视图，添加代码以显示书籍，状态，到期日期和ID（而不是默认__str__()文本）。
          
- 2. 添加的在线上市Book项目的Author使用，因为我们做了同样的做法详细视图Book/ BookInstance。
          
+
          1. 对于  BookInstance列表视图，添加代码以显示书籍，状态，到期日期和 ID（而不是默认__str__()文本）。
          
+ 2. 添加的在线上市 Book 项目的 Author 使用，因为我们做了同样的做法详细视图Book/ BookInstance。
          
 
 
          概要
          
 
diff --git a/files/zh-cn/learn/server-side/django/authentication/index.html b/files/zh-cn/learn/server-side/django/authentication/index.html
index fddcbdce25d70a..fdb575c628bf28 100644
--- a/files/zh-cn/learn/server-side/django/authentication/index.html
+++ b/files/zh-cn/learn/server-side/django/authentication/index.html
@@ -12,11 +12,11 @@
 
        
  
   
        前提:前提：
    完成: Django Tutorial Part 3: 使用模型。
   
        
   
        目的:目的：
    
     
        了解关于管理站点的优点与缺点，并且可以使用它为我们模型创建一些记录。
        
            		
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        
-   
+   
-   
+   
@@ -27,18 +27,18 @@ 
        概观
        Django 提供了一个身份验证和授权（“权限”）系统，该系统构建在上一个教程中讨论的会话框架之上，允许您验证用户凭据，并定义每个用户可允许执行的操作。该框架包括用户Users和分组Groups的内置模型（一次向多个用户应用权限的通用方法），用于登录用户的权限/标志，以指定用户是否可以执行任务，表单和视图，以及查看限制内容的工具。
        
-
        注意: Django身份验证系统的目标非常通用，因此不提供其他Web身份验证系统中，所提供的某些功能。某些常见问题的解决方案，可作为第三方软件包提供。例如，限制登录尝试，和针对第三方的身份验证（例如 OAuth）。
        
+
        注意: Django 身份验证系统的目标非常通用，因此不提供其他 Web 身份验证系统中，所提供的某些功能。某些常见问题的解决方案，可作为第三方软件包提供。例如，限制登录尝试，和针对第三方的身份验证（例如 OAuth）。
        
 
        在本教程中，我们将向您展示，如何在LocalLibrary网站中，启用用户身份验证，创建您自己的登录和注销页面，为模型添加权限，以及控制对页面的访问。我们将使用身份验证/权限，来显示用户和图书馆员借用图书的列表。
        
 
-
        身份验证系统非常灵活，您可以根据需要，从头开始构建 URLs，表单，视图和模板，只需调用提供的API，即可登录用户。但是，在本文中，我们将在登录和注销页面，使用 Django 的“库存” 身份验证视图和表单。我们仍然需要创建一些模板，但这很简单。
        
+
        身份验证系统非常灵活，您可以根据需要，从头开始构建 URLs，表单，视图和模板，只需调用提供的 API，即可登录用户。但是，在本文中，我们将在登录和注销页面，使用 Django 的“库存”身份验证视图和表单。我们仍然需要创建一些模板，但这很简单。
        我们还将向您展示如何创建权限，以及检查视图和模板中的登录状态和权限。
        启用身份验证
        
 
-
        我们在创建框架网站时（在教程2中），自动启用了身份验证，因此您此时，无需再执行任何操作。
        
+
        我们在创建框架网站时（在教程 2 中），自动启用了身份验证，因此您此时，无需再执行任何操作。
        
 
        注意: 当我们使用 django-admin startproject 命令，以创建应用程序时，所有必要的配置都已完成。当我们第一次调用 python manage.py migrate 时，创建了用户和模型权限的数据库表。
        
@@ -81,14 +81,14 @@ 
        创建用户和分组
        
 
 
        下面，我们首先创建一个分组，然后创建一个用户。即使我们还没有为我们的图书馆成员添加任何权限，如果我们以后需要，将它们添加到分组中，要比单独添加到每个成员要容易得多。
        
 
-
        启动开发服务器，并到本地 Web 浏览器中的管理站点（http://127.0.0.1:8000/admin/）。使用超级用户帐户的凭据，登录该站点。 Admin 站点的最上级显示所有模型，按 “django application” 排序。在 “身份验证和授权” Authentication and Authorisation 部分 ，您可以单击用户 Users ，或分组 Groups 链接，以查看其现有记录。
        
+
        启动开发服务器，并到本地 Web 浏览器中的管理站点（http://127.0.0.1:8000/admin/）。使用超级用户帐户的凭据，登录该站点。Admin 站点的最上级显示所有模型，按“django application”排序。在“身份验证和授权” Authentication and Authorisation 部分，您可以单击用户 Users ，或分组 Groups 链接，以查看其现有记录。
        
 
 
        Admin site - add groups or users
        
 
 
        首先，我们为图书馆成员，创建一个新的分组。
        
 
 
          
- 
        1. 单击“添加” Add 按钮（“分组” Group 旁边）以创建新的分组；在分组的名称 Name ，输入“Library Members”。Admin site - add group
          2. 
+ 
        2. 单击“添加” Add 按钮（“分组”Group 旁边）以创建新的分组；在分组的名称 Name ，输入“Library Members”。Admin site - add group
          3. 
  
        3. 我们不需要该组的任何权限，因此只需按SAVE（您将进入分组列表）。
          4. 
 
        
 
@@ -101,13 +101,13 @@ 
        创建用户和分组
        
  
      • 按 SAVE 创建用户。
   
         
        
 
-  
        管理站点将创建新用户，并立即转到 “更改用户” 屏幕，您可以在其中更改用户名（username），并添加用户模型的可选字段的信息。这些字段包括名字，姓氏，电子邮件地址，用户状态和权限（仅应设置活动标志 Active）。再往下，您可以指定用户的分组和权限，并查看与用户相关的重要日期（例如，他们的加入日期和上次登录日期）。
        
+  
        管理站点将创建新用户，并立即转到“更改用户”屏幕，您可以在其中更改用户名（username），并添加用户模型的可选字段的信息。这些字段包括名字，姓氏，电子邮件地址，用户状态和权限（仅应设置活动标志 Active）。再往下，您可以指定用户的分组和权限，并查看与用户相关的重要日期（例如，他们的加入日期和上次登录日期）。
        
   Admin site - add user pt2
        • 
  
      • 在“分组”（Groups）部分中，从“可用分组”（Available groups）列表中，选择“图书馆成员”分组 Library Member，然后点击这些框之间的右箭头，将其移动到“选择的分组”（Chosen groups）框中。Admin site - add user to group
        • 
  
      • 我们不需要在此处执行任何其他操作，因此只需再次选择 SAVE ，即可转到用户列表。
        • 
 
 
-
        就是这样！现在您有一个 “普通的图书馆成员” 帐户，您可以使用该帐户进行测试（一旦我们实现了页面，使他们能够登录）。
        
+
        就是这样！现在您有一个“普通的图书馆成员”帐户，您可以使用该帐户进行测试（一旦我们实现了页面，使他们能够登录）。
        
 
 
        
 
        注意: 您应该尝试创建另一个图书馆用户。此外，为图书馆管理员创建一个分组，并添加一个用户！
        
@@ -115,7 +115,7 @@ 
        创建用户和分组
        
 
 
        设置身份验证视图
        
 
-
        Django 提供了创建身份验证页面所需的几乎所有功能，让处理登录，注销和密码管理等工作，都能 “开箱即用”。这些相关功能包括了 url 映射器，视图和表单，但它不包括模板 - 我们必须创建自己的模板！
        
+
        Django 提供了创建身份验证页面所需的几乎所有功能，让处理登录，注销和密码管理等工作，都能“开箱即用”。这些相关功能包括了 url 映射器，视图和表单，但它不包括模板 - 我们必须创建自己的模板！
        
 
 
        在本节中，我们将展示如何将默认系统，集成到 LocalLibrary 网站并创建模板。我们将它们放在主项目的 URL 当中。
        
 
@@ -124,7 +124,7 @@ 
        设置身份验证视图
        
 
        
 
 
        
-
        注意: 在这种情况下，我们可以合理地将认证页面（包括URL和模板）放在我们的目录应用程序中。但是，如果我们有多个应用程序，最好将这个共享登录行为分开，并让它在整个站点上可用，这就是我们在这里展示的内容！
        
+
        注意：在这种情况下，我们可以合理地将认证页面（包括 URL 和模板）放在我们的目录应用程序中。但是，如果我们有多个应用程序，最好将这个共享登录行为分开，并让它在整个站点上可用，这就是我们在这里展示的内容！
        
 
        
 
 
        项目网址
        
@@ -140,10 +140,10 @@ 
        项目网址
        
 ]
 
 
-
        打开 URL http://127.0.0.1:8000/accounts/ （注意前面的斜杠！），Django将显示一个错误，它无法找到此URL，并列出它尝试过的所有URL。从中您可以看到可以使用的URL，例如：
        
+
        打开 URL http://127.0.0.1:8000/accounts/ （注意前面的斜杠！），Django 将显示一个错误，它无法找到此 URL，并列出它尝试过的所有 URL。从中您可以看到可以使用的 URL，例如：
        
 
 
        
-
        注意: 使用上面的方法，添加以下带有方括号中的名称的 URL，可用于反转 URL 映射。您不必实现任何其他内容 - 上面的 url 映射，会自动映射下面提到的URL。
        
+
        注意：使用上面的方法，添加以下带有方括号中的名称的 URL，可用于反转 URL 映射。您不必实现任何其他内容 - 上面的 url 映射，会自动映射下面提到的 URL。
        
 
        
 
 
        
@@ -171,7 +171,7 @@ 
        模板目录
        
 
        对于此站点，我们将 HTML 页面，放在 templates/registration/ 目录中。此目录应该位于项目的根目录中，即与 catalog 和 locallibrary 文件夹相同的目录）。请立即创建这些文件夹。
        
 
 
        
-
        注意: 您的文件夹结构，现在应如下所示：
        
+
        注意： 您的文件夹结构，现在应如下所示：
        
  locallibrary (django project folder)
        
     |_catalog
        
     |_locallibrary
        
@@ -179,7 +179,7 @@ 
        模板目录
        
                  |_registration
        
 
        
 
-
        要使这些目录对模板加载器可见（即将此目录放在模板搜索路径中），请打开项目设置（/locallibrary/locallibrary/settings.py），并更新TEMPLATES 部分的 “DIRS” 那一行，如下所示。
        
+
        要使这些目录对模板加载器可见（即将此目录放在模板搜索路径中），请打开项目设置（/locallibrary/locallibrary/settings.py），并更新TEMPLATES 部分的“DIRS”那一行，如下所示。
        
 
 
        TEMPLATES = [
     {
@@ -195,7 +195,7 @@ 
        登录模板
        
 
        重要说明: 本文提供的身份验证模板，是 Django 演示登录模板的基本/略微修改版本。您可能需要自定义它们，以供自己使用！
        
 
        
 
-
        创建一个名为 /locallibrary/templates/registration/login.html 的新HTML文件。为它加入以下内容：
        
+
        创建一个名为 /locallibrary/templates/registration/login.html 的新 HTML 文件。为它加入以下内容：
        
 
 
        {% extends "base_generic.html" %}
 
@@ -243,7 +243,7 @@ 
        登录模板
        
 
 
        Library login page v1
        
 
-
        如果您尝试登录，将会成功，并且您将被重定向到另一个页面（默认情况下，这将是 http://127.0.0.1:8000/accounts/profile/）。这里的问题是，默认情况下，Django希望在登录后，你可能会被带到个人资料页面，这可能是，也可能不是。由于您还没有定义此页面，您将收到另一个错误！
        
+
        如果您尝试登录，将会成功，并且您将被重定向到另一个页面（默认情况下，这将是 http://127.0.0.1:8000/accounts/profile/）。这里的问题是，默认情况下，Django 希望在登录后，你可能会被带到个人资料页面，这可能是，也可能不是。由于您还没有定义此页面，您将收到另一个错误！
        
 
 
        打开项目设置（/locallibrary/locallibrary/settings.py），并将下面的文本添加到底部。现在登录时，您应该默认重定向到站点主页。
        
 
@@ -371,7 +371,7 @@ 
        测试新的身份验证页面
        
  
      • http://127.0.0.1:8000/accounts/logout/
        • 
 
 
-
        您将能够从登录页面中的链接，测试密码重置功能。请注意，Django只会向已存储在其数据库中的地址（用户）发送重置电子邮件！
        
+
        您将能够从登录页面中的链接，测试密码重置功能。请注意，Django 只会向已存储在其数据库中的地址（用户）发送重置电子邮件！
        
 
 
        
 
        注意: 密码重置系统，要求您的网站支持电子邮件，这超出了本文的范围，因此该部分将无法使用。要测试此功能，请将以下一行放在 settings.py 文件的末尾。这会记录发送到命令行控制台的所有电子邮件（因此您可以从命令行控制台，复制密码重置链接）。
        
@@ -379,7 +379,7 @@ 
        测试新的身份验证页面
        
 
        EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
 
        
 
-
        有关更多信息，请参阅发送电子邮件（Django文档）。
        
+
        有关更多信息，请参阅发送电子邮件（Django 文档）。
        
 
        
 
 
        测试已验证身份的用户
        
@@ -406,9 +406,9 @@ 
        在模板中测试
        
    {% endif %} 
   </ul>
        
 
-
        如您所见，我们使用 if-else-endif模板标签，根据 \{{ user.is_authenticated }} 是否为 true ，来有条件地显示文本。如果用户已通过身份验证，那么我们知道，我们拥有有效用户，因此我们会调用 \{{ user.get_username }} ，来显示其名称。
        
+
        如您所见，我们使用 if-else-endif模板标签，根据 \{{ user.is_authenticated }} 是否为 true，来有条件地显示文本。如果用户已通过身份验证，那么我们知道，我们拥有有效用户，因此我们会调用 \{{ user.get_username }} ，来显示其名称。
        
 
-
        我们使用 url模板标记，和相应 URL 配置的名称，创建登录和登出链接 URL。另外请注意，我们如何将 “?next=\{{request.path}}附加到URL的末尾。这样做，是将包含当前页面地址（URL）的URL参数，添加到链接URL的末尾。用户成功登录/登出后，视图将使用此“下一个”值，将用户重定向，回到他们首次单击登录/登出链接的页面。
        
+
        我们使用 url模板标记，和相应 URL 配置的名称，创建登录和登出链接 URL。另外请注意，我们如何将“?next=\{{request.path}}附加到 URL 的末尾。这样做，是将包含当前页面地址（URL）的 URL 参数，添加到链接 URL 的末尾。用户成功登录/登出后，视图将使用此“下一个”值，将用户重定向，回到他们首次单击登录/登出链接的页面。
        
 
 
        
 
        注意: 试试吧！如果您在主页上，并单击侧栏中的“登录/登出”，在操作完成后，您应该返回到同一页面。
        
@@ -418,7 +418,7 @@ 
        在视图中测试
        
 
 
        如果您正在使用基于函数的视图，则限制访问函数的最简单方法，是将login_required装饰器，应用于您的视图函数，如下所示。如果用户已登录，则您的视图代码将正常执行。
        
 
-
        如果用户未登录，则会重定向到项目设置 （settings.LOGIN_URL）中定义的登录URL，并将当前绝对路径，作为URL参数（"下一个"next）来传递。如果用户成功登录，则会返回到此页面，但这次会进行身份验证。
        
+
        如果用户未登录，则会重定向到项目设置（settings.LOGIN_URL）中定义的登录 URL，并将当前绝对路径，作为 URL 参数（"下一个"next）来传递。如果用户成功登录，则会返回到此页面，但这次会进行身份验证。
        
 
 
        from django.contrib.auth.decorators import login_required
 
@@ -427,7 +427,7 @@ 
        在视图中测试
        
     ...
        
 
 
        
-
        注意: 您可以通过request.user.is_authenticated，测试手动执行类似的操作，但装饰器更方便！
        
+
        注意： 您可以通过request.user.is_authenticated，测试手动执行类似的操作，但装饰器更方便！
        
 
        
 
 
        同样，在基于类别的视图中，限制对登录用户的访问的最简单方法，是从LoginRequiredMixin派生。您需要在主视图类之前的超类列表中，首先声明此 mixin。
        
@@ -437,7 +437,7 @@ 
        在视图中测试
        
 class MyView(LoginRequiredMixin, View):
     ...
 
-
        这与login_required装饰器，具有完全相同的重定向行为。如果用户未经过身份验证（login_url），还可以指定一个替代位置，以将用户重定向到该位置，并使用URL参数名称，而不是“next”，来插入当前绝对路径（redirect_field_name）。
        
+
        这与login_required装饰器，具有完全相同的重定向行为。如果用户未经过身份验证（login_url），还可以指定一个替代位置，以将用户重定向到该位置，并使用 URL 参数名称，而不是“next”，来插入当前绝对路径（redirect_field_name）。
        
 
 
        class MyView(LoginRequiredMixin, View):
     login_url = '/login/'
@@ -450,7 +450,7 @@ 
        示例 - 列出当前用户的书
 
 
        现在我们知道，如何将页面限制为特定用户，让我们为当前用户借阅的书本，创建一个视图。
        
 
-
        不幸的是，我们还没有办法让用户借书！因此，在我们创建图书清单之前，我们首先会扩展BookInstance模型，以支持借阅的概念，并使用Django Admin应用程序，借给测试用户一些书。
        
+
        不幸的是，我们还没有办法让用户借书！因此，在我们创建图书清单之前，我们首先会扩展BookInstance模型，以支持借阅的概念，并使用 Django Admin 应用程序，借给测试用户一些书。
        
 
 
        模型
        
 
@@ -477,7 +477,7 @@ 
        模型
        
     return False
        
 
 
        
-
        注意: 在进行比较之前，我们首先验证due_back是否为空。空的due_back字段，会导致Django抛出错误，而不是显示页面：空值不具有可比性。这不是我们希望用户体验到的东西！
        
+
        注意: 在进行比较之前，我们首先验证due_back是否为空。空的due_back字段，会导致 Django 抛出错误，而不是显示页面：空值不具有可比性。这不是我们希望用户体验到的东西！
        
 
        
 
 
        现在我们已经更新了模型，我们需要对项目进行新的迁移，然后应用这些迁移：
        
@@ -488,7 +488,7 @@ 
        模型
        
 
 
        管理员
        
 
-
        现在打开 catalog/admin.py，并将borrower字段，添加到BookInstanceAdmin类别中的list_display和fieldsets，如下所示。这将使该字段在Admin部分中可见，以便我们可以在需要时将User分配给BookInstance。
        
+
        现在打开 catalog/admin.py，并将borrower字段，添加到BookInstanceAdmin类别中的list_display和fieldsets，如下所示。这将使该字段在 Admin 部分中可见，以便我们可以在需要时将User分配给BookInstance。
        
 
 
        @admin.register(BookInstance)
 class BookInstanceAdmin(admin.ModelAdmin):
@@ -506,7 +506,7 @@ 
        管理员
        
 
 
        借几本书
        
 
-
        现在可以将书本借给特定用户，然后借出一些BookInstance记录。将他们的借用字段borrowed，设置为您的测试用户，将状态status设置为 “On loan”，并在将来和过去设置截止日期。
        
+
        现在可以将书本借给特定用户，然后借出一些BookInstance记录。将他们的借用字段borrowed，设置为您的测试用户，将状态status设置为“On loan”，并在将来和过去设置截止日期。
        
 
 
        
 
        注意: 我们不会一步一步说明这个流程，因为您已经知道如何使用管理站点！
        
@@ -596,7 +596,7 @@ 
        它看起来是什么样子的？
        权限
 
-
        权限与模型相关联，并定义可以由具有权限的用户，在模型实例上执行的操作。默认情况下，Django会自动为所有模型提供添加，更改和删除权限，这允许具有权限的用户，通过管理站点执行相关操作。您可以为模型定义自己的权限，并将其授予特定用户。您还可以更改与同一模型的不同实例关联的权限。
        
+
        权限与模型相关联，并定义可以由具有权限的用户，在模型实例上执行的操作。默认情况下，Django 会自动为所有模型提供添加，更改和删除权限，这允许具有权限的用户，通过管理站点执行相关操作。您可以为模型定义自己的权限，并将其授予特定用户。您还可以更改与同一模型的不同实例关联的权限。
        
 
 
        对于视图和模板中的权限测试，非常类似于对身份验证状态的测试（实际上，测试权限也会测试身份验证）。
        
 
@@ -616,7 +616,7 @@ 
        模型
        
 
 
        模板
        
 
-
        当前用户的权限，存在名为 \{{ perms }}的模板变量中。您可以使用关联的Django “app” 中的特定变量名，来检查当前用户是否具有特定权限 - 例如，如果用户具有此权限，则 \{{ perms.catalog.can_mark_returned }}将为True，否则为False。我们通常使用模板标记 {% if %} 测试权限，如下所示：
        
+
        当前用户的权限，存在名为 \{{ perms }}的模板变量中。您可以使用关联的 Django“app”中的特定变量名，来检查当前用户是否具有特定权限 - 例如，如果用户具有此权限，则 \{{ perms.catalog.can_mark_returned }}将为 True，否则为 False。我们通常使用模板标记 {% if %} 测试权限，如下所示：
        
 
 
        {% if perms.catalog.can_mark_returned %}
     <!-- We can mark a BookInstance as returned. -->
@@ -673,13 +673,13 @@ 
        总结
        
 
 
        做的太好了 — 你已经创造了一个网站，图书馆用户可以登入并检视他们拥有的内容，图书管理员（有正确的授权）可以检视所有借出的书本以及借阅者。目前，我们仍然只是查看内容，但是当您想要开始修改和添加数据时，会使用相同的原则和技术。
        
 
-
        在我们的下一篇文章，我们将介绍如何使用Django 表单，收集使用者输入，然后开始修改我们储存的一些资料。
        
+
        在我们的下一篇文章，我们将介绍如何使用 Django 表单，收集使用者输入，然后开始修改我们储存的一些资料。
        
 
 
        也可以参考
        
 
 
 
@@ -692,7 +692,7 @@ 
        本教程文档
        
 
          
  
        • Django 介绍
          • 
  
        • 架设 Django 开发环境
          • 
- 
        • Django 教程: The Local Library website
          • 
+ 
        • Django 教程：The Local Library website
          • 
  
        • Django 教程 2: Creating a skeleton website
          • 
  
        • Django 教程 3: Using models
          • 
  
        • Django 教程 4: Django admin site
          • 
diff --git a/files/zh-cn/learn/server-side/django/deployment/index.html b/files/zh-cn/learn/server-side/django/deployment/index.html
index 7543c4e10df092..ec23a4bde20ef8 100644
--- a/files/zh-cn/learn/server-side/django/deployment/index.html
+++ b/files/zh-cn/learn/server-side/django/deployment/index.html
@@ -7,7 +7,7 @@
 
 
          {{PreviousMenuNext("Learn/Server-side/Django/Testing", "Learn/Server-side/Django/web_application_security", "Learn/Server-side/Django")}}
          
 
-
          现在，您已经创建（并测试）了一个令人敬畏的LocalLibrary网站，如果您希望将其安装在公共Web服务器上，以便图书馆工作人员和成员可以通过Internet访问它。本文概述了如何找到主机来部署您的网站，以及您需要做什么才能让您的网站准备好生产。
          
+
          现在，您已经创建（并测试）了一个令人敬畏的LocalLibrary网站，如果您希望将其安装在公共 Web 服务器上，以便图书馆工作人员和成员可以通过 Internet 访问它。本文概述了如何找到主机来部署您的网站，以及您需要做什么才能让您的网站准备好生产。
          
 
 
        
  
   
        先决条件:先决条件：
    完成之前的所有教程主题，包括Django 教程 7：Sessions 框架。
   
        
   
        目的:目的：
    了解如何设置和使用用户身份验证和权限。
   
        
          
 
 
 
 
 
 
 
 
 
 
 
        
@@ -19,7 +19,7 @@
   
-   
+   
        
  
   
        
    目的：了解您可以在何处以及如何将Django应用程序部署到生产环境。了解您可以在何处以及如何将 Django 应用程序部署到生产环境。
   
        
          
 
        
@@ -28,21 +28,21 @@ 
        概述
        
 
 
        一旦您的网站完成（或完成“足够”开始公开测试），您将需要将其托管在比您的个人开发计算机更公开和可访问的地方。
        
 
-
        到目前为止，您一直在开发环境中工作，使用Django开发Web服务器将您的站点共享到本地浏览器/网络，并使用暴露调试和其他私人信息的（不安全）开发设置运行您的网站。在您可以从外部托管网站之前，您首先必须：
        
+
        到目前为止，您一直在开发环境中工作，使用 Django 开发 Web 服务器将您的站点共享到本地浏览器/网络，并使用暴露调试和其他私人信息的（不安全）开发设置运行您的网站。在您可以从外部托管网站之前，您首先必须：
        
 
 
          
 
        
 
 
          
- 
        • 对你的项目设置(project settings)做一定的修改
          • 
- 
        • 选择一个用来托管Django app的环境
          • 
+ 
        • 对你的项目设置 (project settings) 做一定的修改
          • 
+ 
        • 选择一个用来托管 Django app 的环境
          • 
  
        • 选择一个用来托管所有静态文件的环境
          • 
  
        • 设置一个产品级的设施来为你的网站服务
          • 
 
        
 
-
        本教程为您选择托管站点提供了一些指导，简要概述了为了让您的Django应用程序可用于生产需要做什么以及如何将LocalLibrary网站安装到Heroku云托管上服务。
        
+
        本教程为您选择托管站点提供了一些指导，简要概述了为了让您的 Django 应用程序可用于生产需要做什么以及如何将 LocalLibrary 网站安装到Heroku云托管上服务。
        
 
-
        什么是生产环境?
        
+
        什么是生产环境？
        
 
 
        生产环境是一个由服务器电脑提供的环境，你将在这里运行你的网站，为外部使用提供服务。生产环境包括：
        
 
@@ -50,7 +50,7 @@ 
        什么是生产环境?
        
  
      • 网站运行所需要的电脑硬件
        • 
  
      • 操作系统 (例如 Linux, Windows).
        • 
  
      • 编程语言运行库和框架库，在其上编写您的网站。
        • 
- 
      • 用于提供页面和其他内容的Web服务器（例如Nginx，Apache）。
        • 
+ 
      • 用于提供页面和其他内容的 Web 服务器（例如 Nginx，Apache）。
        • 
  
      • 在 Django 网站和 Web 服务器之间，传递“动态”请求的应用程序服务器。
        • 
  
      • 您的网站所依赖的数据库。
        • 
 
      
@@ -59,12 +59,12 @@ 
      什么是生产环境?
      
 
      注意: 根据您的生产配置方式，您可能还有反向代理，负载均衡器等。
      
 

 
-
服务器计算机可以位于您的场所，并通过快速链接连接到 Internet，但使用托管“在云中”的计算机更为常见。这实际上意味着，您的代码在托管公司的数据中心的某台远程计算机（或可能是“虚拟”计算机）上运行。远程服务器通常会以特定价格，提供一些保证级别的计算资源（例如CPU，RAM，存储器等）和互联网连接。

+
服务器计算机可以位于您的场所，并通过快速链接连接到 Internet，但使用托管“在云中”的计算机更为常见。这实际上意味着，您的代码在托管公司的数据中心的某台远程计算机（或可能是“虚拟”计算机）上运行。远程服务器通常会以特定价格，提供一些保证级别的计算资源（例如 CPU，RAM，存储器等）和互联网连接。

 
-
这种可远程访问的计算/网络硬件，称为基础架构即服务（IaaS）。许多IaaS供应商，提供预安装特定操作系统的选项，您必须在其上安装生产环境的其他组件。其他供应商允许您选择功能更全面的环境，可能包括完整的 Django ，和 Web 服务器设置。

+
这种可远程访问的计算/网络硬件，称为基础架构即服务（IaaS）。许多IaaS供应商，提供预安装特定操作系统的选项，您必须在其上安装生产环境的其他组件。其他供应商允许您选择功能更全面的环境，可能包括完整的 Django，和 Web 服务器设置。

 
 

-
注意: 预构建环境可以使您的网站设置变得非常简单，因为它们会减少配置，但可用选项可能会限制您使用不熟悉的服务器（或其他组件），并且可能基于较旧版本的操作系统。通常最好自己安装组件，以便获得所需的组件，当您需要升级系统的某些部分时，您就知道从哪里开始！

+
注意： 预构建环境可以使您的网站设置变得非常简单，因为它们会减少配置，但可用选项可能会限制您使用不熟悉的服务器（或其他组件），并且可能基于较旧版本的操作系统。通常最好自己安装组件，以便获得所需的组件，当您需要升级系统的某些部分时，您就知道从哪里开始！

 

 
 
其他托管服务提供商，支持 Django 作为平台即服务（PaaS）产品的一部分。在这种托管中，您不必担心大多数生产环境（Web 服务器，应用程序服务器，负载平衡器），因为主机平台会为您处理这些（以及为了扩展您的应用程序，而需要做的大部分工作）。这使得部署非常简单，因为您只需要专注于 Web 应用程序，而不是所有其他服务器的基础结构。

@@ -72,12 +72,12 @@ 
什么是生产环境?

 
相对于 PaaS，一些开发人员会选择 IaaS 所提供的更高灵活性，而其他开发人员，则欣赏 PaaS 降低的维护开销，和更轻松地扩展。当您开始使用时，在 PaaS 系统上设置您的网站，要容易得多，因此我们将在本教程中这么做。

 
 

-
提示: 如果您选择一个 Python/Django 友好的托管服务提供商，他们应该提供有关如何使用不同配置的网络服务器，应用服务器，反向代理等设置 Django 网站的说明（如果您选择 PaaS，这就没有关系了）。例如，Digital Ocean Django 社区文档 中的各种配置，有许多手把手指南。

+
提示： 如果您选择一个 Python/Django 友好的托管服务提供商，他们应该提供有关如何使用不同配置的网络服务器，应用服务器，反向代理等设置 Django 网站的说明（如果您选择 PaaS，这就没有关系了）。例如，Digital Ocean Django 社区文档 中的各种配置，有许多手把手指南。

 

 
 
选择托管服务提供商

 
-
已知有超过100个托管服务提供商，积极支持或与 Django 合作（您可以在 Djangofriendly hosts 主机上，找到相当广泛的列表）。这些供应商提供不同类型的环境（IaaS，PaaS），以及不同价格、不同级别的计算和网络资源。

+
已知有超过 100 个托管服务提供商，积极支持或与 Django 合作（您可以在 Djangofriendly hosts 主机上，找到相当广泛的列表）。这些供应商提供不同类型的环境（IaaS，PaaS），以及不同价格、不同级别的计算和网络资源。

 
 
选择主机时需要考虑的一些事项：

 
@@ -93,12 +93,12 @@ 
选择托管服务提供商

  
  • 您所依赖的“免费”等级，是否会随着时间的推移而过期，以及迁移到更昂贵等级的成本，是否意味着，您最好一开始就使用其他服务！
    • 
 
 
-
    当你刚开始时，好消息是，有很多网站提供了 “免费” 的 “评估”、“开发者” 或 “爱好者” 计算环境。这些始终是资源相当受限/有限的环境，您需要注意，它们可能会在广告期限后过期。然而，它们非常适合在真实环境中，测试低流量站点，并且可以在您的站点变得更加繁忙时，付费取得更多资源，并轻松迁移。此类别中的热门选择包括Heroku, Python Anywhere, Amazon Web Services, Microsoft Azure 等。
    
+
    当你刚开始时，好消息是，有很多网站提供了“免费”的“评估”、“开发者”或“爱好者”计算环境。这些始终是资源相当受限/有限的环境，您需要注意，它们可能会在广告期限后过期。然而，它们非常适合在真实环境中，测试低流量站点，并且可以在您的站点变得更加繁忙时，付费取得更多资源，并轻松迁移。此类别中的热门选择包括Heroku, Python Anywhere, Amazon Web Services, Microsoft Azure 等。
    
 
 
    许多提供商还有“基本”层，可提供更多有用的计算能力和更少的限制。Digital Ocean 和 Python Anywhere ，就是流行的托管服务提供商的例子，提供相对便宜的基本计算等级（每月 5 美元到 10 美元不等）。
    
 
 
    
-
    注意: 请记住，价格不是唯一的选择标准。如果您的网站成功，可能会发现，可扩展性是最重要的考虑因素。
    
+
    注意： 请记住，价格不是唯一的选择标准。如果您的网站成功，可能会发现，可扩展性是最重要的考虑因素。
    
 
    
 
 
    让您的网站准备好发布
    
@@ -106,14 +106,14 @@ 
    让您的网站准备好发布
    
 
    使用 django-admin 和 manage.py 工具创建的 Django 骨架网站，是为了使开发更容易而配置的。出于安全性或性能原因，许多 Django 项目设置（在settings.py中指定），在生产应该是不同的。
    
 
 
    
-
    提示: 通常有一个单独的 settings.py 文件用于生产环境，并从单独的文件或环境变量，导入敏感设置。即使其他源代码在公共存储库中可用，也应保护此文件。
    
+
    提示： 通常有一个单独的 settings.py 文件用于生产环境，并从单独的文件或环境变量，导入敏感设置。即使其他源代码在公共存储库中可用，也应保护此文件。
    
 
    
 
 
    您必须检查的关键设置是：
    -

    注意:

    +

    注意：

    @@ -353,7 +353,7 @@
    psycopg2 (Python Postgres dat

    Django 需要 psycopg2 来处理 Postgres 数据库，你需要将它添加到requirements.txt 中，以便 Heroku 在远程服务器上进行设置（如下面的 requirements 部分所述）。

    -

    Django 默认会在本地使用我们的 SQLite 数据库，因为我们的本地环境中，没有设置DATABASE_URL环境变量。如果您想完全切换到Postgres ，并使用我们的 Heroku 免费等级数据库，进行开发和生产，那么您可以这么做。例如，要在基于 Linux 的系统上，本地安装psycopg2 及其依赖项，您将使用以下 bash / terminal 命令：

    +

    Django 默认会在本地使用我们的 SQLite 数据库，因为我们的本地环境中，没有设置DATABASE_URL环境变量。如果您想完全切换到 Postgres，并使用我们的 Heroku 免费等级数据库，进行开发和生产，那么您可以这么做。例如，要在基于 Linux 的系统上，本地安装 psycopg2 及其依赖项，您将使用以下 bash / terminal 命令：

    sudo apt-get install python-pip python-dev libpq-dev postgresql postgresql-contrib
 pip3 install psycopg2
@@ -368,16 +368,16 @@ 
    在生产环境中提供静态文
 
    在开发过程中，我们使用 Django 和 Django 开发 Web 服务器，来提供静态文件（CSS，JavaScript 等）。在生产环境中，我们通常提供来自内容传送网络（CDN）或 Web 服务器的静态文件。
    
 
 
    
-
    注意: 通过 Django/web 应用程序提供静态文件是低效的，因为请求必须通过不必要的附加代码（Django），而不是由 Web 服务器或完全独立的 CDN 直接处理。虽然这对于开发期间的本地使用无关紧要，但如果我们在生产环境中使用相同的方法，则会对性能产生重大影响。
    
+
    注意： 通过 Django/web 应用程序提供静态文件是低效的，因为请求必须通过不必要的附加代码（Django），而不是由 Web 服务器或完全独立的 CDN 直接处理。虽然这对于开发期间的本地使用无关紧要，但如果我们在生产环境中使用相同的方法，则会对性能产生重大影响。
    
 
    
 
-
    为了便于将静态文件与 Django Web 应用程序分开托管，Django 提供了 collectstatic 工具，来收集这些文件以进行部署（有一个设置变量，用于定义在运行 collectstatic 时，应该收集文件的位置）。 Django 模板是指相对于设置变量（STATIC_URL）的静态文件的托管位置，因此如果将静态文件移动到另一个主机/服务器，则可以更改此位置。
    
+
    为了便于将静态文件与 Django Web 应用程序分开托管，Django 提供了 collectstatic 工具，来收集这些文件以进行部署（有一个设置变量，用于定义在运行 collectstatic 时，应该收集文件的位置）。Django 模板是指相对于设置变量（STATIC_URL）的静态文件的托管位置，因此如果将静态文件移动到另一个主机/服务器，则可以更改此位置。
    
 
 
    相关的设置变量是：
    
 
 
      
- 
    • STATIC_URL:  这是将提供静态文件的基本 URL 位置，例如，在CDN上。这用于在我们的基本模板中访问的静态模板变量（请参阅 Django 教程 5：创建我们的主页）。
      • 
- 
    • STATIC_ROOT: 这是 Django 的 “collectstatic” 工具将收集模板中引用的任何静态文件的目录的绝对路径。收集完成后，可以将这些文件，作为一个组上载到托管文件的任何位置。
      • 
+ 
    • STATIC_URL:  这是将提供静态文件的基本 URL 位置，例如，在 CDN 上。这用于在我们的基本模板中访问的静态模板变量（请参阅 Django 教程 5：创建我们的主页）。
      • 
+ 
    • STATIC_ROOT: 这是 Django 的“collectstatic”工具将收集模板中引用的任何静态文件的目录的绝对路径。收集完成后，可以将这些文件，作为一个组上载到托管文件的任何位置。
      • 
  
    • STATICFILES_DIRS: 这列出了 Django 的 collectstatic 工具应该搜索静态文件的其他目录。
      • 
 
    
 
@@ -397,14 +397,14 @@ 
    settings.py
    
 
 
    我们实际上，将使用名为 WhiteNoise 的库来提供文件，我们将在下一节中安装和配置。
    
 
-
    有关更多信息，请参阅 Django和静态资产（Heroku 文档）。
    
+
    有关更多信息，请参阅 Django 和静态资产（Heroku 文档）。
    
  
    
  Whitenoise
    
 
-
    有许多方法可以在生产环境中提供静态文件（我们在前面的部分中看到了相关的 Django 设置）。 Heroku 建议在生产环境中使用 WhiteNoise 项目，直接从 Gunicorn 提供静态资产。
    
+
    有许多方法可以在生产环境中提供静态文件（我们在前面的部分中看到了相关的 Django 设置）。Heroku 建议在生产环境中使用 WhiteNoise 项目，直接从 Gunicorn 提供静态资产。
    
 
 
    
-
    注意: Heroku 会在上传您的应用程序后，自动调用collectstatic 并准备静态文件，以供 WhiteNoise 使用。查看 WhiteNoise 文档，了解其工作原理以及实现，为什么是提供这些文件的相对有效方法。
    
+
    注意：Heroku 会在上传您的应用程序后，自动调用 collectstatic 并准备静态文件，以供 WhiteNoise 使用。查看 WhiteNoise 文档，了解其工作原理以及实现，为什么是提供这些文件的相对有效方法。
    
 
    
 
 
    设置 WhiteNoise 以便在项目中使用的步骤如下：
    
@@ -441,7 +441,7 @@ 
    settings.py
    
 
 
    Requirements
    
 
-
    Web 应用程序的 Python requirements ，必须放在储存库根目录中的文件 requirements.txt 中。然后 Heroku 将在重建您的环境时，自动安装它们。您可以在命令行上，使用 pip 创建此文件（在 repo 根目录中，运行以下命令）：
    
+
    Web 应用程序的 Python requirements，必须放在储存库根目录中的文件 requirements.txt 中。然后 Heroku 将在重建您的环境时，自动安装它们。您可以在命令行上，使用 pip 创建此文件（在 repo 根目录中，运行以下命令）：
    
 
 
    pip3 freeze > requirements.txt
    
 
@@ -465,7 +465,7 @@ 
    Runtime
    
 
    python-3.6.4
    
 
 
    
-
    注意: Heroku 只支持少量的 Python 运行库（在编写本文时，包括上面的那个）。 Heroku 将使用受支持的运行库，而不管此文件中指定的值。
    
+
    注意： Heroku 只支持少量的 Python 运行库（在编写本文时，包括上面的那个）。Heroku 将使用受支持的运行库，而不管此文件中指定的值。
    
 
    
 
 
    将更改保存到 Github 并重新测试
    
@@ -484,7 +484,7 @@ 
    将更改保存到 Github 并
 
 
    获取 Heroku 帐户
    
 
-
    要开始使用Heroku，您首先需要创建一个帐户：
    
+
    要开始使用 Heroku，您首先需要创建一个帐户：
    
 
 
      
  
    • 访问 www.heroku.com ，并单击免费注册按钮（SIGN UP FOR FREE）。
      • 
@@ -510,18 +510,18 @@ 
      创建并上传网站
      
 
      heroku create
      
 
 
      
-
      注意: 如果您愿意，可以通过在“创建”之后指定值来命名远程。如果你不这样做，你会得到一个随机的名字。该名称用于默认URL。
      
+
      注意： 如果您愿意，可以通过在“创建”之后指定值来命名远程。如果你不这样做，你会得到一个随机的名字。该名称用于默认 URL。
      
 
      
 
 
      然后我们可以将应用程序，推送到 Heroku 储存库，如下所示。这将上传应用程序，将其打包到 dyno 中，运行 collectstatic，然后启动该站点。
      
 
 
      git push heroku master
      
 
-
      如果我们很幸运，该应用程序现在在网站上“运行”，但它将无法正常工作，因为我们尚未设置数据库表，以供我们的应用程序使用。为此，我们需要使用 heroku run命令，并启动 “one off dyno” 来执行迁移操作。在终端中输入以下命令：
      
+
      如果我们很幸运，该应用程序现在在网站上“运行”，但它将无法正常工作，因为我们尚未设置数据库表，以供我们的应用程序使用。为此，我们需要使用 heroku run 命令，并启动“one off dyno”来执行迁移操作。在终端中输入以下命令：
      
 
 
      heroku run python manage.py migrate
      
 
-
      我们还需要能够添加书本和作者，所以我们再次使用一次性dyno，创建我们的管理超级用户：
      
+
      我们还需要能够添加书本和作者，所以我们再次使用一次性 dyno，创建我们的管理超级用户：
      
 
 
      heroku run python manage.py createsuperuser
      
 
@@ -542,7 +542,7 @@ 
      管理附加组件（插件）
      
 heroku-postgresql (postgresql-flat-26536)  hobby-dev  free   created
  └─ as DATABASE
    -

    在这里，我们看到我们只有一个附加组件，即 postgres SQL数据库。这是免费的，并且是在我们创建应用时，自动创建的。您可以使用以下命令，更详细地打开网页，以检查数据库附加组件（或任何其他附加组件）：

    +

    在这里，我们看到我们只有一个附加组件，即 postgres SQL 数据库。这是免费的，并且是在我们创建应用时，自动创建的。您可以使用以下命令，更详细地打开网页，以检查数据库附加组件（或任何其他附加组件）：

    heroku addons:open heroku-postgresql
    @@ -561,7 +561,7 @@

    设定配置变量

    如果您回想起来准备发布网站的部分，我们必须为DJANGO_SECRET_KEY 和 DJANGO_DEBUG设置环境变量。我们现在就这样做。

    -

    注意: 密钥需要真正的保密！生成新密钥的一种方法，是创建一个新的 Django 项目（django-admin startproject someprojectname），然后从 settings.py 中，获取为您生成的密钥。

    +

    注意： 密钥需要真正的保密！生成新密钥的一种方法，是创建一个新的 Django 项目（django-admin startproject someprojectname），然后从 settings.py 中，获取为您生成的密钥。

    我们使用 config:set命令，设置DJANGO_SECRET_KEY（如下所示）。记得使用自己的密钥！

    @@ -598,7 +598,7 @@

    设定配置变量

    除错调试

    -

    Heroku客户端提供了一些调试工具：

    +

    Heroku 客户端提供了一些调试工具：

    heroku logs  # Show current logs
 heroku logs --tail # Show current logs and keep updating with any new results
@@ -610,7 +610,7 @@ 
    除错调试
    
 
 
    总结
    
 
-
    本教程讲述如何在生产环境中配置Django应用，也是本系列Django教程的结尾。我们希望你觉得教程有用。你可以在Github上取得一个完全可工作版本的源码（用力点击此处）。
    
+
    本教程讲述如何在生产环境中配置 Django 应用，也是本系列 Django 教程的结尾。我们希望你觉得教程有用。你可以在 Github 上取得一个完全可工作版本的源码（用力点击此处）。
    
 
 
    下一步是阅读我们此前的一些文章，然后完成评估任务。
    
 
diff --git a/files/zh-cn/learn/server-side/django/development_environment/index.html b/files/zh-cn/learn/server-side/django/development_environment/index.html
index e7c17b65bf554d..4abe20e0005cdd 100644
--- a/files/zh-cn/learn/server-side/django/development_environment/index.html
+++ b/files/zh-cn/learn/server-side/django/development_environment/index.html
@@ -1,5 +1,5 @@
 ---
-title: 设置Django开发环境
+title: 设置 Django 开发环境
 slug: Learn/Server-side/Django/development_environment
 tags:
   - Python
@@ -11,64 +11,64 @@
 
 
    {{PreviousMenuNext("Learn/Server-side/Django/Introduction", "Learn/Server-side/Django/Tutorial_local_library_website", "Learn/Server-side/Django")}}
    
 
-
    现在，你知道什么是Django。
    
- 那么我们将向你展示如何在Windows，Linux（Ubuntu）和 Mac OSX上设置和测试Django开发环境—无论你常用哪种操作系统，本文能给你开发Django应用所需的一切。
    
+
    现在，你知道什么是 Django。
    
+ 那么我们将向你展示如何在 Windows，Linux（Ubuntu）和 Mac OSX 上设置和测试 Django 开发环境—无论你常用哪种操作系统，本文能给你开发 Django 应用所需的一切。
    
 
 
-   
+   
-   
-   
+   
+   
    
  
   
    先决条件:先决条件：
    知道如何在你开发所用的计算机操作系统中，打开终端/命令行和安装软件包。
   
    
   
    目的:在你的计算机中运行Django（1.10）开发环境。目的：在你的计算机中运行 Django（1.10）开发环境。
   
    
      
 
    
 
 
    Django 开发环境概述
    
 
-
    Django 使你可以轻松配置自己的电脑，以便开始开发网络应用。本节解释您可以从开发环境中获得什么，并提供一些设置和配置选项的概述。本文的其余部分介绍了在Ubuntu，Mac OSX和Windows上安装Django开发环境的 推荐方法，以及如何测试。
    
+
    Django 使你可以轻松配置自己的电脑，以便开始开发网络应用。本节解释您可以从开发环境中获得什么，并提供一些设置和配置选项的概述。本文的其余部分介绍了在Ubuntu，Mac OSX 和Windows上安装 Django 开发环境的 推荐方法，以及如何测试。
    
 
-
    什么是Django开发环境?
    
+
    什么是 Django 开发环境？
    
 
-
    开发环境是本地计算机上的Django安装，在将Django应用程序部署到生产环境之前，您可以使用它来开发和测试Django应用程序。
    
+
    开发环境是本地计算机上的 Django 安装，在将 Django 应用程序部署到生产环境之前，您可以使用它来开发和测试 Django 应用程序。
    
 
-
    Django 本身提供的主要工具是一组用于创建和使用Django项目的Python脚本，以及可在你电脑的web 浏览器中测试本地Django web应用（在你的计算机，而不是在外部的web 服务器）。
    
+
    Django 本身提供的主要工具是一组用于创建和使用 Django 项目的 Python 脚本，以及可在你电脑的 web 浏览器中测试本地 Django web 应用（在你的计算机，而不是在外部的 web 服务器）。
    
 
-
    还有其他外部工具, 它们构成了开发环境的一部分, 我们将不再赘述。这些包括 文本编辑器 或编辑代码的IDE，以及像 Git 这样的源代码控制管理工具，用于安全地管理不同版本的代码。我们假设你已经安装了一个文本编辑器。
    
+
    还有其他外部工具，它们构成了开发环境的一部分，我们将不再赘述。这些包括 文本编辑器 或编辑代码的 IDE，以及像 Git 这样的源代码控制管理工具，用于安全地管理不同版本的代码。我们假设你已经安装了一个文本编辑器。
    
 
-
    什么是Django设置选项?
    
+
    什么是 Django 设置选项？
    
 
-
    Django 在安装和配置方面非常灵活。Django可以：
    
+
    Django 在安装和配置方面非常灵活。Django 可以：
    
 
 
 
-
    每个选项都需要略微不同的配置和设置。以下小节解释了你的一些选择。在本文的其余部分中，我们将介绍Django在几个操作系统上的设置，并且在本教程的剩余模块中将假设你已进行该设置。
    
+
    每个选项都需要略微不同的配置和设置。以下小节解释了你的一些选择。在本文的其余部分中，我们将介绍 Django 在几个操作系统上的设置，并且在本教程的剩余模块中将假设你已进行该设置。
    
 
 
    
-
    注意: 其他可能的安装选项在官方Django文档中介绍。相应文件 点击这里.
    
+
    注意: 其他可能的安装选项在官方 Django 文档中介绍。相应文件 点击这里.
    
 
    
 
-
    支持哪些操作系统?
    
+
    支持哪些操作系统？
    
 
-
    Django web应用程序能运行在几乎任何可以运行Python3的计算机上：Windows，Mac OSX，Linux/Unix，Solaris，仅举几例。几乎任何计算机都具备在开发期间运行Django所需的性能。
    
+
    Django web 应用程序能运行在几乎任何可以运行 Python3 的计算机上：Windows，Mac OSX，Linux/Unix，Solaris，仅举几例。几乎任何计算机都具备在开发期间运行 Django 所需的性能。
    
 
-
    在本文中。我们将提供Windows，macOS 和Linux/Unix的说明。
    
+
    在本文中。我们将提供 Windows，macOS 和Linux/Unix的说明。
    
 
-
    你应该使用什么版本的Python?
    
+
    你应该使用什么版本的 Python?
    
 
-
    我们建议你使用最近发行的版本，在本文档写作的时候是Python 3.8.2。
    
+
    我们建议你使用最近发行的版本，在本文档写作的时候是 Python 3.8.2。
    
 
-
    事实上，Python 3.5 以及更新的版本都可以用来开发，不过对Python 3.5的支持可能会在未来的版本更新中被移除。
    
+
    事实上，Python 3.5 以及更新的版本都可以用来开发，不过对 Python 3.5 的支持可能会在未来的版本更新中被移除。
    
 
-
    我们建议你使用最新版本的Python 3，除非该站点依赖于仅适用于Python 2 的第三方库。本文将介绍如何为Python 3安装环境（Python 2 的等效设置将非常相似）。
    
+
    我们建议你使用最新版本的 Python 3，除非该站点依赖于仅适用于 Python 2 的第三方库。本文将介绍如何为 Python 3 安装环境（Python 2 的等效设置将非常相似）。
    
 
 
@@ -77,137 +77,137 @@ 
    你应该使用什么版本的Pyth
 
    注意: Python 2.7 无法用于当前的 Django 发行版本（Django 1.11.x 系列是最后支持 Python 2.7 的版本）。
    
 
 
-
    我们在哪里下载Django?
    
+
    我们在哪里下载 Django?
    
 
-
    有三个地方可以下载Django:
    
+
    有三个地方可以下载 Django:
    
 
 
 
-
    本文介绍如何从PyPi安装Django的最新稳定版本。
    
+
    本文介绍如何从 PyPi 安装 Django 的最新稳定版本。
    
 
-
    哪个数据库?
    
+
    哪个数据库？
    
 
-
    Django支持四个主要数据库（PostgreSQL，MySQL，Oracle和SQLite），还有一些社区库可以为其他流行的SQL和NOSQL数据库提供不同级别的支持。我们建议你为生产和开发选择相同的数据库（尽管Django使用其对象关系映射器（ORM）抽象了许多数据库之间的差异，但是仍然存在本可以避免的潜在问题 ).
    
+
    Django 支持四个主要数据库（PostgreSQL，MySQL，Oracle 和 SQLite），还有一些社区库可以为其他流行的 SQL 和 NOSQL 数据库提供不同级别的支持。我们建议你为生产和开发选择相同的数据库（尽管 Django 使用其对象关系映射器（ORM）抽象了许多数据库之间的差异，但是仍然存在本可以避免的潜在问题 ).
    
 
-
    对于本文（和本模块的大部分），我们将使用将数据存储在文件中的SQLite数据库。SQLite旨在用作轻量级数据库，不能支持高并发。然而，这确实是只读的应用程序的绝佳选择。
    
+
    对于本文（和本模块的大部分），我们将使用将数据存储在文件中的 SQLite 数据库。SQLite 旨在用作轻量级数据库，不能支持高并发。然而，这确实是只读的应用程序的绝佳选择。
    
 
 
    
-
    注意：当你使用标准工具（django-admin）启动你的网站项目时，Django将默认使用SQLite。用来入门时，这是一个很好的选择，因为它不需要额外的配置和设置。
    
+
    注意：当你使用标准工具（django-admin）启动你的网站项目时，Django 将默认使用 SQLite。用来入门时，这是一个很好的选择，因为它不需要额外的配置和设置。
    
 
    
 
-
    安装本机系统还是Python虚拟环境中?
    
+
    安装本机系统还是 Python 虚拟环境中？
    
 
-
    当你安装Python3时，将获得一个由所有Python3代码共享的全局环境。虽然你可以在该环境中安装任何你喜欢的Python包，但是每次只能安装每个包的一个特定版本。
    
+
    当你安装 Python3 时，将获得一个由所有 Python3 代码共享的全局环境。虽然你可以在该环境中安装任何你喜欢的 Python 包，但是每次只能安装每个包的一个特定版本。
    
 
 
    
-
    注意：安装到全局环境的Python应用程序可能会相互冲突（例如如果它们依赖于同一包的不同版本）。
    
+
    注意：安装到全局环境的 Python 应用程序可能会相互冲突（例如如果它们依赖于同一包的不同版本）。
    
 
    
 
 
    如果你把Django安装到默认/全局环境中，那么在该计算机上将只能定位到Django的一个版本。如果你想创建新的网站(使用最新版本的Django)，同时仍然维护依赖旧版本的网站，这可能是个问题。
    
 
-
    因此，经验丰富的Python/Django开发人员通常在独立Python虚拟环境中运行Python应用程序。这样就可以在一台计算机上实现多个不同的Django环境。Django开发团队同样建议你使用Python虚拟环境。
    
+
    因此，经验丰富的 Python/Django 开发人员通常在独立 Python 虚拟环境中运行 Python 应用程序。这样就可以在一台计算机上实现多个不同的 Django 环境。Django 开发团队同样建议你使用 Python 虚拟环境。
    
 
-
    本模块假设已经将Django安装到虚拟环境中，下面我们会演示如何进行。
    
+
    本模块假设已经将 Django 安装到虚拟环境中，下面我们会演示如何进行。
    
 
 
    安装 Python 3
    
 
-
    为了使用Django，你需要在你的操作系统中安装Python。如果你使用Python3，那么你同样需要Python 包管理工具  — pip3 — 用来管理 (安装，更新和删除)被Django和其他Python应用程序使用的Python软件包／库。
    
+
    为了使用 Django，你需要在你的操作系统中安装 Python。如果你使用 Python3，那么你同样需要Python 包管理工具  — pip3 — 用来管理 (安装，更新和删除) 被 Django 和其他 Python 应用程序使用的 Python 软件包／库。
    
 
-
    本节简要介绍了如何检查有哪些版本的Python，并根据需要安装适用于 Ubuntu Linux 16.04,macOS, and Windows 10的新版本。
    
+
    本节简要介绍了如何检查有哪些版本的 Python，并根据需要安装适用于 Ubuntu Linux 16.04,macOS, and Windows 10的新版本。
    
 
 
    
-
    注意: 根据你的平台, 您还可以从操作系统自己的软件包管理器或其他机制安装Python / pip。对于大多数平台，您可以从https://www.python.org/downloads/下载所需的安装文件，并使用该平台特定的方法进行安装。
    
+
    注意: 根据你的平台，您还可以从操作系统自己的软件包管理器或其他机制安装 Python / pip。对于大多数平台，您可以从https://www.python.org/downloads/下载所需的安装文件，并使用该平台特定的方法进行安装。
    
 
    
 
 
    Ubuntu 18.04
    
 
-
    Ubuntu Linux 18.04 LTS默认包含Python 3.6.6。你可以通过在Bash终端中运行以下命令来确认这一点：
    
+
    Ubuntu Linux 18.04 LTS 默认包含 Python 3.6.6。你可以通过在 Bash 终端中运行以下命令来确认这一点：
    
 
 
    python3 -V
  Python 3.6.6
    
 
-
    然而，在默认情况下，为Python 3（包括Django）安装软件包的Python包管理工具不可用。你可以在bash终端中使用以下命令安装pip3：
    
+
    然而，在默认情况下，为 Python 3（包括 Django）安装软件包的 Python 包管理工具不可用。你可以在bash终端中使用以下命令安装pip3：
    
 
 
    sudo apt-get install python3-pip
 
    
 
 
    macOS
    
 
-
    macOS 的"El Capitan" 及其他最新版本不包含Python 3。你可以通过在bash终端中运行一下命令来确认：
    
+
    macOS 的"El Capitan" 及其他最新版本不包含 Python 3。你可以通过在 bash 终端中运行一下命令来确认：
    
 
 
    python3 -V
  -bash: python3: command not found
    
 
-
    你可以轻松地从 python.org安装Python 3（以及pip3工具）:
    
+
    你可以轻松地从 python.org安装 Python 3（以及 pip3 工具）:
    
 
 
      
- 
    1. 下载所需的安装程序:
+ 
    2. 下载所需的安装程序：
   
        
    
      1. 点击 https://www.python.org/downloads/
        2. 
    
      2. 选择 Download Python 3.8.2  (具体的版本号可能不同)。
        3. 
   
      
  
      3. 
- 
    3. 使用Finder找到安装包，然后双击运行，并按照提示进行安装。
      4. 
+ 
    4. 使用 Finder 找到安装包，然后双击运行，并按照提示进行安装。
      5. 
 
    
 
-
    之后可以通过检查Python3版本确认是否安装成功，如下所示:
    
+
    之后可以通过检查 Python3 版本确认是否安装成功，如下所示：
    
 
 
    python3 -V
 Python 3.8.2
    
 
-
    你也可以通过列出可用的包来检查pip3是否安装了：
    
+
    你也可以通过列出可用的包来检查 pip3 是否安装了：
    
 
 
    pip3 list
    
 
 
    Windows 10
    
 
-
    windows默认不包含Python, 但你可以从 python.org轻松地安装它（以及pip3工具）：
    
+
    windows 默认不包含 Python, 但你可以从 python.org轻松地安装它（以及 pip3 工具）：
    
 
 
      
- 
    1. 下载所需版本:
+ 
    2. 下载所需版本：
   
        
    
      1. 点击 https://www.python.org/downloads/
        2. 
    
      2. 选择 Download Python 3.8.2  (具体的版本号可能不同)。
        3. 
   
      
  
      3. 
- 
    3. 双击现在的文件并按照提示安装Python。
      4. 
+ 
    4. 双击现在的文件并按照提示安装 Python。
      5. 
  
    5. 确保勾选了"Add Python to PATH"选项。
      6. 
 
    
 
-
    你可以在命令提示符中输入以下内容来验证是否安装了Python:
    
+
    你可以在命令提示符中输入以下内容来验证是否安装了 Python:
    
 
 
    python -V
  Python 3.8.2
 
    
 
-
    Windows安装程序默认包含pip3 (Python包管理器)。同样在命令提示符中输入以下内容来列出已安装的包:
    
+
    Windows 安装程序默认包含 pip3 (Python 包管理器)。同样在命令提示符中输入以下内容来列出已安装的包：
    
 
 
    pip3 list
 
    
 
 
    
-
    注意：安装包应该已把运行上述命令所需的一切设置完成。但如果你得到的消息是找不到Python，那么你可能忘记将Python添加到系统路径中了。你可以通过再次运行安装包，选择"Modify"，并在下一页面中勾选 "Add Python to environment variables"来修复这个问题。
    
+
    注意：安装包应该已把运行上述命令所需的一切设置完成。但如果你得到的消息是找不到 Python，那么你可能忘记将 Python 添加到系统路径中了。你可以通过再次运行安装包，选择"Modify"，并在下一页面中勾选 "Add Python to environment variables"来修复这个问题。
    
 
    
 
-
    在Python虚拟环境中使用Django
    
+
    在 Python 虚拟环境中使用 Django
    
 
-
    我们使用virtualenvwrapper（Linux及macOS）和 virtualenvwrapper-win（WIndows）来创建Python虚拟环境，而它们又使用了virtualenv。封装工具创建了一个一致的接口来管理各个平台上的接口。
    
+
    我们使用virtualenvwrapper（Linux 及 macOS）和 virtualenvwrapper-win（WIndows）来创建 Python 虚拟环境，而它们又使用了virtualenv。封装工具创建了一个一致的接口来管理各个平台上的接口。
    
 
 
    安装虚拟环境软件
    
 
-
    Ubuntu虚拟环境设置
    
+
    Ubuntu 虚拟环境设置
    
 
-
    安装了Python和pip之后，你就可以安装virtualenvwrapper（包括了virtualenv）。可以在这里找到正式的安装指南，或按照以下指导操作。
    
+
    安装了 Python 和 pip 之后，你就可以安装 virtualenvwrapper（包括了 virtualenv）。可以在这里找到正式的安装指南，或按照以下指导操作。
    
 
-
    使用pip3安装该工具：​​​​​​
    
+
    使用 pip3 安装该工具：​​​​​​
    
 
 
    sudo pip3 install virtualenvwrapper
    
 
-
    然后将以下代码行添加到shell启动文件的末尾(这是主目录中的一个隐藏文件，名字是.bashrc)。这些文件设置了虚拟环境应该存在的位置、开发项目目录的位置以及与这个包一起安装的脚本的位置。
    
+
    然后将以下代码行添加到 shell 启动文件的末尾 (这是主目录中的一个隐藏文件，名字是.bashrc)。这些文件设置了虚拟环境应该存在的位置、开发项目目录的位置以及与这个包一起安装的脚本的位置。
    
 
 
    export WORKON_HOME=$HOME/.virtualenvs
 export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
@@ -216,7 +216,7 @@ 
    Ubuntu虚拟环境设置
    
 source /usr/local/bin/virtualenvwrapper.sh
    
 
 
    
-
    注意：VIRTUALENVWRAPPER_PYTHON 和 VIRTUALENVWRAPPER_VIRTUALENV_ARGS变量指向Python3的常规安装位置，source /usr/local/bin/virtualenvwrapper.sh指向virtualenvwrapper.sh脚本的一般安装位置。 如果您在测试时发现virtualenv无法正常工作，则要检查的一件事是Python和该脚本是否在预期的位置（然后适当更改启动文件）。
    
+
    注意：VIRTUALENVWRAPPER_PYTHON 和 VIRTUALENVWRAPPER_VIRTUALENV_ARGS变量指向 Python3 的常规安装位置，source /usr/local/bin/virtualenvwrapper.sh指向virtualenvwrapper.sh脚本的一般安装位置。 如果您在测试时发现virtualenv无法正常工作，则要检查的一件事是 Python 和该脚本是否在预期的位置（然后适当更改启动文件）。
    
 
 
    你可以使用which virtualenvwrapper.sh 和 which python3命令为你的系统找到正确的安装位置。
    
 
    
@@ -238,13 +238,13 @@ 
    Ubuntu虚拟环境设置
    
 
 
    macOS 虚拟环境设置
    
 
-
    在macOS上设置virtualenvwrapper 几乎和在Ubuntu上是一样的（你同样可以按照以下指导操作，或在这里找到正式的安装指南）。
    
+
    在 macOS 上设置virtualenvwrapper 几乎和在 Ubuntu 上是一样的（你同样可以按照以下指导操作，或在这里找到正式的安装指南）。
    
 
 
    使用pip安装virtualenvwrapper(并绑定virtualenv)，如下所示。
    
 
 
    sudo pip3 install virtualenvwrapper
    
 
-
    然后将以下代码行添加到shell启动文件的末尾：
    
+
    然后将以下代码行添加到 shell 启动文件的末尾：
    
 
 
    export WORKON_HOME=$HOME/.virtualenvs
 export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
@@ -252,9 +252,9 @@ 
    macOS 虚拟环境设置
    
 source /usr/local/bin/virtualenvwrapper.sh
    
 
 
    
-
    注意：VIRTUALENVWRAPPER_PYTHON 和 VIRTUALENVWRAPPER_VIRTUALENV_ARGS变量指向Python3的常规安装位置，source /usr/local/bin/virtualenvwrapper.sh指向virtualenvwrapper.sh脚本的一般安装位置。 如果您在测试时发现virtualenv无法正常工作，则要检查的一件事是Python和该脚本是否在预期的位置（然后适当更改启动文件）。
    
+
    注意：VIRTUALENVWRAPPER_PYTHON 和 VIRTUALENVWRAPPER_VIRTUALENV_ARGS变量指向 Python3 的常规安装位置，source /usr/local/bin/virtualenvwrapper.sh指向virtualenvwrapper.sh脚本的一般安装位置。 如果您在测试时发现virtualenv无法正常工作，则要检查的一件事是 Python 和该脚本是否在预期的位置（然后适当更改启动文件）。
    
 
-
    例如，在macOS上的一个安装测试中，启动文件中必须有以下几行代码：
    
+
    例如，在 macOS 上的一个安装测试中，启动文件中必须有以下几行代码：
    
 
 
    export WORKON_HOME=$HOME/.virtualenvs
 export VIRTUALENVWRAPPER_PYTHON=/Library/Frameworks/Python.framework/Versions/3.7/bin/python3
@@ -264,10 +264,10 @@ 
    macOS 虚拟环境设置
    
 
    你可以使用which virtualenvwrapper.sh 和 which python3命令为你的系统找到正确的安装位置。
    
 
    
 
-
    此处使用和Ubuntu相同的代码行，但是启动文件是主目录中叫做.bash_profile的隐藏文件。
    
+
    此处使用和 Ubuntu 相同的代码行，但是启动文件是主目录中叫做.bash_profile的隐藏文件。
    
 
 
    
-
    注意：如果找不到.bash_profile进行编辑，也可以使用nano在终端中打开它，命令看起来类似于：
    
+
    注意：如果找不到.bash_profile进行编辑，也可以使用 nano 在终端中打开它，命令看起来类似于：
    
 
 
    cd ~  # Navigate to my home directory
 ls -la #List the content of the directory. YOu should see .bash_profile
@@ -280,11 +280,11 @@ 
    macOS 虚拟环境设置
    
 
 
    source ~/.bashrc
    
 
-
    此时，你应该能看到一些脚本正在运行（和Ubuntu中同样的脚本）。然后你就可以使用 mkvirtualenv命令创建一个新的虚拟环境。
    
+
    此时，你应该能看到一些脚本正在运行（和 Ubuntu 中同样的脚本）。然后你就可以使用 mkvirtualenv命令创建一个新的虚拟环境。
    
 
 
    Windows 10 虚拟环境设置
    
 
-
    安装 virtualenvwrapper-win 甚至比设置virtualenvwrapper 更简单，因为你无需配置工具用来存储虚拟环境信息的位置（有一个默认值）。你需要做的只是在命令提示符中运行以下命令:
    
+
    安装 virtualenvwrapper-win 甚至比设置virtualenvwrapper 更简单，因为你无需配置工具用来存储虚拟环境信息的位置（有一个默认值）。你需要做的只是在命令提示符中运行以下命令：
    
 
 
    pip3 install virtualenvwrapper-win
    
 
@@ -294,7 +294,7 @@ 
    创建虚拟环境
    
 
 
    一旦你成功安装了virtualenvwrapper 或 virtualenvwrapper-win，那么在所有平台中使用虚拟环境的方法是非常相似的。
    
 
-
    现在你可以使用 mkvirtualenv命令创建一个新的虚拟环境。在运行此命令时，你将看到正在设置的环境（你所看到的只略微与平台相关）。命令完成后，新的虚拟环境将被激活——你能看到提示符的开头就是括号中的环境名称（以下我们展示的是Ubuntu的，但是在Windows/macOS上，末行时相似的|）
    
+
    现在你可以使用 mkvirtualenv命令创建一个新的虚拟环境。在运行此命令时，你将看到正在设置的环境（你所看到的只略微与平台相关）。命令完成后，新的虚拟环境将被激活——你能看到提示符的开头就是括号中的环境名称（以下我们展示的是 Ubuntu 的，但是在 Windows/macOS 上，末行时相似的|）
    
 
 
    $ mkvirtualenv my_django_environment
 
@@ -303,32 +303,32 @@ 
    创建虚拟环境
    
 virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/t_env7/bin/get_env_details
 (my_django_environment) ubuntu@ubuntu:~$
    
 
-
    现在你已进入虚拟环境，可以进行Django安装并开始开发。
    
+
    现在你已进入虚拟环境，可以进行 Django 安装并开始开发。
    
 
 
    
-
    注意：从现在开始，在本文(实际上是该模块)中，请假定所有命令都在类似于我们上面设置的Python虚拟环境中运行。
    
+
    注意：从现在开始，在本文 (实际上是该模块) 中，请假定所有命令都在类似于我们上面设置的 Python 虚拟环境中运行。
    
 
    
 
 
    使用一个虚拟环境
    
 
-
    您应该知道一些其他有用的命令(在工具的文档中还有更多，但这些是您将经常使用的命令)：
    
+
    您应该知道一些其他有用的命令 (在工具的文档中还有更多，但这些是您将经常使用的命令)：
    
 
 
      
- 
    • deactivate —退出当前的Python虚拟环境
      • 
+ 
    • deactivate —退出当前的 Python 虚拟环境
      • 
  
    • workon — 列出可用的所有虚拟环境
      • 
- 
    • workon name_of_environment —激活特定的Python虚拟环境
      • 
+ 
    • workon name_of_environment —激活特定的 Python 虚拟环境
      • 
  
    • rmvirtualenv name_of_environment — 移除特定的虚拟环境
      • 
 
    
 
 
    
 
-
    安装Django
    
+
    安装 Django
    
 
-
    一旦你创建了一个虚拟环境，并且使用workon 进入了它，就可以使用pip3来安装Django。
    
+
    一旦你创建了一个虚拟环境，并且使用workon 进入了它，就可以使用 pip3 来安装 Django。
    
 
 
    pip3 install django
    
 
-
    您可以通过运行以下命令来测试Django是否安装（这只是用来测试Python是否可以找到Django模块）：
    
+
    您可以通过运行以下命令来测试 Django 是否安装（这只是用来测试 Python 是否可以找到 Django 模块）：
    
 
 
    # Linux/macOS
 python3 -m django --version
@@ -340,15 +340,15 @@ 
    安装Django
    
 
    
 
 
    
-
    注意：如果上面的Windows命令没有显示django模块，请尝试：
    
+
    注意：如果上面的 Windows 命令没有显示 django 模块，请尝试：
    
 
 
    py -m django --version
    
 
-
    在Windows中，Python 3脚本是通过在命令前面加上py -3来启动的，尽管该脚本可能会因您的特定安装而有所不同。 如果遇到命令问题，请尝试省略-3修饰符。 在Linux /macOS中，命令是python3。
    
+
    在 Windows 中，Python 3 脚本是通过在命令前面加上py -3来启动的，尽管该脚本可能会因您的特定安装而有所不同。如果遇到命令问题，请尝试省略-3修饰符。在 Linux /macOS 中，命令是 python3。
    
 
    
 
 
    
-
    重要提示：本模块的其余部分使用Linux命令来调用Python 3（python3）。如果您在Windows上工作，只需将此前缀替换为： py -3
    
+
    重要提示：本模块的其余部分使用 Linux 命令来调用 Python 3（python3）。如果您在 Windows 上工作，只需将此前缀替换为： py -3
    
 
    
 
 
    测试你的安装
    
@@ -359,12 +359,12 @@ 
    测试你的安装
    
 cd django_test
 
    
 
-
    然后，您可以像所展示的一样使用django-admin工具创建一个名为“ mytestsite ” 的新框架站点。创建网站后，您可以CD到此文件夹，并将在其中找到管理项目的主要脚本，名为manage.py。
    
+
    然后，您可以像所展示的一样使用 django-admin 工具创建一个名为“ mytestsite ”的新框架站点。创建网站后，您可以 CD 到此文件夹，并将在其中找到管理项目的主要脚本，名为manage.py。
    
 
 
    django-admin startproject mytestsite
 cd mytestsite
    
 
-
    我们可以在这个文件夹中使用manager.py和runserver命令运行开发web服务器，如下所示。
    
+
    我们可以在这个文件夹中使用manager.py和runserver命令运行开发 web 服务器，如下所示。
    
 
 
    $ python3 manage.py runserver
 Performing system checks...
@@ -380,10 +380,10 @@ 
    测试你的安装
    
 Quit the server with CONTROL-C.
    
 
 
    
-
    注意：上面的命令显示了Linux /macOS命令。您可以忽略关于“15 unapplied migration(s)”的警告！
    
+
    注意：上面的命令显示了 Linux /macOS 命令。您可以忽略关于“15 unapplied migration(s)”的警告！
    
 
    
 
-
    一旦服务器运行，您可以通过本地Web浏览器打开http://127.0.0.1:8000/来查看该站点。你应该看到一个如下所示的网站：
    
+
    一旦服务器运行，您可以通过本地 Web 浏览器打开http://127.0.0.1:8000/来查看该站点。你应该看到一个如下所示的网站：
    
 
 
    The home page of the skeleton Django app.
    
 
@@ -392,16 +392,16 @@ 
    测试你的安装
    
 
 
    概要
    
 
-
    现在，你的计算机中已经启动并运行了一个Django开发环境。
    
+
    现在，你的计算机中已经启动并运行了一个 Django 开发环境。
    
 
-
    在测试部分，您还简要地了解了如何使用django-admin startproject创建一个新的Django网站，并使用开发web服务器(python3 manager .py runserver)在浏览器中运行它。在下一篇文章中，我们将对此过程进行扩展，构建一个简单但完整的web应用程序。
    
+
    在测试部分，您还简要地了解了如何使用django-admin startproject创建一个新的 Django 网站，并使用开发 web 服务器 (python3 manager .py runserver) 在浏览器中运行它。在下一篇文章中，我们将对此过程进行扩展，构建一个简单但完整的 web 应用程序。
    
 
 
    看看瞧瞧
    
 
 
 
 
    {{PreviousMenuNext("Learn/Server-side/Django/Introduction", "Learn/Server-side/Django/Tutorial_local_library_website", "Learn/Server-side/Django")}}
    
diff --git a/files/zh-cn/learn/server-side/django/django_assessment_blog/index.html b/files/zh-cn/learn/server-side/django/django_assessment_blog/index.html
index e7d947beea45bd..df8fbc31fb6703 100644
--- a/files/zh-cn/learn/server-side/django/django_assessment_blog/index.html
+++ b/files/zh-cn/learn/server-side/django/django_assessment_blog/index.html
@@ -12,19 +12,19 @@
 
-   
+   
-   
-   
+   
+   
    
  
   
    先决条件:先决条件：
    在尝试此评估之前，您应该已经完成​​了本模块中的所有文章。
   
    
   
    目标:测试对Django基础知识的理解，包括URL配置，模型，视图，表单和模板。目标：测试对 Django 基础知识的理解，包括 URL 配置，模型，视图，表单和模板。
   
    
      
 
    
 
 
    項目概要
    
 
-
    下面列出了需要显示的页面、URL和其它要求：
    
+
    下面列出了需要显示的页面、URL 和其它要求：
    
 
 
@@ -44,7 +44,7 @@ 
    項目概要
    
@@ -120,7 +120,7 @@ 
    項目概要
    
@@ -152,7 +152,7 @@ 
    項目概要
      
  
    • 所有模型字段都具有正确的标签和长度。
      • 
  
    • 所有模型都具有预期的对象名称（例如 __str__() 返回预期值）。
      • 
- 
    • 模型具有单个博客和评论记录的预期URL（例如，get_absolute_url()返回预期的URL）。
      • 
+ 
    • 模型具有单个博客和评论记录的预期 URL（例如，get_absolute_url()返回预期的 URL）。
      • 
  
    • BlogListView（所有博客页面）可在预期位置访问（例如 /blog/blogs）
      • 
  
    • BlogListView（所有博客页面）可通过预期的命名网址访问（例如 'blogs'）
      • 
  
    • BlogListView（所有博客页面）使用预期的模板（例如默认模板）
      • 
@@ -171,7 +171,7 @@ 
      截图
      
 
 
      所有博客文章列表
      
 
-
      这将显示所有博客帖子的列表（可从侧栏中的“所有博客” All blogs 链接访问）。注意事项：
      
+
      这将显示所有博客帖子的列表（可从侧栏中的“所有博客”All blogs 链接访问）。注意事项：
      
 
 
        
  
      • 侧栏还列出了登录用户。
        • 
@@ -184,7 +184,7 @@ 
        所有博客文章列表
        
 
 
        所有博主的列表
        
 
-
        这提供了到所有博客的链接，如同来自侧栏中的“所有博客” All bloggers 链接。在这种情况下，我们可以从侧边栏看到，并没有用户登录。
        
+
        这提供了到所有博客的链接，如同来自侧栏中的“所有博客”All bloggers 链接。在这种情况下，我们可以从侧边栏看到，并没有用户登录。
        
 
 
        List of all bloggers
        
 
@@ -215,7 +215,7 @@ 
        完成的步骤
        
 
        以下部分，描述了您需要执行的操作。
        
 
 
          
- 
        1. 为站点创建骨架项目和Web应用程序（如Django教程 2：创建骨架网站中所述）。您可以使用 'diyblog' 作为项目名称，使用 'blog' 作为应用程序名称。
          2. 
+ 
        2. 为站点创建骨架项目和 Web 应用程序（如Django 教程 2：创建骨架网站中所述）。您可以使用 'diyblog' 作为项目名称，使用 'blog' 作为应用程序名称。
          3. 
  
        3. 为博客帖子，评论和所需的任何其他对象创建模型。在考虑您的设计时，请记住：
   
            
    
          • 每个评论只有一个博客，但博客可能有很多评论。
            • 
@@ -238,18 +238,18 @@ 
            提示和技巧
            
 
            一些一般提示：
            
 
 
              
- 
            1. 索引页面可以实现为基本功能视图和模板（就像locallibrary一样）。
              2. 
- 
            2. T可以使用通用列表和详细信息视图，以创建博客帖子和博主的列表视图，以及博客帖子的详细信息视图。
              3. 
+ 
            3. 索引页面可以实现为基本功能视图和模板（就像 locallibrary 一样）。
              4. 
+ 
            4. T 可以使用通用列表和详细信息视图，以创建博客帖子和博主的列表视图，以及博客帖子的详细信息视图。
              5. 
  
            5. 可以使用通用列表的博客列表视图，并对指定作者匹配的博客对象进行过滤，来创建特定作者的博客帖子列表。
   
                
-   
              • 您将必须实现get_queryset(self)来进行过滤（很像我们的图书馆类LoanedBooksAllListView），并从URL获取作者信息。
                • 
+   
              • 您将必须实现get_queryset(self)来进行过滤（很像我们的图书馆类LoanedBooksAllListView），并从 URL 获取作者信息。
                • 
    
              • 您还需要将作者的名称，传递给上下文中的页面。要在基于类的视图中执行此操作，您需要实现get_context_data()（在下面讨论）。
                • 
   
              
  
              6. 
  
            6. 可以使用基于函数的视图（以及关联的模型和表单），或使用通用CreateView，以创建添加注释表单。如果您使用CreateView（推荐），那么：
   
                
    
              • 您还需要将博客文章的名称，传递到上下文中的评论页面（实现get_context_data() ，如下所述）。
                • 
-   
              • 表单应仅显示用户输入的注释“description”（日期和相关的博客文章，不应该是可编辑的）。由于它们本身不在表单中，因此您的代码，需要在 form_valid() 函数中，设置注释的作者，以便将其保存到模型中（如此处所述 -  Django文档）。在同一个功能中，我们设置了相关的博客。可能的实现如下所示（pk是从URL / URL配置传入的博客ID）。
+   
              • 表单应仅显示用户输入的注释“description”（日期和相关的博客文章，不应该是可编辑的）。由于它们本身不在表单中，因此您的代码，需要在 form_valid() 函数中，设置注释的作者，以便将其保存到模型中（如此处所述 -  Django 文档）。在同一个功能中，我们设置了相关的博客。可能的实现如下所示（pk是从 URL / URL 配置传入的博客 ID）。
     
                    def form_valid(self, form):
         """
         Add author and associated blog to form data before setting it as valid (so it is saved to model)
@@ -262,12 +262,12 @@ 
                提示和技巧
                
         return super(BlogCommentCreate, self).form_valid(form)
 
                
    
                • 
-   
              • 在表单验证后，您需要提供成功的 URL，以进行重新定向；这应该是原来的博客。为此，您需要覆盖 get_success_url()，并为原来的博客 “反转” URL 。您可以使用self.kwargs属性，获取所需的博客ID，如上面的 form_valid() 方法所示。
                • 
+   
              • 在表单验证后，您需要提供成功的 URL，以进行重新定向；这应该是原来的博客。为此，您需要覆盖 get_success_url()，并为原来的博客“反转”URL。您可以使用self.kwargs属性，获取所需的博客 ID，如上面的 form_valid() 方法所示。
                • 
   
              
  
              7. 
 
            
 
-
            我们简要地讨论了在Django教程 6：通用列表和详细信息视图主题中，在基于类的视图中，将上下文传递给模板。要执行此操作，您需要覆盖get_context_data()（首先，获取现有上下文，使用要传递给模板的任何其他变量，更新它，然后返回更新的上下文）。例如，下面的代码片段，显示了如何根据BlogAuthor id，将 blogger 对象添加到上下文中。
            
+
            我们简要地讨论了在Django 教程 6：通用列表和详细信息视图主题中，在基于类的视图中，将上下文传递给模板。要执行此操作，您需要覆盖get_context_data()（首先，获取现有上下文，使用要传递给模板的任何其他变量，更新它，然后返回更新的上下文）。例如，下面的代码片段，显示了如何根据BlogAuthor id，将 blogger 对象添加到上下文中。
            
 
 
            class SomeView(generic.ListView):
     ...
@@ -282,7 +282,7 @@ 
            提示和技巧
            
 
 
            评估
            
 
-
            这个任务的评估，可以在Github上找到。此评估主要基于您的应用程序，满足上面列出要求的程度，尽管评估的某些部分，会检查您的代码是否使用了适当的模型，并且您至少编写了一些测试代码。完成后，您可以查看我们完成的示例，该示例项目的表现是 “满分”。
            
+
            这个任务的评估，可以在Github上找到。此评估主要基于您的应用程序，满足上面列出要求的程度，尽管评估的某些部分，会检查您的代码是否使用了适当的模型，并且您至少编写了一些测试代码。完成后，您可以查看我们完成的示例，该示例项目的表现是“满分”。
            
 
 
            完成本单元后，表示您还完成了所有 MDN 用于学习《基本 Django 服务器端网站编程》的内容！我们希望您喜欢这个模块，并感觉您已经掌握了基础知识！
            
 
@@ -295,7 +295,7 @@ 
            本系列教程
            
 
              
  
            • Django 介绍
              • 
  
            • 架设 Django 开发环境
              • 
- 
            • Django 教程: 本地图书馆网站
              • 
+ 
            • Django 教程：本地图书馆网站
              • 
  
            • Django 教程 2: 创建骨架网站
              • 
  
            • Django 教程 3: 使用模型
              • 
  
            • Django 教程 4: Django 管理站点
              • 
diff --git a/files/zh-cn/learn/server-side/django/forms/index.html b/files/zh-cn/learn/server-side/django/forms/index.html
index 49bc0928779568..496ac67aad31c9 100644
--- a/files/zh-cn/learn/server-side/django/forms/index.html
+++ b/files/zh-cn/learn/server-side/django/forms/index.html
@@ -7,16 +7,16 @@
 
 
              {{PreviousMenuNext("Learn/Server-side/Django/authentication_and_sessions", "Learn/Server-side/Django/Testing", "Learn/Server-side/Django")}}
              
 
-
              在本教程中，我们将向您展示如何在Django中使用HTML表单，特别是编写表单以创建，更新和删除模型实例的最简单方法。作为本演示的一部分，我们将扩展LocalLibrary网站，以便图书馆员可以使用我们自己的表单（而不是使用管理员应用程序）更新图书，创建，更新和删除作者。
              
+
              在本教程中，我们将向您展示如何在 Django 中使用 HTML 表单，特别是编写表单以创建，更新和删除模型实例的最简单方法。作为本演示的一部分，我们将扩展LocalLibrary网站，以便图书馆员可以使用我们自己的表单（而不是使用管理员应用程序）更新图书，创建，更新和删除作者。
              
 
 
    
  
    
    所有博客文章列表
    /blog/blogs/
    
-    
    所有博客文章列表:
    
+    
    所有博客文章列表：
    
 
     
      
      
    • 可通过侧边栏链接访问所有用户。
      • 
@@ -60,7 +60,7 @@ 
      項目概要
      
    
    		博客作者（博主）详细信息页面
    /blog/blogger/<author-id>
    
-    
    指定作者的信息（按ID）和他们的博客文章列表：
    
+    
    指定作者的信息（按 ID）和他们的博客文章列表：
    
 
     
      
      
    • 可以从博客文章等的作者链接访问所有用户
      • 
@@ -84,7 +84,7 @@ 
      項目概要
      
      
    • 博客文章的评论应显示在底部。
      • 
      
    • 评论应按顺序排序：从最旧到最近。
      • 
      
    • 包含为登录用户添加注释的链接（请参阅注释表单页面）
      • 
-     
    • 博客帖子和评论，只需显示纯文本。不需要支持任何类型的HTML标记（例如链接，图像，粗体/斜体等）。
      • 
+     
    • 博客帖子和评论，只需显示纯文本。不需要支持任何类型的 HTML 标记（例如链接，图像，粗体/斜体等）。
      • 
     
    
        		
   
    
    
    用户认证页面
    /accounts/<standard urls>
    
-    
    用于登录，注销和设置密码的标准Django身份验证页面：
    
+    
    用于登录，注销和设置密码的标准 Django 身份验证页面：
    
 
     
     
    
 
@@ -139,7 +139,7 @@ 
    項目概要
    
 
     
      
      
    • 管理站点的博客帖子记录，应显示内联的相关评论列表（在每篇博客文章下方）。
      • 
-     
    • 管理站点中的注释名称，是通过将注释说明，截断为75个字符来创建的。
      • 
+     
    • 管理站点中的注释名称，是通过将注释说明，截断为 75 个字符来创建的。
      • 
      
    • 其他类型的记录，可以使用基本注册。
      • 
     
    
        		
 
    
-   
+   
-   
+   
@@ -24,9 +24,9 @@
 
 
    概览
    
 
-
    一张 HTML 表单 ，是由一个或多个栏位/widget在一个网页上组成的，以用于向使用者收集资料，并提交至伺服器。表单是一个弹性的机制，用于收集使用者输入，有合适的 widgets 可输入许多不同型态的资料，包含文字框、复选框、单选按钮、日期选取组件等等。若是允许我们用 POST 方式传送资料，并附加 CSRF 跨站要求伪造保护，表单也是与伺服器分享资料的一种相对安全的方式。
    
+
    一张 HTML 表单 ，是由一个或多个栏位/widget 在一个网页上组成的，以用于向使用者收集资料，并提交至伺服器。表单是一个弹性的机制，用于收集使用者输入，有合适的 widgets 可输入许多不同型态的资料，包含文字框、复选框、单选按钮、日期选取组件等等。若是允许我们用 POST 方式传送资料，并附加 CSRF 跨站要求伪造保护，表单也是与伺服器分享资料的一种相对安全的方式。
    
 
-
    在这个教程目前为止，我们还没有创造任何表单，但我们已经在 Django 管理站点遇到这些表单了— 例如以下的撷图展示了一张表单，用于编辑我们的一个 Book书本模型，包含一些选择列表以及文字编辑框。
    
+
    在这个教程目前为止，我们还没有创造任何表单，但我们已经在 Django 管理站点遇到这些表单了— 例如以下的撷图展示了一张表单，用于编辑我们的一个 Book 书本模型，包含一些选择列表以及文字编辑框。
    Admin Site - Book Add
    
 
@@ -36,11 +36,11 @@ 
    概览
    HTML 表单
    
 
-
    首先简要概述HTML表单。考虑一个简单的HTML表单，其中包含一个文本字段，用于输入某些“团队”的名称及其相关标签：
    
+
    首先简要概述HTML 表单。考虑一个简单的 HTML 表单，其中包含一个文本字段，用于输入某些“团队”的名称及其相关标签：
    Simple name field example in HTML form
    
 
-
    表单在HTML中定义为<form>...</form> 标记内的元素集合，包含至少一个type="submit"的input 输入元素。
    
+
    表单在 HTML 中定义为<form>...</form> 标记内的元素集合，包含至少一个type="submit"的input 输入元素。
    <form action="/team_name_url/" method="post">
     <label for="team_name">Enter name: </label>
@@ -48,27 +48,27 @@ 
    HTML 表单
    
     <input type="submit" value="OK">
 </form>
    
 
-
    虽然在这里，我们只有一个文本字段，用于输入团队名称，但表单可能包含任意数量的其他输入元素，及其相关标签。字段的type 属性，定义将显示哪种窗口小部件。该字段的名称name 和 id，用于标识 JavaScript / CSS / HTML中的字段，而value 定义字段首次显示时的初始值。匹配团队标签使用label 标签指定（请参阅上面的“输入名称” Enter name），其中for 字段包含相关input输入的id 值。
    
+
    虽然在这里，我们只有一个文本字段，用于输入团队名称，但表单可能包含任意数量的其他输入元素，及其相关标签。字段的type 属性，定义将显示哪种窗口小部件。该字段的名称name 和 id，用于标识 JavaScript / CSS / HTML 中的字段，而value 定义字段首次显示时的初始值。匹配团队标签使用label 标签指定（请参阅上面的“输入名称”Enter name），其中for 字段包含相关input输入的id 值。
    提交输入submit 将显示为一个按钮（默认情况下），用户可以按下该按钮，将表单中所有其他输入元素中的数据，上传到服务器（在本例中，只有team_name）。表单属性定义用于发送数据的 HTTP method 方法，和服务器上数据的目标（action）：       
      
  
    • action: 提交表单时，要发送数据以进行处理的资源 /URL。如果未设置（或设置为空字符串），则表单将提交回当前页面 URL。
      • 
- 
    • method: 用于发送数据的HTTP方法：post 或 get。
+ 
    • method: 用于发送数据的 HTTP 方法：post 或 get。
   
        
    
      • 如果数据将导致服务器数据库的更改，则应始终使用POST 方法，因为这可以更加抵抗跨站点伪造请求攻击。
        • 
-   
      • GET 方法，只应用于不更改用户数据的表单（例如搜索表单）。当您希望能够为URL添加书签、或共享时，建议使用此选项。
        • 
+   
      • GET 方法，只应用于不更改用户数据的表单（例如搜索表单）。当您希望能够为 URL 添加书签、或共享时，建议使用此选项。
        • 
   
      
  
      • 
 
    
 
-
    服务器的角色，首先是呈现初始表单状态 - 包含空白字段或预先填充初始值。在用户按下提交按钮之后，服务器将从Web浏览器，接收具有值的表单数据，并且必须验证该信息。如果表单包含无效数据，则服务器应再次显示表单，这次使用用户输入的数据在“有效”字段中，并使用消息来描述无效字段的问题。一旦服务器获得具有所有有效表单数据的请求，它就可以执行适当的操作（例如，保存数据，返回搜索结果，上载文件等），然后通知用户。
    
+
    服务器的角色，首先是呈现初始表单状态 - 包含空白字段或预先填充初始值。在用户按下提交按钮之后，服务器将从 Web 浏览器，接收具有值的表单数据，并且必须验证该信息。如果表单包含无效数据，则服务器应再次显示表单，这次使用用户输入的数据在“有效”字段中，并使用消息来描述无效字段的问题。一旦服务器获得具有所有有效表单数据的请求，它就可以执行适当的操作（例如，保存数据，返回搜索结果，上载文件等），然后通知用户。
    
 
-
    可以想象，创建HTML，验证返回的数据，根据需要重新显示输入的数据，和错误报告，以及对有效数据执行所需的操作，都需要花费很多精力才能“正确”。通过删除一些繁重的重复代码，Django 使这变得更容易！
    
+
    可以想象，创建 HTML，验证返回的数据，根据需要重新显示输入的数据，和错误报告，以及对有效数据执行所需的操作，都需要花费很多精力才能“正确”。通过删除一些繁重的重复代码，Django 使这变得更容易！
    Django 表单处理流程
    
 
-
    Django 的表单处理，使用了我们在之前的教程中，学到的所有相同技术（用于显示有关模型的信息）：视图获取请求，执行所需的任何操作，包括从模型中读取数据，然后生成并返回HTML页面（从模板中，我们传递一个包含要显示的数据的上下文。使事情变得更复杂的是，服务器还需要能够处理用户提供的数据，并在出现任何错误时，重新显示页面。
    
+
    Django 的表单处理，使用了我们在之前的教程中，学到的所有相同技术（用于显示有关模型的信息）：视图获取请求，执行所需的任何操作，包括从模型中读取数据，然后生成并返回 HTML 页面（从模板中，我们传递一个包含要显示的数据的上下文。使事情变得更复杂的是，服务器还需要能够处理用户提供的数据，并在出现任何错误时，重新显示页面。
    下面显示了 Django 如何处理表单请求的流程图，从对包含表单的页面的请求开始（以绿色显示）。
    
 
@@ -104,7 +104,7 @@ 
    Django 表单处理流程
    Django 提供了许多工具和方法，来帮助您完成上述任务。最基本的是 Form 类，它简化了表单 HTML 和数据清理/验证的生成。在下一节中，我们将描述表单如何使用页面的实际示例，来允许图书馆员更新书本籍。
    
-
    注意: 在我们讨论 Django 更“高级”的表单框架类时，了解 Form 的使用方式，将对您有所帮助。
    
+
    注意： 在我们讨论 Django 更“高级”的表单框架类时，了解 Form 的使用方式，将对您有所帮助。
    
 
    续借表单 - 使用表单和功能视图
    
@@ -131,7 +131,7 @@ 
    声明表单
    表单字段
    
 
-
    在这种情况下，我们有一个 DateField 用于输入续借日期，该日期将使用空白值在 HTML 中呈现，默认标签为“续借日期：”，以及一些有用的用法文本：“输入从现在到 4 周之间的日期（默认为 3）周）。”  由于没有指定其他可选参数，该字段将使用 input_formats 接受日期：YYYY-MM-DD（2016-11-06）、MM/DD/YYYY（02/26/2016）、MM/DD/YY（ 10/25/16），并且将使用默认小部件呈现：DateInput。
    
+
    在这种情况下，我们有一个 DateField 用于输入续借日期，该日期将使用空白值在 HTML 中呈现，默认标签为“续借日期：”，以及一些有用的用法文本：“输入从现在到 4 周之间的日期（默认为 3）周）。”  由于没有指定其他可选参数，该字段将使用 input_formats 接受日期：YYYY-MM-DD（2016-11-06）、MM/DD/YYYY（02/26/2016）、MM/DD/YY（10/25/16），并且将使用默认小部件呈现：DateInput。
    还有许多其他类型的表单字段，您可以从它们与等效模型字段类的相似性中大致认识到：
    
 
@@ -179,12 +179,12 @@ 
    验证
    
         # Remember to always return the cleaned data.
         return data
 
-
    有两件重要的事情需要注意。首先，我们使用self.cleaned_data['renewal_date'] 获取数据，并且无论是否在函数末尾更改数据，我们都会返回此数据。此步骤使用默认验证器，将数据“清理”、并清除可能不安全的输入，并转换为数据的正确标准类型（在本例中为Python datetime.datetime对象）。
    
+
    有两件重要的事情需要注意。首先，我们使用self.cleaned_data['renewal_date'] 获取数据，并且无论是否在函数末尾更改数据，我们都会返回此数据。此步骤使用默认验证器，将数据“清理”、并清除可能不安全的输入，并转换为数据的正确标准类型（在本例中为 Python datetime.datetime对象）。
    第二点是，如果某个值超出了我们的范围，我们会引发ValidationError，指定在输入无效值时，我们要在表单中显示的错误文本。上面的例子，也将这个文本包含在 Django 的翻译函数ugettext_lazy()中（导入为 _()），如果你想在稍后翻译你的网站，这是一个很好的做法。
    
-
    注意:  在表单和字段验证（Django docs）中验证表单还有其他很多方法和示例。例如，如果您有多个相互依赖的字段，则可以覆盖Form.clean() 函数并再次引发ValidationError。
    
+
    注意：  在表单和字段验证（Django docs）中验证表单还有其他很多方法和示例。例如，如果您有多个相互依赖的字段，则可以覆盖Form.clean() 函数并再次引发ValidationError。
    
 
    这就是我们在这个例子中，对表单所需要了解的全部内容！
    
@@ -201,17 +201,17 @@ 
    URL 配置
    
     path('book/<uuid:pk>/renew/', views.renew_book_librarian, name='renew-book-librarian'),
 ]
 
-
    URL 配置会将格式为 /catalog/book/<bookinstance id>/renew/的URL，重定向到 views.py 中，名为renew_book_librarian() 的函数，并将BookInstance id作为名为 pk的参数发送。只有 pk是正确格式化的 uuid，该模式才会匹配。
    
+
    URL 配置会将格式为 /catalog/book/<bookinstance id>/renew/的 URL，重定向到 views.py 中，名为renew_book_librarian() 的函数，并将BookInstance id 作为名为 pk的参数发送。只有 pk是正确格式化的 uuid，该模式才会匹配。
    
-
    注意:  我们可以将捕获的 URL 数据，命名为“pk”，因为我们可以完全控制视图函数（我们不使用需要具有特定名称的参数的通用详细视图类）。然而，pk，“主键” primary key 的缩写，是一个合理的惯例！
    
+
    注意:  我们可以将捕获的 URL 数据，命名为“pk”，因为我们可以完全控制视图函数（我们不使用需要具有特定名称的参数的通用详细视图类）。然而，pk，“主键”primary key 的缩写，是一个合理的惯例！
    
 
    视图
    正如上面的 Django 表单处理过程中，所讨论的那样，视图必须在首次调用时呈现默认表单，然后在数据无效时，重新呈现它，并显示错误消息，或者数据有效时，处理数据，并重定向到新页面。为了执行这些不同的操作，视图必须能够知道，它是第一次被调用以呈现默认表单，还是后续处理以验证数据。
    
 
-
    对于使用POST 请求向服务器提交信息的表单，最常见的模式，是视图针对POST 请求类型进行测试（if request.method == 'POST':)以识别表单验证请求和GET （使用一个else 条件）来识别初始表单创建请求。如果要使用GET 请求提交数据，则识别这是第一个、还是后续视图调用的典型方法，是读取表单数据（例如，读取表单中的隐藏值）。
    
+
    对于使用POST 请求向服务器提交信息的表单，最常见的模式，是视图针对POST 请求类型进行测试（if request.method == 'POST':) 以识别表单验证请求和GET （使用一个else 条件）来识别初始表单创建请求。如果要使用GET 请求提交数据，则识别这是第一个、还是后续视图调用的典型方法，是读取表单数据（例如，读取表单中的隐藏值）。
    书本续借过程将写入我们的数据库，因此按照惯例，我们使用 POST 请求方法。下面的代码片段，显示了这种函数视图的（非常标准）模式。
    
 
@@ -251,7 +251,7 @@ 
    视图
      
  
    • get_object_or_404():  根据模型的主键值，从模型返回指定的对象，如果记录不存在，则引发Http404 异常（未找到）。
      • 
- 
    • HttpResponseRedirect:  这将创建指向指定URL的重定向（HTTP状态代码 302）。
      • 
+ 
    • HttpResponseRedirect:  这将创建指向指定 URL 的重定向（HTTP 状态代码 302）。
      • 
  
    • reverse():  这将从 URL 配置名称和一组参数生成 URL。它是我们在模板中使用的 url 标记的 Python 等价物。
      • 
  
    • datetime:  用于操作日期和时间的 Python 库。
      • 
 
    
@@ -267,7 +267,7 @@ 
    视图
    
 
     return render(request, 'catalog/book_renew_librarian.html', {'form': form, 'bookinst':book_inst})
 
-
    创建表单后，我们调用 render() 来创建HTML页面，指定模板和包含表单的上下文。在这种情况下，上下文还包含我们的 BookInstance，我们将在模板中使用它，来提供有关我们正在续借的书本信息。
    
+
    创建表单后，我们调用 render() 来创建 HTML 页面，指定模板和包含表单的上下文。在这种情况下，上下文还包含我们的 BookInstance，我们将在模板中使用它，来提供有关我们正在续借的书本信息。
    但是，如果这是一个POST 请求，那么我们创建表单对象，并使用请求中的数据填充它。此过程称为“绑定”，并且允许我们验证表单。然后我们检查表单是否有效，它运行所有字段上的所有验证代码 - 包括用于检查我们的日期字段，实际上是有效日期的通用代码，以及用于检查日期的特定表单的clean_renewal_date()函数在合适的范围内。
    
 
@@ -298,7 +298,7 @@ 
    视图
    重要:  虽然您也可以通过请求直接访问表单数据（例如request.POST['renewal_date'] 或 request.GET['renewal_date']（如果使用 GET 请求），但不建议这样做。清理后的数据是无害的、验证过的、并转换为 Python 友好类型。
    
 
-
    视图的表单处理部分的最后一步，是重定向到另一个页面，通常是“成功”页面。在这种情况下，我们使用 HttpResponseRedirect 和 reverse() ，重定向到名为'all-borrowed'的视图（这是在 Django 教程第 8 部分中创建的 “挑战”：用户身份验证和权限）。如果您没有创建该页面，请考虑重定向到URL'/'处的主页。
    
+
    视图的表单处理部分的最后一步，是重定向到另一个页面，通常是“成功”页面。在这种情况下，我们使用 HttpResponseRedirect 和 reverse() ，重定向到名为'all-borrowed'的视图（这是在 Django 教程第 8 部分中创建的“挑战”：用户身份验证和权限）。如果您没有创建该页面，请考虑重定向到 URL'/'处的主页。
    这就是表单处理本身所需的一切，但我们仍然需要将视图，限制为图书馆员可以访问。我们应该在 BookInstance （“can_renew”）中创建一个新的权限，但为了简单起见，我们只需使用@permission_required函数装饰器，和我们现有的 can_mark_returned 权限。
    
 
@@ -366,10 +366,10 @@ 
    模板
    这里大部分内容，和以前的教程都是完全类似的。我们扩展基本模板，然后重新定义内容块。我们能够引用 \{{bookinst}}（及其变量），因为它被传递到 render()函数中的上下文对象中，我们使用这些来列出书名，借阅者和原始截止日期。
    
 
-
    表单代码相对简单。首先，我们声明表单标签，指定表单的提交位置（action）和提交数据的方法（在本例中为 “HTTP POST”） - 如果您回想一下页面顶部的 HTML 表单概述，如图所示的空action ，意味着表单数据将被发布回页面的当前 URL（这是我们想要的！）。在标签内部，我们定义了submit 提交输入，用户可以按这个输入来提交数据。在表单标签内添加的{% csrf_token %} ，是 Django 跨站点伪造保护的一部分。
    
+
    表单代码相对简单。首先，我们声明表单标签，指定表单的提交位置（action）和提交数据的方法（在本例中为“HTTP POST”） - 如果您回想一下页面顶部的 HTML 表单概述，如图所示的空action ，意味着表单数据将被发布回页面的当前 URL（这是我们想要的！）。在标签内部，我们定义了submit 提交输入，用户可以按这个输入来提交数据。在表单标签内添加的{% csrf_token %} ，是 Django 跨站点伪造保护的一部分。
    
-
    注意:  将{% csrf_token %} 添加到您创建的每个使用 POST 提交数据的 Django 模板中。这将减少恶意用户劫持表单的可能性。
    
+
    注意：  将{% csrf_token %} 添加到您创建的每个使用 POST 提交数据的 Django 模板中。这将减少恶意用户劫持表单的可能性。
    
 
    剩下的就是 \{{form}}模板变量，我们将其传递给上下文字典中的模板。也许不出所料，当如图所示使用时，它提供了所有表单字段的默认呈现，包括它们的标签、小部件、和帮助文本 - 呈现如下所示：
    
@@ -385,7 +385,7 @@ 
    模板
    
-
    注意:   它可能并不明显，因为我们只有一个字段，但默认情况下，每个字段都在其自己的表格行中定义（这就是变量在上面的table 表格标记内部的原因）。如果您引用模板变量\{{ form.as_table }}，会提供相同的渲染。
    
+
    注意：   它可能并不明显，因为我们只有一个字段，但默认情况下，每个字段都在其自己的表格行中定义（这就是变量在上面的table 表格标记内部的原因）。如果您引用模板变量\{{ form.as_table }}，会提供相同的渲染。
    
 
    如果您输入无效日期，您还会获得页面中呈现的错误列表（下面以粗体显示）。
    
@@ -411,16 +411,16 @@ 
    使用表单模板变量的其
 
      
  
    • \{{form.renewal_date}}: 整个领域。
      • 
  
    • \{{form.renewal_date.errors}}: 错误列表。
      • 
- 
    • \{{form.renewal_date.id_for_label}}: 标签的 id 。
      • 
+ 
    • \{{form.renewal_date.id_for_label}}: 标签的 id。
      • 
  
    • \{{form.renewal_date.help_text}}: 字段帮助文本。
      • 
- 
    •  其他等等!
      • 
+ 
    •  其他等等！
      • 
 
    
 
-
    有关如何在模板中，手动呈现表单，并动态循环模板字段的更多示例，请参阅使用表单>手动呈现字段（Django文档）。
    
+
    有关如何在模板中，手动呈现表单，并动态循环模板字段的更多示例，请参阅使用表单>手动呈现字段（Django 文档）。
    
 
 
    测试页面
    
 
-
    如果您接受了Django 教程第 8 部分中的 “挑战”：用户身份验证和权限，您将获得图书馆中借出的所有书本的列表，这只有图书馆工作人员才能看到。我们可以使用下面的模板代码，为每个项目旁边的续借页面，添加链接。
    
+
    如果您接受了Django 教程第 8 部分中的“挑战”：用户身份验证和权限，您将获得图书馆中借出的所有书本的列表，这只有图书馆工作人员才能看到。我们可以使用下面的模板代码，为每个项目旁边的续借页面，添加链接。
    {% if perms.catalog.can_mark_returned %}- <a href="{% url 'renew-book-librarian' bookinst.id %}">Renew</a>  {% endif %}
    
 
@@ -428,7 +428,7 @@ 
    测试页面
    注意:  请记住，您的测试登录需要具有“catalog.can_mark_returned”权限，才能访问续借书本页面（可能使用您的超级用户帐户）。
    
 
-
    您也可以手动构建这样的测试URL  -  http://127.0.0.1:8000/catalog/book/<bookinstance_id>/renew/ （可以通过导航到图书馆中的书本详细信息页面，获取有效的 bookinstance id，并复制id 字段）。
    
+
    您也可以手动构建这样的测试 URL  -  http://127.0.0.1:8000/catalog/book/<bookinstance_id>/renew/ （可以通过导航到图书馆中的书本详细信息页面，获取有效的 bookinstance id，并复制id 字段）。
    它看起来是什么样子？
    
 
@@ -465,7 +465,7 @@ 
    模型表单
    注意:  这可能看起来不像使用Form 那么简单（在这种情况下不是这样，因为我们只有一个字段）。但是，如果你有很多字段，它可以显着减少代码量！
    
 
-
    其余信息来自模型字段的定义（例如标签、小部件、帮助文本、错误消息）。如果这些不太正确，那么我们可以在 Meta类中覆盖它们，指定包含要更改的字段、及其新值的字典。例如，在这种形式中，我们可能需要 “更新日期” Renewal date 字段的标签（而不是基于字段名称的默认值：截止日期 Due date），并且我们还希望我们的帮助文本，特定于此用例。下面的Meta 显示了如何覆盖这些字段，如果默认值不够，您可以类似地方式设置widgets 窗口小部件和error_messages 。
    
+
    其余信息来自模型字段的定义（例如标签、小部件、帮助文本、错误消息）。如果这些不太正确，那么我们可以在 Meta类中覆盖它们，指定包含要更改的字段、及其新值的字典。例如，在这种形式中，我们可能需要“更新日期” Renewal date 字段的标签（而不是基于字段名称的默认值：截止日期 Due date），并且我们还希望我们的帮助文本，特定于此用例。下面的Meta 显示了如何覆盖这些字段，如果默认值不够，您可以类似地方式设置widgets 窗口小部件和error_messages 。
    class Meta:
     model = BookInstance
@@ -505,10 +505,10 @@ 
    模型表单
    
 
 
    通用编辑视图
    
 
-
    我们在上面的函数视图示例中，使用的表单处理算法，表示表单编辑视图中非常常见的模式。 Django 通过创建基于模型创建、编辑和删除视图的通用编辑视图，为您抽象出大部分“样板”。这些不仅处理“视图”行为，而且它们会自动从模型中为您创建表单类（ModelForm）。
    
+
    我们在上面的函数视图示例中，使用的表单处理算法，表示表单编辑视图中非常常见的模式。Django 通过创建基于模型创建、编辑和删除视图的通用编辑视图，为您抽象出大部分“样板”。这些不仅处理“视图”行为，而且它们会自动从模型中为您创建表单类（ModelForm）。
    
 
 
    
-
    注意:  除了这里描述的编辑视图之外，还有一个 FormView 类，它位于我们的函数视图，和其他通用视图之间的 “灵活性” 与 “编码工作” 之间。使用 FormView ，您仍然需要创建表单，但不必实现所有标准表单处理模式。相反，您只需提供一个函数的实现，一旦知道提交有效，就会调用该函数。
    
+
    注意:  除了这里描述的编辑视图之外，还有一个 FormView 类，它位于我们的函数视图，和其他通用视图之间的“灵活性”与“编码工作”之间。使用 FormView ，您仍然需要创建表单，但不必实现所有标准表单处理模式。相反，您只需提供一个函数的实现，一旦知道提交有效，就会调用该函数。
    
 
    
 
 
    在本节中，我们将使用通用编辑视图，来创建页面，以添加从我们的库中创建、编辑和删除Author 作者记录的功能 - 有效地提供管理站点一部分的基本重新实现（这可能很有用，如果您需要比管理站点能提供的、更加灵活的管理功能）。
    
@@ -536,13 +536,13 @@ 
    视图
    
 
 
    如您所见，要创建视图，您需要从CreateView, UpdateView, 和 DeleteView（分别）派生，然后定义关联的模型。
    
 
-
    对于 “创建” 和 “更新” 的情况，您还需要指定要在表单中显示的字段（使用与ModelForm相同的语法）。在这种情况下，我们将说明两者的语法，如何显示 “所有” 字段，以及如何单独列出它们。您还可以使用 field_name / value对的字典，为每个字段指定初始值（此处我们为了演示目的，而任意设置死亡日期 - 您可能希望删除它！）。默认情况下，这些视图会在成功时，重定向到显示新创建/编辑的模型项的页面，在我们的示例中，这将是我们在上一个教程中，创建的作者详细信息视图。您可以通过显式声明参数success_url  ，指定备用重定向位置（与AuthorDelete 类一样）。
    
+
    对于“创建”和“更新”的情况，您还需要指定要在表单中显示的字段（使用与ModelForm相同的语法）。在这种情况下，我们将说明两者的语法，如何显示“所有”字段，以及如何单独列出它们。您还可以使用 field_name / value 对的字典，为每个字段指定初始值（此处我们为了演示目的，而任意设置死亡日期 - 您可能希望删除它！）。默认情况下，这些视图会在成功时，重定向到显示新创建/编辑的模型项的页面，在我们的示例中，这将是我们在上一个教程中，创建的作者详细信息视图。您可以通过显式声明参数success_url  ，指定备用重定向位置（与AuthorDelete 类一样）。
    
 
 
    AuthorDelete 类不需要显示任何字段，因此不需要指定这些字段。但是你需要指定success_url，因为 Django 没有明显的默认值。在这种情况下，我们使用reverse_lazy()函数，在删除作者后，重定向到我们的作者列表 -  reverse_lazy()是一个延迟执行的reverse()版本，在这里使用，是因为我们提供了一个基于类的 URL 查看属性。
    
 
 
    模板
    
 
-
    “创建” 和 “更新” 视图默认使用相同的模板，它将以您的模型命名：model_name_form.html（您可以使用视图中的template_name_suffix 字段，将后缀更改为_form 以外的其他内容，例如，template_name_suffix = '_other_suffix'）
    
+
    “创建”和“更新”视图默认使用相同的模板，它将以您的模型命名：model_name_form.html（您可以使用视图中的template_name_suffix 字段，将后缀更改为_form 以外的其他内容，例如，template_name_suffix = '_other_suffix'）
    
 
 
    创建模板文件 locallibrary/catalog/templates/catalog/author_form.html，并复制到下面的文本中。
    
 
@@ -580,7 +580,7 @@ 
    模板
    
 {% endblock %}
 
    
 
-
    URL配置
    
+
    URL 配置
    打开 URL 配置文件（locallibrary/catalog/urls.py），并将以下配置，添加到文件的底部：
    
 
@@ -608,9 +608,9 @@ 
    测试页面
    输入字段的值，然后按“提交” Submit  ，保存作者记录。现在，您应该进入新作者的详细视图，其 URL 为 http://127.0.0.1:8000/catalog/author/10。
    
 
-
    您可以通过将 /update/ ，附加到详细视图 URL 的末尾，来测试编辑记录（例如http://127.0.0.1:8000/catalog/author/10/update/） - 我们不显示截图，因为它看起来就像“创建”页面！
    
+
    您可以通过将 /update/ ，附加到详细视图 URL 的末尾，来测试编辑记录（例如 http://127.0.0.1:8000/catalog/author/10/update/） - 我们不显示截图，因为它看起来就像“创建”页面！
    
 
-
    最后，我们可以删除页面，方法是将删除，附加到作者详细信息视图URL的末尾（例如http://127.0.0.1:8000/catalog/author/10/delete/）。 Django应该显示如下所示的删除页面。按 "是，删除" (Yes, delete)。删除记录，并将其带到所有作者的列表中。
    
+
    最后，我们可以删除页面，方法是将删除，附加到作者详细信息视图 URL 的末尾（例如 http://127.0.0.1:8000/catalog/author/10/delete/）。Django 应该显示如下所示的删除页面。按 "是，删除" (Yes, delete)。删除记录，并将其带到所有作者的列表中。
    
 
@@ -627,7 +627,7 @@ 
    挑战自己
    总结
    
 
-
    创建和处理表单可能是一个复杂的过程！ Django通过提供声明、呈现和验证表单的编程机制，使其变得更加容易。此外，Django提供了通用的表单编辑视图，几乎可以完成所有工作，以定义可以创建，编辑和删除与单个模型实例关联的记录的页面。
    
+
    创建和处理表单可能是一个复杂的过程！Django 通过提供声明、呈现和验证表单的编程机制，使其变得更加容易。此外，Django 提供了通用的表单编辑视图，几乎可以完成所有工作，以定义可以创建，编辑和删除与单个模型实例关联的记录的页面。
    表单可以完成更多工作（请参阅下面的“请参阅”列表），但您现在应该了解，如何将基本表单和表单处理代码，添加到您自己的网站。
    
 
diff --git a/files/zh-cn/learn/server-side/django/generic_views/index.html b/files/zh-cn/learn/server-side/django/generic_views/index.html
index 85a33ef6436d3b..1497c1ae9d85d9 100644
--- a/files/zh-cn/learn/server-side/django/generic_views/index.html
+++ b/files/zh-cn/learn/server-side/django/generic_views/index.html
@@ -7,17 +7,17 @@
 
 
    {{PreviousMenuNext("Learn/Server-side/Django/Home_page", "Learn/Server-side/Django/Sessions", "Learn/Server-side/Django")}}
    
 
-
    本教程扩充了 LocalLibrary 网站，为书本与作者增加列表与细节页面。此处我们将学到通用类别视图，并演示如何降低你必须为一般使用案例撰写的程式码数量。我们也会更加深入URL处理细节，演示如何实施基本模式匹配。
    
+
    本教程扩充了 LocalLibrary 网站，为书本与作者增加列表与细节页面。此处我们将学到通用类别视图，并演示如何降低你必须为一般使用案例撰写的程式码数量。我们也会更加深入 URL 处理细节，演示如何实施基本模式匹配。
    
  
   
    前置条件:前置条件：
    完成所有先前的教程主题，包含 Django 教程 8: 使用者授权与许可。
   
    
   
    目標:目標：
    了解如何撰写表单，向使用者取得资料，并更新资料库。了解通用类别表单编辑视图，如何大量地简化用于单一模型的新表单制作。
   
    
      
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
    
-   
+   
-   
-   
+   
+   
    
  
   
    先决条件:先决条件：
    完成所有先前的教程主题，包含Django 教程 5: 创建主页。
   
    
   
    目标:了解如何使用、在何处使用通用类别视图，以及如何从URLs取出模式，如何传送资料到视图。目标：了解如何使用、在何处使用通用类别视图，以及如何从 URLs 取出模式，如何传送资料到视图。
   
    
      
 
    
@@ -26,17 +26,17 @@ 
    概览
    
 
 
    本教程中，通过为书本和作者添加列表和详细信息页面，我们将完成第一个版本的LocalLibrary 网站（或者更准确地说，我们将向您展示如何实现书页，并让您自己创建作者页面！）
    
 
-
    该过程类似于创建索引页面，我们在上一个教程中展示了该页面。我们仍然需要创建URL地图，视图和模板。主要区别在于，对于详细信息页面，我们还有一个额外的挑战，即从URL中的模式中提取信息，并将其传递给视图。对于这些页面，我们将演示一种完全不同的视图类型：基于类别的通用列表和详细视图。这些可以显着减少所需的视图代码量，使其更易于编写和维护。
    
+
    该过程类似于创建索引页面，我们在上一个教程中展示了该页面。我们仍然需要创建 URL 地图，视图和模板。主要区别在于，对于详细信息页面，我们还有一个额外的挑战，即从 URL 中的模式中提取信息，并将其传递给视图。对于这些页面，我们将演示一种完全不同的视图类型：基于类别的通用列表和详细视图。这些可以显着减少所需的视图代码量，使其更易于编写和维护。
    
 
 
    本教程的最后一部分，将演示在使用基于类别的通用列表视图时，如何对数据进行分页。
    
 
 
    书本清单页面
    
 
-
    书本清单页面，将显示页面中所有可用图书记录的列表，使用url: catalog/books/进行访问。该页面将显示每条记录的标题和作者，标题是指向相关图书详细信息页面的超链接。该页面将具有与站点中，所有其他页面相同的结构和导航，因此，我们可以扩展在上一个教程中创建的基本模板（base_generic.html）。
    
+
    书本清单页面，将显示页面中所有可用图书记录的列表，使用 url: catalog/books/进行访问。该页面将显示每条记录的标题和作者，标题是指向相关图书详细信息页面的超链接。该页面将具有与站点中，所有其他页面相同的结构和导航，因此，我们可以扩展在上一个教程中创建的基本模板（base_generic.html）。
    
 
 
    URL 映射
    
 
-
    打开/catalog/urls.py ，并复制到下面粗体显示的行中。就像索引页面的方式，这个path()函数，定义了一个与 URL 匹配的模式（'books/'），如果URL匹配，将调用视图函数（views.BookListView.as_view()）和一个对应这个特定映射的名称。
    
+
    打开/catalog/urls.py ，并复制到下面粗体显示的行中。就像索引页面的方式，这个path()函数，定义了一个与 URL 匹配的模式（'books/'），如果 URL 匹配，将调用视图函数（views.BookListView.as_view()）和一个对应这个特定映射的名称。
    
 
 
    urlpatterns = [
     path('', views.index, name='index'),
@@ -45,7 +45,7 @@ 
    URL 映射
    
 
 
    正如前一个教程中所讨论的，URL 必须已经先匹配了/catalog，因此实际上将为 URL 调用的视图是：/catalog/books/。
    
 
-
    视图函数具有与以前不同的格式 - 这是因为该视图，实际上将以类别来实现。我们将继承现有的泛型视图函数，该函数已经完成了我们希望此视图函数执行的大部分工作，而不是从头开始编写自己的函数。对于基于Django类的视图，我们通过调用类方法as_view()，来访问适当的视图函数。这样做可以创建类的实例，并确保为传入的 HTTP 请求调用正确的处理程序方法。
    
+
    视图函数具有与以前不同的格式 - 这是因为该视图，实际上将以类别来实现。我们将继承现有的泛型视图函数，该函数已经完成了我们希望此视图函数执行的大部分工作，而不是从头开始编写自己的函数。对于基于 Django 类的视图，我们通过调用类方法as_view()，来访问适当的视图函数。这样做可以创建类的实例，并确保为传入的 HTTP 请求调用正确的处理程序方法。
    
 
 
    视图 (基于类别)
    
 
@@ -64,7 +64,7 @@ 
    视图 (基于类别)
    
 
    注意: 模板位置的这个尴尬路径不是印刷错误 - 通用视图在应用程序的/application_name/templates/目录中（/catalog/templates/），查找模板/application_name/the_model_name_list.html（在本例中为catalog/book_list.html）。
    
 
    
 
-
    您可以添加属性，以更改上面的默认行为。例如，如果需要使用同一模型的多个视图，则可以指定另一个模板文件，或者如果book_list对于特定模板用例不直观，则可能需要使用不同的模板变量名称。可能最有用的变更，是更改/过滤返回的结果子集 - 因此，您可能会列出其他用户阅读的前5本书，而不是列出所有书本。
    
+
    您可以添加属性，以更改上面的默认行为。例如，如果需要使用同一模型的多个视图，则可以指定另一个模板文件，或者如果book_list对于特定模板用例不直观，则可能需要使用不同的模板变量名称。可能最有用的变更，是更改/过滤返回的结果子集 - 因此，您可能会列出其他用户阅读的前 5 本书，而不是列出所有书本。
    
 
 
    class BookListView(generic.ListView):
     model = Book
@@ -106,7 +106,7 @@ 
    覆盖基于类别的视图中
 
 
 
    
-
    注意: 查看内置的基于类的通用视图（Django文档），了解更多可以执行的操作示例。
    
+
    注意: 查看内置的基于类的通用视图（Django 文档），了解更多可以执行的操作示例。
    
 
    
 
 
    创建列表视图模板
    
@@ -170,15 +170,15 @@ 
    访问变量
    
 
 
    我们使用“点符号”（例如 book.title 和 book.author）访问相关书本记录的字段，其中书本项目book后面的文本是字段名称（如同在模型中定义的）。
    
 
-
    我们还可以在模板中，调用模型中的函数 - 在这里，我们调用Book.get_absolute_url()，来获取可用于显示关联详细记录的URL。这项工作提供的函数没有任何参数（没有办法传递参数！）
    
+
    我们还可以在模板中，调用模型中的函数 - 在这里，我们调用Book.get_absolute_url()，来获取可用于显示关联详细记录的 URL。这项工作提供的函数没有任何参数（没有办法传递参数！）
    
 
 
    
-
    注意: 在模板中调用函数时，我们必须要小心“副作用”。在这里我们只需要显示一个URL，但是一个函数几乎可以做任何事情 - 我们不想仅仅通过渲染模板，而删除了我们的数据库（例如）！
    
+
    注意: 在模板中调用函数时，我们必须要小心“副作用”。在这里我们只需要显示一个 URL，但是一个函数几乎可以做任何事情 - 我们不想仅仅通过渲染模板，而删除了我们的数据库（例如）！
    
 
    
 
 
    更新基本模板
    
 
-
    打开基本模板（/locallibrary/catalog/templates/base_generic.html）并将 {% url 'books' %} 插入所有书本 All books 的 URL 链接，如下所示。这将启用所有页面中的链接（由于我们已经创建了 “books” 的 url 映射器，我们可以成功地将其设置到位）。
    
+
    打开基本模板（/locallibrary/catalog/templates/base_generic.html）并将 {% url 'books' %} 插入所有书本 All books 的 URL 链接，如下所示。这将启用所有页面中的链接（由于我们已经创建了“books”的 url 映射器，我们可以成功地将其设置到位）。
    
 
 
    <li><a href="{% url 'index' %}">Home</a></li>
 <li><a href="{% url 'books' %}">All books</a></li>
@@ -186,7 +186,7 @@ 
    更新基本模板
    
 
 
    它看起来是什么样子？
    
 
-
    您将无法构建书本清单，因为我们仍然缺少依赖项 - 书本详细信息页面的URL地图，这是创建单个书本的超链接所必需的。我们将在下一节之后，说明列表和详细视图的部分。
    
+
    您将无法构建书本清单，因为我们仍然缺少依赖项 - 书本详细信息页面的 URL 地图，这是创建单个书本的超链接所必需的。我们将在下一节之后，说明列表和详细视图的部分。
    
 
 
    书本详细信息页面
    
 
@@ -202,12 +202,12 @@ 
    URL 映射
    
     path('book/<int:pk>', views.BookDetailView.as_view(), name='book-detail'),
 ]
    
 
-
    对于书本详细信息路径，URL 模式使用特殊语法，来捕获我们想要查看的书本的特定 id。语法非常简单：尖括号定义要捕获的URL部分，包含视图可用于访问捕获数据的变量的名称。例如，<something> 将捕获标记的模式，并将值作为变量 “something” ，传递给视图。您可以选择在变量名称前，加上一个定义数据类型的转换器规范（int，str，slug，uuid，path）。
    
+
    对于书本详细信息路径，URL 模式使用特殊语法，来捕获我们想要查看的书本的特定 id。语法非常简单：尖括号定义要捕获的 URL 部分，包含视图可用于访问捕获数据的变量的名称。例如，<something> 将捕获标记的模式，并将值作为变量“something” ，传递给视图。您可以选择在变量名称前，加上一个定义数据类型的转换器规范（int，str，slug，uuid，path）。
    
 
 
    在这里，我们使用 '<int:pk>' 来捕获 book id，它必须是一个整数，并将其作为名为 pk 的参数（主键的缩写）传递给视图。
    
 
 
    
-
    注意: 如前所述，我们匹配的URL实际上是 catalog/book/<digits>（因为我们在应用程序 catalog 中，假定使用/catalog/）。
    
+
    注意: 如前所述，我们匹配的 URL 实际上是 catalog/book/<digits>（因为我们在应用程序 catalog 中，假定使用/catalog/）。
    
 
    
 
 
    
@@ -263,7 +263,7 @@ 
    高级路径匹配/正则表达
   
   
    +
-   匹配前面一个或多个字符。例如，要匹配一个或多个位数的数字，您将使用\d+。要匹配一个或多个“ a” 字符，您可以使用 a+
+   匹配前面一个或多个字符。例如，要匹配一个或多个位数的数字，您将使用\d+。要匹配一个或多个“a”字符，您可以使用 a+
   
   
    *
@@ -308,14 +308,14 @@ 
    高级路径匹配/正则表达
   
   
    r'^book/(\d+)$'
-   这与前面的例子匹配相同的URL。捕获的信息，将作为未命名的参数，发送到视图。
+   这与前面的例子匹配相同的 URL。捕获的信息，将作为未命名的参数，发送到视图。
   
   
    r'^book/(?P<stub>[-\w]+)$'
    
-    
    这匹配一个字符串，该字符串在行（^book/）的开头具有book/，然后有一个或多个字符，可以是 ' - ' 或单词字符（([-\w]+），然后结束。它还捕获这组字符，并将它们传递给名为 “stub” 的参数中的视图。
    
+    
    这匹配一个字符串，该字符串在行（^book/）的开头具有book/，然后有一个或多个字符，可以是 ' - ' 或单词字符（([-\w]+），然后结束。它还捕获这组字符，并将它们传递给名为“stub”的参数中的视图。
    
 
-    
    这是 “stub” 的一种相当典型的模式。存根stub 是用于数据的、 URL 友好的、基于单词的主键。如果您希望本书网址提供更多信息，则可以使用 stub。例如 /catalog/book/the-secret-garden ，而不是/catalog/book/33。
    
+    
    这是“stub”的一种相当典型的模式。存根 stub 是用于数据的、URL 友好的、基于单词的主键。如果您希望本书网址提供更多信息，则可以使用 stub。例如 /catalog/book/the-secret-garden ，而不是/catalog/book/33。
    
    
   
  
@@ -338,7 +338,7 @@ 
    在 URL 地图中传递其他选项
 
    
 
 
    
-
    注意: 额外选项和命名捕获的模式，二者都作为命名参数传递给视图。如果对捕获的模式和额外选项使用相同的名称，则仅将捕获的模式值发送到视图（将删除附加选项中指定的值）。
    
+
    注意： 额外选项和命名捕获的模式，二者都作为命名参数传递给视图。如果对捕获的模式和额外选项使用相同的名称，则仅将捕获的模式值发送到视图（将删除附加选项中指定的值）。
    
 
    
 
 
    视图 (基于类别)
    
@@ -348,13 +348,13 @@ 
    视图 (基于类别)
    
 
    class BookDetailView(generic.DetailView):
     model = Book
    
 
-
    就是这样！您现在需要做的就是创建一个名为 /locallibrary/catalog/templates/catalog/book_detail.html 的模板，该视图将向此模板，传递 URL 映射器提取的特定 Book 记录的数据库信息。在模板中，您可以使用名为  object 或 book的模板变量（即通常为 “the_model_name”），以访问书本列表。
    
+
    就是这样！您现在需要做的就是创建一个名为 /locallibrary/catalog/templates/catalog/book_detail.html 的模板，该视图将向此模板，传递 URL 映射器提取的特定 Book 记录的数据库信息。在模板中，您可以使用名为  object 或 book的模板变量（即通常为“the_model_name”），以访问书本列表。
    
 
 
    如果需要，可以更改使用的模板，以及用于在模板中，引用该书本的上下文对象的名称。您还可以覆盖方法，例如，向上下文添加其他信息。
    
 
 
    如果记录不存在会怎样？
    
 
-
    如果请求的记录不存在，那么基于类的通用详细信息视图，将自动为您引发 Http404 异常 - 在生产环境中，这将自动显示适当的 “未找到资源” 页面，您可以根据需要自定义该页面。
    
+
    如果请求的记录不存在，那么基于类的通用详细信息视图，将自动为您引发 Http404 异常 - 在生产环境中，这将自动显示适当的“未找到资源”页面，您可以根据需要自定义该页面。
    
 
 
    为了让您了解其工作原理，下面的代码片段，演示了如何在不使用基于类的详细信息视图的情况下，将基于类的视图实现为函数。
    
 
@@ -373,7 +373,7 @@ 
    如果记录不存在会怎样？
    
 
-
    视图首先尝试从模型中，获取特定的书本记录。如果失败，则视图应引发 Http404异常，以指示该书本 “未找到”。然后，最后一步是使用模板名称，和上下文参数context中的书本数据（作为字典）调用render()。
    
+
    视图首先尝试从模型中，获取特定的书本记录。如果失败，则视图应引发 Http404异常，以指示该书本“未找到”。然后，最后一步是使用模板名称，和上下文参数context中的书本数据（作为字典）调用render()。
    
 
 
    
 
    注意: get_object_or_404()（如上所示）是一个方便的快捷方式，用于在未找到记录时，引发 Http404 异常。
    
@@ -411,7 +411,7 @@ 
    创建详细信息视图模板
    
 
 
 
    
-
    注意: 上面模板中的作者链接，有一个空 URL，因为我们尚未创建作者详细信息页面。一旦创建了，您应该像这样更新URL：
    
+
    注意：上面模板中的作者链接，有一个空 URL，因为我们尚未创建作者详细信息页面。一旦创建了，您应该像这样更新 URL：
    
 
 
    <a href="{% url 'author-detail' book.author.pk %}">\{{ book.author }}</a>
 
    
@@ -420,19 +420,19 @@ 
    创建详细信息视图模板
    
 
    虽然有点大，但此模板中的几乎所有内容，都已在前面描述过：
    
 
 
      
- 
    • 我们扩展基本模板，并覆盖 “内容”区块 content。
      • 
+ 
    • 我们扩展基本模板，并覆盖“内容”区块 content。
      • 
  
    • 我们使用条件处理，来确定是否显示特定内容。
      • 
  
    • 我们使用 for 循环遍历对象列表。
      • 
- 
    • 我们使用 "点表示法" 访问上下文字段（因为我们使用了详细的通用视图，上下文被命名为book；我们也可以使用 “object”）。
      • 
+ 
    • 我们使用 "点表示法" 访问上下文字段（因为我们使用了详细的通用视图，上下文被命名为book；我们也可以使用“object”）。
      • 
 
    
 
-
    我们以前没见过的一件有趣的事情是函数book.bookinstance_set.all()。此方法由 Django “自动” 构造，以便返回与特定 Book 相关联的 BookInstance记录集合。
    
+
    我们以前没见过的一件有趣的事情是函数book.bookinstance_set.all()。此方法由 Django“自动”构造，以便返回与特定 Book 相关联的 BookInstance记录集合。
    
 
 
    {% for copy in book.bookinstance_set.all %}
 <!-- code to iterate across each copy/instance of a book -->
 {% endfor %}
    
 
-
    需要此方法，是因为您仅在关系的 “一” 侧声明 ForeignKey（一对多）字段。由于您没有做任何事情，来声明其他（“多”）模型中的关系，因此它没有任何字段，来获取相关记录集。为了解决这个问题，Django构造了一个适当命名的 “反向查找” 函数，您可以使用它。函数的名称，是通过对声明 ForeignKey 的模型名称，转化为小写来构造的，然后是_set（即，在 Book 中创建的函数是 bookinstance_set()）。
    
+
    需要此方法，是因为您仅在关系的“一”侧声明 ForeignKey（一对多）字段。由于您没有做任何事情，来声明其他（“多”）模型中的关系，因此它没有任何字段，来获取相关记录集。为了解决这个问题，Django 构造了一个适当命名的“反向查找”函数，您可以使用它。函数的名称，是通过对声明 ForeignKey 的模型名称，转化为小写来构造的，然后是_set（即，在 Book 中创建的函数是 bookinstance_set()）。
    
 
 
    
 
    注意: 这里我们使用all()来获取所有记录（默认值）。虽然您可以使用filter()方法获取代码中的记录子集，但您无法直接在模板中执行此操作，因为您无法指定函数的参数。
    
@@ -450,8 +450,8 @@ 
    创建详细信息视图模板
    
 
 
      
  
    1. 在模型的class Meta声明中，添加排序ordering。
      2. 
- 
    2. Add a queryset attribute in your custom class-based view, specifying a order_by().在自定义基于类的视图中添加queryset属性，指定order_by（）。
      3. 
- 
    3. Adding a get_queryset method to your custom class-based view and also specify the order_by().将get_queryset方法添加到基于类的自定义视图中，并指定order_by（）。
      4. 
+ 
    4. Add a queryset attribute in your custom class-based view, specifying a order_by().在自定义基于类的视图中添加 queryset 属性，指定 order_by（）。
      5. 
+ 
    5. Adding a get_queryset method to your custom class-based view and also specify the order_by().将 get_queryset 方法添加到基于类的自定义视图中，并指定 order_by（）。
      6. 
 
    
 
 
    如果您决定使用class Meta 作为作者模型Author（可能不像定制基于类的视图那样灵活，但很容易），您最终会得到这样的结果：
    
@@ -481,7 +481,7 @@ 
    它看起来是什么样子？
    
 
    此时，我们应该创建了显示书本列表，和书本详细信息页面所需的所有内容。运行服务器（python3 manage.py runserver），并打开浏览器到 http://127.0.0.1:8000/。
    
 
 
    
-
    警告: 请还不要点击任何作者、或作者详细信息链接 - 您将在挑战练习中，创建这些链接！
    
+
    警告： 请还不要点击任何作者、或作者详细信息链接 - 您将在挑战练习中，创建这些链接！
    
 
    
 
 
    单击所有书籍链接 All books ，以显示书籍列表。
    
@@ -506,7 +506,7 @@ 
    视图
    
     model = Book
     paginate_by = 10
    -

    通过添加这行，只要您有超过10条记录，视图就会开始对它发送到模板的数据，进行分页。使用 GET 参数访问不同的页面 - 要访问第2页，您将使用URL：/catalog/books/?page=2。

    +

    通过添加这行，只要您有超过 10 条记录，视图就会开始对它发送到模板的数据，进行分页。使用 GET 参数访问不同的页面 - 要访问第 2 页，您将使用 URL：/catalog/books/?page=2。

    模板

    @@ -534,15 +534,15 @@

    模板

    {% endif %} {% endblock %} -

    page_obj 是一个 Paginator 对象，如果在当前页面上使用分页，它将存在。 它允许您获取有关当前页面，之前页面，有多少页面等的所有信息。

    +

    page_obj 是一个 Paginator 对象，如果在当前页面上使用分页，它将存在。它允许您获取有关当前页面，之前页面，有多少页面等的所有信息。

    -

    我们使用 \{{ request.path }}，来获取用于创建分页链接的当前页面URL。 这很有用，因为它独立于我们正在分页的对象。

    +

    我们使用 \{{ request.path }}，来获取用于创建分页链接的当前页面 URL。这很有用，因为它独立于我们正在分页的对象。

    就是这样！

    它看起来是什么样子的？

    -

    下面的屏幕截图,显示了分页的样子 - 如果您没有在数据库中输入超过10个标题，那么您可以通过降低 catalog/views.py 文件中 paginate_by 行指定的数量，来更轻松地测试它。 为了得到以下结果，我们将其更改为 paginate_by = 2。

    +

    下面的屏幕截图，显示了分页的样子 - 如果您没有在数据库中输入超过 10 个标题，那么您可以通过降低 catalog/views.py 文件中 paginate_by 行指定的数量，来更轻松地测试它。为了得到以下结果，我们将其更改为 paginate_by = 2。

    分页链接显示在底部，根据您所在的页面，显示下一个/上一个链接。

    @@ -550,7 +550,7 @@

    它看起来是什么样子的？

    挑战自己 -

    本文中的挑战，是创建完成项目所需的作者详细信息视图，和列表视图。这些应在以下URL中提供：

    +

    本文中的挑战，是创建完成项目所需的作者详细信息视图，和列表视图。这些应在以下 URL 中提供：