The Django Book

QueryDict Objects

QueryDict 对象

In an HttpRequest object, the GET and POST attributes are instances of django.http.QueryDict . QueryDict is a dictionary-like class customized to deal with multiple values for the same key. This is necessary because some HTML form elements, notably <select multiple="multiple"> , pass multiple values for the same key.

在一个 HttpRequest 对象中， GET 和 POST 属性都是 django.http.QueryDict 的实例。 QueryDict 是一个类似于字典的类，专门用�处�用一个键的多值。当处�一些HTML表�中的元素，特别是 <select multiple="multiple"> 之类传递�一key的多值的元素时，就需�这个类了。

QueryDict instances are immutable, unless you create a copy() of them. That means you cant change attributes of request.POST and request.GET directly.

QueryDict 实例是���的，除�创建了一个 copy() 副本。也就是说�能直接更改 request.POST 和 request.GET 的属性。

QueryDict implements the all standard dictionary methods, because its a subclass of dictionary. Exceptions are outlined in Table H-3.

QueryDict 实现了所有标准的字典的方法，因为它正是字典的一个�类。与其��的东西都已在表H-3中列出。

>>> q = QueryDict('a=1')
>>> q = q.copy() # to make it mutable
>>> q.update({'a': '2'})
>>> q.getlist('a')
['1', '2']
>>> q['a'] # returns the last
['2']

>>> q = QueryDict('a=1&a=2&a=3')
>>> q.items()
[('a', '3')]

>>> q = QueryDict('a=1')
>>> q = q.copy() # 使其��
>>> q.update({'a': '2'})
>>> q.getlist('a')
['1', '2']
>>> q['a'] # 返回最�一个值
['2']

>>> q = QueryDict('a=1&a=2&a=3')
>>> q.items()
[('a', '3')]

In addition, QueryDict has the methods shown in Table H-4.

�外， QueryDict 还有在表H-4中列出的方法。

>>> q = QueryDict('a=1&a=2&a=3')
>>> q.lists()
[('a', ['1', '2', '3'])]

>>> q = QueryDict('a=1&a=2&a=3')
>>> q.lists()
[('a', ['1', '2', '3'])]

A Complete Example

一个完整的例�

For example, given this HTML form:

例如, 给定这个HTML表�:

<form action="/foo/bar/" method="post">
<input type="text" name="your_name" />
<select multiple="multiple" name="bands">
    <option value="beatles">The Beatles</option>
    <option value="who">The Who</option>
    <option value="zombies">The Zombies</option>
</select>
<input type="submit" />
</form>

if the user enters "John Smith" in the your_name field and selects both The Beatles and The Zombies in the multiple select box, heres what Djangos request object would have:

如果用户在 your_name 中输入 "John Smith" ，并且在多选框中�时选择了The Beatles和The Zombies，那么以下就是Django的request对象所拥有的：

>>> request.GET
{}
>>> request.POST
{'your_name': ['John Smith'], 'bands': ['beatles', 'zombies']}
>>> request.POST['your_name']
'John Smith'
>>> request.POST['bands']
'zombies'
>>> request.POST.getlist('bands')
['beatles', 'zombies']
>>> request.POST.get('your_name', 'Adrian')
'John Smith'
>>> request.POST.get('nonexistent_field', 'Nowhere Man')
'Nowhere Man'

Implementation Note:

使用时请注�:

The GET , POST , COOKIES , FILES , META , REQUEST , raw_post_data , and user attributes are all lazily loaded. That means Django doesnt spend resources calculating the values of those attributes until your code requests them.

GET , POST , COOKIES , FILES , META , REQUEST , raw_post_data 和 user 这些属性都是延迟加载的。 也就是说除�代�中访问它们，�则Django并�会花费资��计算这些属性值。

Construction HttpResponses

构造HttpResponse

Typically, youll construct an HttpResponse to pass the contents of the page, as a string, to the HttpResponse constructor:

一般情况下，你创建一个 HttpResponse 时，以字符串的形��传递页�的内容给 HttpResponse 的构造函数：

>>> response = HttpResponse("Here's the text of the Web page.")
>>> response = HttpResponse("Text only, please.", mimetype="text/plain")

But if you want to add content incrementally, you can use response as a filelike object:

但是如果希望��增加内容，则�以把 response 当作一个类文件对象使用：

>>> response = HttpResponse()
>>> response.write("<p>Here's the text of the Web page.</p>")
>>> response.write("<p>Here's another paragraph.</p>")

You can pass HttpResponse an iterator rather than passing it hard-coded strings. If you use this technique, follow these guidelines:

你�以将一个迭代器传递给 HttpResponse ，而�是固定的字符串。如果你�这样�的�，请�循以下规则：

• The iterator should return strings.

• 迭代器应返回字符串。

• If an HttpResponse has been initialized with an iterator as its content, you cant use the HttpResponse instance as a filelike object. Doing so will raise Exception .

• 若一个 HttpResponse å·²ç»�通过实例化，并以一个迭代器作为其内容，就ä¸�能以一个类文件对象使用 HttpResponse 实例。这样å�šçš„è¯�，会导致一个 Exception 。

Finally, note that HttpResponse implements a write() method, which makes is suitable for use anywhere that Python expects a filelike object. See Chapter 11 for some examples of using this technique.

最�，注� HttpResponse 实现了一个 write() 方法，使其�以在任何�以使用类文件对象的地方使用。 这方�的例��第11章。

Setting Headers

设置 Headers

You can add and delete headers using dictionary syntax:

您�以使用字典一样地添加和删除头信�。

>>> response = HttpResponse()
>>> response['X-DJANGO'] = "It's the best."
>>> del response['X-PHP']
>>> response['X-DJANGO']
"It's the best."

You can also use has_header(header) to check for the existence of a header.

你也�以使用 has_header(header) �检查一个头信�项是�存在。

Avoid setting Cookie headers by hand; instead, see Chapter 12 for instructions on how cookies work in Django.

请��手工设置 Cookie 头，��第12章Django中cookie工作原�的说明。

HttpResponse Subclasses

HttpResponse的�类

Django includes a number of HttpResponse subclasses that handle different types of HTTP responses (see Table H-5). Like HttpResponse , these subclasses live in django.http .

Django包�许多处���类型的HTTP请求的 HttpResponse �类（�表H-5）。� HttpResponse 一样，这些类在 django.http 中。

.. table:: 表 H-5. HttpResponse �类

    +---------------------------------+-------------------------------------------+
    |类�                             |�述                                       |
    +=================================+===========================================+
    |``HttpResponseRedirect``         |构造函数的�数有一个：                     |
    |                                 |�定�的路径。 它�以是一个完整的URL       |
    |                                 |（例如， ``'http://search.yahoo.com/'`` ） |
    |                                 |或者�包括域�的�对路径（如               |
    |                                 |``'/search/'`` ）。 注�它返回             |
    |                                 |HTTP 状�� 302。                          |
    +---------------------------------+-------------------------------------------+
    |``HttpResponsePermanentRedirect``|类似 ``HttpResponseRedirect`` ， 但是它    |
    |                                 |返回一个永久�定� （HTTP 状�� 301），     |
    |                                 |而�是暂时性�定�（状��302）。            |
    +---------------------------------+-------------------------------------------+
    |``HttpResponseNotModified``      |构造函数没有任何�数。                     |
    |                                 |用它�表示这个页�在上次请求�未改�。     |
    +---------------------------------+-------------------------------------------+
    |``HttpResponseBadRequest``       |类似 ``HttpResponse`` ，但使用400状��。  |
    +---------------------------------+-------------------------------------------+
    |``HttpResponseNotFound``         |类似 ``HttpResponse`` ，但使用404状��。  |
    +---------------------------------+-------------------------------------------+
    |``HttpResponseForbidden``        |类似 ``HttpResponse`` ，但使用403状��。  |
    +---------------------------------+-------------------------------------------+
    |``HttpResponseNotAllowed``       |类似 ``HttpResponse`` ，但使用405状��。  |
    |                                 |它必须有一个�数：                         |
    |                                 |�许方法的列表。                           |
    |                                 |（例如， ``['GET', 'POST']`` ）。          |
    +---------------------------------+-------------------------------------------+
    |``HttpResponseGone``             |类似 ``HttpResponse`` ，但使用410状��。  |
    +---------------------------------+-------------------------------------------+
    |``HttpResponseServerError``      |类似 ``HttpResponse`` ，但使用500状��。  |
    +---------------------------------+-------------------------------------------+

You can, of course, define your own HttpResponse subclass to support different types of responses not supported out of the box.

当然，如果框架�支�一些特性，你也�以定义自己的 HttpResponse �类�处���的请求。

Returning Errors

返回错误

Returning HTTP error codes in Django is easy. Weve already mentioned the HttpResponseNotFound , HttpResponseForbidden , HttpResponseServerError , and other subclasses. Just return an instance of one of those subclasses instead of a normal HttpResponse in order to signify an error, for example:

在Django中返回HTTP错误代�很容易。我们��已��到 HttpResponseNotFound ， HttpResponseForbidden ， HttpResponseServerError ，和其它�类。为了更好地表示一个错误，��返回这些�类之一的一个实例，而�是一个通常的 HttpResponse ，例如：

def my_view(request):
    # ...
    if foo:
        return HttpResponseNotFound('<h1>Page not found</h1>')
    else:
        return HttpResponse('<h1>Page was found</h1>')

Because a 404 error is by far the most common HTTP error, theres an easier way to handle it.

至今为止，404错误是最常�的HTTP错误，有一�更容易的方��处�。

When you return an error such as HttpResponseNotFound , youre responsible for defining the HTML of the resulting error page:

当返回一个错误，比如 HttpResponseNotFound 时，需�定义错误页�的HTML：

return HttpResponseNotFound('<h1>Page not found</h1>')

For convenience, and because its a good idea to have a consistent 404 error page across your site, Django provides an Http404 exception. If you raise Http404 at any point in a view function, Django will catch it and return the standard error page for your application, along with an HTTP error code 404.

为了方便，而且定义一个通用的应用于网站的404错误页�也是一个很好的选择，Django�供了一个 Http404 异常。如果在视图的任何地方引� Http404 异常，Django就会�获错误并返回应用程�的标准错误页�，当然，还有HTTP错误代�404。

Heres an example:

例如：

from django.http import Http404

def detail(request, poll_id):
    try:
        p = Poll.objects.get(pk=poll_id)
    except Poll.DoesNotExist:
        raise Http404
    return render_to_response('polls/detail.html', {'poll': p})

In order to use the Http404 exception to its fullest, you should create a template that is displayed when a 404 error is raised. This template should be called 404.html , and it should be located in the top level of your template tree.

为了完全�挥出 Http404 的功能，应创建一个模�，在404错误被引�时显示。模�的�字应该是 404.html ，而且应该�于模�树的最高层。

Customizing the 404 (Not Found) View

自定义 404 (无法找到) 视图

When you raise an Http404 exception, Django loads a special view devoted to handling 404 errors. By default, its the view django.views.defaults.page_not_found , which loads and renders the template 404.html .

当引� Http404 异常，Django加载一个专门处�404错误的视图。默认情况下，这个视图是 django.views.defaults.page_not_found ，它会加载并显示模� 404.html 。

This means you need to define a 404.html template in your root template directory. This template will be used for all 404 errors.

这�味�需�在根模�目录定义一个 404.html 模�。这个模�会作用于所有404错误。

This page_not_found view should suffice for 99% of Web applications, but if you want to override the 404 view, you can specify handler404 in your URLconf, like so:

视图 page_not_found 适用于99%的网站应用程�，但若是希望�载该视图，�以在URLconf中指定 handler404 ，就�这样：sfas

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    ...
)

handler404 = 'mysite.views.my_custom_404_view'

Behind the scenes, Django determines the 404 view by looking for handler404 . By default, URLconfs contain the following line:

��执行时，Django以 handler404 �确定404视图。默认情况下，URLconf包�以下内容：

from django.conf.urls.defaults import *

That takes care of setting handler404 in the current module. As you can see in django/conf/urls/defaults.py , handler404 is set to 'django.views.defaults.page_not_found' by default.

这��负责当�模�中的 handler404 设置。正如你所�，在 django/conf/urls/defaults.py 中， handler404 默认被设为 'django.views.defaults.page_not_found' 。

There are three things to note about 404 views:

关于404视图，有三点需�注�：

• The 404 view is also called if Django doesnt find a match after checking every regular expression in the URLconf.

• 当Django在URLconf无法找到匹é…�的正则表达å¼�时，404视图会显示。

• If you dont define your own 404 view and simply use the default, which is recommended you still have one obligation: to create a 404.html template in the root of your template directory. The default 404 view will use that template for all 404 errors.

• 如果没有定义自己的404视图，而å�ªæ˜¯ç®€å�•åœ°ä½¿ç”¨é»˜è®¤çš„视图，此时就需è¦�在模æ�¿ç›®å½•çš„根目录创建一个 404.html 模æ�¿ã€‚默认的404视图会对所有404错误使用改模æ�¿ã€‚

• If DEBUG is set to True (in your settings module), then your 404 view will never be used, and the traceback will be displayed instead.

• è‹¥ DEBUG 被设为 True （在settings模å�—内），则404视图ä¸�会被使用，此时显示的是跟踪信æ�¯ã€‚

Customizing the 500 (Server Error) View

自定义 500 (�务器错误) 视图

Similarly, Django executes special-case behavior in the case of runtime errors in view code. If a view results in an exception, Django will, by default, call the view django.views.defaults.server_error , which loads and renders the template 500.html .

�样地，若是在试图代�中出现了�行时错误，Django会进行特殊情况处�。如果视图引�了一个异常，Django会默认访问视图 django.views.defaults.server_error ，加载并显示模� 500.html 。

This means you need to define a 500.html template in your root template directory. This template will be used for all server errors.

这�味�需�在根模�目录定义一个 500.html 模�。该模�作用于所有�务器错误。

This server_error view should suffice for 99% of Web applications, but if you want to override the view, you can specify handler500 in your URLconf, like so:

视图 server_error 适用于99%的网站应用程�，但若是希望�载该视图，�以在URLconf中指定 handler500 ，就�这样：

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    ...
)

handler500 = 'mysite.views.my_custom_error_view'