```
#### `QueryDict.__getitem__(key)`
Renvoie la valeur de la clé indiquée. Si la clé possède plus d’une valeur, elle renvoie la dernière valeur. Génère `django.utils.datastructures.MultiValueDictKeyError` si la clé n’existe pas (cette exception héritant de l’exception Python standard [`KeyError`](https://docs.python.org/3/library/exceptions.html#KeyError), vous pouvez toujours l’intercepter par `KeyError`).
#### `QueryDict.__setitem__(key, value)`
Définit la clé donnée à `[value]` (une liste dont l’unique élément est `value`). Notez que tout comme les autres fonctions de dictionnaire qui ont des effets de bord, cette méthode ne peut être appelée que pour un objet `QueryDict` modifiable (comme une instance créée par [`QueryDict.copy()`](#django.http.QueryDict.copy)).
#### `QueryDict.__contains__(key)`
Renvoie `True` si la clé donnée est définie. Cela permet par exemple d’écrire `if "foo" in request.GET`.
#### `QueryDict.get(key, default=None)`
Utilise la même logique que [`__getitem__()`](#django.http.QueryDict.__getitem__), avec un point d’entrée pour renvoyer une valeur par défaut si la clé n’existe pas.
#### `QueryDict.setdefault(key, default=None)`
Comme [`dict.setdefault()`](https://docs.python.org/3/library/stdtypes.html#dict.setdefault), sauf qu’en interne, c’est [`__setitem__()`](#django.http.QueryDict.__setitem__) qui est utilisé.
#### `QueryDict.update(other_dict)`
Accepte soit un objet `QueryDict`, soit un dictionnaire. Identique à [`dict.update()`](https://docs.python.org/3/library/stdtypes.html#dict.update), sauf que le contenu est *ajouté* aux éléments actuels du dictionnaire au lieu de les remplacer. Par exemple :
```
>>> q = QueryDict('a=1', mutable=True)
>>> q.update({'a': '2'})
>>> q.getlist('a')
['1', '2']
>>> q['a'] # returns the last
'2'
```
#### `QueryDict.items()`
Identique à [`dict.items()`](https://docs.python.org/3/library/stdtypes.html#dict.items), sauf qu’elle utilise la même logique de dernière valeur que [`__getitem__()`](#django.http.QueryDict.__getitem__) et renvoie un objet d’itération au lieu d’un objet vue. Par exemple :
```
>>> q = QueryDict('a=1&a=2&a=3')
>>> list(q.items())
[('a', '3')]
```
#### `QueryDict.values()`
Identique à [`dict.values()`](https://docs.python.org/3/library/stdtypes.html#dict.values), sauf qu’elle utilise la même logique de dernière valeur que [`__getitem__()`](#django.http.QueryDict.__getitem__) et renvoie un objet d’itération au lieu d’un objet vue. Par exemple :
```
>>> q = QueryDict('a=1&a=2&a=3')
>>> list(q.values())
['3']
```
De plus, `QueryDict` possède les méthodes suivantes :
#### `QueryDict.copy()`
Renvoie une copie de l’objet en utilisant [`copy.deepcopy()`](https://docs.python.org/3/library/copy.html#copy.deepcopy). La copie est modifiable, même si l’objet de départ ne l’est pas.
#### `QueryDict.getlist(key, default=None)`
Renvoie une liste des données correspondant à la clé demandée. Renvoie une liste vide si la clé n’existe pas et qu’aucune valeur par défaut n’a été fournie. Elle renvoie dans tous les cas une liste, sauf si la valeur par défaut fournie n’est pas une liste.
#### `QueryDict.setlist(key, list_)`
Définit la clé indiquée à `list_` (au contraire de [`__setitem__()`](#django.http.QueryDict.__setitem__)).
#### `QueryDict.appendlist(key, item)`
Ajoute un élément à la liste interne associée à la clé.
#### `QueryDict.setlistdefault(key, default_list=None)`
Identique à [`setdefault()`](#django.http.QueryDict.setdefault), sauf qu’elle accepte une liste de valeurs au lieu d’une valeur unique.
#### `QueryDict.lists()`
Comme [`items()`](#django.http.QueryDict.items), sauf qu’elle inclut toutes les valeurs, sous forme de liste, pour chaque élément du dictionnaire. Par exemple :
```
>>> q = QueryDict('a=1&a=2&a=3')
>>> q.lists()
[('a', ['1', '2', '3'])]
```
#### `QueryDict.pop(key)`
Renvoie une liste de valeurs correspondant à la clé donnée et les enlève du dictionnaire. Génère `KeyError` si la clé n’existe pas. Par exemple :
```
>>> q = QueryDict('a=1&a=2&a=3', mutable=True)
>>> q.pop('a')
['1', '2', '3']
```
#### `QueryDict.popitem()`
Enlève un élément arbitraire du dictionnaire (puisque ce dernier n’a pas de notion de tri) et renvoie un tuple à deux valeurs contenant la clé ainsi qu’une liste de toutes les valeurs de cette clé. Génère `KeyError` si le dictionnaire concerné est vide. Par exemple :
```
>>> q = QueryDict('a=1&a=2&a=3', mutable=True)
>>> q.popitem()
('a', ['1', '2', '3'])
```
#### `QueryDict.dict()`
Renvoie une représentation `dict` de `QueryDict`. Pour chaque paire clé/liste dans `QueryDict`, `dict` comportera la paire clé/élément ou élément est un élément de la liste en suivant la même logique que [`QueryDict.__getitem__()`](#django.http.QueryDict.__getitem__):
```
>>> q = QueryDict('a=1&a=3&a=5')
>>> q.dict()
{'a': '5'}
```
#### `QueryDict.urlencode(safe=None)`
Renvoie une représentation textuelle des données au format « chaîne de requête ». Par exemple :
```
>>> q = QueryDict('a=2&b=3&b=5')
>>> q.urlencode()
'a=2&b=3&b=5'
```
Utilisez le paramètre `safe` pour transmettre des caractères qui n’ont pas besoin d’être codés. Par exemple :
```
>>> q = QueryDict(mutable=True)
>>> q['next'] = '/a&b/'
>>> q.urlencode(safe='/')
'next=/a%26b/'
```
## Objets `HttpResponse`
#### `class HttpResponse`
Contrairement aux objets [`HttpRequest`](#django.http.HttpRequest) qui sont automatiquement créés par Django, les objets [`HttpResponse`](#django.http.HttpResponse) sont de votre responsabilité. Chaque vue que vous écrivez est responsable d’instancier, de remplir et de renvoyer un objet [`HttpResponse`](#django.http.HttpResponse).
La classe [`HttpResponse`](#django.http.HttpResponse) se trouve dans le module [`django.http`](#module-django.http).
### Utilisation
#### Transmission de chaînes
L’usage typique est de transmettre le contenu de la page, sous forme de chaîne ou d’octets, au constructeur [`HttpResponse`](#django.http.HttpResponse):
```
>>> 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.')
```
Mais si vous souhaitez ajouter du contenu de manière incrémentale, vous pouvez utiliser `response` comme un objet de type fichier :
```
>>> response = HttpResponse()
>>> response.write("Here's the text of the Web page.
")
>>> response.write("Here's another paragraph.
")
```
#### Transmission d’itérateurs
Pour terminer, vous pouvez transmettre un itérateur au lieu d’une chaîne à `HttpResponse`. `HttpResponse` consomme immédiatement l’itérateur, stocke son contenu sous forme de chaîne et ne s’en occupe plus. Les objets ayant une méthode `close()` tels que les fichiers et les générateurs sont immédiatement fermés.
Si vous avez besoin que la réponse soit transmise sous forme de flux de l’itérateur vers le client, vous devez utilisez plutôt la classe [`StreamingHttpResponse`](#django.http.StreamingHttpResponse).
#### Définition de champs d’en-tête
Pour définir ou enlever un champ d’en-tête de la réponse, considérez cette dernière comme un dictionnaire :
```
>>> response = HttpResponse()
>>> response['Age'] = 120
>>> del response['Age']
```
Au contraire d’un dictionnaire, `del` ne génère pas d’exception `KeyError` si le champ d’en-tête n’existe pas.
Pour définir les champs d’en-tête `Cache-Control` et `Vary`, il est recommandé d’utiliser les méthodes [`patch_cache_control()`](/fr/2.2/ref/utils/#django.utils.cache.patch_cache_control) et [`patch_vary_headers()`](/fr/2.2/ref/utils/#django.utils.cache.patch_vary_headers) provenant de [`django.utils.cache`](/fr/2.2/ref/utils/#module-django.utils.cache), car ces champs peuvent contenir plusieurs valeurs séparées par des virgules. Les méthodes « patch » garantissent que les autres valeurs, par exemple celles ajoutées par un intergiciel, ne sont pas écrasées.
Les champs d’en-tête HTTP ne peuvent contenir de sauts de ligne. Si vous essayez de définir un contenu de champ d’en-tête avec un caractère de saut de ligne (CR ou LF), une exception `BadHeaderError` sera générée.
#### Réponse indiquant au navigateur de la traiter comme fichier à télécharger
Pour indiquer au navigateur qu’une réponse doit être traitée comme un fichier à télécharger, utilisez le paramètre `content_type` et définissez l’en-tête `Content-Disposition`. Par exemple, voici comment vous pouvez renvoyer une feuille de calcul Microsoft Excel :
```
>>> response = HttpResponse(my_data, content_type='application/vnd.ms-excel')
>>> response['Content-Disposition'] = 'attachment; filename="foo.xls"'
```
Il n’y a rien de spécifique à Django à propos de l’en-tête `Content-Disposition`, mais cette syntaxe est vite oubliée, c’est pourquoi nous l’avons incluse ici.
### Attributs
#### `HttpResponse.content`
Une chaîne d’octets représentant le contenu, codée à partir d’une chaîne, si nécessaire.
#### `HttpResponse.charset`
Une chaîne indiquant le jeu de caractères dans lequel la réponse sera codée. Si ce paramètre n’est pas indiqué au moment de l’instanciation de `HttpResponse`, il sera extrait à partir de `content_type`, et si ce n’est pas fructueux, c’est le réglage [`DEFAULT_CHARSET`](/fr/2.2/ref/settings/#std-setting-DEFAULT_CHARSET) qui est utilisé.
#### `HttpResponse.status_code`
Le [**code de statut HTTP**](https://datatracker.ietf.org/doc/html/rfc7231.html#section-6) de la réponse.
Tant que [`reason_phrase`](#django.http.HttpResponse.reason_phrase) n’est pas explicitement défini, la modification de la valeur de `status_code` en dehors du constructeur modifie également la valeur de `reason_phrase`.
#### `HttpResponse.reason_phrase`
La phrase de raison HTTP de la réponse. Elle utilise les phrases de raison par défaut du [**standard HTTP**](https://datatracker.ietf.org/doc/html/rfc7231.html#section-6.1).
Tant que `reason_phrase` n’est pas explicitement défini, il est déterminé par la valeur de [`status_code`](#django.http.HttpResponse.status_code).
#### `HttpResponse.streaming`
Cet attribut est toujours `False`.
Cet attribut existe pour que des intergiciels puissent traiter les réponses en flux différemment des réponse normales.
#### `HttpResponse.closed`
`True` si la réponse a été fermée.
### Méthodes
#### `HttpResponse.__init__(content=b'', content_type=None, status=200, reason=None, charset=None)`
Instancie un objet `HttpResponse` avec le contenu de page et le type de contenu donnés.
`content` et le plus souvent un itérateur, une chaîne d’octets ou une chaîne. Les autres types sont convertis en chaîne d’octets en codant leur représentation textuelle. Les itérateurs doivent renvoyer des chaînes ou chaînes d’octets et celles-ci seront concaténées pour former le contenu de la réponse.
`content_type` est le type MIME pouvant être facultativement complété par un codage de jeu de caractères et sert à remplir l’en-tête HTTP `Content-Type`. Quand il n’est pas fourni, ce paramètre est formé par les réglages [`DEFAULT_CONTENT_TYPE`](/fr/2.2/ref/settings/#std-setting-DEFAULT_CONTENT_TYPE) et [`DEFAULT_CHARSET`](/fr/2.2/ref/settings/#std-setting-DEFAULT_CHARSET), par défaut « text/html; charset=utf-8 ».
`status` est le [**code d’état HTTP**](https://datatracker.ietf.org/doc/html/rfc7231.html#section-6) de la réponse. Vous pouvez utiliser la classe [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus) de Python pour attribuer des alias signifiants, tel que `HTTPStatus.NO_CONTENT`.
`reason` est la phrase de réponse HTTP. Quand elle n’est pas indiquée, une phrase par défaut est utilisée.
`charset` est le jeu de caractères dans lequel la réponse sera codée. S’il n’est pas fourni, il sera extrait à partir de `content_type`, et si ce n’est pas fructueux, c’est le réglage [`DEFAULT_CHARSET`](/fr/2.2/ref/settings/#std-setting-DEFAULT_CHARSET) qui est utilisé.
#### `HttpResponse.__setitem__(header, value)`
Définit le nom d’en-tête donné à la valeur donnée. `header` et `value` doivent tous les deux être des chaînes.
#### `HttpResponse.__delitem__(header)`
Supprime l’en-tête nommé. Échoue silencieusement si l’en-tête n’existe pas. Insensible à la casse.
#### `HttpResponse.__getitem__(header)`
Renvoie la valeur correspondant au nom d’en-tête nommé. Insensible à la casse.
#### `HttpResponse.has_header(header)`
Renvoie `True` ou `False` sur la base d’une recherche insensible à la casse d’un en-tête ayant le nom indiqué.
#### `HttpResponse.setdefault(header, value)`
Définit un en-tête pour autant qu’il ne soit pas déjà présent.
#### `HttpResponse.set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=None, httponly=False, samesite=None)`
Définit un cookie. Les paramètres sont les mêmes que pour l’objet [`Morsel`](https://docs.python.org/3/library/http.cookies.html#http.cookies.Morsel) de la bibliothèque Python standard.
- `max_age` doit être un nombre de secondes ou `None` (par défaut) si le cookie ne doit durer que le temps de la session du navigateur client. Si `expires` n’est pas fourni, il est calculé.
- `expires` doit être soit une chaîne au format `"Wdy, DD-Mon-YY HH:MM:SS GMT"`, soit un objet `datetime.datetime` en UTC. Si `expires` est un objet `datetime`, la valeur de `max_age` est calculée.
- Utilisez `domain` si vous souhaitez définir un cookie inter-domaine. Par exemple, `domain="example.com"` définit un cookie lisible par les domaines www.example.com, blog.example.com, etc. Sinon, un cookie est seulement accessible par le domaine qui l’a définit.
- Utilisez `httponly=True` si vous souhaitez empêcher du code JavaScript client de pouvoir accéder au cookie.
[HttpOnly](https://www.owasp.org/index.php/HttpOnly) est un drapeau inclus dans un en-tête de réponse HTTP Set-Cookie. Il fait partie du standard [**RFC 6265**](https://datatracker.ietf.org/doc/html/rfc6265.html#section-4.1.2.6) pour les cookies, et c’est un moyen utile de réduire le risque d’un script côté client accédant aux données d’un cookie protégé.
- Utilisez `samesite='Strict'` ou `samesite='Lax'` pour indiquer au navigateur de ne pas envoyer ce cookie lors d’une requête vers une origine différente. [SameSite](https://www.owasp.org/index.php/SameSite) n’est pas pris en charge par tous les navigateurs, ce n’est donc pas une solution de remplacement pour la protection CSRF de Django, mais plutôt une mesure défensive de consolidation.
> **Changed in Django 2.1**
>
> Le paramètre `samesite` a été ajouté.
> **Warning**
>
> La [**RFC 6265**](https://datatracker.ietf.org/doc/html/rfc6265.html#section-6.1) précise que les agents utilisateurs doivent prendre en charge les cookies d’au moins 4096 octets. Pour beaucoup de navigateurs, c’est aussi la taille maximale. Django ne génère pas d’exception lors de la création d’un cookie de plus de 4096 octets, mais beaucoup de navigateurs ne vont pas stocker le cookie correctement.
#### `HttpResponse.set_signed_cookie(key, value, salt='', max_age=None, expires=None, path='/', domain=None, secure=None, httponly=False, samesite=None)`
Comme [`set_cookie()`](#django.http.HttpResponse.set_cookie), mais le cookie est [signé par chiffrement](/fr/2.2/topics/signing/) avant d’être défini. À utiliser en combinaison avec [`HttpRequest.get_signed_cookie()`](#django.http.HttpRequest.get_signed_cookie). Vous pouvez utiliser le paramètre facultatif `salt` pour renforcer la clé, mais vous ne devrez alors pas oublier de le transmettre aussi à l’appel [`HttpRequest.get_signed_cookie()`](#django.http.HttpRequest.get_signed_cookie) correspondant.
#### `HttpResponse.delete_cookie(key, path='/', domain=None, samesite=None)`
Supprime le cookie correspondant à la clé nommée. Échoue silencieusement si la clé n’existe pas.
En raison du fonctionnement des cookies, `path` et `domain` doivent contenir les mêmes valeurs qui ont été utilisées pour `set_cookie()` – sinon, le cookie pourrait ne pas être supprimé.
> **Changed in Django 2.2.15**
>
> Le paramètre `samesite` a été ajouté.
#### `HttpResponse.close()`
Cette méthode est appelée à la fin de la requête directement par le serveur WSGI.
#### `HttpResponse.write(content)`
Cette méthode transforme une instance [`HttpResponse`](#django.http.HttpResponse) en objet de type fichier.
#### `HttpResponse.flush()`
Cette méthode transforme une instance [`HttpResponse`](#django.http.HttpResponse) en objet de type fichier.
#### `HttpResponse.tell()`
Cette méthode transforme une instance [`HttpResponse`](#django.http.HttpResponse) en objet de type fichier.
#### `HttpResponse.getvalue()`
Renvoie la valeur de [`HttpResponse.content`](#django.http.HttpResponse.content). Cette méthode transforme une instance [`HttpResponse`](#django.http.HttpResponse) en un objet de type flux.
#### `HttpResponse.readable()`
Toujours `False`. Cette méthode transforme une instance [`HttpResponse`](#django.http.HttpResponse) en un objet de type flux.
#### `HttpResponse.seekable()`
Toujours `False`. Cette méthode transforme une instance [`HttpResponse`](#django.http.HttpResponse) en un objet de type flux.
#### `HttpResponse.writable()`
Toujours `True`. Cette méthode transforme une instance [`HttpResponse`](#django.http.HttpResponse) en un objet de type flux.
#### `HttpResponse.writelines(lines)`
Écrit une liste de lignes dans la réponse. Les séparateurs de ligne ne sont pas ajoutés. Cette méthode transforme une instance [`HttpResponse`](#django.http.HttpResponse) en un objet de type flux.
### Sous-classes de `HttpResponse`
Django inclut un certain nombre de sous-classes de `HttpResponse` gérant différents types de réponses HTTP. Comme `HttpResponse`, ces sous-classes se trouvent dans [`django.http`](#module-django.http).
#### `class HttpResponseRedirect`
Le premier paramètre du constructeur est obligatoire, le chemin vers lequel la redirection doit se faire. Il peut s’agir d’une URL pleinement qualifiée (par ex. `'https://www.yahoo.com/search/'`), un chemin absolu sans domaine (par ex. `'/search/'`) ou même un chemin relatif (par ex. `'search/'`). Dans ce dernier cas, le navigateur du client reconstruira lui-même l’URL complète en fonction du chemin actuel. Voir [`HttpResponse`](#django.http.HttpResponse) pour les autres paramètres facultatifs du constructeur. Notez que cette classe renvoie un code de statut HTTP 302.
#### `url`
Cet attribut en lecture seule représente l’URL vers laquelle la réponse va rediriger (équivalent à l’en-tête de réponse `Location`).
#### `class HttpResponsePermanentRedirect`
Comme [`HttpResponseRedirect`](#django.http.HttpResponseRedirect), mais renvoie une redirection permanente (code de statut HTTP 301) au lieu d’un redirection « found » (code de statut 302).
#### `class HttpResponseNotModified`
Le constructeur n’accepte aucun paramètre et cette réponse n’accepte aucun contenu. Cette classe permet d’indiquer qu’une page n’a pas été modifiée depuis la dernière requête de l’utilisateur (code de statut 304).
#### `class HttpResponseBadRequest`
Se comporte comme [`HttpResponse`](#django.http.HttpResponse) mais renvoie un code de statut 400.
#### `class HttpResponseNotFound`
Se comporte comme [`HttpResponse`](#django.http.HttpResponse) mais renvoie un code de statut 404.
#### `class HttpResponseForbidden`
Se comporte comme [`HttpResponse`](#django.http.HttpResponse) mais renvoie un code de statut 403.
#### `class HttpResponseNotAllowed`
Comme [`HttpResponse`](#django.http.HttpResponse) mais renvoie un code de statut 405. Le premier paramètre du constructeur est obligatoire : une liste de méthodes autorisées (par ex. `['GET', 'POST']`).
#### `class HttpResponseGone`
Se comporte comme [`HttpResponse`](#django.http.HttpResponse) mais renvoie un code de statut 410.
#### `class HttpResponseServerError`
Se comporte comme [`HttpResponse`](#django.http.HttpResponse) mais renvoie un code de statut 500.
> **Note**
>
> Si une sous-classe personnalisée de [`HttpResponse`](#django.http.HttpResponse) implémente une méthode `render`, Django considère qu’elle émule une réponse [`SimpleTemplateResponse`](/fr/2.2/ref/template-response/#django.template.response.SimpleTemplateResponse), et la méthode `render` doit elle-même renvoyer un objet réponse valide.
#### Classes de réponses personnalisées
Si vous rencontrez le besoin d’utiliser une classe de réponse que Django ne fournit pas, vous pouvez la créer à l’aide de [`http.HTTPStatus`](https://docs.python.org/3/library/http.html#http.HTTPStatus). Par exemple
```
from http import HTTPStatus
from django.http import HttpResponse
class HttpResponseNoContent(HttpResponse):
status_code = HTTPStatus.NO_CONTENT
```
## Objets `JsonResponse`
#### `class JsonResponse(data, encoder=DjangoJSONEncoder, safe=True, json_dumps_params=None, **kwargs)`
Une sous-classe de [`HttpResponse`](#django.http.HttpResponse) aidant à la création d’une réponse codée en JSON. Elle hérite de la plupart du comportement de sa classe parente avec quelques différences :
La valeur par défaut de son en-tête `Content-Type` est `application/json`.
Le premier paramètre, `data`, doit être une instance de `dict`. Si le paramètre `safe` est défini à `False` (voir ci-dessous), il peut s’agir de n’importe quel objet sérialisable en JSON.
Le codeur `encoder` qui contient par défaut [`django.core.serializers.json.DjangoJSONEncoder`](/fr/2.2/topics/serialization/#django.core.serializers.json.DjangoJSONEncoder) est utilisé pour sérialiser les données. Voir [sérialisation JSON](/fr/2.2/topics/serialization/#serialization-formats-json) pour plus de détails sur ce sérialiseur.
Le paramètre booléen `safe` vaut `True` par défaut. S’il est défini à `False`, n’importe quel objet peut être soumis à la sérialisation (sinon seules les instances de `dict` sont autorisées). Si `safe` vaut `True` et qu’un objet qui n’est pas un dictionnaire est transmis comme premier paramètre, une exception [`TypeError`](https://docs.python.org/3/library/exceptions.html#TypeError) est générée.
Le paramètre `json_dumps_params` est un dictionnaire de paramètres nommés à transmettre à l’appel `json.dumps()` utilisé pour générer la réponse.
### Utilisation
Voici à quoi peut ressembler une utilisation typique :
```
>>> from django.http import JsonResponse
>>> response = JsonResponse({'foo': 'bar'})
>>> response.content
b'{"foo": "bar"}'
```
#### Sérialisation d’objets non dictionnaires
Pour pouvoir sérialiser des objets autres que des dictionnaires, il faut définir le paramètre `safe` à `False`:
```
>>> response = JsonResponse([1, 2, 3], safe=False)
```
Dans le cas où `safe=False` n’est pas transmis, une exception [`TypeError`](https://docs.python.org/3/library/exceptions.html#TypeError) est produite.
> **Warning**
>
> Avant la [5e édition de ECMAScript](https://www.ecma-international.org/ecma-262/5.1/index.html#sec-11.1.4), il était possible de corrompre le constructeur `Array` de JavaScript. C’est pour cette raison que Django ne permet pas de transmettre par défaut des objets non dictionnaires au constructeur [`JsonResponse`](#django.http.JsonResponse). Cependant, la plupart des navigateurs modernes implémentent EcmaScript 5, ce qui élimine ce vecteur d’attaque. Il est donc possible de désactiver cette mesure de sécurité.
#### Modification du codeur JSON par défaut
Si vous avez besoin d’utiliser une classe de codage JSON différente, vous pouvez transmettre le paramètre `encoder` à la méthode du constructeur :
```
>>> response = JsonResponse(data, encoder=MyJSONEncoder)
```
## Objets `StreamingHttpResponse`
#### `class StreamingHttpResponse`
La classe [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) est utilisée pour diffuser une réponse en flux de Django vers le navigateur. Ceci peut être utilisé pour générer une réponse qui prend beaucoup de temps ou qui utilise beaucoup de mémoire. Par exemple, c’est utile pour [générer de gros fichiers CSV](/fr/2.2/howto/outputting-csv/#streaming-csv-files).
> **Considérations sur la performance**
>
> Django est conçu pour traiter des requêtes de courte durée. Les réponses en flux lient un processus de travail pour toute la durée de la réponse. Cela peut amener à des pertes de performance.
>
> Généralement, les tâches lourdes devraient être exécutées en dehors du cycle requête-réponse, plutôt que de faire appel à une réponse en flux.
La classe [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) n’hérite pas de [`HttpResponse`](#django.http.HttpResponse), parce que son API est légèrement différente. Cependant, elle est presque identique, à l’exception des différences notables suivantes :
- Elle doit recevoir un itérateur qui produit des chaînes comme contenu.
- Le seul moyen d’accéder à son contenu est d’itérer sur l’objet réponse lui-même. Cela ne devrait se faire qu’au moment de renvoyer la réponse au client.
- Elle ne possède pas d’attribut `content`. À la place, elle possède l’attribut [`streaming_content`](#django.http.StreamingHttpResponse.streaming_content).
- Vous ne pouvez pas utiliser les méthodes de type fichier `tell()` ou `write()`. Si vous le faites, vous obtiendrez une exception.
[`StreamingHttpResponse`](#django.http.StreamingHttpResponse) ne devrait être utilisée que dans les situations qui exigent vraiment que l’accès par itération au contenu global ne se fasse qu’au moment de transférer les données au client. Comme le contenu n’est pas directement accessible, beaucoup d’intergiciels ne peuvent pas fonctionner correctement. Par exemple, les en-têtes `ETag` et `Content-Length` ne peuvent pas être générés pour les réponses en flux.
### Attributs
#### `StreamingHttpResponse.streaming_content`
Un itérateur de contenu de la réponse, codé en chaîne d’octets en fonction de [`HttpResponse.charset`](#django.http.HttpResponse.charset).
#### `StreamingHttpResponse.status_code`
Le [**code de statut HTTP**](https://datatracker.ietf.org/doc/html/rfc7231.html#section-6) de la réponse.
Tant que [`reason_phrase`](#django.http.StreamingHttpResponse.reason_phrase) n’est pas explicitement défini, la modification de la valeur de `status_code` en dehors du constructeur modifie également la valeur de `reason_phrase`.
#### `StreamingHttpResponse.reason_phrase`
La phrase de raison HTTP de la réponse. Elle utilise les phrases de raison par défaut du [**standard HTTP**](https://datatracker.ietf.org/doc/html/rfc7231.html#section-6.1).
Tant que `reason_phrase` n’est pas explicitement défini, il est déterminé par la valeur de [`status_code`](#django.http.StreamingHttpResponse.status_code).
#### `StreamingHttpResponse.streaming`
Cet attribut est toujours `True`.
## Objets `FileResponse`
#### `class FileResponse(open_file, as_attachment=False, filename='', **kwargs)`
[`FileResponse`](#django.http.FileResponse) est une sous-classe de [`StreamingHttpResponse`](#django.http.StreamingHttpResponse) optimisée pour les fichiers binaires. Elle utilise [wsgi.file\_wrapper](https://www.python.org/dev/peps/pep-3333/#optional-platform-specific-file-handling) si le serveur WSGI le propose, sinon elle diffuse le fichier par petits morceaux.
Si `as_attachment=True`, l’en-tête `Content-Disposition` est défini, ce qui pousse le navigateur à proposer le fichier en téléchargement pour l’utilisateur.
Si `open_file` ne possède pas de nom ou si son nom n’est pas adéquat, fournissez un nom de fichier personnalisé en utilisant le paramètre `filename`. Notez que si vous passez un objet de type fichier tel que `io.BytesIO`, c’est à vous d’appeler `seek()` si nécessaire avant de le passer à `FileResponse`.
Les en-têtes `Content-Length`, `Content-Type` rz `Content-Disposition` sont automatiquement définis lorsqu’ils peuvent être déduits à partir du contenu de `open_file`.
> **New in Django 2.1**
>
> Les paramètres nommés `as_attachment` et `filename` ont été ajoutés. De plus, `FileResponse` définit les en-têtes `Content` s’il arrive à les déterminer.
`FileResponse` accepte tout objet de type fichier avec contenu binaire, par exemple un fichier ouvert en mode binaire, comme ceci :
```
>>> from django.http import FileResponse
>>> response = FileResponse(open('myfile.png', 'rb'))
```
Le fichier sera automatiquement fermé, ne l’ouvrez donc pas avec un gestionnaire de contexte.
### Méthodes
#### `FileResponse.set_headers(open_file)`
> **New in Django 2.1**
Cette méthode est automatiquement appelée durant l’initialisation de la réponse ; elle définit différents en-têtes (`Content-Length`, `Content-Type` et `Content-Disposition`) en fonction du fichier `open_file`.