Changes between Initial Version and Version 1 of DocItRequestResponse

Timestamp:

Jun 6, 2006, 6:08:18 PM (19 years ago)

Author:

paolo <paolo@…>

Comment:

Request and response objects, Italian translation.

DocItRequestResponse

@@ +1 @@
+{{{
+ #!rst
+
+..
+  ============================
+  Request and response objects
+  ============================
+
+===============================
+Oggetti di richiesta e risposta
+===============================
+
+.. 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: 2869
+
+.. _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 ``<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.
+
+..
+  ``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.
+
+}}}