url(r'^(?P<question_id>[0-9]+)/vote/$', views.vote, name='vote'),

polls/urls.py

我们还创建了该vote()函数的虚拟实现。让我们创建一个真实版本。将以下内容添加到polls/views.py：

from django.shortcuts import get_object_or_404, render
from django.http import HttpResponseRedirect, HttpResponse
from django.urls import reverse

from .models import Choice, Question
# ...
def vote(request, question_id):
    question = get_object_or_404(Question, pk=question_id)
    try:
        selected_choice = question.choice_set.get(pk=request.POST['choice'])
    except (KeyError, Choice.DoesNotExist):
        # Redisplay the question voting form.
        return render(request, 'polls/detail.html', {
            'question': question,
            'error_message': "You didn't select a choice.",
        })
    else:
        selected_choice.votes += 1
        selected_choice.save()
        # Always return an HttpResponseRedirect after successfully dealing
        # with POST data. This prevents data from being posted twice if a
        # user hits the Back button.
        return HttpResponseRedirect(reverse('polls:results', args=(question.id,)))

polls/views.py

此代码包含我们在本教程中尚未涉及的一些内容：

• request.POST是一个类似字典的对象，允许您按键名访问提交的数据。在这种情况下， request.POST['choice']返回所选选项的ID，作为字符串。request.POST值始终是字符串。

  请注意，Django也提供request.GET了以相同方式访问GET数据 - 但我们request.POST在代码中明确使用，以确保数据仅通过POST调用进行更改。

• request.POST['choice']KeyError如果 choicePOST数据中没有提供，则会引发。上面的代码检查 KeyError并重新显示问题表单，如果choice没有给出错误消息。

• 增加选择计数后，代码返回 HttpResponseRedirect而不是正常 HttpResponse。 HttpResponseRedirect采用一个参数：用户将被重定向到的URL（在这种情况下，请参阅以下关于我们如何构造URL的点）。

  正如上面的Python注释指出的那样，HttpResponseRedirect在成功处理POST数据之后应该总是返回一个 。这个提示不是Django特有的; 这只是一个很好的Web开发实践。

• 我们在这个例子中使用构造reverse()函数中的 HttpResponseRedirect函数。此功能有助于避免在视图功能中对URL进行硬编码。它给出了我们想要将控制权传递给的视图的名称以及指向该视图的URL模式的可变部分。在这种情况下，使用我们在教程3中设置的URLconf ，此reverse()调用将返回一个类似的字符串

  '/polls/3/results/'

  • 其中的3是值question.id。然后，此重定向的URL将调用'results'视图以显示最终页面。

  如教程3中所述，request是一个 HttpRequest对象。有关HttpRequest对象的更多信息 ，请参阅请求和响应文档。

  在某人投票问题后，该vote()视图会重定向到问题的结果页面。让我们写下这个观点：

  

  from django.shortcuts import get_object_or_404, render
  
  
  def results(request, question_id):
      question = get_object_or_404(Question, pk=question_id)
      return render(request, 'polls/results.html', {'question': question})

  polls/views.py

  这几乎detail()与教程3中的视图完全相同。唯一的区别是模板名称。我们稍后会修复此冗余。

  现在，创建一个polls/results.html模板：

  

  <h1>{{ question.question_text }}</h1>
  
  <ul>
  {% for choice in question.choice_set.all %}
      <li>{{ choice.choice_text }} -- {{ choice.votes }} vote{{ choice.votes|pluralize }}</li>
  {% endfor %}
  </ul>
  
  <a href="{% url 'polls:detail' question.id %}">Vote again?</a>

  polls/templates/polls/results.html

  现在，转到/polls/1/您的浏览器并在问题中投票。您应该会看到每次投票时都会更新的结果页面。如果您在未选择的情况下提交表单，则应该看到错误消息。

  注意

  我们vote()视图的代码确实存在一个小问题。它首先selected_choice从数据库中获取对象，然后计算新值votes，然后将其保存回数据库。如果您网站的两个用户尝试在同一时间投票，则可能会出错：将检索相同的值，例如42 votes。然后，对于两个用户，计算并保存新值43，但是44将是期望值。

  这被称为竞争条件。如果您有兴趣，可以阅读 使用F（）来避免竞争条件，以了解如何解决此问题。

  使用通用视图：更少的代码更好?

  在detail()（从教程3）和results() 意见是非常简单的-并且如上面提到的，冗余的。index() 显示民意调查列表的视图类似。

  这些视图代表了基本Web开发的常见情况：根据URL中传递的参数从数据库获取数据，加载模板并返回呈现的模板。因为这是如此常见，Django提供了一种称为“通用视图”系统的快捷方式。

  通用视图将常见模式抽象到您甚至不需要编写Python代码来编写应用程序的程度。

  让我们将我们的民意调查应用程序转换为使用通用视图系统，这样我们就可以删除一堆自己的代码。我们只需要采取一些步骤进行转换。我们会：

  1. 转换URLconf。
  2. 删除一些旧的，不需要的视图。
  3. 基于Django的通用视图引入新视图。

  继续阅读以了解详情。

  为什么代码洗牌？

  通常，在编写Django应用程序时，您将评估通用视图是否适合您的问题，并且您将从一开始就使用它们，而不是在中途重构代码。但本教程有意集中于直到现在“以艰难的方式”编写视图，专注于核心概念。

  在开始使用计算器之前，您应该先了解基本数学。

  修改URL配置?

  首先，打开polls/urls.pyURLconf并将其更改为：

  

  from django.conf.urls import url
  
  from . import views
  
  app_name = 'polls'
  urlpatterns = [
      url(r'^$', views.IndexView.as_view(), name='index'),
      url(r'^(?P<pk>[0-9]+)/$', views.DetailView.as_view(), name='detail'),
      url(r'^(?P<pk>[0-9]+)/results/$', views.ResultsView.as_view(), name='results'),
      url(r'^(?P<question_id>[0-9]+)/vote/$', views.vote, name='vote'),
  ]

  polls/urls.py

  请注意，第二个和第三个模式的正则表达式中匹配模式的名称已从更改<question_id>为<pk>。

  修改意见?

  接下来，我们将删除我们的老index，detail和results 视图，并使用Django的通用视图代替。为此，请打开 polls/views.py文件并进行更改，如下所示：

  

  from django.shortcuts import get_object_or_404, render
  from django.http import HttpResponseRedirect
  from django.urls import reverse
  from django.views import generic
  
  from .models import Choice, Question
  
  
  class IndexView(generic.ListView):
      template_name = 'polls/index.html'
      context_object_name = 'latest_question_list'
  
      def get_queryset(self):
          """Return the last five published questions."""
          return Question.objects.order_by('-pub_date')[:5]
  
  
  class DetailView(generic.DetailView):
      model = Question
      template_name = 'polls/detail.html'
  
  
  class ResultsView(generic.DetailView):
      model = Question
      template_name = 'polls/results.html'
  
  
  def vote(request, question_id):
      ... # same as above, no changes needed.

  polls/views.py

  我们在这里使用两个通用视图： ListView和 DetailView。这两个视图分别抽象出“显示对象列表”和“显示特定类型对象的详细页面”的概念。

  • 每个通用视图都需要知道它将采用什么模型。这是使用model属性提供的。
  • 该DetailView通用视图预计从URL中捕获的主键值被调用 "pk"，所以我们已经改变question_id，以pk用于通用视图。

  默认情况下，DetailView通用视图使用名为的模板。在我们的例子中，它将使用模板。该 属性用于告诉Django使用特定的模板名称而不是自动生成的默认模板名称。我们还为列表视图指定了- 这确保了结果视图和详细视图在渲染时具有不同的外观，即使它们都是 幕后的。<appname>/<model name>_detail.html"polls/question_detail.html"template_nametemplate_nameresultsDetailView

  同样，ListView通用视图使用一个名为的默认模板; 我们用来告诉 使用我们现有的 模板。<app name>/<modelname>_list.htmltemplate_nameListView"polls/index.html"

  在本教程的前几部分中，为模板提供了包含question和latest_question_list 上下文变量的上下文。对于DetailView该question自动提供的变量-因为我们使用的Django模型（Question），Django的是能够确定一个适当的名称为上下文变量。但是，对于ListView，自动生成的上下文变量是 question_list。要覆盖它，我们提供context_object_name 属性，指定我们要使用的属性latest_question_list。作为替代方法，您可以更改模板以匹配新的默认上下文变量 - 但只是告诉Django使用您想要的变量要容易得多。

  运行服务器，并使用基于通用视图的新轮询应用程序。

  有关通用视图的完整详细信息，请参阅通用视图文档。

   

  编写你的第一个Django应用程序，第5部分?

  本教程从教程4停止的地方开始。我们已经构建了一个Web轮询应用程序，现在我们将为它创建一些自动化测试。

  介绍自动化测试?

  什么是自动化测试？?

  测试是检查代码操作的简单例程。

  测试在不同级别进行。某些测试可能适用于一个微小的细节（特定模型方法是否按预期返回值？）而其他测试则检查软件的整体操作（网站上的一系列用户输入是否会产生所需的结果？）。这与您在教程2中之前所做的测试类型没有什么不同，使用它 shell来检查方法的行为，或者运行应用程序并输入数据来检查它的行为方式。

  自动化测试的不同之处在于测试工作是由系统完成的。您只需创建一组测试，然后在对应用程序进行更改时，可以检查代码是否仍按预期工作，而无需执行耗时的手动测试。

  为什么需要创建测试?

  那么为什么要创建测试，为什么现在呢？

  您可能觉得自己已经足够了解Python / Django，并且还有另外一些需要学习和做的事情可能看起来势不可挡，也许是不必要的。毕竟，我们的民意调查申请现在非常愉快; 经历创建自动化测试的麻烦不会让它更好地工作。如果创建民意调查应用程序是您将要做的最后一点Django编程，那么，您不需要知道如何创建自动化测试。但是，如果情况并非如此，那么现在是学习的绝佳时机。

  测试会节省你的时间?

  在某一点上，“检查它似乎有用”将是一个令人满意的测试。在更复杂的应用程序中，组件之间可能会有许多复杂的交互。

  任何这些组件的更改都可能会对应用程序的行为产生意外后果。检查它是否“似乎工作”可能意味着通过代码的功能运行20种不同的测试数据变体，以确保您没有破坏某些东西 - 不能充分利用您的时间。

  当自动化测试可以在几秒钟内为您完成此操作时尤其如此。如果出现问题，测试还将有助于识别导致意外行为的代码。

  有时，如果您知道自己的代码工作正常，那么将自己从富有成效的创造性编程工作中剔除，以面对编写测试的无趣和令人兴奋的业务，这似乎是件苦差事。

  但是，编写测试的任务比花费数小时手动测试应用程序或尝试确定新引入的问题的原因要多得多。

  测试不只是识别问题，而是阻止它们?

  将测试仅仅视为发展的消极方面是错误的。

  如果没有测试，应用程序的目的或预期行为可能会相当不透明。即使它是你自己的代码，你有时会发现自己在试图找出它究竟在做什么。

  测试改变了; 他们从内部点亮你的代码，当出现问题时，他们将光线集中在出错的部分 - 即使你甚至没有意识到它出了问题。

  测试使您的代码更具吸引力?

  您可能已经创建了一个出色的软件，但您会发现很多其他开发人员只会拒绝查看它，因为它缺少测试; 没有测试，他们就不会相信它。Django最初的开发人员之一Jacob Kaplan-Moss说：“没有测试的代码被设计破坏了。”

  其他开发人员希望在认真对待之前在软件中看到测试是您开始编写测试的另一个原因。

  测试帮助团队一起工作?

  以前的观点是从维护应用程序的单个开发人员的角度编写的。复杂的应用程序将由团队维护。测试保证同事不会无意中破坏您的代码（并且您不会在不知情的情况下破坏他们的代码）。如果你想以Django程序员谋生，你必须善于编写测试！

  基本测试策略?

  有很多方法可以用来编写测试。

  一些程序员遵循一门名为“ 测试驱动开发 ” 的学科; 他们实际上在编写代码之前编写测试。这可能看似违反直觉，但实际上它与大多数人经常会做的类似：他们描述一个问题，然后创建一些代码来解决它。测试驱动的开发只是在Python测试用例中形式化了问题。

  更常见的情况是，测试的新手将创建一些代码，然后决定它应该进行一些测试。也许最早写一些测试会好一些，但是从来没有太晚开始。

  有时候很难弄清楚从哪里开始编写测试。如果您已经编写了几千行Python，那么选择要测试的东西可能并不容易。在这种情况下，无论是在添加新功能还是修复错误时，下次进行更改时编写第一个测试都很有成效。

  所以让我们马上做。

  写第一次测试?

  我们发现了一个错误?

  幸运的是，在一个小错误polls的应用为我们立即进行修复：该Question.was_published_recently()方法返回True，如果Question是最后一天（这是正确的）内发布，而且如果Question的pub_date领域是未来（这当然不是） 。

  要检查错误是否确实存在，请使用Admin创建一个日期位于将来的问题，并使用以下方法检查方法shell：

  >>> import datetime
  >>> from django.utils import timezone
  >>> from polls.models import Question
  >>> # create a Question instance with pub_date 30 days in the future
  >>> future_question = Question(pub_date=timezone.now() + datetime.timedelta(days=30))
  >>> # was it published recently?
  >>> future_question.was_published_recently()
  True

  由于未来的事情不是“最近的”，这显然是错误的。

  创建测试以揭示错误?

  我们在shell测试问题时所做的正是我们在自动化测试中可以做的，所以让我们把它变成一个自动测试。

  应用程序测试的常规位置在应用程序的 tests.py文件中; 测试系统将自动在名称以...开头的任何文件中查找测试test。

  将以下内容放在应用程序的tests.py文件中polls：

  

  import datetime
  
  from django.utils import timezone
  from django.test import TestCase
  
  from .models import Question
  
  
  class QuestionModelTests(TestCase):
  
      def test_was_published_recently_with_future_question(self):
          """
          was_published_recently() returns False for questions whose pub_date
          is in the future.
          """
          time = timezone.now() + datetime.timedelta(days=30)
          future_question = Question(pub_date=time)
          self.assertIs(future_question.was_published_recently(), False)

  polls/tests.py

  我们在这里所做的是创建一个django.test.TestCase子类，其中Question包含一个pub_date在将来创建一个实例的方法。然后我们检查输出was_published_recently()- 哪个 应该是假的。

  运行测试?

  在终端中，我们可以运行我们的测试：

  $ python manage.py test polls

  你会看到类似的东西：

  Creating test database for alias 'default'...
  System check identified no issues (0 silenced).
  F
  ======================================================================
  FAIL: test_was_published_recently_with_future_question (polls.tests.QuestionModelTests)
  ----------------------------------------------------------------------
  Traceback (most recent call last):
    File "/path/to/mysite/polls/tests.py", line 16, in test_was_published_recently_with_future_question
      self.assertIs(future_question.was_published_recently(), False)
  AssertionError: True is not False
  
  ----------------------------------------------------------------------
  Ran 1 test in 0.001s
  
  FAILED (failures=1)
  Destroying test database for alias 'default'...

  发生了什么事：

  • python manage.py test polls在polls应用程序中寻找测试
  • 它找到了django.test.TestCase该类的子类
  • 它创建了一个特殊的数据库用于测试
  • 它寻找测试方法 - 名称以其开头的方法 test
  • 在test_was_published_recently_with_future_question其中创建了一个Question 实例，其pub_date字段在将来30天
  • ...并且使用该assertIs()方法，它发现它的 was_published_recently()返回True，尽管我们希望它返回 False

  测试通知我们哪个测试失败，甚至是发生故障的线路。

  修复错误?

  我们已经知道问题是什么：如果它是将来Question.was_published_recently()应该返回。修改方法 ，以便只有在日期也是过去时它才会返回：Falsepub_datemodels.pyTrue

  

  def was_published_recently(self):
      now = timezone.now()
      return now - datetime.timedelta(days=1) <= self.pub_date <= now

  polls/models.py

  并再次运行测试：

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

  在识别出错误之后，我们编写了一个公开它的测试并更正了代码中的错误，以便我们的测试通过。

  我们的应用程序将来可能会出现许多其他问题，但我们可以肯定，我们不会无意中重新引入此错误，因为只需运行测试就会立即向我们发出警告。我们可以认为应用程序的这一小部分永远安全地固定下来。

  更全面的测试?

  当我们在这里时，我们可以进一步确定was_published_recently() 方法; 事实上，如果修复我们引入另一个错误的一个错误，那将是非常尴尬的。

  在同一个类中再添加两个测试方法，以更全面地测试该方法的行为：

  

  def test_was_published_recently_with_old_question(self):
      """
      was_published_recently() returns False for questions whose pub_date
      is older than 1 day.
      """
      time = timezone.now() - datetime.timedelta(days=1, seconds=1)
      old_question = Question(pub_date=time)
      self.assertIs(old_question.was_published_recently(), False)
  
  def test_was_published_recently_with_recent_question(self):
      """
      was_published_recently() returns True for questions whose pub_date
      is within the last day.
      """
      time = timezone.now() - datetime.timedelta(hours=23, minutes=59, seconds=59)
      recent_question = Question(pub_date=time)
      self.assertIs(recent_question.was_published_recently(), True)

  polls/tests.py

  现在，我们有三项测试证实可以Question.was_published_recently() 为过去，近期和未来的问题返回合理的价值。

  同样，它polls是一个简单的应用程序，但无论它在将来如何复杂，以及它与之交互的其他代码，我们现在都能保证我们编写的测试方法将以预期的方式运行。

  测试视图?

  民意调查申请是相当无差别的：它将发布任何问题，包括其pub_date领域在未来的问题。我们应该改善这一点。pub_date在将来设置a 应该意味着该问题在那个时刻发布，但在此之前是不可见的。

  对视图的测试?

  当我们修复上面的错误时，我们首先编写测试，然后编写代码来修复它。事实上，这是测试驱动开发的一个简单示例，但我们的工作顺序并不重要。

  在我们的第一次测试中，我们密切关注代码的内部行为。对于此测试，我们希望检查用户通过Web浏览器体验的行为。

  在我们尝试解决任何问题之前，让我们来看看我们可以使用的工具。

  Django测试客户端?

  Django提供了一个测试Client来模拟用户在视图级别与代码交互。我们可以在它中使用它tests.py 甚至在它中使用它shell。

  我们将重新开始shell，我们需要做一些不必要的事情tests.py。首先是在以下位置设置测试环境shell：

  >>> from django.test.utils import setup_test_environment
  >>> setup_test_environment()

  setup_test_environment()安装模板渲染器，这将允许我们检查响应上的一些其他属性 response.context，否则将无法使用。请注意，此方法不会设置测试数据库，因此将针对现有数据库运行以下内容，并且输出可能会略有不同，具体取决于您已创建的问题。如果你的TIME_ZONE输入settings.py不正确，你可能会得到意想不到的结果 。如果您不记得先提前设置，请在继续之前进行检查。

  接下来我们需要导入测试客户端类（稍后tests.py我们将使用django.test.TestCase该类，它带有自己的客户端，因此不需要）：

  >>> from django.test import Client
  >>> # create an instance of the client for our use
  >>> client = Client()

  准备好后，我们可以要求客户为我们做一些工作：

  >>> # get a response from '/'
  >>> response = client.get('/')
  Not Found: /
  >>> # we should expect a 404 from that address; if you instead see an
  >>> # "Invalid HTTP_HOST header" error and a 400 response, you probably
  >>> # omitted the setup_test_environment() call described earlier.
  >>> response.status_code
  404
  >>> # on the other hand we should expect to find something at '/polls/'
  >>> # we'll use 'reverse()' rather than a hardcoded URL
  >>> from django.urls import reverse
  >>> response = client.get(reverse('polls:index'))
  >>> response.status_code
  200
  >>> response.content
  b'\n    <ul>\n    \n        <li><a href="/polls/1/">What&#39;s up?</a></li>\n    \n    </ul>\n\n'
  >>> response.context['latest_question_list']
  <QuerySet [<Question: What's up?>]>

  改善我们的观点?

  民意调查清单显示尚未公布的民意调查（即pub_date未来的民意调查 ）。我们来解决这个问题。

  在教程4中，我们介绍了一个基于类的视图，基于ListView：

  

  class IndexView(generic.ListView):
      template_name = 'polls/index.html'
      context_object_name = 'latest_question_list'
  
      def get_queryset(self):
          """Return the last five published questions."""
          return Question.objects.order_by('-pub_date')[:5]

  polls/views.py

  我们需要修改get_queryset()方法并对其进行更改，以便通过比较来检查日期timezone.now()。首先我们需要添加一个导入：

  

  from django.utils import timezone

  polls/views.py

  然后我们必须get_queryset像这样修改方法：

  

  def get_queryset(self):
      """
      Return the last five published questions (not including those set to be
      published in the future).
      """
      return Question.objects.filter(
          pub_date__lte=timezone.now()
      ).order_by('-pub_date')[:5]

  polls/views.py

  Question.objects.filter(pub_date__lte=timezone.now())返回一个查询集，其中包含的Questions pub_date小于或等于 - 即早于或等于 - timezone.now。

  测试我们的新视图?

  现在，您可以通过启动runserver，在浏览器中加载站点，Questions在过去和将来创建日期以及检查是否仅列出已发布的日期来满足您自己的行为。您不希望每次进行任何可能影响此更改的更改时都这样做- 所以我们也要根据上面的shell会话创建一个测试 。

  将以下内容添加到polls/tests.py：

  

  from django.urls import reverse

  polls/tests.py

  我们将创建一个快捷函数来创建问题以及一个新的测试类：

  

  def create_question(question_text, days):
      """
      Create a question with the given `question_text` and published the
      given number of `days` offset to now (negative for questions published
      in the past, positive for questions that have yet to be published).
      """
      time = timezone.now() + datetime.timedelta(days=days)
      return Question.objects.create(question_text=question_text, pub_date=time)
  
  
  class QuestionIndexViewTests(TestCase):
      def test_no_questions(self):
          """
          If no questions exist, an appropriate message is displayed.
          """
          response = self.client.get(reverse('polls:index'))
          self.assertEqual(response.status_code, 200)
          self.assertContains(response, "No polls are available.")
          self.assertQuerysetEqual(response.context['latest_question_list'], [])
  
      def test_past_question(self):
          """
          Questions with a pub_date in the past are displayed on the
          index page.
          """
          create_question(question_text="Past question.", days=-30)
          response = self.client.get(reverse('polls:index'))
          self.assertQuerysetEqual(
              response.context['latest_question_list'],
              ['<Question: Past question.>']
          )
  
      def test_future_question(self):
          """
          Questions with a pub_date in the future aren't displayed on
          the index page.
          """
          create_question(question_text="Future question.", days=30)
          response = self.client.get(reverse('polls:index'))
          self.assertContains(response, "No polls are available.")
          self.assertQuerysetEqual(response.context['latest_question_list'], [])
  
      def test_future_question_and_past_question(self):
          """
          Even if both past and future questions exist, only past questions
          are displayed.
          """
          create_question(question_text="Past question.", days=-30)
          create_question(question_text="Future question.", days=30)
          response = self.client.get(reverse('polls:index'))
          self.assertQuerysetEqual(
              response.context['latest_question_list'],
              ['<Question: Past question.>']
          )
  
      def test_two_past_questions(self):
          """
          The questions index page may display multiple questions.
          """
          create_question(question_text="Past question 1.", days=-30)
          create_question(question_text="Past question 2.", days=-5)
          response = self.client.get(reverse('polls:index'))
          self.assertQuerysetEqual(
              response.context['latest_question_list'],
              ['<Question: Past question 2.>', '<Question: Past question 1.>']
          )

  polls/tests.py

  让我们更仔细地看看其中的一些。

  首先是一个问题快捷方式功能，create_question在创建问题的过程中重复一些。

  test_no_questions不会产生任何问题，但会检查消息：“没有可用的民意调查。”并验证是否latest_question_list为空。请注意，django.test.TestCase该类提供了一些额外的断言方法。在这些例子中，我们使用 assertContains()和 assertQuerysetEqual()。

  在test_past_question，我们创建一个问题并验证它是否出现在列表中。

  在test_future_question，我们pub_date将来会创建一个问题。为每个测试方法重置数据库，因此第一个问题不再存在，因此索引不应该有任何问题。

  等等。实际上，我们使用测试来讲述网站上管理员输入和用户体验的故事，并检查每个州的状态以及系统状态的每次新变化，都会发布预期结果。

  测试DetailView?

  我们的工作做得很好; 但是，即使未来的问题没有出现在索引中，如果用户知道或猜到正确的URL，他们仍然可以联系到他们。所以我们需要添加一个类似的约束DetailView：

  

  class DetailView(generic.DetailView):
      ...
      def get_queryset(self):
          """
          Excludes any questions that aren't published yet.
          """
          return Question.objects.filter(pub_date__lte=timezone.now())

  polls/views.py

  当然，我们将增加一些测试，以检查一个Question，其 pub_date在过去可以显示，而一个具有pub_date 在未来是不是：

  

  class QuestionDetailViewTests(TestCase):
      def test_future_question(self):
          """
          The detail view of a question with a pub_date in the future
          returns a 404 not found.
          """
          future_question = create_question(question_text='Future question.', days=5)
          url = reverse('polls:detail', args=(future_question.id,))
          response = self.client.get(url)
          self.assertEqual(response.status_code, 404)
  
      def test_past_question(self):
          """
          The detail view of a question with a pub_date in the past
          displays the question's text.
          """
          past_question = create_question(question_text='Past Question.', days=-5)
          url = reverse('polls:detail', args=(past_question.id,))
          response = self.client.get(url)
          self.assertContains(response, past_question.question_text)

  polls/tests.py

  更多测试的想法?

  我们应该为该视图添加一个类似的get_queryset方法ResultsView并创建一个新的测试类。它与我们刚创造的非常相似; 事实上会有很多重复。

  我们还可以通过其他方式改进我们的应用程序，并在此过程中添加测试。例如，Questions可以在没有的网站上发布它是愚蠢的Choices。因此，我们的观点可以检查这一点，并排除这种情况 Questions。我们的测试会创建一个Question没有Choices，然后测试它没有发布，以及创建一个类似Question 的 Choices，并测试它是否已发布。

  也许应该允许登录的管理员用户看到未发布的Questions，但不能看到 普通的访问者。再说一次：无论需要添加到软件中来实现这一点，都应该伴随着测试，无论是先编写测试还是让代??码通过测试，或者首先在代码中计算出逻辑，然后再编写测试证明给我看。

  在某个时刻，你一定会看看你的测试，并想知道你的代码是否遭受了测试膨胀，这导致我们：

  测试时，越多越好?

  我们的测试似乎越来越失控。按照这个速度，我们的测试中的代码很快会比我们的应用程序中的代码更多，并且与其他代码的优雅简洁相比，重复是不美观的。

  没关系。让他们成长。在大多数情况下，您可以编写一次测试然后忘掉它。在您继续开发程序时，它将继续执行其有用的功能。

  有时需要更新测试。假设我们修正了我们的观点，以便只Questions与Choices发布。在这种情况下，我们现有的许多测试都会失败 - 告诉我们究竟需要修改哪些测试以使它们更新，所以在这种程度上测试有助于照顾自己。

  在最坏的情况下，当您继续开发时，您可能会发现您有一些现在多余的测试。即使这不是问题; 在测试中的冗余是一个很好的事情。

  只要您的测试得到合理安排，它们就不会变得难以管理。良好的经验法则包括：

  • TestClass每个模型或视图单独一个
  • 针对要测试的每组条件的单独测试方法
  • 描述其功能的测试方法名称

  进一步测试?

  本教程仅介绍一些测试基础知识。你可以做很多事情，并且可以使用一些非常有用的工具来实现一些非常聪明的事情。

  例如，虽然我们的测试涵盖了模型的一些内部逻辑以及我们的视图发布信息的方式，但您可以使用“浏览器内”框架（如Selenium）来测试HTML在浏览器中实际呈现的方式。这些工具不仅可以检查Django代码的行为，还可以检查JavaScript的行为。很有可能看到测试启动浏览器，并开始与您的网站进行交互，就像一个人在驾驶它一样！Django包括LiveServerTestCase 促进与Selenium等工具的集成。

  如果您有一个复杂的应用程序，您可能希望在每次提交时自动运行测试以实现持续集成，以便质量控制本身 - 至少部分 - 自动化。

  发现应用程序未经测试的部分的一个好方法是检查代码覆盖率。这也有助于识别脆弱甚至死亡的代码。如果您无法测试一段代码，通常意味着代码应该被重构或删除。覆盖范围将有助于识别死代码。有关详细信息，请参阅 与coverage.py集成。

  Django中的测试具有关于测试的全面信息。

  有关测试的完整详细信息，请参阅Django中的测试。

   

   

  编写你的第一个Django应用程序，第6部分?

  本教程从教程5停止的地方开始。我们已经构建了一个经过测试的Web轮询应用程序，现在我们将添加样式表和图像。

  除了服务器生成的HTML之外，Web应用程序通常还需要提供呈现完整网页所需的其他文件（如图像，JavaScript或CSS）。在Django中，我们将这些文件称为“静态文件”。

  对于小型项目，这不是什么大问题，因为您可以将静态文件保存在Web服务器可以找到的位置。但是，在更大的项目中 - 特别是那些由多个应用程序组成的项目 - 处理每个应用程序提供的多组静态文件开始变得棘手。

  这django.contrib.staticfiles就是：它从您的每个应用程序（以及您指定的任何其他位置）收集静态文件到一个可以在生产中轻松提供的位置。

  自定义应用程序的外观?

  首先，创建目录中调用static的polls目录。Django会在那里查找静态文件，类似于Django在其中找到模板的方式polls/templates/。

  Django的STATICFILES_FINDERS设置包含一个知道如何从各种来源发现静态文件的查找器列表。其中一个默认值是AppDirectoriesFinder查找每个中的“静态”子目录 INSTALLED_APPS，就像polls我们刚刚创建的那个。管理站点对其静态文件使用相同的目录结构。

  在static刚刚创建的目录中，创建另一个名为的目录，polls并在其中创建一个名为的文件style.css。换句话说，你的样式表应该是polls/static/polls/style.css。由于AppDirectoriesFinder静态文件查找器的工作原理，您可以简单地在Django中引用此静态文件polls/style.css，类似于引用模板路径的方式。

  静态文件命名空间

  就像模板一样，我们可能能够直接放入我们的静态文件polls/static（而不是创建另一个polls 子目录），但这实际上是个坏主意。Django将选择其名称匹配的第一个静态文件，如果在不同的应用程序中有一个具有相同名称的静态文件，Django将无法区分它们。我们需要能够将Django指向正确的，并且确保这一点的最简单方法是通过命名它们。也就是说，将这些静态文件放在为应用程序本身命名的另一个目录中。

  将以下代码放在该stylesheet（polls/static/polls/style.css）中：

  

  li a {
      color: green;
  }

  polls/static/polls/style.css

  接下来，在顶部添加以下内容polls/templates/polls/index.html：

  

  {% load static %}
  
  <link rel="stylesheet" type="text/css" href="{% static 'polls/style.css' %}" />

  polls/templates/polls/index.html

  该模板标签生成静态文件的绝对路径。{% static %}

  这就是开发所需要做的一切。重新加载 http://localhost:8000/polls/，您应该看到问题链接是绿色（Django样式！），这意味着您的样式表已正确加载。

  添加背景图像?

  接下来，我们将为图像创建一个子目录。images在polls/static/polls/目录中创建一个子目录。在此目录中，放置一个名为的图像background.gif。换句话说，把你的形象放进去 polls/static/polls/images/background.gif。

  然后，添加到stylesheet（polls/static/polls/style.css）：

  

  body {
      background: white url("images/background.gif") no-repeat right bottom;
  }

  polls/static/polls/style.css

  重新加载http://localhost:8000/polls/，您应该看到屏幕右下方加载了背景。

  警告

  当然，模板标签不能用于像样式表那样不是由Django生成的静态文件。您应始终使用相对路径将静态文件链接到彼此之间，因为您可以更改（由 模板标记用于生成其URL），而无需修改静态文件中的一堆路径。{% static %}STATIC_URLstatic

  这些是基础知识。有关框架中包含的设置和其他位的更多详细信息，请参阅 静态文件howto和 staticfiles引用。部署静态文件讨论了如何在真实服务器上使用静态文件。

   

  编写你的第一个Django应用程序，第7部分?

  本教程从教程6停止的地方开始。我们将继续使用Web-poll应用程序，并将专注于自定义Django自动生成的管理站点，这是我们在教程2中首次探讨的。

  自定义管理表单?

  通过注册Question模型admin.site.register(Question)，Django能够构造默认的表单表示。通常，您需要自定义管理表单的外观和工作方式。你可以通过在注册对象时告诉Django你想要的选项来做到这一点。

  让我们通过重新排序编辑表单上的字段来了解它是如何工作的。将admin.site.register(Question)线替换为：

  

  from django.contrib import admin
  
  from .models import Question
  
  
  class QuestionAdmin(admin.ModelAdmin):
      fields = ['pub_date', 'question_text']
  
  admin.site.register(Question, QuestionAdmin)

  polls/admin.py

  您将遵循此模式 - 创建模型管理类，然后将其作为第二个参数传递给admin.site.register()- 任何时候您需要更改模型的管理选项。

  上述特定更改使“发布日期”出现在“问题”字段之前：

  

  仅使用两个字段并不令人印象深刻，但对于具有数十个字段的管理表单，选择直观的顺序是一个重要的可用性细节。

  说到有几十个字段的表单，您可能希望将表单拆分为字段集：

  

  from django.contrib import admin
  
  from .models import Question
  
  
  class QuestionAdmin(admin.ModelAdmin):
      fieldsets = [
          (None,               {'fields': ['question_text']}),
          ('Date information', {'fields': ['pub_date']}),
      ]
  
  admin.site.register(Question, QuestionAdmin)

  polls/admin.py

  每个元组的第一个元素 fieldsets是fieldset的标题。这就是我们现在的形式：

  

  添加相关对象?

  好的，我们有问题管理页面，但是Question有多个 Choices，管理页面不显示选项。

  然而。

  有两种方法可以解决这个问题。第一个是Choice 像我们一样向管理员注册Question。这很简单：

  

  from django.contrib import admin
  
  from .models import Choice, Question
  # ...
  admin.site.register(Choice)

  polls/admin.py

  现在，“选择”是Django管理员中的一个可用选项。“添加选项”表单如下所示：

  

  在该表单中，“问题”字段是包含数据库中每个问题的选择框。Django知道ForeignKey应该在管理员中将a表示为一个<select>框。在我们的例子中，此时只存在一个问题。

  另请注意“问题”旁边的“添加另一个”链接。与ForeignKey另一个有关系的每个对象 都可以免费获得。当您单击“添加另一个”时，您将看到一个带有“添加问题”表单的弹出窗口。如果您在该窗口中添加一个问题并单击“保存”，Django会将问题保存到数据库，并在您正在查看的“添加选项”表单中将其作为所选选项动态添加。

  但是，实际上，这是Choice向系统添加对象的低效方法。如果你可以在创建Question对象时直接添加一堆Choices，那会更好 。让我们实现这一目标。

  删除模型的register()调用Choice。然后，编辑Question 注册码阅读：

  

  from django.contrib import admin
  
  from .models import Choice, Question
  
  
  class ChoiceInline(admin.StackedInline):
      model = Choice
      extra = 3
  
  
  class QuestionAdmin(admin.ModelAdmin):
      fieldsets = [
          (None,               {'fields': ['question_text']}),
          ('Date information', {'fields': ['pub_date'], 'classes': ['collapse']}),
      ]
      inlines = [ChoiceInline]
  
  admin.site.register(Question, QuestionAdmin)

  polls/admin.py

  这告诉Django：“ Choice在Question管理页面上编辑对象。默认情况下，为3个选项提供足够的字段。“

  加载“添加问题”页面以查看其外观：

  

  它的工作方式如下：相关选项有三个插槽 - 由指定extra- 并且每次返回已更改对象的“更改”页面时，您将获得另外三个额外插槽。

  在三个当前位置的末尾，您将找到“添加另一个选择”链接。如果单击它，将添加一个新插槽。如果要删除添加的插槽，可以单击添加插槽右上角的X. 请注意，您无法删除原来的三个插槽。此图显示了添加的插槽：

  

  但是有一个小问题。显示用于输入相关Choice对象的所有字段需要大量屏幕空间。出于这个原因，Django提供了一种显示内联相关对象的表格方式; 你只需要将ChoiceInline声明改为：

  

  class ChoiceInline(admin.TabularInline):
      #...

  polls/admin.py

  使用它TabularInline（而不是StackedInline），相关对象以更紧凑，基于表格的格式显示：

  

  请注意，还有一个额外的“删除？”列，允许删除使用“添加另一个选择”按钮添加的行和已保存的行。

  自定义管理员更改列表?

  现在问题管理页面看起来很好，让我们对“更改列表”页面进行一些调整 - 显示系统中所有问题的页面。

  这就是它在这一点上的样子：

  

  默认情况下，Django显示str()每个对象。但有时如果我们可以显示单个字段会更有帮助。为此，请使用 list_displayadmin选项，该选项是要在对象的更改列表页面上显示的字段名称元组：

  

  class QuestionAdmin(admin.ModelAdmin):
      # ...
      list_display = ('question_text', 'pub_date')

  polls/admin.py

  为了更好的衡量，我们还要包含教程2中的was_published_recently() 方法：

  

  class QuestionAdmin(admin.ModelAdmin):
      # ...
      list_display = ('question_text', 'pub_date', 'was_published_recently')

  polls/admin.py

  现在，问题更改列表页面如下所示：

  

  您可以单击列标题以按这些值排序 - 除了was_published_recently标题之外，因为不支持按任意方法的输出进行排序。另请注意，was_published_recently默认情况下，列标题 是方法的名称（下划线替换为空格），并且每行包含输出的字符串表示形式。

  您可以通过为该方法（in polls/models.py）提供一些属性来改进它，如下所示：

  

  class Question(models.Model):
      # ...
      def was_published_recently(self):
          now = timezone.now()
          return now - datetime.timedelta(days=1) <= self.pub_date <= now
      was_published_recently.admin_order_field = 'pub_date'
      was_published_recently.boolean = True
      was_published_recently.short_description = 'Published recently?'

  polls/models.py

  有关这些方法属性的更多信息，请参阅 list_display。

  polls/admin.py再次编辑您的文件，并在Question更改列表页面中添加一项改进 ：使用 list_filter。将以下行添加到QuestionAdmin：

  list_filter = ['pub_date']

  这会添加一个“过滤器”侧边栏，让人们按pub_date字段过滤更改列表 ：

  

  显示的过滤器类型取决于您要过滤的字段类型。因为pub_date是DateTimeField，Django知道给出适当的过滤选项：“任何日期”，“今天”，“过去7天”，“本月”，“今年”。

  这很好。让我们添加一些搜索功能：

  search_fields = ['question_text']

  这会在更改列表的顶部添加一个搜索框。当某人输入搜索词时，Django将搜索该question_text字段。您可以使用任意数量的字段 - 尽管因为它LIKE在后台使用查询，将搜索字段的数量限制为合理的数字将使您的数据库更容易进行搜索。

  现在也是注意更改列表为您提供免费分页的好时机。默认设置是每页显示100个项目。，，，，和 所有的工作在一起，就像你认为他们应该。Change list paginationsearch boxesfiltersdate-hierarchiescolumn-header-ordering

  自定义管理员外观?

  显然，在每个管理页面的顶部都有“Django管理”是荒谬的。它只是占位符文本。

  但是，使用Django的模板系统很容易改变。Django管理员由Django本身提供支持，其界面使用Django自己的模板系统。

  自定义项目的模板?

  templates在项目目录（包含的目录）中创建一个目录manage.py。模板可以存放在Django可以访问的文件系统的任何位置。（Django以您的服务器运行的任何用户身份运行。）但是，将模板保留在项目中是一个很好的约定。

  打开您的设置文件（mysite/settings.py请记住）并DIRS在TEMPLATES设置中添加一个 选项：

  

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

  mysite/settings.py

  DIRS是加载Django模板时要检查的文件系统目录列表; 这是一条搜索路径。

  组织模板

  就像静态文件一样，我们可以将所有模板放在一个大模板目录中，并且它可以很好地工作。但是，属于特定应用程序的模板应放在该应用程序的模板目录（例如polls/templates）中，而不是项目的（templates）。我们将在可重用的应用程序教程中更详细地讨论 为什么我们这样做。

  现在创建一个名为admininside 的目录templates，并将模板admin/base_site.html从Django本身（django/contrib/admin/templates）的源代码中的默认Django管理模板目录中复制到该目录中。

  Django源文件在哪里？

  如果您在查找Django源文件在系统中的位置时遇到困难，请运行以下命令：

  $ python -c "import django; print(django.__path__)"

  然后，只需编辑文件，并根据自己的网站名称替换 （包括花括号）。你应该得到一段代码，如：{{ site_header|default:_('Djangoadministration') }}

  {% block branding %}
  <h1 id="site-name"><a href="{% url 'admin:index' %}">Polls Administration</a></h1>
  {% endblock %}

  我们使用这种方法来教你如何覆盖模板。在实际项目中，您可能会使用该django.contrib.admin.AdminSite.site_header属性来更轻松地进行此特定自定义。

  此模板文件包含许多类似 和的文本。在和标签是Django的模板语言的一部分。当Django呈现时，将评估此模板语言以生成最终的HTML页面，就像我们在教程3中看到的那样。{% block branding %}{{ title }}{%{{admin/base_site.html

  请注意，任何Django的默认管理模板都可以被覆盖。要覆盖模板，只需执行与之相同的操作base_site.html- 将其从默认目录复制到自定义目录中，然后进行更改。

  自定义应用程序的模板?

  精明的读者会问：但如果DIRS默认为空，Django如何找到默认的管理模板？答案是，自APP_DIRS设置为True，Django会自动templates/在每个应用程序包中查找子目录，以用作后备（不要忘记这 django.contrib.admin是一个应用程序）。

  我们的民意调查应用程序不是很复杂，也不需要自定义管理模板。但是如果它变得越来越复杂并且需要修改Django的标准管理模板以实现其某些功能，那么修改应用程序的模板（而不是项目中的模板） 会更加明智。这样，您可以将民意调查应用程序包含在任何新项目中，并确保它可以找到所需的自定义模板。

  有关Django如何找到其模板的更多信息，请参阅模板加载文档。

  自定义管理索引页面?

  在类似的说明中，您可能希望自定义Django管理员索引页面的外观。

  默认情况下，它INSTALLED_APPS按字母顺序显示已在管理应用程序中注册的所有应用程序。您可能希望对布局进行重大更改。毕竟，索引可能是管理员最重要的页面，它应该易于使用。

  要自定义的模板是admin/index.html。（与admin/base_site.html上一节中的相同 - 将其从默认目录复制到自定义模板目录）。编辑文件，你会看到它使用一个名为的模板变量app_list。该变量包含每个已安装的Django应用程序。您可以以您认为最好的方式将链接硬编码到特定于对象的管理页面，而不是使用它。

  与此同时，您可能想查看一些关于从何处开始的指示。

   

  高级教程：如何编写可重用的应用程序?

  这个高级教程从教程7 停止的地方开始。我们将把Web-poll变成一个独立的Python包，您可以在新项目中重用它并与其他人共享。

  如果您最近没有完成教程1-7，我们建议您查看这些内容，以便您的示例项目与下面描述的项目相匹配。

  可重用性问题?

  设计，构建，测试和维护Web应用程序需要做很多工作。许多Python和Django项目都存在共同的问题。如果我们能省下一些重复的工作，那不是很好吗？

  可重用性是Python的生活方式。Python包索引（PyPI）包含大量的包，您可以在自己的Python程序中使用它们。查看Django Packages，了解您可以在项目中包含的现有可重用应用程序。Django本身也只是一个Python包。这意味着您可以使用现有的Python包或Django应用程序并将它们组合到您自己的Web项目中。您只需编写使您的项目独特的部分。

  假设您正在开始一个需要民意调查应用程序的新项目，就像我们一直在努力的那样。你如何使这个应用程序可重用？幸运的是，你已经很好了。在教程3中，我们看到了如何使用一个方法将民意调查与项目级URLconf分离include。在本教程中，我们将采取进一步措施，使应用程序易于在新项目中使用，并准备发布供其他人安装和使用。

  包？应用程序？

  Python 包提供了一种对相关Python代码进行分组的方法，以便于重用。包中包含一个或多个Python代码文件（也称为“模块”）。

  包可以用或导入。对于形成包的目录（如），它必须包含一个特殊文件，即使该文件为空。import foo.barfrom fooimport barpolls__init__.py

  Django 应用程序只是一个专门用于Django项目的Python包。应用程序可以使用通用的Django约定，诸如具有models，tests，urls，和views 子模块。

  稍后我们使用术语包装来描述使Python包易于安装的过程。我们知道，这可能有点令人困惑。

  您的项目和可重用的应用程序?

  在前面的教程之后，我们的项目应如下所示：

  mysite/
      manage.py
      mysite/
          __init__.py
          settings.py
          urls.py
          wsgi.py
      polls/
          __init__.py
          admin.py
          migrations/
              __init__.py
              0001_initial.py
          models.py
          static/
              polls/
                  images/
                      background.gif
                  style.css
          templates/
              polls/
                  detail.html
                  index.html
                  results.html
          tests.py
          urls.py
          views.py
      templates/
          admin/
              base_site.html

   

  您创建mysite/templates的教程7，并且polls/templates在教程3。现在也许更清楚的是为什么我们选择为项目和应用程序提供单独的模板目录：作为民意调查应用程序一部分的所有内容都在 polls。它使应用程序自包含，更容易进入新项目。

  该polls目录现在可以复制到新的Django项目中并立即重用。虽然它还没有准备好发表。为此，我们需要打包应用程序，以便其他人安装。

  安装一些先决条件?

  Python包装的当前状态与各种工具有点混乱。在本教程中，我们将使用setuptools来构建我们的包。这是推荐的打包工具（与distributefork 合并）。我们还将使用pip来安装和卸载它。您应该立即安装这两个包。如果您需要帮助，可以参考如何使用pip安装Django。您可以setuptools 以相同的方式安装。

  打包您的应用?

  Python 打包是指以易于安装和使用的特定格式准备应用程序。Django本身的打包非常像这样。对于像民意调查这样的小应用程序，这个过程并不太难。

  1. 首先，polls在Django项目之外创建一个父目录。调用此目录django-polls。

     为您的应用选择一个名称

     为包选择名称时，请检查PyPI等资源，以避免与现有包发生命名冲突。django-在创建要分发的包时，在模块名称前添加通常很有用 。这有助于其他寻找Django应用的用户将您的应用识别为特定于Django。

     应用程序标签（即应用程序包的虚线路径的最后部分）必须是唯一的INSTALLED_APPS。避免使用相同的标签为任何Django的的的contrib包，例如auth，admin或 messages。

  2. 将polls目录移动到django-polls目录中。

  3. 创建django-polls/README.rst包含以下内容的文件：

     

     =====
     Polls
     =====
     
     民意调查是一个简单的Django应用程序，用于进行基于Web的民意调查。 对于每一个
     问题，访问者可以选择固定数量的答案。
     
     详细文档位于“docs”目录中。
     
     快速开始
     -----------
     
     1.将“民意调查”添加到您的INSTALLED_APPS设置中，如下所示::
     
         INSTALLED_APPS = [
             ...
             'polls',
         ]
     
     2. 在您的项目urls.py中包含民意调查URLconf，如下所示::
     
         url(r'^polls/', include('polls.urls')),
     
     3.运行`python manage.py migrate`以创建民意调查模型。
     
     4.启动开发服务器并访问http://127.0.0.1:8000/admin/
         创建投票（您需要启用管理员应用）。
     
     5. 访问http://127.0.0.1:8000/polls/参加投票。

     django-polls/README.rst

  4. 创建一个django-polls/LICENSE文件。选择许可证超出了本教程的范围，但足以说明没有许可证公开发布的代码是无用的。Django和许多兼容Django的应用程序是根据BSD许可证分发的; 但是，您可以自由选择自己的许可证。请注意，您的许可选择将影响谁可以使用您的代码。

  5. 接下来，我们将创建一个setup.py文件，提供有关如何构建和安装应用程序的详细信息。该文件的完整说明超出了本教程的范围，但setuptools文档有一个很好的解释。创建django-polls/setup.py包含以下内容的文件：

     

     import os
     from setuptools import find_packages, setup
     
     with open(os.path.join(os.path.dirname(__file__), 'README.rst')) as readme:
         README = readme.read()
     
     # allow setup.py to be run from any path
     os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
     
     setup(
         name='django-polls',
         version='0.1',
         packages=find_packages(),
         include_package_data=True,
         license='BSD License',  # example license
         description='A simple Django app to conduct Web-based polls.',
         long_description=README,
         url='https://www.example.com/',
         author='Your Name',
         author_email='yourname@example.com',
         classifiers=[
             'Environment :: Web Environment',
             'Framework :: Django',
             'Framework :: Django :: X.Y',  # replace "X.Y" as appropriate
             'Intended Audience :: Developers',
             'License :: OSI Approved :: BSD License',  # example license
             'Operating System :: OS Independent',
             'Programming Language :: Python',
             # Replace these appropriately if you are stuck on Python 2.
             'Programming Language :: Python :: 3',
             'Programming Language :: Python :: 3.4',
             'Programming Language :: Python :: 3.5',
             'Topic :: Internet :: WWW/HTTP',
             'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
         ],
     )

     django-polls/setup.py

      

  6. 默认情况下，程序包中仅包含Python模块和程序包。要包含其他文件，我们需要创建一个MANIFEST.in文件。上一步中提到的setuptools文档更详细地讨论了该文件。要包含模板，README.rst和我们的LICENSE 文件，请创建一个django-polls/MANIFEST.in包含以下内容的文件：
     

     include LICENSE
     include README.rst
     recursive-include polls/static *
     recursive-include polls/templates *

     django-polls/MANIFEST.in

      

  7. 它是可选的，但建议在您的应用程序中包含详细的文档。django-polls/docs为将来的文档创建一个空目录。添加一行到django-polls/MANIFEST.in：

     recursive-include docs *

     请注意，docs除非您向其中添加一些文件，否则该目录将不会包含在您的包中。许多Django应用程序还通过readthedocs.org等网站在线提供文档。

  8. 1. 尝试使用（从内部运行 ）构建包。这将创建一个名为的目录并构建您的新包。python setup.py sdistdjango-pollsdistdjango-polls-0.1.tar.gz

     有关打包的更多信息，请参阅Python的打包和分发项目教程。

     使用自己的包?

     由于我们将polls目录移出项目，因此不再有效。我们现在将通过安装我们的新django-polls软件包解决这个问题。

     作为用户库安装

     以下步骤django-polls作为用户库安装。与在系统范围内安装软件包相比，每用户安装具有许多优势，例如可以在您没有管理员访问权限的系统上使用，以及防止软件包影响系统服务和机器的其他用户。

     请注意，每用户安装仍然会影响以该用户身份运行的系统工具的行为，因此virtualenv是一种更强大的解决方案（请参见下文）。

     1. 要安装软件包，请使用pip（您已安装它，对吧？）：

        pip install --user django-polls/dist/django-polls-0.1.tar.gz

         

     2. 幸运的是，您的Django项目现在应该再次正常工作。再次运行服务器以确认这一点。
     3. 要卸载软件包，请使用pip：

        pip uninstall django-polls

        发布你的应用?

        现在我们已经打包并进行了测试django-polls，它已准备好与全世界分享！如果这不仅仅是一个例子，你现在可以：

        • 将包裹通过电子邮件发送给朋友
        • 上传您网站上的包裹。
        • 将包发布在公共存储库上，例如Python包索引（PyPI）。packaging.python.org提供了一个很好的教程 。

        使用virtualenv安装Python包?

        之前，我们将民意调查应用程序安装为用户库。这有一些缺点：

        • 修改用户库可能会影响系统上的其他Python软件。
        • 您将无法运行此软件包的多个版本（或其他具有相同名称的版本）。

        通常，只有在维护多个Django项目时才会出现这些情况。当他们这样做时，最好的解决方案是使用virtualenv。此工具允许您维护多个隔离的Python环境，每个环境都有自己的库和包命名空间的副本。

         

        接下来要读什么?

        所以你已经阅读了所有的介绍材料，并决定你继续使用Django。我们只是简单介绍了这个介绍（事实上，如果你读过每一个单词，你已经阅读了大约5％的整体文档）。

        下一个是什么？

        好吧，我们一直都是通过实践学习的忠实粉丝。在这一点上，你应该知道自己开始一个项目并开始愚弄。当您需要学习新技巧时，请回到文档。

        我们付出了很多努力使Django的文档变得有用，易于阅读并尽可能完整。本文档的其余部分将详细介绍文档的工作原理，以便您可以充分利用它。

        （是的，这是关于文档的文档。请放心，我们没有计划编写有关如何阅读有关文档的文档的文档。）

        查找文档?

        Django有很多文档 - 大约450,000个单词和数量 - 所以找到你需要的东西有时候会很棘手。一些好的开始是搜索页面和索引。

        或者你可以浏览一下！

        如何组织文档?

        Django的主要文档被分解为“块”，旨在满足不同的需求：

        • 在介绍性的材料是专为人们新的Django的-或者Web开发一般。它没有深入介绍任何内容，而是对Django的“感觉”发展进行了高级概述。

        • 该主题将指导，另一方面，深潜入的Django的各个部分。有完整的Django 模型系统，模板引擎，表单框架等指南。

          这可能是你想要花费大部分时间的地方; 如果你通过这些指南工作，你应该知道几乎所有关于Django的知识。

        • Web开发通常很广泛，而不是很深入 - 跨越许多领域的问题。我们编写了一套操作指南来回答常见的“我如何......？”的问题。在这里，您可以找到有关 使用Django生成PDF，编写自定义模板标签等信息。

          答案非常常见的问题，也可以在发现的常见问题。

        • 指南和操作方法不包括Django中可用的每个类，功能和方法 - 当您尝试学习时，这将是压倒性的。相反，有关各个类，函数，方法和模块的详细信息保留在参考中。您可以在此处查找特定功能的详细信息或您需要的任何内容。

        • 如果您有兴趣部署项目供公众使用，我们的文档有 各种部署设置的几个指南，以及 您需要考虑的一些部署清单。

        • 最后，有一些“专业”文档通常与大多数开发人员无关。这包括那些想要向Django本身添加代码的人的发行说明和 内部文档，以及其他一些不适合其他地方的东西。

        如何更新文档?

        正如Django代码库每天都在开发和改进一样，我们的文档也在不断改进。我们改进文档有以下几个原因：

        • 进行内容修复，例如语法/拼写错误修正。
        • 向需要扩展的现有部分添加信息和/或示例。
        • 记录尚未记录的Django功能。（这些功能的列表正在缩小，但仍然存在。）
        • 在添加新功能或添加Django API或行为时添加新功能的文档。

        Django的文档与其代码保存在同一个源代码控制系统中。它位于我们的Git存储库的docs目录中。在线的每个文档都是存储库中的单独文本文件。

        哪里可以得到它?

        您可以通过多种方式阅读Django文档。它们按优先顺序排列：

        在网络上?

        最新版本的Django文档位于 https://docs.djangoproject.com/en/dev/。这些HTML页面是从源代码管理中的文本文件自动生成的。这意味着它们反映了Django中的“最新和最好的” - 它们包括最新的更正和补充，并且它们讨论了最新的Django功能，这些功能可能只适用于Django开发版本的用户。（参见下面的“版本之间的差异”。）

        我们建议您通过在故障单系统中提交更改，更正和建议来帮助改进文档。Django开发人员主动监控票务系统并使用您的反馈来改进每个人的文档。

        但请注意，票证应明确与文档相关，而不是询问广泛的技术支持问题。如果您需要有关特定Django设置的帮助，请尝试使用django-users邮件列表或#django IRC频道。

        用明文?

        对于离线阅读，或者为了方便起见，您可以用纯文本阅读Django文档。

        如果您正在使用Django的官方发行版，请注意代码的压缩包（tarball）包含一个docs/目录，其中包含该发行版的所有文档。

        如果您使用的是Django的开发版本（又名“trunk”），请注意该 docs/目录包含所有文档。您可以更新您的Git结帐以获取最新的更改。

        利用文本文档的一种低技术方法是使用Unix grep实用程序在所有文档中搜索短语。例如，这将显示在任何Django文档中每次提到短语“max_length”：

        $ grep -r max_length /path/to/django/docs/

         

        作为HTML，本地?

        您可以通过以下几个简单步骤获取HTML文档的本地副本：

        • Django的文档使用一个名为Sphinx的系统将纯文本转换为HTML。您需要通过从Sphinx网站下载和安装软件包来安装Sphinx，或者使用pip：

          $ pip install Sphinx

        • 然后，只需使用包含Makefile将文档转换为HTML：

          $ cd path/to/django/docs
          $ make html

          你需要为此安装GNU Make。

          如果您使用的是Windows，则可以使用附带的批处理文件：

          cd path\to\django\docs
          make.bat html

        • HTML文档将被放入docs/_build/html。

        版本之间的差异?

        如前所述，我们的Git存储库中的文本文档包含“最新和最好的”更改和添加。这些更改通常包括Django开发版本中添加的新功能的文档 - Django的Git（“trunk”）版本。出于这个原因，值得指出我们关于保持框架的各种版本的文档的政策。

        我们遵循这一政策：

        • djangoproject.com上的主要文档是Git中最新文档的HTML版本。这些文档始终对应于最新的官方Django版本，以及自最新版本以来我们在框架中添加/更改的任何功能。
        • 当我们向Django的开发版本添加功能时，我们尝试在同一个Git提交事务中更新文档。
        • 为了区分文档中的功能更改/添加，我们使用短语：“版本XY中的新功能”，XY是下一个版本（因此，正在开发的版本）。
        • 文档修复和改进可能会被提交到最后一个版本分支，由提交者自行决定，但是，一旦不再支持 Django 版本，该版本的文档将不会获得任何进一步的更新。
        • 在主文档Web页面包含指向文档，所有以前的版本。请确保您使用的是与您正在使用的Django版本相对应的文档版本！

         

        为Django编写第一个补丁?

        介绍?

        有兴趣回馈一下社区吗？也许您在Django中发现了一个您希望修复的错误，或者您想添加一个小功能。

        回馈Django本身是了解自己关注的最佳方式。这一开始看起来令人生畏，但它真的很简单。我们将引导您完成整个过程，以便您可以通过示例学习。

        这个教程是谁的？?

        也可以看看

        如果要查找有关如何提交修补程序的参考，请参阅 提交修补程序 文档。

        对于本教程，我们希望您至少对Django的工作原理有基本的了解。这意味着您应该熟悉编写第一个Django应用程序的现有教程。另外，你应该对Python本身有一个很好的理解。但是，如果你不这样做，Dive Into Python是一本非常棒的（免费）在线书籍，适合初学Python程序员。

        那些不熟悉版本控制系统和Trac的人会发现本教程及其链接包含足够的信息以便入门。但是，如果您计划定期为Django做贡献，您可能希望阅读更多有关这些不同工具的内容。

        但是，在大多数情况下，本教程试图尽可能地解释，以便它可以用于最广泛的受众。

        哪里可以获得帮助：

        如果您在阅读本教程时遇到问题，请向django-developers发送消息，或者通过irc.freenode.net上的＃django-dev与其他可能提供帮助的Django用户聊天。

        本教程涵盖哪些内容？?

        我们将第一次带您到Django的补丁。在本教程结束时，您应该对所涉及的工具和过程有基本的了解。具体来说，我们将涵盖以下内容：

        • 安装Git。
        • 如何下载Django的开发副本。
        • 运行Django的测试套件。
        • 为您的补丁编写测试。
        • 编写补丁的代码。
        • 测试你的补丁。
        • 提交拉取请求。
        • 在哪里寻找更多信息。

        完成本教程后，您可以查看Django关于贡献的其余 文档。它包含很多很棒的信息，对于那些想成为Django常规贡献者的人来说，必读。如果你有问题，可能会得到答案。

        需要Python 3！

        本教程假设您使用的是Python 3.在Python的下载页面或使用操作系统的软件包管理器获取最新版本 。

        对于Windows用户

        在Windows上安装Python时，请确保选中“将python.exe添加到路径”选项，以便它始终在命令行中可用。

        行为准则?

        作为贡献者，您可以帮助我们保持Django社区的开放性和包容性。请阅读并遵守我们的行为准则。

        安装Git?

        对于本教程，您需要安装Git才能下载Django的当前开发版本，并为您所做的更改生成补丁文件。

        要检查是否安装了Git，请进入git命令行。如果您收到消息说无法找到此命令，则必须下载并安装它，请参阅Git的下载页面。

        对于Windows用户

        在Windows上安装Git时，建议您选择“Git Bash”选项，以便Git在自己的shell中运行。本教程假设您已经安装了它。

        如果您对Git不熟悉，可以通过在命令行输入来了解有关其命令（一旦安装）的更多信息。git help

        获取Django开发版本的副本?

        为Django做贡献的第一步是获取源代码的副本。首先，在GitHub上分叉Django。然后，从命令行，使用该cd命令导航到您希望Django的本地副本存在的目录。

        使用以下命令下载Django源代码存储库：

        $ git clone git@github.com:YourGitHubName/django.git

        现在您已经拥有了Django的本地副本，您可以像安装任何软件包一样安装它pip。最方便的方法是使用虚拟环境（或virtualenv），这是Python内置的一个功能，允许您为每个项目保留一个单独的已安装软件包目录，以便它们不会相互干扰。

        将所有virtualenvs保存在一个位置是个好主意，例如 .virtualenvs/在您的主目录中。如果它还不存在，请创建它：

        $ mkdir ~/.virtualenvs

        现在运行以下命令创建一个新的virtualenv：

        $ python3 -m venv ~/.virtualenvs/djangodev

        该路径是新环境将保存在您的计算机上的位置。

        对于Windows用户

        venv如果您还在Windows上使用Git Bash shell，则使用内置模块将无法工作，因为仅为系统shell（.bat）和PowerShell（.ps1）创建了激活脚本。virtualenv 改为使用包：

        $ pip install virtualenv
        $ virtualenv ~/.virtualenvs/djangodev
        

        对于Ubuntu用户

        在某些版本的Ubuntu上，上述命令可能会失败。请改用 virtualenv包装，首先确保您拥有pip3：

        $ sudo apt-get install python3-pip
        $ # Prefix the next command with sudo if it gives a permission denied error
        $ pip3 install virtualenv
        $ virtualenv --python=`which python3` ~/.virtualenvs/djangodev

        设置virtualenv的最后一步是激活它：

        $ source ~/.virtualenvs/djangodev/bin/activate

        如果该source命令不可用，您可以尝试使用点代替：

        $ . ~/.virtualenvs/djangodev/bin/activate

        对于Windows用户

        要在Windows上激活virtualenv，请运行：

        $ source ~/virtualenvs/djangodev/Scripts/activate

        每当打开新的终端窗口时，您都必须激活virtualenv。 virtualenvwrapper是一个有用的工具，使这更方便。

        pip从现在开始安装的任何内容都将安装在新的virtualenv中，与其他环境和系统范围的软件包隔离。此外，命令行上会显示当前激活的virtualenv的名称，以帮助您跟踪正在使用的名称。继续安装之前克隆的Django副本：

        $ pip install -e /path/to/your/local/clone/django/

        已安装的Django版本现在指向您的本地副本。您将立即看到对其所做的任何更改，这在编写第一个补丁时非常有用。

        回滚到以前版本的Django?

        在本教程中，我们将使用＃24788作为案例研究，因此我们将在应用该票证补丁之前将gang中的Django版本历史回滚。这将允许我们完成从头开始编写该补丁所涉及的所有步骤，包括运行Django的测试套件。

        请记住，虽然我们将在下面的教程中使用较旧的Django主干版本，但在处理自己的票证补丁时，应始终使用Django的当前开发版本！

        注意

        这张票的补丁是由Pawe?Marczewski编写的，它被应用于Django作为提交4df7e8483b2679fc1cba3410f08960bac6f51115。因此，我们将在此之前使用Django的修订版， 提交4ccfc4439a7add24f8db4ef3960d02ef8ae09887。

        导航到Django的根目录下（这是包含一个django， docs，tests，AUTHORS，等）。然后，您可以查看我们将在下面的教程中使用的旧版Django：

        $ git checkout 4ccfc4439a7add24f8db4ef3960d02ef8ae09887

        第一次运行Django的测试套件?

        在为Django做贡献时，您的代码更改不会将错误引入Django的其他区域非常重要。在进行更改后检查Django是否仍然有效的一种方法是运行Django的测试套件。如果所有测试仍然通过，那么您可以合理地确定您的更改并未完全破坏Django。如果您以前从未运行过Django的测试套件，那么最好先预先运行一次，以便熟悉其输出应该是什么样子。

        在运行测试套件之前，首先将其依赖项安装cd到Django tests/目录中，然后运行：

        $ pip install -r requirements/py3.txt
        

        如果在安装过程中遇到错误，则系统可能缺少一个或多个Python包的依赖项。查阅失败的软件包文档或使用您遇到的错误消息在Web上搜索。

        现在我们准备运行测试套件了。如果您使用的是GNU / Linux，macOS或其他一些Unix版本，请运行：

        $ ./runtests.py
        

        现在坐下来放松一下。Django的整个测试套件有超过9,600种不同的测试，因此运行时间可能需要5到15分钟，具体取决于计算机的速度。

        当Django的测试套件运行时，您将看到一个字符流，表示每个测试运行时的状态。E表示在测试期间引发了错误，并F指示测试的断言失败。这两个都被认为是测试失败。同时，x并s 表示预期的失败和分别跳过的测试。圆点表示通过测试。

        跳过的测试通常是由于缺少运行测试所需的外部库; 请参阅运行所有测试以获取依赖项列表，并确保安装任何与您正在进行的更改相关的测试（本教程不需要任何测试）。某些测试特定于特定的数据库后端，如果不使用该后端进行测试，则会跳过这些测试。SQLite是默认设置的数据库后端。要使用其他后端运行测试，请参阅使用其他设置模块。

        测试完成后，应该会收到一条消息，通知您测试套件是通过还是失败。由于您尚未对Django的代码进行任何更改，因此整个测试套件应该通过。如果您遇到故障或错误，请确保您已正确执行了上述所有步骤。有关更多信息，请参阅 运行单元测试。如果您使用的是Python 3.5+，则可能会忽略与弃用警告相关的一些故障。这些失败已经在Django中得到修复。

        请注意，最新的Django主干可能并不总是稳定的。在针对主干进行开发时，您可以检查Django的持续集成构建，以确定故障是否特定于您的计算机，或者它们是否也出现在Django的官方版本中。如果单击以查看特定构建，则可以查看“配置矩阵”，其中显示了由Python版本和数据库后端细分的故障。

        注意

        对于本教程和我们正在处理的故障单，对SQLite进行测试就足够了，但是，使用不同的数据库运行测试是可能的（有时是必要的） 。

        为补丁创建分支?

        在进行任何更改之前，请为故障单创建一个新分支：

        $ git checkout -b ticket_24788
        

        您可以为分支选择任何名称，“ticket_24788”就是一个例子。此分支中所做的所有更改都将特定于故障单，并且不会影响我们之前克隆的代码的主副本。

        为你的票写一些测试?

        在大多数情况下，对于要接受Django的补丁，它必须包括测试。对于错误修复补丁，这意味着编写回归测试以确保以后永远不会将错误重新引入Django。回归测试应该以这样的方式编写，即在错误仍然存??在时它将失败并在错误修复后通过。对于包含新功能的修补程序，您需要包含可确保新功能正常运行的测试。它们也应该在新功能不存在时失败，然后在实现后再通过。

        执行此操作的一种好方法是在对代码进行任何更改之前先编写新测试。这种开发方式称为 测试驱动开发，可以应用于整个项目和单个补丁。在编写测试之后，然后运行它们以确保它们确实失败（因为您尚未修复该错误或添加了该功能）。如果您的新测试没有失败，您需要修复它们以便它们执行。毕竟，无论是否存在错误，都会通过回归测试，这对于防止错误重复发生并非常有帮助。

        现在我们亲自动手的例子。

        为票＃24788写一些测试?

        故障＃24788提出了一个小功能添加：能够prefix在Form类上指定类级别属性，以便：

        […] forms which ship with apps could effectively namespace themselves such
        that N overlapping form fields could be POSTed at once and resolved to the
        correct form.

        为了解决此故障单，我们将向该类添加一个prefix属性 BaseForm。在创建此类的实例时，将前缀传递给__init__()方法仍将在创建的实例上设置该前缀。但是不传递前缀（或传递None）将使用类级前缀。在我们进行这些更改之前，我们将编写几个测试来验证我们的修改是否正常运行并在将来继续正常运行。

        导航到Django的tests/forms_tests/tests/文件夹并打开 test_forms.py文件。在test_forms_with_null_boolean函数前面的第1674行添加以下代码 ：

        def test_class_prefix(self):
            # Prefix can be also specified at the class level.
            class Person(Form):
                first_name = CharField()
                prefix = 'foo'
        
            p = Person()
            self.assertEqual(p.prefix, 'foo')
        
            p = Person(prefix='bar')
            self.assertEqual(p.prefix, 'bar')

        此新测试检查设置类级别前缀是否按预期工作，并且prefix在创建实例时传递参数仍然有效。

        但是这个测试的东西看起来有点难......

        如果您以前从未处理过测试，那么乍一看它们看起来有点难以写。幸运的是，测试是计算机编程中非常重要的主题，所以有很多信息：

        • 在编写和运行测试的文档中可以找到为Django编写测试的第一眼。
        • Dive Into Python（一本面向初学Python开发人员的免费在线书籍）包括对单元测试的精彩介绍。
        • 阅读完这些内容之后，如果你想要一些稍微有点内容的东西，那么总会有Python unittest文档。

        运行新测试?

        请记住，我们尚未对其进行任何修改BaseForm，因此我们的测试将失败。让我们运行forms_tests 文件夹中的所有测试，以确保真正发生的事情。从命令行cd 进入Django tests/目录并运行：

        $ ./runtests.py forms_tests
        

        如果测试运行正确，您应该看到与我们添加的测试方法相对应的一个失败。如果所有测试都通过了，那么您需要确保将上面显示的新测试添加到相应的文件夹和类中。

        编写机票代码?

        接下来，我们将把票号＃24788中描述的功能添加到Django。

        编写故障单＃24788的代码?

        导航到该django/django/forms/文件夹并打开该forms.py文件。BaseForm在第72行找到该类，并在prefix属性后面添加class field_order属性：

        class BaseForm(object):
            # This is the main implementation of all the Form logic. Note that this
            # class is different than Form. See the comments by the Form class for
            # more information. Any improvements to the form API should be made to
            # *this* class, not to the Form class.
            field_order = None
            prefix = None

        验证您的测试现在通过?

        一旦你完成了修改Django，我们需要确保我们之前写的测试通过，所以我们可以看到上面编写的代码是否正常工作。要在forms_tests文件夹中运行测试，请cd进入Django tests/目录并运行：

        $ ./runtests.py forms_tests
        

        哎呀，我们编写这些测试的好东西！您仍然应该看到一个失败，但有以下异常：

        AssertionError: None != 'foo'
        

        我们忘了在__init__方法中添加条件语句。继续改变现在的第87行 ，添加一个条件语句：self.prefix =prefixdjango/forms/forms.py

        if prefix is not None:
            self.prefix = prefix
        

        重新运行测试，一切都应该通过。如果没有，请确保BaseForm如上所示正确修改了类并正确复制了新测试。

        第二次运行Django的测试套件?

        一旦你确认你的补丁和测试工作正常，最好运行整个Django测试套件，以验证你的更改没有在Django的其他区域引入任何错误。虽然成功通过整个测试套件并不能保证您的代码没有错误，但它确实有助于识别可能会被忽视的许多错误和回归。

        要运行整个Django测试套件，cd进入Django tests/ 目录并运行：

        $ ./runtests.py
        

        只要你没有看到任何失败，你就会很高兴。

        编写文档?

        这是一个新功能，因此应该记录在案。在第1068行（文件末尾）添加以下部分django/docs/ref/forms/api.txt：

        The prefix can also be specified on the form class::
        
            >>> class PersonForm(forms.Form):
            ...     ...
            ...     prefix = 'person'
        
        .. versionadded:: 1.9
        
            The ability to specify ``prefix`` on the form class was added.

        由于这个新功能将在即将发布的版本中，因此它也会添加到Django 1.9的发行说明中，位于文件中“Forms”部分的第164行docs/releases/1.9.txt：

        * A form prefix can be specified inside a form class, not only when
          instantiating a form. See :ref:`form-prefix` for details.

        有关编写文档的更多信息，包括对versionadded所有内容的解释，请参阅 编写文档。该页面还包括如何在本地构建文档副本的说明，以便您可以预览将生成的HTML。

        预览您的更改?

        现在是时候完成补丁中的所有更改了。要显示当前Django副本（包括您的更改）与您最初在本教程中检出的修订版之间的差异：

        $ git diff
        

        使用箭头键上下移动。

        diff --git a/django/forms/forms.py b/django/forms/forms.py
        index 509709f..d1370de 100644
        --- a/django/forms/forms.py
        +++ b/django/forms/forms.py
        @@ -75,6 +75,7 @@ class BaseForm(object):
             # information. Any improvements to the form API should be made to *this*
             # class, not to the Form class.
             field_order = None
        +    prefix = None
        
             def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
                          initial=None, error_class=ErrorList, label_suffix=None,
        @@ -83,7 +84,8 @@ class BaseForm(object):
                 self.data = data or {}
                 self.files = files or {}
                 self.auto_id = auto_id
        -        self.prefix = prefix
        +        if prefix is not None:
        +            self.prefix = prefix
                 self.initial = initial or {}
                 self.error_class = error_class
                 # Translators: This is the default suffix added to form field labels
        diff --git a/docs/ref/forms/api.txt b/docs/ref/forms/api.txt
        index 3bc39cd..008170d 100644
        --- a/docs/ref/forms/api.txt
        +++ b/docs/ref/forms/api.txt
        @@ -1065,3 +1065,13 @@ You can put several Django forms inside one ``<form>`` tag. To give each
             >>> print(father.as_ul())
             <li><label for="id_father-first_name">First name:</label> <input type="text" name="father-first_name" id="id_father-first_name" /></li>
             <li><label for="id_father-last_name">Last name:</label> <input type="text" name="father-last_name" id="id_father-last_name" /></li>
        +
        +The prefix can also be specified on the form class::
        +
        +    >>> class PersonForm(forms.Form):
        +    ...     ...
        +    ...     prefix = 'person'
        +
        +.. versionadded:: 1.9
        +
        +    The ability to specify ``prefix`` on the form class was added.
        diff --git a/docs/releases/1.9.txt b/docs/releases/1.9.txt
        index 5b58f79..f9bb9de 100644
        --- a/docs/releases/1.9.txt
        +++ b/docs/releases/1.9.txt
        @@ -161,6 +161,9 @@ Forms
           :attr:`~django.forms.Form.field_order` attribute, the ``field_order``
           constructor argument , or the :meth:`~django.forms.Form.order_fields` method.
        
        +* A form prefix can be specified inside a form class, not only when
        +  instantiating a form. See :ref:`form-prefix` for details.
        +
         Generic Views
         ^^^^^^^^^^^^^
        
        diff --git a/tests/forms_tests/tests/test_forms.py b/tests/forms_tests/tests/test_forms.py
        index 690f205..e07fae2 100644
        --- a/tests/forms_tests/tests/test_forms.py
        +++ b/tests/forms_tests/tests/test_forms.py
        @@ -1671,6 +1671,18 @@ class FormsTestCase(SimpleTestCase):
                 self.assertEqual(p.cleaned_data['last_name'], 'Lennon')
                 self.assertEqual(p.cleaned_data['birthday'], datetime.date(1940, 10, 9))
        
        +    def test_class_prefix(self):
        +        # Prefix can be also specified at the class level.
        +        class Person(Form):
        +            first_name = CharField()
        +            prefix = 'foo'
        +
        +        p = Person()
        +        self.assertEqual(p.prefix, 'foo')
        +
        +        p = Person(prefix='bar')
        +        self.assertEqual(p.prefix, 'bar')
        +
             def test_forms_with_null_boolean(self):
                 # NullBooleanField is a bit of a special case because its presentation (widget)
                 # is different than its data. This is handled transparently, though.

        完成预览修补后，q按键返回命令行。如果补丁的内容看起来没问题，那么是时候提交更改了。

        提交补丁中的更改?

        提交更改：

        $ git commit -a
        

        这将打开一个文本编辑器来键入提交消息。遵循提交消息准则并编写如下消息：

        Fixed #24788 -- Allowed Forms to specify a prefix at the class level.
        

        推送提交并发出拉取请求?

        提交补丁后，将其发送到GitHub上的分支（如果不同，请将“ticket_24788”替换为分支的名称）：

        $ git push origin ticket_24788
        

        您可以通过访问Django GitHub页面来创建拉取请求。你会在“你最近被推动的分支”下看到你的分支。点击旁边的“比较并提取请求”。

        请不要为本教程执行此操作，但在显示修补程序预览的下一页上，您将单击“创建拉取请求”。

        后续步骤?

        恭喜，您已经学会了如何向Django发出拉取请求！您可能需要的更高级技术的详细信息在 使用Git和GitHub。

        现在，您可以通过帮助改进Django的代码库来充分利用这些技能。

        有关新贡献者的更多信息?

        在你为Django编写补丁之前，还有一些关于贡献的更多信息，你应该看一下：

        • 您应该确保阅读Django关于声明票证和提交补丁的文档 。它涵盖了Trac礼仪，如何为自己索取门票，预期补丁的编码风格以及许多其他重要细节。
        • 第一次贡献者也应该首次阅读Django的文档。对于我们这些刚接触Django的人来说，它有很多很好的建议。
        • 在那之后，如果您仍然渴望了解有关贡献的更多信息，您可以随时浏览Django关于贡献的其余 文档。它包含大量有用的信息，应该是您回答任何问题的第一手资料。

        找到你的第一张真票?

        一旦你浏览了一些这些信息，你就可以出去找一张你自己的票来写一个补丁了。使用“轻松选择”标准特别注意门票。这些门票通常更简单，对于初次参与者来说非常棒。一旦熟悉了对Django的贡献，您就可以继续为更复杂的故障单编写补丁。

        如果您只想开始使用（并且没有人会责怪您！），请尝试查看需要补丁的简单票证列表以及包含需要改进的补丁的 简单票证。如果您熟悉编写测试，还可以查看需要测试的简单票证列表 。请记住遵循关于声明票证的说明，这些票据是在Django的文档链接中提到的，用于 声明票证和提交补丁。

        创建拉取请求后的下一步是什么？?

        票证有补丁后，需要通过第二组眼睛进行审核。提交拉取请求后，通过将故障单上的标记设置为“有补丁”，“不需要测试”等来更新故障单元数据，以便其他人可以找到它进行查看。贡献并不一定意味着从头开始编写补丁。查看现有补丁也是一项非常有用的贡献。有关详细信息，请参阅分类票证