{{{ #!rst .. ============================ Request and response objects ============================ .. sidebar:: Oggetti di richiesta e risposta :subtitle: traduzione in lingua italiana. Documento originale: `Request and response objects`_ Traduzione: paolo `` Aggiornato alla revisione: 2869 .. contents:: **Contenuti del capitolo** =============================== Oggetti di richiesta e risposta =============================== .. _Request and response objects: http://www.djangoproject.com/documentation/request_response/ .. Quick overview ============== Breve panoramica ================ .. Django uses request and response objects to pass state through the system. Django usa oggetti di richiesta e risposta per passare lo stato nel sistema. .. When a page is requested, Django creates an ``HttpRequest`` object that contains metadata about the request. Then Django loads the appropriate view, passing the ``HttpRequest`` as the first argument to the view function. Each view is responsible for returning an ``HttpResponse`` object. Quando è richiesta una pagina, Django crea un oggetto ``HttpRequest`` contenente i metadati relativi alla richiesta effettuata. Poi avviene il caricamento della view appropriata ed il passaggio dell'oggetto ``HttpRequest`` alla funzione corrispondente alla view, come primo argomento. Infine, ogni view è tenuta a fornire come risposta un oggetto ``HttpResponse``. .. This document explains the APIs for ``HttpRequest`` and ``HttpResponse`` objects. Questo documento descrive le API relative agli oggetti ``HttpRequest`` e ``HttpResponse``. .. HttpRequest objects =================== Oggetti HttpRequest =================== .. Attributes ---------- Attributi --------- .. All attributes except ``session`` should be considered read-only. Tutti gli attributi eccetto ``session`` sono utilizzabili in sola lettura. .. ``path`` A string representing the full path to the requested page, not including the domain. Example: ``"/music/bands/the_beatles/"`` ``path`` Una stringa che rappresenta il percorso completo della pagina richiesta, escludendo il nome del dominio. Esempio: ``"/music/bands/the_beatles/"`` .. ``GET`` A dictionary-like object containing all given HTTP GET parameters. See the ``QueryDict`` documentation below. ``GET`` Un oggetto "dictionary-like" contenente tutti i parametri HTTP GET che sono stati specificati. Vedi la documentazione seguente relativa a ``QueryDict``. .. ``POST`` A dictionary-like object containing all given HTTP POST parameters. See the ``QueryDict`` documentation below. Note: ``POST`` does *not* include file-upload information. See ``FILES``. ``POST`` Un oggetto "dictionary-like" contenente tutti i parametri HTTP POST che sono stati specificati. Vedi la documentazione seguente relativa a ``QueryDict``. Nota: l'attributo ``POST`` *non* include le informazioni sui file caricati tramite form. Per questo vedi la sezione ``FILES``. .. ``REQUEST`` For convenience, a dictionary-like object that searches ``POST`` first, then ``GET``. Inspired by PHP's ``$_REQUEST``. For example, if ``GET = {"name": "john"}`` and ``POST = {"age": '34'}``, ``REQUEST["name"]`` would be ``"john"``, and ``REQUEST["age"]`` would be ``"34"``. It's strongly suggested that you use ``GET`` and ``POST`` instead of ``REQUEST``, because the former are more explicit. ``REQUEST`` Definito per comodità, è un oggetto "dictionary-like" in cui la ricerca dei parametri avviene prima usando l'attributo ``POST``, poi usando ``GET``. L'idea di implementare ``REQUEST`` è nata prendendo spunto da ``$_REQUEST`` di PHP. Ad esempio, se ``GET = {"name": "john"}`` e ``POST = {"age": '34'}``, ``REQUEST["name"]`` restituirebbe ``"john"``, e ``REQUEST["age"]`` restituirebbe ``"34"``. E' vivamente consigliato l'utilizzo di ``GET`` e ``POST`` al posto di ``REQUEST``, in quanto le prime due formule risultano più esplicite. .. ``COOKIES`` A standard Python dictionary containing all cookies. Keys and values are strings. ``COOKIES`` E' un dizionario contenente tutti i cookies. Le chiavi e valori sono stringhe. .. ``FILES`` A dictionary-like object containing all uploaded files. Each key in ``FILES`` is the ``name`` from the ````. Each value in ``FILES`` is a standard Python dictionary with the following three keys: * ``filename`` -- The name of the uploaded file, as a Python string. * ``content-type`` -- The content type of the uploaded file. * ``content`` -- The raw content of the uploaded file. Note that ``FILES`` will only contain data if the request method was POST and the ``
`` that posted to the request had ``enctype="multipart/form-data"``. Otherwise, ``FILES`` will be a blank dictionary-like object. ``FILES`` Un oggetto "dictionary-like" contenente le informazioni su tutti i file caricati dall'utente tramite form. Ogni chiave di ``FILES`` coincide con il valore di ``name`` ottenuto da ````. Ogni valore invece è un normale dizionario in cui compaiono tre chiavi: * ``filename`` -- Il nome del file, come stringa. * ``content-type`` -- Il tipo di contenuto del file. * ``content`` -- Il contenuto del file. Nota che l'attributo ``FILES`` conterrà dati solamente se il metodo della richiesta è di tipo POST e il tipo di contenuto specificato in ```` mediante enctype risulta essere ``multipart/form-data`` (``enctype="multipart/form-data"``). Diversamente ``FILES`` sarà un oggetto "dictionary-like" vuoto. .. ``META`` A standard Python dictionary containing all available HTTP headers. Available headers depend on the client and server, but here are some examples: * ``CONTENT_LENGTH`` * ``CONTENT_TYPE`` * ``HTTP_ACCEPT_ENCODING`` * ``HTTP_ACCEPT_LANGUAGE`` * ``HTTP_REFERER`` -- The referring page, if any. * ``HTTP_USER_AGENT`` -- The client's user-agent string. * ``QUERY_STRING`` -- The query string, as a single (unparsed) string. * ``REMOTE_ADDR`` -- The IP address of the client. * ``REMOTE_HOST`` -- The hostname of the client. * ``REQUEST_METHOD`` -- A string such as ``"GET"`` or ``"POST"``. * ``SERVER_NAME`` -- The hostname of the server. * ``SERVER_PORT`` -- The port of the server. ``META`` E' un dizionario contenente tutti gli header HTTP disponibili. In genere la disponibilità degli header varia in funzione del client e del server; di seguito sono elencate alcune intestazioni HTTP a titolo di esempio: * ``CONTENT_LENGTH`` * ``CONTENT_TYPE`` * ``HTTP_ACCEPT_ENCODING`` * ``HTTP_ACCEPT_LANGUAGE`` * ``HTTP_REFERER`` -- La pagina di provenienza, se esiste. * ``HTTP_USER_AGENT`` -- La stringa di identificazione del browser che ha effettuato la richiesta. * ``QUERY_STRING`` -- La stringa contenente i parametri, sottoforma di un'unica stringa non elaborata. * ``REMOTE_ADDR`` -- L'indirizzo IP del client. * ``REMOTE_HOST`` -- Il nome host del client. * ``REQUEST_METHOD`` -- Una stringa come ``"GET"`` o ``"POST"``. * ``SERVER_NAME`` -- Il nome host del server. * ``SERVER_PORT`` -- La porta di comunicazione del server. .. ``user`` A ``django.contrib.auth.models.User`` object representing the currently logged-in user. If the user isn't currently logged in, ``user`` will be set to an instance of ``django.contrib.auth.models.AnonymousUser``. You can tell them apart with ``is_anonymous()``, like so:: if request.user.is_anonymous(): # Do something for anonymous users. else: # Do something for logged-in users. ``user`` is only available if your Django installation has the ``AuthenticationMiddleware`` activated. For more, see `Authentication in Web requests`_. .. _Authentication in Web requests: http://www.djangoproject.com/documentation/authentication/#authentication-in-web-requests ``user`` Rappresenta l'utente attualmente loggato come oggetto ``django.contrib.auth.models.User``. Se non sono disponibili le credenziali d'accesso dell'utente che ha effettuato la richiesta, ``user`` conterrà un'istanza di ``django.contrib.auth.models.AnonymousUser``. Puoi diversificare le possibilità per questo tipo di utente rispetto agli utenti loggati usando ``is_anonymous()`` come nell'esempio:: if request.user.is_anonymous(): # Fai qualcosa per gli utenti anonimi. else: # Fai qualcosa per gli utenti autenticati. ``user`` è disponibile soltanto se ``AuthenticationMiddleware`` è stato attivato per questa installazione di Django. Per ulteriori dettagli consulta `Autenticazione nelle richieste Web`_. .. _Autenticazione nelle richieste Web: http://www.djangoproject.com/documentation/authentication/#authentication-in-web-requests .. ``session`` A readable-and-writable, dictionary-like object that represents the current session. This is only available if your Django installation has session support activated. See the `session documentation`_ for full details. .. _`session documentation`: http://www.djangoproject.com/documentation/sessions/ ``session`` E' un oggetto "dictionary-like" a cui si può accedere in lettura e scrittura con cui viene rappresentata la sessione corrente. L'oggetto session è disponibile solamente se nell'installazione di Django è attivo il supporto per le sessioni. Per i dettagli completi consulta la `documentazione relativa alle sessioni`_. .. _`documentazione relativa alle sessioni`: http://www.djangoproject.com/documentation/sessions/ .. ``raw_post_data`` The raw HTTP POST data. This is only useful for advanced processing. Use ``POST`` instead. ``raw_post_data`` I dati grezzi di HTTP POST. Viene usato per elaborazioni avanzate. Nella maggior parte dei casi userai ``POST`` invece di ``raw_post_data``. .. Methods ------- Metodi ------ .. ``__getitem__(key)`` Returns the GET/POST value for the given key, checking POST first, then GET. Raises ``KeyError`` if the key doesn't exist. This lets you use dictionary-accessing syntax on an ``HttpRequest`` instance. Example: ``request["foo"]`` would return ``True`` if either ``request.POST`` or ``request.GET`` had a ``"foo"`` key. ``__getitem__(key)`` Restituisce il valore GET/POST per la chiave specificata (key), controllando prima POST poi GET. Solleva un'eccezione ``KeyError`` se la chiave non esiste. Questo consente di accedere ad una istanza ``HttpRequest`` usando la sintassi con cui normalmente si accede ai dizionari. Ad esempio: ``request["foo"]`` restituisce ``True`` se ``"foo"`` è presente come chiave in ``request.POST`` o ``request.GET`` .. ``has_key()`` Returns ``True`` or ``False``, designating whether ``request.GET`` or ``request.POST`` has the given key. ``has_key()`` Restituisce ``True`` o ``False``, indicando se la chiave specificata è presente in ``request.GET`` o in ``request.POST``. .. ``get_full_path()`` Returns the ``path``, plus an appended query string, if applicable. Example: ``"/music/bands/the_beatles/?print=true"`` ``get_full_path()`` Restituisce il ``path``, accodando la query string, se presente. Ad esempio: ``"/music/bands/the_beatles/?print=true"`` .. QueryDict objects ----------------- Oggetti 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 ````, passano più valori per la stessa chiave. .. ``QueryDict`` instances are immutable, unless you create a ``copy()`` of them. That means you can't change attributes of ``request.POST`` and ``request.GET`` directly. Le istanze ``QueryDict`` sono immutabili, a meno che ne venga creata una copia con ``copy()``. Ne segue che non puoi cambiare direttamente gli attributi di ``request.POST`` e ``request.GET``. .. ``QueryDict`` implements the all standard dictionary methods, because it's a subclass of dictionary. Exceptions are outlined here: Essendo ``QueryDict`` una classe derivata dagli oggetti dizionario, tutti i metodi standard propri dei dizionari vengono implementati, con le differenze elencate di seguito: .. * ``__getitem__(key)`` -- Returns the value for the given key. If the key has more than one value, ``__getitem__()`` returns the last value. * ``__getitem__(key)`` -- Restituisce il valore corrispondente alla chiave fornita (key), o l'ultimo dei valori se la chiave è associata a più di un valore. .. * ``__setitem__(key, value)`` -- Sets the given key to ``[value]`` (a Python list whose single element is ``value``). Note that this, as other dictionary functions that have side effects, can only be called on a mutable ``QueryDict`` (one that was created via ``copy()``). * ``__setitem__(key, value)`` -- Imposta la chiave specificata (key) al valore ``[value]`` (una lista Python il cui singolo elemento è ``value``). Nota che questa funzione, come le altre funzioni sui dizionari che prevedano conseguenze "attive", può essere eseguita soltanto su ``QueryDict`` mutabili (quelli creati usando ``copy()``). .. * ``__contains__(key)`` -- Returns ``True`` if the given key is set. This lets you do, e.g., ``if "foo" in request.GET``. * ``__contains__(key)`` -- Restituisce ``True`` se la chiave (key) è impostata. In questo modo è possibile, ad esempio, scrivere: ``if "foo" in request.GET``. .. * ``get(key, default)`` -- Uses the same logic as ``__getitem__()`` above, with a hook for returning a default value if the key doesn't exist. * ``get(key, default)`` -- Usa la stessa logica adottata da ``__getitem__()`` restituendo un valore predefinito (default) se la chiave (key) non esiste. .. * ``has_key(key)`` * ``has_key(key)`` .. * ``setdefault(key, default)`` -- Just like the standard dictionary ``setdefault()`` method, except it uses ``__setitem__`` internally. * ``setdefault(key, default)`` -- equivalente al metodo ``setdefault()`` dei dizionari usuali, eccetto per l'utilizzo interno di ``__setitem__``. .. * ``update(other_dict)`` -- Takes either a ``QueryDict`` or standard dictionary. Just like the standard dictionary ``update()`` method, except it *appends* to the current dictionary items rather than replacing them. For example:: >>> 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'] * ``update(other_dict)`` -- Accetta un ``QueryDict`` o un normale dizionario. Si comporta come il metodo ``update()`` dei normali dizionari, salvo per il fatto di accodare gli elementi al dizionario corrente, invece di rimpiazzarli. Ad esempio:: >>> q = QueryDict('a=1') >>> q = q.copy() # lo rende mutabile >>> q.update({'a': '2'}) >>> q.getlist('a') ['1', '2'] >>> q['a'] # restituisce l'ultimo ['2'] .. * ``items()`` -- Just like the standard dictionary ``items()`` method, except this uses the same last-value logic as ``__getitem()__``. For example:: >>> q = QueryDict('a=1&a=2&a=3') >>> q.items() [('a', '3')] * ``items()`` -- Si comporta come il metodo ``items()`` dei normali dizionari, salvo per il fatto che viene usata la logica adottata da ``__getitem()__`` di restituire l'ultimo valore. Ad esempio:: >>> q = QueryDict('a=1&a=2&a=3') >>> q.items() [('a', '3')] .. * ``values()`` -- Just like the standard dictionary ``values()`` method, except this uses the same last-value logic as ``__getitem()__``. For example:: >>> q = QueryDict('a=1&a=2&a=3') >>> q.values() ['3'] * ``values()`` -- Si comporta come il metodo ``values()`` dei normali dizionari, salvo per il fatto che viene usata la logica di restituire l'ultimo valore adottata da ``__getitem()__``. Ad esempio:: >>> q = QueryDict('a=1&a=2&a=3') >>> q.values() ['3'] .. In addition, ``QueryDict`` has the following methods: In aggiunta, ``QueryDict`` fornisce i seguenti metodi: .. * ``copy()`` -- Returns a copy of the object, using ``copy.deepcopy()`` from the Python standard library. The copy will be mutable -- that is, you can change its values. * ``copy()`` -- Restituisce una copia dell'oggetto generata usando ``copy.deepcopy()`` fornito dalla libreria standard di Pyhton. La copia sarà mutabile -- ovvero, i valori potranno essere modificati. .. * ``getlist(key)`` -- Returns the data with the requested key, as a Python list. Returns an empty list if the key doesn't exist. It's guaranteed to return a list of some sort. * ``getlist(key)`` -- Restituisce i dati assieme alla chiave (key), sottoforma di lista Python. Se la chiave non esiste viene restituita una lista vuota. Usando questo metodo è garantito che il risultato sia comunque una lista. .. * ``setlist(key, list_)`` -- Sets the given key to ``list_`` (unlike ``__setitem__()``). * ``setlist(key, list_)`` -- Imposta la chiave (key) al valore ``list_`` (diversamente da ``__setitem__()``). .. * ``appendlist(key, item)`` -- Appends an item to the internal list associated with key. * ``appendlist(key, item)`` -- Accoda un elemento (item) alla lista associata alla chiave (key). .. * ``setlistdefault(key, default_list)`` -- Just like ``setdefault``, except it takes a list of values instead of a single value. * ``setlistdefault(key, default_list)`` -- Equivalente al metodo ``setdefault``, fatto salvo che ammette una lista (default_list) invece di un singolo valore. .. * ``lists()`` -- Like ``items()``, except it includes all values, as a list, for each member of the dictionary. For example:: >>> q = QueryDict('a=1&a=2&a=3') >>> q.lists() [('a', ['1', '2', '3'])] * ``lists()`` -- funziona come ``items()``, ma vengono inclusi tutti i valori, in forma di lista, per ogni elemento del dizionario. Ad esempio:: >>> q = QueryDict('a=1&a=2&a=3') >>> q.lists() [('a', ['1', '2', '3'])] .. * ``urlencode()`` -- Returns a string of the data in query-string format. Example: ``"a=2&b=3&b=5"``. * ``urlencode()`` -- Restituisce una stringa dei dati sottoforma di query-string. Ad esempio: ``"a=2&b=3&b=5"``. .. Examples -------- Esempi ------ .. Here's an example HTML form and how Django would treat the input::
Questo è un esempio di form HTML e di come Django tratterebbe gli input::
.. If the user enters ``"John Smith"`` in the ``your_name`` field and selects both "The Beatles" and "The Zombies" in the multiple select box, here's what Django's request object would have:: >>> 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' Se l'utente inserisce ``"John Smith"`` nel campo ``your_name`` e sceglie sia "The Beatles" che "The Zombies" dalla select box a scelta multipla, la richiesta si presenterebbe in questo modo:: >>> 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 notes -------------------- Note sull'implementazione ------------------------- .. The ``GET``, ``POST``, ``COOKIES``, ``FILES``, ``META``, ``REQUEST``, ``raw_post_data`` and ``user`` attributes are all lazily loaded. That means Django doesn't spend resources calculating the values of those attributes until your code requests them. Al fine di ottimizzare l'utilizzo delle risorse disponibili, i valori degli attributi ``GET``, ``POST``, ``COOKIES``, ``FILES``, ``META``, ``REQUEST``, ``raw_post_data`` e ``user`` vengono caricati soltanto nel momento in cui ne è richiesto l'utilizzo da parte del codice. .. HttpResponse objects ==================== Oggetti HttpResponse ==================== .. In contrast to ``HttpRequest`` objects, which are created automatically by Django, ``HttpResponse`` objects are your responsibility. Each view you write is responsible for instantiating, populating and returning an ``HttpResponse``. Diversamente dagli oggetti ``HttpRequest``, creati automaticamente da Django, gli oggetti ``HttpResponse`` sono una tua responsabilità. Devi prevedere che qualsiasi view che scrivi istanzi, popoli e restituisca un ``HttpResponse``. .. The ``HttpResponse`` class lives at ``django.http.HttpResponse``. La classe ``HttpResponse`` si trova in ``django.http.HttpResponse``. .. Usage ----- Utilizzo -------- .. Passing strings ~~~~~~~~~~~~~~~ Passaggio di stringhe ~~~~~~~~~~~~~~~~~~~~~ .. Typical usage is to pass the contents of the page, as a string, to the ``HttpResponse`` constructor:: >>> response = HttpResponse("Here's the text of the Web page.") >>> response = HttpResponse("Text only, please.", mimetype="text/plain") La tipica situazione di utilizzo è il passaggio dei contenuti di una pagina, come stringa, al costruttore dell'oggetto ``HttpResponse``:: >>> response = HttpResponse("Questo è il testo della pagina Web.") >>> response = HttpResponse("Soltanto testo, per cortesia.", mimetype="text/plain") .. But if you want to add content incrementally, you can use ``response`` as a file-like object:: >>> response = HttpResponse() >>> response.write("

Here's the text of the Web page.

") >>> response.write("

Here's another paragraph.

") Se vuoi aggiungere contenuti in modo incrementale, puoi usare ``response`` come fosse un oggetto file:: >>> response = HttpResponse() >>> response.write("

Questo è il testo della pagina Web.

") >>> response.write("

Questo è un altro paragrafo.

") .. 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." Puoi inserire nuovi header o effettuare rimozioni usando la sintassi valida per i dizionari:: >>> response = HttpResponse() >>> response['X-DJANGO'] = "E' il migliore." >>> del response['X-PHP'] >>> response['X-DJANGO'] "E' il migliore." .. Note that ``del`` doesn't raise ``KeyError`` if the header doesn't exist. Nota che ``del`` non solleva un ``KeyError`` se l'header non esiste. .. Passing iterators ~~~~~~~~~~~~~~~~~ Passaggio di iteratori ~~~~~~~~~~~~~~~~~~~~~~ .. Finally, you can pass ``HttpResponse`` an iterator rather than passing it hard-coded strings. If you use this technique, follow these guidelines: * The iterator should return strings. * If an ``HttpResponse`` has been initialized with an iterator as its content, you can't use the ``HttpResponse`` instance as a file-like object. Doing so will raise ``Exception``. Invece di passare stringhe predefinite, ad ``HttpResponse`` puoi passare un iteratore. Se intendi utilizzare questa tecnica attieniti alle seguenti direttive: * L'iteratore deve restituire stringhe. * Se un oggetto ``HttpResponse`` è stato inizializzato con un iteratore come suo contenuto, non potrai usare le sue istanze come oggetti "file-like". Ciò solleverebbe un'eccezione. .. Methods ------- Metodi ------ .. ``__init__(content='', mimetype=DEFAULT_MIME_TYPE)`` Instantiates an ``HttpResponse`` object with the given page content (a string) and MIME type. The ``DEFAULT_MIME_TYPE`` is ``'text/html'``. ``content`` can be an iterator or a string. If it's an iterator, it should return strings, and those strings will be joined together to form the content of the response. ``__init__(content='', mimetype=DEFAULT_MIME_TYPE)`` Istanzia un oggeto ``HttpResponse`` con il contenuto della pagina come stringa (content) e un tipo MIME (mimetype). Il tipo MIME predefinito, ``DEFAULT_MIME_TYPE`` è ``'text/html'``. ``content`` può essere un iteratore o una stringa. Nel caso sia un iteratore, ci si aspetta che restituisca stringhe, che saranno in seguito unite e per diventare il contenuto della risposta. .. ``__setitem__(header, value)`` Sets the given header name to the given value. Both ``header`` and ``value`` should be strings. ``__setitem__(header, value)`` Imposta un valore per l'header specificato. E' richiesto che ``header`` e ``value`` siano stringhe. .. ``__delitem__(header)`` Deletes the header with the given name. Fails silently if the header doesn't exist. Case-sensitive. ``__delitem__(header)`` Rimuove l'header specificato. Se l'header è inesistente non vengono segnalati errori. Distingue lettere maiuscole da lettere minuscole. .. ``__getitem__(header)`` Returns the value for the given header name. Case-sensitive. ``__getitem__(header)`` Restituisce il valore dell'header specificato. Distingue lettere maiuscole da lettere minuscole. .. ``has_header(header)`` Returns ``True`` or ``False`` based on a case-insensitive check for a header with the given name. ``has_header(header)`` Restituisce ``True`` o ``False`` sulla base dell'esistenza dell'header specificato. Non vi è distinzione tra lettere maiuscole e lettere minuscole. .. ``set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=None)`` Sets a cookie. The parameters are the same as in the `cookie Morsel`_ object in the Python standard library. * ``max_age`` should be a number of seconds, or ``None`` (default) if the cookie should last only as long as the client's browser session. * ``expires`` should be a string in the format ``"Wdy, DD-Mon-YY HH:MM:SS GMT"``. * Use ``domain`` if you want to set a cross-domain cookie. For example, ``domain=".lawrence.com"`` will set a cookie that is readable by the domains www.lawrence.com, blogs.lawrence.com and calendars.lawrence.com. Otherwise, a cookie will only be readable by the domain that set it. .. _`cookie Morsel`: http://www.python.org/doc/current/lib/morsel-objects.html ``set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=None)`` Imposta un cookie. I parametri sono gli stessi che si trovano nell'oggetto `cookie Morsel`_ nella libreria standard di Python. * ``max_age`` specifica un numero di secondi, o ``None`` (impostazione predefinita) se è previsto che il cookie venga mantenuto per tutta la durata della sessione di navigazione dell'utente (chiusura del browser). * ``expires`` specifica una stringa nel formato ``"Wdy, DD-Mon-YY HH:MM:SS GMT"``. * Usa il parametro ``domain`` se vuoi impostare un cookie cross-domain. Ad esempio, ``domain=".lawrence.com"`` ha l'effetto di impostare un cookie leggibile dai domini www.lawrence.com, blogs.lawrence.com e calendars.lawrence.com. Non impostando il valore di domain il cookie sarebbe leggibile soltanto dal dominio che ne ha originato la creazione. .. _`cookie Morsel`: http://www.python.org/doc/current/lib/morsel-objects.html .. ``delete_cookie(key)`` Deletes the cookie with the given key. Fails silently if the key doesn't exist. ``delete_cookie(key)`` Elimina il cookie con la chiave specificata (key). Se la chiave è inesistente non vengono segnalati errori. .. ``content`` Returns the content as a Python string, encoding it from a Unicode object if necessary. Note this is a property, not a method, so use ``r.content`` instead of ``r.content()``. ``content`` Restituisce il contenuto come stringa Python, eseguendo l'encoding Unicode se necessario. Nota che ``content`` è una proprietà, non un metodo, perciò usa ``r.content`` invece di ``r.content()``. .. ``write(content)``, ``flush()`` and ``tell()`` These methods make an ``HttpResponse`` instance a file-like object. ``write(content)``, ``flush()`` e ``tell()`` Questi metodi rendono un'istanza ``HttpResponse`` un oggetto file-like. .. HttpResponse subclasses ----------------------- Sottoclassi di HttpResponse --------------------------- .. Django includes a number of ``HttpResponse`` subclasses that handle different types of HTTP responses. Like ``HttpResponse``, these subclasses live in ``django.http``. Django include alcune sottoclassi di ``HttpResponse`` adatte a fornire differenti tipologie di risposte HTTP. Come per ``HttpResponse``, queste sottoclassi si trovano in ``django.http``. .. ``HttpResponseRedirect`` The constructor takes a single argument -- the path to redirect to. This can be a fully qualified URL (e.g. ``'http://www.yahoo.com/search/'``) or an absolute URL with no domain (e.g. ``'/search/'``). Note that this returns an HTTP status code 302. ``HttpResponseRedirect`` Il costruttore accetta un solo argomento -- il percorso di redirezione, come URL completamente specificato (ad esempio, ``'http://www.yahoo.com/search/'``) o come URL assoluto senza dominio (ad esempio, ``'/search/'``). Nota che il codice di stato HTTP restituito è 302. .. ``HttpResponsePermanentRedirect`` Like ``HttpResponseRedirect``, but it returns a permanent redirect (HTTP status code 301) instead of a "found" redirect (status code 302). ``HttpResponsePermanentRedirect`` Funziona come ``HttpResponseRedirect``, ma restituisce uno stato di redirezione permanente (codice HTTP 301) invece di un redirect con codice 302. .. ``HttpResponseNotModified`` The constructor doesn't take any arguments. Use this to designate that a page hasn't been modified since the user's last request. ``HttpResponseNotModified`` Il costruttore non prevede alcun argomento. Usa questo tipo di risposta per indicare che una pagina non è stata modificata dall'ultima richiesta dell'utente. .. ``HttpResponseNotFound`` Acts just like ``HttpResponse`` but uses a 404 status code. ``HttpResponseNotFound`` Si comporta come ``HttpResponse`` ma usa il codice di stato 404. .. ``HttpResponseForbidden`` Acts just like ``HttpResponse`` but uses a 403 status code. ``HttpResponseForbidden`` Si comporta come ``HttpResponse`` ma usa il codice di stato 403. .. ``HttpResponseGone`` Acts just like ``HttpResponse`` but uses a 410 status code. ``HttpResponseGone`` Si comporta come ``HttpResponse`` ma usa il codice di stato 410. .. ``HttpResponseServerError`` Acts just like ``HttpResponse`` but uses a 500 status code. ``HttpResponseServerError`` Si comporta come ``HttpResponse`` ma usa il codice di stato 500. }}}