..
  ============================
  Request and response objects
  ============================

.. sidebar:: Oggetti di richiesta e risposta
  :subtitle: traduzione in lingua italiana.

  Documento originale: `Request and response objects`_
  
  Traduzione: paolo `<paolo@php3.it>`
  
  Aggiornato alla revisione: 3164

.. 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/"``

..
  ``method``
      A string representing the HTTP method used in the request. This is
      guaranteed to be uppercase. Example::
  
          if request.method == 'GET':
              do_something()
          elif request.method == 'POST':
              do_something_else()

``method``
    Una stringa che corrispondente al metodo HTTP usato nella richiesta. E'
    garantito che vengano utilizzate lettere maiuscole. Esempio::

        if request.method == 'GET':
            fai_qualcosa()
        elif request.method == 'POST':
            fai_qualcosa_di_altro()

..
  ``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.
  
      It's possible that a request can come in via POST with an empty ``POST``
      dictionary -- if, say, a form is requested via the POST HTTP method but
      does not include form data. Therefore, you shouldn't use ``if request.POST``
      to check for use of the POST method; instead, check `method`_.

      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``.

    E' possibile che una richiesta possa arrivare via POST pur essendo vuoto il
    dizionario ``POST`` -- se, ad esempio, un form viene inviato via HTTP POST
    ma non include dati. Perciò non dovresti usare ``if request.POST`` per prendere
    decisioni. Invece, puoi effettuare una verifica corretta tramite il metodo ``method``.

    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 ``<input type="file" name="" />``. 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 ``<form>`` 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 ``<input type="file" name="" />``. 
    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 ``<form>``
    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
  ``<select multiple="multiple">``, pass multiple values for the same key.

Gli attributi ``GET`` e ``POST`` di un oggetto ``HttpRequest`` sono istanze di
``django.http.QueryDict``. ``QueryDict`` è una classe "dictionary-like", cioè
simile ad un dizionario, progettata per gestire molteplici valori per una
stessa chiave. Ciò si rende necessario perché alcuni elementi relativi ai form
HTML, in particolare ``<select multiple="multiple">``, 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::
  
      <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>

Questo è un esempio di form HTML e di come Django tratterebbe gli input::

    <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, 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("<p>Here's the text of the Web page.</p>")
      >>> response.write("<p>Here's another paragraph.</p>")

Se vuoi aggiungere contenuti in modo incrementale, puoi usare ``response`` come
fosse un oggetto file::

    >>> response = HttpResponse()
    >>> response.write("<p>Questo è il testo della pagina Web.</p>")
    >>> response.write("<p>Questo è un altro paragrafo.</p>")

..
  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.

..
  ``HttpResponseNotAllowed``
      Like ``HttpResponse``, but uses a 405 status code. Takes a single,
      required argument: a list of permitted methods (e.g. ``['GET', 'POST']``).
 
``HttpResponseNotAllowed``
    Si comporta come ``HttpResponse`` ma usa il codice di stato 405. Accetta un
    solo argomento, richiesto: una lista di metodi ammessi (ad esempio,
    ``['GET', 'POST']``).

..
  ``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.

Last modified 18 years ago Last modified on Jun 20, 2006, 4:36:54 PM
Note: See TracWiki for help on using the wiki.
Back to Top