```
#### `QueryDict.__getitem__(key)`
指定されたキーに対する最後の値を返します。キーは存在するが値がない場合は空リスト（ `[]` ）を返します。キーが存在しない場合は `django.utils.datastructures.MultiValueDictKeyError` を送出します。（これは Python 標準の [`KeyError`](https://docs.python.org/3/library/exceptions.html#KeyError) のサブクラスなので、単に `KeyError` を捕捉しても構いません。）
```pycon
>>> q = QueryDict("a=1&a=2&a=3", mutable=True)
>>> q.__getitem__("a")
'3'
>>> q.__setitem__("b", [])
>>> q.__getitem__("b")
[]
```
#### `QueryDict.__setitem__(key, value)`
指定したキーを `[value]` (各要素が `value` のリスト) にセットします。 副作用を持つ他のディクショナリ関数と同様に、編集可能な `QueryDict` ([`QueryDict.copy()`](#django.http.QueryDict.copy) で作成されたものなど) のみで呼び出し可能です.
#### `QueryDict.__contains__(key)`
指定したキーがセットされている場合 `True` を返します。例えば `if "foo" in request.GET` を実行するのと同じです。
#### `QueryDict.get(key, default=None)`
[`__getitem__()`](#django.http.QueryDict.__getitem__) と同じロジックを使いますが、キーが存在しない場合のデフォルト値をフックします。
#### `QueryDict.setdefault(key, default=None)`
[`dict.setdefault()`](https://docs.python.org/3/library/stdtypes.html#dict.setdefault) に似ていますが、内部では [`__setitem__()`](#django.http.QueryDict.__setitem__) を使用します。
#### `QueryDict.update(other_dict)`
`QueryDict` または辞書のどちらかを取ります。 [`dict.update()`](https://docs.python.org/3/library/stdtypes.html#dict.update) と似ていますが、現在の辞書の項目を置き換えるのではなく *追加* します。例えば:
```pycon
>>> q = QueryDict("a=1", mutable=True)
>>> q.update({"a": "2"})
>>> q.getlist("a")
['1', '2']
>>> q["a"] # returns the last
'2'
```
#### `QueryDict.items()`
[`dict.items()`](https://docs.python.org/3/library/stdtypes.html#dict.items) と似ていますが、これは [`__getitem__()`](#django.http.QueryDict.__getitem__) と同じ最後の値のロジックを使用し、ビューオブジェクトの代わりにイテレータオブジェクトを返します。例えば:
```pycon
>>> q = QueryDict("a=1&a=2&a=3")
>>> list(q.items())
[('a', '3')]
```
#### `QueryDict.values()`
[`dict.values()`](https://docs.python.org/3/library/stdtypes.html#dict.values) のように、[`__getitem__()`](#django.http.QueryDict.__getitem__) と同じ最後の値のロジックを使用しますが、ビューオブジェクトの代わりにイテレータを返します。例えば:
```pycon
>>> q = QueryDict("a=1&a=2&a=3")
>>> list(q.values())
['3']
```
加えて、`QueryDict` は以下のメソッドを持ちます:
#### `QueryDict.copy()`
[`copy.deepcopy()`](https://docs.python.org/3/library/copy.html#copy.deepcopy) を使用してオブジェクトのコピーを返します。このコピーは、元のオブジェクトがイミュータブルであったとしても、ミュータブルです。
#### `QueryDict.getlist(key, default=None)`
リクエストされたキーのデータのリストを返します。キーが存在しない場合には、 `default` が `None` であれば空のリストを返します。デフォルト値がリストでない限り、リストを返すことが保証されています。
#### `QueryDict.setlist(key, list_)`
指定されたキーを `list_` に設定します ( [`__setitem__()`](#django.http.QueryDict.__setitem__) と異なります)。
#### `QueryDict.appendlist(key, item)`
key に関連付けられた内部リストに項目を追加します。
#### `QueryDict.setlistdefault(key, default_list=None)`
[`setdefault()`](#django.http.QueryDict.setdefault) に似ていますが、単一の値の代わりに値のリストを取ります。
#### `QueryDict.lists()`
Like [`items()`](#django.http.QueryDict.items), except it includes all values, as a list, for each
member of the dictionary. For example:
```pycon
>>> q = QueryDict("a=1&a=2&a=3")
>>> q.lists()
[('a', ['1', '2', '3'])]
```
#### `QueryDict.pop(key)`
指定されたキーに対応する値のリストを返し、それらを辞書から削除します。キーが存在しない場合は `KeyError` を発生させます。例えば:
```pycon
>>> q = QueryDict("a=1&a=2&a=3", mutable=True)
>>> q.pop("a")
['1', '2', '3']
```
#### `QueryDict.popitem()`
辞書の任意のメンバーを削除し (順序の概念がないため)、キーとキーに対するすべての値のリストを含む2値タプルを返します。空の辞書に対して呼び出されると `KeyError` を発生させます。例えば:
```pycon
>>> q = QueryDict("a=1&a=2&a=3", mutable=True)
>>> q.popitem()
('a', ['1', '2', '3'])
```
#### `QueryDict.dict()`
`QueryDict` の各(key, list)ペアに対して、 `dict` 形式の表現を返します。 `dict` は、リストの中の要素の1つである item に対して、(key, item) のペアを持ちます。これは、 [`QueryDict.__getitem__()`](#django.http.QueryDict.__getitem__) と同じロジックを使用します。
```pycon
>>> q = QueryDict("a=1&a=3&a=5")
>>> q.dict()
{'a': '5'}
```
#### `QueryDict.urlencode(safe=None)`
クエリ文字列形式のデータを文字列で返します。例えば：
```pycon
>>> q = QueryDict("a=2&b=3&b=5")
>>> q.urlencode()
'a=2&b=3&b=5'
```
`safe` パラメータを使って、エンコードを不要とする文字を渡すことができます。たとえば:
```pycon
>>> q = QueryDict(mutable=True)
>>> q["next"] = "/a&b/"
>>> q.urlencode(safe="/")
'next=/a%26b/'
```
## `HttpResponse` オブジェクト
#### `class HttpResponse`
Django によって自動的に生成される [`HttpRequest`](#django.http.HttpRequest) オブジェクトとは対照的に、[`HttpResponse`](#django.http.HttpResponse) オブジェクトの作成はあなたの責任です。プログラム内に記述されるあらゆるビューは、[`HttpResponse`](#django.http.HttpResponse) をインスタンス化し、データを格納して返す必要があります。
[`HttpResponse`](#django.http.HttpResponse) クラスは [`django.http`](#module-django.http) モジュール内に存在します。
### 使い方
#### 文字列を渡す
一般的な使い方としては、ページのコンテンツを文字列、バイト文字列、または [`memoryview`](https://docs.python.org/3/library/stdtypes.html#memoryview) として、 [`HttpResponse`](#django.http.HttpResponse) コンストラクタに渡します。
```pycon
>>> from django.http import HttpResponse
>>> response = HttpResponse("Here's the text of the web page.")
>>> response = HttpResponse("Text only, please.", content_type="text/plain")
>>> response = HttpResponse(b"Bytestrings are also accepted.")
>>> response = HttpResponse(memoryview(b"Memoryview as well."))
```
しかし、内容を段階的に追加したい場合は、 `response` をファイルライクオブジェクトとして使用できます:
```pycon
>>> response = HttpResponse()
>>> response.write("Here's the text of the web page.
")
>>> response.write("Here's another paragraph.
")
```
#### イテレータを渡す
最後に、文字列ではなくイテレータを `HttpResponse` に渡すこともできます。 `HttpResponse` はイテレータを即座に受け取り、その内容を文字列として保存し、破棄します。ファイルやジェネレータのような `close()` メソッドを持つオブジェクトは、すぐに閉じられます。
レスポンスに対して、イテレータからクライアントにストリーミングさせる必要がある場合には、代わりに [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) クラスを使う必要があります。
#### ヘッダーフィールドをセットする
レスポンスでヘッダーフィールドを設定または削除するには、 [`HttpResponse.headers`](#django.http.HttpResponse.headers) を使用してください。
```pycon
>>> response = HttpResponse()
>>> response.headers["Age"] = 120
>>> del response.headers["Age"]
```
レスポンスを辞書のように扱うことで、ヘッダーを操作することもできます:
```pycon
>>> response = HttpResponse()
>>> response["Age"] = 120
>>> del response["Age"]
```
これは `HttpResponse.headers` へのプロキシで、 `HttpResponse` が提供する本来のインタフェースです。
このインターフェースを使用する際、辞書とは異なり、ヘッダーフィールドが存在しない場合に `del` が `KeyError` を発生させることはありません。
インスタンス化の際にもヘッダーを設定できます:
```pycon
>>> response = HttpResponse(headers={"Age": 120})
```
`Cache-Control` および `Vary` ヘッダーフィールドを設定するには、これらのフィールドが複数のカンマ区切りの値を持ち得るため、 [`django.utils.cache`](/ja/6.1/ref/utils/#module-django.utils.cache) から [`patch_cache_control()`](/ja/6.1/ref/utils/#django.utils.cache.patch_cache_control) と [`patch_vary_headers()`](/ja/6.1/ref/utils/#django.utils.cache.patch_vary_headers) メソッドを使用することが推奨されます。"patch" メソッドは、ミドルウェアによって追加された他の値が削除されないように保証します。
HTTP ヘッダフィールドには改行を含めることはできません。改行文字 (CR または LF) を含むヘッダフィールドを設定しようとすると、`BadHeaderError` が発生します。
#### レスポンスをファイル添付物として扱うようにブラウザに指示します。
ブラウザにレスポンスをファイル添付として扱うように指示するためには、`Content-Type` と `Content-Disposition` ヘッダを設定します。例えば、Microsoft Excel スプレッドシートを返す方法は以下のようになります:
```pycon
>>> response = HttpResponse(
... my_data,
... headers={
... "Content-Type": "application/vnd.ms-excel",
... "Content-Disposition": 'attachment; filename="foo.xls"',
... },
... )
```
`Content-Disposition` ヘッダについては Django 固有のものはありませんが、その構文を忘れやすいので、ここに含めています。
### 属性
#### `HttpResponse.content`
必要に応じて文字列からエンコードされた、コンテンツを表すバイト文字列。
#### `HttpResponse.text`
レスポンスの [`HttpResponse.charset`](#django.http.HttpResponse.charset) （空の場合は `UTF-8` がデフォルト）を用いてデコードした、 [`HttpResponse.content`](#django.http.HttpResponse.content) の文字列表現。
#### `HttpResponse.cookies`
A [`http.cookies.SimpleCookie`](https://docs.python.org/3/library/http.cookies.html#http.cookies.SimpleCookie) object holding the cookies included
in the response.
#### `HttpResponse.headers`
大文字小文字を区別しない辞書型オブジェクトで、`Set-Cookie` ヘッダを除くすべてのHTTPヘッダに対するインターフェイスを提供します。 [ヘッダーフィールドをセットする](#setting-header-fields) および [`HttpResponse.cookies`](#django.http.HttpResponse.cookies) を参照してください。
#### `HttpResponse.charset`
応答がエンコードされる文字セットを示す文字列です。 `HttpResponse` のインスタンス化の際に指定されなかった場合、 `content_type` から抽出され、もしこれが失敗した場合は、 [`DEFAULT_CHARSET`](/ja/6.1/ref/settings/#std-setting-DEFAULT_CHARSET) 設定が使用されます。
#### `HttpResponse.status_code`
レスポンスの [**HTTP ステータスコード**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-15) 。
[`reason_phrase`](#django.http.HttpResponse.reason_phrase) が明示的にセットされていない限り、コンストラクタの外で `status_code` の値を変更すると `reason_phrase` の値も変更されます。
#### `HttpResponse.reason_phrase`
レスポンスの HTTP reason フレーズです。これは [**HTTP 標準の**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-15.1) デフォルトの reason フレーズを使用します。
`reason_phrase` が明示的に設定されていない場合、 [`status_code`](#django.http.HttpResponse.status_code) の値に基づいて決定されます。
#### `HttpResponse.streaming`
これは常に `False` です。
この属性は、ミドルウェアが通常のレスポンスとは違う形でストリーミングレスポンスを扱えるようにするために存在しています。
#### `HttpResponse.closed`
レスポンスが閉じられた場合、`True` となります。
### メソッド
#### `HttpResponse.__init__(content=b'', content_type=None, status=200, reason=None, charset=None, headers=None)`
指定されたページ内容、コンテンツタイプ、およびヘッダーを持つ `HttpResponse` オブジェクトをインスタンス化します。
`content` は、最も一般的にはイテレータ、バイト文字列、 [`memoryview`](https://docs.python.org/3/library/stdtypes.html#memoryview) 、または文字列です。その他の型は、文字列表現をエンコードしてバイト文字列に変換されます。イテレータは文字列またはバイト文字列を返すべきで、それらはレスポンスの内容を形成するために連結されます。
`content_type` は、MIME タイプであり、オプションで文字セットエンコーディングを指定して HTTP `Content-Type` ヘッダを埋めるために使用されます。指定されていない場合、デフォルトでは `'text/html'` と [`DEFAULT_CHARSET`](/ja/6.1/ref/settings/#std-setting-DEFAULT_CHARSET) 設定によって形成されます: つまり `"text/html; charset=utf-8"` 。
`status` is the [**HTTP status code**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-15) for the
response. You can use Python's [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus) for meaningful
aliases, such as `HTTPStatus.NO_CONTENT`.
`reason` は HTTP レスポンスフレーズです。指定しない場合、デフォルトのフレーズが使用されます。
`charset` は、レスポンスがエンコードされる文字セットです。もし指定されていない場合、`content_type` から抽出されます。それが失敗した場合は、 [`DEFAULT_CHARSET`](/ja/6.1/ref/settings/#std-setting-DEFAULT_CHARSET) 設定が使用されます。
`headers` はレスポンス用のHTTPヘッダーの [`dict`](https://docs.python.org/3/library/stdtypes.html#dict) です。
#### `HttpResponse.__setitem__(header, value)`
指定されたヘッダ名に指定された値を設定します。 `header` と `value` は共に文字列であるべきです。
#### `HttpResponse.__delitem__(header)`
指定された名前のヘッダーを削除します。ヘッダーが存在しなくても、静かに失敗します。大文字小文字を区別しません。
#### `HttpResponse.__getitem__(header)`
指定されたヘッダ名の値を返します。大文字小文字を区別しません。
#### `HttpResponse.get(header, alternate=None)`
指定されたヘッダーの値を返します。ヘッダーが存在しない場合は、`alternate` を返します。
#### `HttpResponse.has_header(header)`
指定された名前のヘッダーが存在するかどうかを大文字小文字を区別せずにチェックし、`True` または `False` を返します。
#### `HttpResponse.items()`
レスポンスのHTTPヘッダに対して、 [`dict.items()`](https://docs.python.org/3/library/stdtypes.html#dict.items) のように動作します。
#### `HttpResponse.setdefault(header, value)`
ヘッダーがまだ設定されていない場合に、ヘッダーを設定します。
#### `HttpResponse.set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=False, httponly=False, samesite=None)`
クッキーを設定します。パラメータは、Python標準ライブラリ内の [`Morsel`](https://docs.python.org/3/library/http.cookies.html#http.cookies.Morsel) クッキーオブジェクトと同じです。
- `max_age` は [`timedelta`](https://docs.python.org/3/library/datetime.html#datetime.timedelta) オブジェクト、整数秒数、または `None` (デフォルト) である必要があります。これにより、クッキーの有効期限はクライアントのブラウザセッションが終了するまでとなります。 `expires` が指定されていない場合は自動的に計算されます。
- `expires` は、 `"Wdy, DD-Mon-YY HH:MM:SS GMT"` 形式の文字列か、UTCの `datetime.datetime` オブジェクトであるべきです。もし `expires` が `datetime` オブジェクトである場合、 `max_age` が計算されます。
- クロスドメインのクッキーを設定したい場合は、`domain` を使用してください。例えば、 `domain="example.com"` とすると、www.example.com、blog.example.com などのドメインから読み取れるクッキーが設定されます。そうでない場合、クッキーは設定したドメインのみから読み取れます。
- `secure=True` を使用すると、リクエストが `https` スキームで行われた場合にのみ、クッキーがサーバーに送信されるようになります。
- クライアントサイドのJavaScriptがクッキーにアクセスするのを防ぎたい場合は、`httponly=True` を使用してください。
[HttpOnly](https://owasp.org/www-community/HttpOnly) は、Set-Cookie HTTP レスポンスヘッダーに含まれるフラグです。これは、クッキーの [**RFC 6265**](https://datatracker.ietf.org/doc/html/rfc6265.html#section-4.1.2.6) 標準の一部であり、クライアントサイドのスクリプトが保護されたクッキーデータにアクセスするリスクを軽減する有用な方法です。
- `samesite='Strict'` や `samesite='Lax'` を使用して、ブラウザにクロスオリジンリクエストを行う際にこのクッキーを送信しないよう指示します。 [SameSite](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#samesitesamesite-value) はすべてのブラウザに対応しているわけではないため、DjangoのCSRF保護の代わりとなるものではありませんが、防御の深度を増すための措置です。
`samesite='None'` (文字列) を使えば、このクッキーが同一サイトおよびクロスサイトのすべてのリクエストに送信されることを明示できます。
> **Warning**
>
> [**RFC 6265**](https://datatracker.ietf.org/doc/html/rfc6265.html#section-6.1) には、ユーザーエージェントが少なくとも 4096 バイトのクッキーをサポートすべきであると記されています。多くのブラウザでは、これが最大サイズでもあります。Django は 4096 バイトを超えるクッキーを保存しようとした際に例外を発生させませんが、多くのブラウザでは正しくクッキーを設定しないでしょう。
#### `HttpResponse.set_signed_cookie(key, value, salt='', max_age=None, expires=None, path='/', domain=None, secure=False, httponly=False, samesite=None)`
Like [`set_cookie()`](#django.http.HttpResponse.set_cookie), but
[cryptographic signing](/ja/6.1/topics/signing/) the cookie before setting
it. Use in conjunction with [`HttpRequest.get_signed_cookie()`](#django.http.HttpRequest.get_signed_cookie).
You can use the optional `salt` argument to put the cookie into a
separate signature namespace, but you will need to remember to pass it to
the corresponding
[`HttpRequest.get_signed_cookie()`](#django.http.HttpRequest.get_signed_cookie) call.
#### `HttpResponse.delete_cookie(key, path='/', domain=None, samesite=None)`
指定されたキーを持つクッキーを削除します。キーが存在しない場合は、静かに失敗します。
クッキーの動作方法により、 `path` と `domain` は `set_cookie()` で使用した値と同じでなければなりません。そうでない場合、クッキーが削除されない可能性があります。
#### `HttpResponse.close()`
This method is called at the end of the request directly by the WSGI
or ASGI server.
#### `HttpResponse.write(content)`
このメソッドは、 [`HttpResponse`](#django.http.HttpResponse) インスタンスをファイルライクオブジェクトにします。
#### `HttpResponse.flush()`
このメソッドは、 [`HttpResponse`](#django.http.HttpResponse) インスタンスをファイルライクオブジェクトにします。
#### `HttpResponse.tell()`
このメソッドは、 [`HttpResponse`](#django.http.HttpResponse) インスタンスをファイルライクオブジェクトにします。
#### `HttpResponse.getvalue()`
[`HttpResponse.content`](#django.http.HttpResponse.content) の値を返します。このメソッドにより、 [`HttpResponse`](#django.http.HttpResponse) インスタンスはストリームライクオブジェクトになります。
#### `HttpResponse.readable()`
常に `False` です。このメソッドは [`HttpResponse`](#django.http.HttpResponse) インスタンスをストリームライクオブジェクトにします。
#### `HttpResponse.seekable()`
常に `False` です。このメソッドは [`HttpResponse`](#django.http.HttpResponse) インスタンスをストリームライクオブジェクトにします。
#### `HttpResponse.writable()`
常に `True` です。このメソッドは [`HttpResponse`](#django.http.HttpResponse) インスタンスをストリームライクオブジェクトにします。
#### `HttpResponse.writelines(lines)`
レスポンスに行のリストを書き込みます。行区切りは追加されません。このメソッドは、 [`HttpResponse`](#django.http.HttpResponse) インスタンスをストリームライクオブジェクトにします。
### `HttpResponse` サブクラス
Djangoには、異なるタイプのHTTPレスポンスを処理するための `HttpResponse` のサブクラスがいくつか含まれています。 `HttpResponse` と同様に、これらのサブクラスは [`django.http`](#module-django.http) に存在します。
#### `class HttpResponseRedirect`
コンストラクタの第1引数は必須で、リダイレクト先のパスを指定します。これは、完全修飾URL（例： `'https://www.yahoo.com/search/'` ）、ドメインを含まない絶対パス（例： `'/search/'` ）、あるいは相対パス（例： `'search/'` ）のいずれでも構いません。最後のケースでは、クライアントのブラウザが現在のパスに基づいて完全なURLを自動的に再構成します。
コンストラクタはオプションの `preserve_request` キーワード引数を受け付け、既定値は `False` です。この場合、302 ステータスコードのレスポンスが生成されます。 `preserve_request` が `True` の場合は、代わりにステータスコードは 307 になります。
The constructor accepts an optional `max_length` keyword argument to
override the maximum allowed length for the redirect URL. You can set it
to `None` to disable the length check.
その他のオプションのコンストラクタ引数については、 [`HttpResponse`](#django.http.HttpResponse) を参照してください。
> **Changed in Django 6.1**
>
> `max_length` was added.
#### `url`
この読み取り専用の属性は、レスポンスがリダイレクトするURLを表しています (`Location` レスポンスヘッダに相当します)。
#### `class HttpResponsePermanentRedirect`
[`HttpResponseRedirect`](#django.http.HttpResponseRedirect) に似ていますが、 "found" リダイレクト（ステータスコード 302）ではなく恒久的リダイレクト（HTTP ステータスコード 301）を返します。 `preserve_request=True` の場合、レスポンスのステータスコードは 308 になります。
#### `class HttpResponseNotModified`
コンストラクタは引数を取らず、このレスポンスにはコンテンツを追加すべきではありません。これを使用して、ページがユーザーの最後のリクエスト以降に変更されていないことを指定します(ステータスコード304)。
#### `class HttpResponseBadRequest`
[`HttpResponse`](#django.http.HttpResponse) と似ていますが、ステータスコードとして 400 を使用します。
#### `class HttpResponseNotFound`
[`HttpResponse`](#django.http.HttpResponse) と似ていますが、404 ステータスコードを使用します。
#### `class HttpResponseForbidden`
[`HttpResponse`](#django.http.HttpResponse) と似ていますが、403 ステータスコードを使用します。
#### `class HttpResponseNotAllowed`
[`HttpResponse`](#django.http.HttpResponse) と似ていますが、ステータスコード 405 を使用します。コンストラクタへの最初の引数は必須です: 許可されているメソッドのリスト (例: `['GET', 'POST']`)。
#### `class HttpResponseGone`
[`HttpResponse`](#django.http.HttpResponse) と似ていますが、410 ステータスコードを使用します。
#### `class HttpResponseServerError`
[`HttpResponse`](#django.http.HttpResponse) と似ていますが、ステータスコードとして 500 を使用します。
> **Note**
>
> [`HttpResponse`](#django.http.HttpResponse) のカスタムサブクラスが `render` メソッドを実装している場合、Djangoはそれを [`SimpleTemplateResponse`](/ja/6.1/ref/template-response/#django.template.response.SimpleTemplateResponse) を模倣しているものとして扱い、 `render` メソッド自体が有効なレスポンスオブジェクトを返さなければなりません。
#### カスタムレスポンスクラス
If you find yourself needing a response class that Django doesn't provide, you
can create it with the help of [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus). For example:
```
from http import HTTPStatus
from django.http import HttpResponse
class HttpResponseNoContent(HttpResponse):
status_code = HTTPStatus.NO_CONTENT
```
## `JsonResponse` オブジェクト
#### `class JsonResponse(data, encoder=DjangoJSONEncoder, safe=True, json_dumps_params=None, **kwargs)`
[`HttpResponse`](#django.http.HttpResponse) のサブクラスで、JSONエンコードされたレスポンスを作成するのに役立ちます。このクラスは、いくつかの違いを除き、その基底クラスからほとんどの動作を継承しています:
デフォルトの `Content-Type` ヘッダーは `application/json` に設定されています。
最初のパラメーター `data` は、`dict` インスタンスであるべきです。`safe` パラメーターが `False` に設定されている場合 (下記参照)、これはどんな JSON シリアライズ可能オブジェクトでも可能です。
`encoder` のデフォルトは [`django.core.serializers.json.DjangoJSONEncoder`](/ja/6.1/topics/serialization/#django.core.serializers.json.DjangoJSONEncoder) で、このエンコーダーがデータのシリアライズに使用されます。このシリアライザについての詳細は、[JSON のシリアライズ](/ja/6.1/topics/serialization/#serialization-formats-json) を参照してください。
`safe` ブールパラメータのデフォルト値は `True` です。もし `False` に設定されている場合、任意のオブジェクトをシリアライズのために渡すことができます（そうでなければ、 `dict` インスタンスのみが許可されます）。`safe` が `True` であり、非 `dict` オブジェクトが第一引数として渡された場合、 [`TypeError`](https://docs.python.org/3/library/exceptions.html#TypeError) が発生します。
`json_dumps_params` パラメーターは、レスポンス生成に使用される `json.dumps()` 呼び出しに渡すキーワード引数の辞書です。
### 使い方
一般的な使用方法は以下のようになります:
```pycon
>>> from django.http import JsonResponse
>>> response = JsonResponse({"foo": "bar"})
>>> response.content
b'{"foo": "bar"}'
```
#### 辞書以外のオブジェクトのシリアライズ
`dict` 以外のオブジェクトをシリアライズする場合、 `safe` パラメータを `False` に設定する必要があります:
```pycon
>>> response = JsonResponse([1, 2, 3], safe=False)
```
`safe=False` を指定しなかった場合、[`TypeError`](https://docs.python.org/3/library/exceptions.html#TypeError) が発生します。
`dict` オブジェクトに基づいた API は、より拡張性が高く、柔軟性があり、前方互換性の維持が容易になります。したがって、JSON エンコードされたレスポンスでは非 dict オブジェクトの使用は避けるべきです。
> **Warning**
>
> Before the [5th edition of ECMAScript](https://262.ecma-international.org/5.1/#sec-11.1.4) it was possible to
> poison the JavaScript `Array` constructor. For this reason, Django does
> not allow passing non-dict objects to the
> [`JsonResponse`](#django.http.JsonResponse) constructor by default. However, most
> modern browsers implement ECMAScript 5 which removes this attack vector.
> Therefore it is possible to disable this security precaution.
#### デフォルトのJSONエンコーダーを変更する
異なるJSONエンコーダークラスを使用する必要がある場合は、コンストラクターメソッドに `encoder` パラメータを渡すことができます。
```pycon
>>> response = JsonResponse(data, encoder=MyJSONEncoder)
```
## `StreamingHttpResponse` オブジェクト
#### `class StreamingHttpResponse`
[`StreamingHttpResponse`](#django.http.StreamingHttpResponse) クラスは、Djangoからブラウザへのレスポンスをストリーミングするために使用されます。
> **高度な使用法**
>
> [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) はやや高度です。アプリケーションを WSGI で同期的に、あるいは ASGI で非同期的に提供するかを知り、使用方法を適切に調整することが重要です。
>
> これらの注意点を注意深く読んでください。
WSGI 下での [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) の使用例としては、レスポンスの生成に時間がかかりすぎる場合やメモリを大量に使用する場合にコンテンツをストリーミングすることが挙げられます。例えば、[大きなCSVファイルを生成する場合](/ja/6.1/howto/outputting-csv/#streaming-csv-files) に役立ちます。
しかしながら、これを行う際にはパフォーマンスを考慮する必要があります。WSGIの下でのDjangoは、短期間のリクエストのために設計されています。ストリーミングレスポンスは、レスポンスの全期間にわたってワーカープロセスを占有します。これにより、パフォーマンスが低下する可能性があります。
一般的に、ストリーミングレスポンスに頼るのではなく、リクエスト/レスポンスサイクルの外で高コストのタスクを行うほうが良いです。
しかし、ASGI の下で提供される場合、[`StreamingHttpResponse`](#django.http.StreamingHttpResponse) はI/Oを待っている間に他のリクエストが提供されるのを妨げる必要はありません。これにより、ストリーミングコンテンツのための長時間生存するリクエストや、ロングポーリングやサーバー送信イベントといったパターンの実装の可能性が開かれます。
ASGI環境下であっても、[`StreamingHttpResponse`](#django.http.StreamingHttpResponse) は、クライアントにデータを転送する前に全内容がイテレートされることが絶対に必要な状況でのみ使用すべきです。コンテンツにアクセスできないため、多くのミドルウェアが正常に機能しません。例えば、ストリーミングレスポンスには `ETag` や `Content-Length` ヘッダを生成することができません。
[`StreamingHttpResponse`](#django.http.StreamingHttpResponse) は、若干異なるAPIを特徴とするため、[`HttpResponse`](#django.http.HttpResponse) のサブクラスではありません。しかし、以下に挙げる顕著な違いを除いて、ほぼ同一です。
- コンテンツとしてバイト文字列、[`memoryview`](https://docs.python.org/3/library/stdtypes.html#memoryview)、または文字列を生成するイテレータを渡すべきです。WSGI下で提供する場合、これは同期イテレータであるべきです。ASGI下で提供する場合、これは非同期イテレータであるべきです。
- その内容にアクセスするには、レスポンスオブジェクト自体をイテレートする必要があります。これはクライアントにレスポンスが返されたときのみ発生すべきです。自分でレスポンスをイテレートすべきではありません。
WSGIでは、レスポンスは同期的にイテレートされます。ASGIでは、レスポンスは非同期的にイテレートされます。(これが、イテレータのタイプが使用しているプロトコルと一致しなければならない理由です。)
クラッシュを回避するため、間違ったイテレータのタイプは、イテレート中に正しいタイプにマッピングされ、警告が発生します。ただし、これを行うにはイテレータを完全に消費する必要があり、これは全く [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) を使用する目的を果たしません。
- これは `content` 属性を持ちません。代わりに [`streaming_content`](#django.http.StreamingHttpResponse.streaming_content) 属性があります。これはミドルウェアでレスポンスのイテラブルをラップするために使用できますが、消費されるべきではありません。
- レスポンスオブジェクトを反復処理する必要があるため、 `text` 属性を持ちません。
- ファイルライクオブジェクトの `tell()` や `write()` メソッドは使用できません。これらを使用すると例外が発生します。
[`HttpResponse`](#django.http.HttpResponse) と [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) は、共通の基底クラス [`HttpResponseBase`](#django.http.HttpResponseBase) を持っています。
### 属性
#### `StreamingHttpResponse.streaming_content`
レスポンス内容のイテレータ。 バイト文字列は [`HttpResponse.charset`](#django.http.HttpResponse.charset) に従ってエンコードされます。
#### `StreamingHttpResponse.status_code`
レスポンスの [**HTTP ステータスコード**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-15) 。
[`reason_phrase`](#django.http.StreamingHttpResponse.reason_phrase) が明示的にセットされていない限り、コンストラクタの外で `status_code` の値を変更すると `reason_phrase` の値も変更されます。
#### `StreamingHttpResponse.reason_phrase`
レスポンスの HTTP reason フレーズです。これは [**HTTP 標準の**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-15.1) デフォルトの reason フレーズを使用します。
`reason_phrase` が明示的に設定されていない場合、 [`status_code`](#django.http.StreamingHttpResponse.status_code) の値に基づいて決定されます。
#### `StreamingHttpResponse.streaming`
これは常に `True` です。
#### `StreamingHttpResponse.is_async`
[`StreamingHttpResponse.streaming_content`](#django.http.StreamingHttpResponse.streaming_content) が非同期イテレータであるかどうかを示す真偽値です。
これは、 [`StreamingHttpResponse.streaming_content`](#django.http.StreamingHttpResponse.streaming_content) をラップする必要があるミドルウェアにとって便利です。
### 切断の取り扱い
クライアントがストリーミングレスポンス中に切断されると、Django はレスポンスを処理しているコルーチンをキャンセルします。リソースの手動クリーンアップを行いたい場合は、`asyncio.CancelledError` をキャッチして行うことができます:
```
async def streaming_response():
try:
# Do some work here
async for chunk in my_streaming_iterator():
yield chunk
except asyncio.CancelledError:
# Handle disconnect
...
raise
async def my_streaming_view(request):
return StreamingHttpResponse(streaming_response())
```
この例は、レスポンスがストリーミングされている間にクライアントの切断をどのように処理するかを示しているだけです。ビュー内で `StreamingHttpResponse` オブジェクトを返す前に長時間実行される操作を行う場合は、ビュー自体で [切断を処理する](/ja/6.1/topics/async/#async-handling-disconnect) 必要があるかもしれません。
## `FileResponse` オブジェクト
#### `class FileResponse(open_file, as_attachment=False, filename='', **kwargs)`
[`FileResponse`](#django.http.FileResponse) はバイナリファイルに最適化された [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) のサブクラスです。もし WSGI サーバーが提供していれば [**wsgi.file\_wrapper**](https://peps.python.org/pep-3333/#optional-platform-specific-file-handling) を使用し、そうでない場合はファイルを小さなチャンクでストリーミングします。
`as_attachment=True` だと、`Content-Disposition` ヘッダーが `attachment` に設定され、ブラウザにファイルをダウンロードするように要求します。それ以外の場合は、ファイル名が利用可能な場合のみ、値が `inline` （ブラウザのデフォルト値）の `Content-Disposition` ヘッダーが設定されます。
もし `open_file` に名前がない、または `open_file` の名前が適切でない場合は、`filename` パラメータを使用してカスタムファイル名を提供してください。`io.BytesIO` のようなファイルライクオブジェクトを渡す場合、それを `FileResponse` に渡す前に `seek()` を行うのはあなたの仕事です。
`open_file` の内容から推測できる場合、 `Content-Length` ヘッダーは自動的に設定されます。
`Content-Type` ヘッダーは、`filename` や `open_file` の名前から推測できる場合には自動的に設定されます。
`FileResponse` は、例えば以下のようにバイナリモードで開かれたファイルのような、バイナリー内容を持つあらゆるファイルライクオブジェクトを受け付けます。
```pycon
>>> from django.http import FileResponse
>>> response = FileResponse(open("myfile.png", "rb"))
```
ファイルは自動的に閉じられるため、コンテキストマネージャーで開かないでください。
> **ASGI における使用**
>
> PythonのファイルAPIは同期的です。これは、ファイルをASGI下で提供するためには、ファイルを完全に消費しなければならないことを意味します。
>
> 非同期にファイルをストリーミングするには、[aiofiles](https://github.com/Tinche/aiofiles) のような非同期ファイルAPIを提供するサードパーティパッケージを使用する必要があります。
### メソッド
#### `FileResponse.set_headers(open_file)`
このメソッドはレスポンス初期化中に自動的に呼び出され、`open_file` に応じてさまざまなヘッダー (`Content-Length`、`Content-Type`、および `Content-Disposition`) を設定します。
## `HttpResponseBase` クラス
#### `class HttpResponseBase`
[`HttpResponseBase`](#django.http.HttpResponseBase) クラスは、Django のすべてのレスポンスに共通です。直接レスポンスを作成するために使用すべきではありませんが、型チェックの際に役立つことがあります。