---
title: "Scrivere la tua prima applicazione in Django, parte 1"
version: 5.2
locale: it
source: https://docs.djangoproject.com/it/5.2/intro/tutorial01/
canonical: https://djangodocs.dev/it/5.2/intro/tutorial01/
---
# Scrivere la tua prima applicazione in Django, parte 1

Impariamo attraverso un esempio.

Durante questa guida, ti accompagneremo attraverso la creazione di una semplice applicazione per sondaggi.

Consisterà di due parti:

- Un sito pubblico, che permette agli utenti di visualizzare sondaggi e votarli.
- Un sito amministrativo che ti permette l’aggiunta, modifica ed eliminazione di sondaggi.

Supponiamo che tu abbia già [Django installato](/it/5.2/intro/install/). Puoi dire che Django sia installato e quale versione sia eseguendo il seguente comando in un prompt della shell (indicato dal prefisso $):

```console
$ python -m django --version
```

*Windows*

```doscon
...\> py -m django --version
```

Se Django è installato, dovresti vedere la versione della tua installazione. Se non lo è, riceverai un errore che dice «No module named django».

Questo tutorial è stato scritto per Django 5.2, che supporta Python 3.10 e successivi. Se la versione di Django è diversa, puoi fare riferimento al tutorial per la tua versione di Django usando il selettore della versione in basso a destra in questa pagina oppure aggiornare Django alla versione più recente. Se stai utilizzando una versione precedente di Python, controlla [Che versione di Python posso usare con Django?](/it/5.2/faq/install/#faq-python-version-support) per trovare una versione compatibile di Django.

> **Dove trovare aiuto:**
>
> Se hai difficoltà a completare questo tutorial,  per favore vai alla sezione [Getting Help](/it/5.2/faq/help/) delle FAQ.

## Creare un progetto

Se questa è la prima volta volta che usi Django, dovrai prenderti cura di qualche configurazione iniziale. Specificatamente, dovrai auto-generare del codice che costituisce un [progetto](/it/5.2/glossary/#term-project) Django – una collezione di settaggi per un’instanza di Django, che include configurazione del database, opzioni specifiche per Django e settaggi specifici per l’applicazione.

From the command line, `cd` into a directory where you’d like to store your
code and create a new directory named `djangotutorial`. (This directory name
doesn’t matter to Django; you can rename it to anything you like.)

```console
$ mkdir djangotutorial
```

*Windows*

```doscon
...\> mkdir djangotutorial
```

Then, run the following command to bootstrap a new Django project:

```console
$ django-admin startproject mysite djangotutorial
```

*Windows*

```doscon
...\> django-admin startproject mysite djangotutorial
```

This will create a project called `mysite` inside the `djangotutorial`
directory. If it didn’t work, see [Problemi nell’esecuzione di django-admin](/it/5.2/faq/troubleshooting/#troubleshooting-django-admin).

> **Note**
>
> Vorrai evitare di chiamare progetti con lo stesso nome di componenti predefiniti in Python o Django. In particolare, questo significa evitare nomi quali `django` (che confligge con Django stesso) o `test` (che confligge con il pacchetto Python di serie).

Diamo un’occhiata a cosa [`startproject`](/it/5.2/ref/django-admin/#django-admin-startproject) ha creato:

```text
djangotutorial/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py
```

Questi file sono:

- `manage.py`: Una utility da linea di comando che ti permette di interagire con questo progetto in svariate maniere. Puoi leggere tutti i dettagli a proposito di `manage.py` in in [django-admin and manage.py](/it/5.2/ref/django-admin/).
- `mysite/`: A directory that is the actual Python package for your
  project. Its name is the Python package name you’ll need to use to import
  anything inside it (e.g. `mysite.urls`).
- `mysite/__init__.py`: Un file vuoto che indica a Python che questa directory dovrebbe essere considerata un pacchetto Python. Se sei un principiante di Python, leggi [ulteriori informazioni sui pacchetti](https://docs.python.org/3/tutorial/modules.html#tut-packages) nella documentazione ufficiale di Python.
- `mysite/settings.py`: Settaggi/configurazione per questo progetto Django. [Django settings](/it/5.2/topics/settings/) ha tutte le informazioni di cui hai bisogno su come funzionano i settaggi.
- `mysite/urls.py`: Le dichiarazione di URL per questo progetto Django; una «tavola di contenuti» del tuo sito Django. Per saperne di più sulle URLs, leggi [URL dispatcher](/it/5.2/topics/http/urls/).
- `mysite/asgi.py`: Un punto di ingresso per i server web compatibili con ASGI per servire il tuo progetto. Vedi [Come distribuire con ASGI.](/it/5.2/howto/deployment/asgi/) per maggiori dettagli .
- `mysite/wsgi.py`: Un punto d’ingresso per web server compatibili con WSGI per servire il tuo progetto. Vedi [Come distribuire con WSGI.](/it/5.2/howto/deployment/wsgi/) per maggiori dettagli.

## Il server di sviluppo

Let’s verify your Django project works. Change into the `djangotutorial`
directory, if you haven’t already, and run the following commands:

```console
$ python manage.py runserver
```

*Windows*

```doscon
...\> py manage.py runserver
```

Vedrai il seguente output nella linea di comando:

```
Performing system checks...

System check identified no issues (0 silenced).

You have unapplied migrations; your app may not work properly until they are applied.
Run 'python manage.py migrate' to apply them.

09 ago 2026 - 15:50:53
Django version 5.2, using settings 'mysite.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

WARNING: This is a development server. Do not use it in a production setting. Use a production WSGI or ASGI server instead.
For more information on production servers see: https://docs.djangoproject.com/en/5.2/howto/deployment/
```

> **Note**
>
> Per ora ignora gli avvisi relativi alle migrazione del database non applicate, ci preoccuperemo a breve del database.

Adesso che il server sta girando, visita <http://127.0.0.1:8000/> con il tuo browser web. Vedrai una pagina «Congratulations!», con un razzo che sta partendo. Funziona!

Hai avviato il server di sviluppo Django, un web server leggero scritto puramente in Python. Lo abbiamo incluso con Django in modo che tu possa sviluppare le cose rapidamente, senza dover avere a che fare con la configurazione di un server di produzione – come Apache – finchè non sei pronto per la produzione.

Adesso è un buon momento per fare un appunto: **non\*** usare questo server in nessun ambiente che somigli anche vagamente alla produzione. E” adatto solo allo sviluppo. (Siamo nel business dei web framework, non dei web server).

(To serve the site on a different port, see the [`runserver`](/it/5.2/ref/django-admin/#django-admin-runserver) reference.)

> **Ricaricamento automatico di runserver**
>
> Quando necessario, il server di sviluppo ricarica automaticamente il codice Python per ogni richiesta. Non c’è bisogno di far ripartire il server per applicare le modifiche al codice. Ciò nonostante, alcune azioni quali l’aggiunta di file non causano un riavvio. In questi casi dovrai quindi riavviare il server.

## Creazione dell’applicazione Sondaggi

Ora che il tuo ambiente – un «progetto»  – è impostato, sei pronto per iniziare a lavorare.

Ogni applicazione che scrivi in Django è composta da un pacchetto Python che segue alcune convenzioni. Django fornisce una utility che genera in automatico la struttura di base delle cartelle di una app, così puoi concentrarti sulla scrittura del codice invece che creare le cartelle.

> **Progetti contro applicazioni**
>
> Qual è la differenza tra un progetto ed una app? Una app è una applicazione web che fa qualcosa – per es. un sistema di blog, un database di record pubblici o una piccola app per i sondaggi. Un progetto è una collezione di configurazioni ed app per un particolare sito web. Un progetto può contenere più app. Una app può far parte di più progetti.

Your apps can live anywhere in your [Python path](https://docs.python.org/3/tutorial/modules.html#tut-searchpath). In
this tutorial, we’ll create our poll app inside the `djangotutorial` folder.

Per creare la tua app, sii sicuro di essere nella stessa cartella di `manage.py` e scrivi il seguente commando:

```console
$ python manage.py startapp polls
```

*Windows*

```doscon
...\> py manage.py startapp polls
```

Questo creerà la cartella `polls`, che è strutturata in questo modo:

```text
polls/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py
```

La struttura di questa cartella contiene la nostra applicazione sondaggio.

## Scrivi la tua prima vista

Scriviamo la nostra prima vista. Apri il file `polls/views.py` e scrivi il seguente codice Python:

*`polls/views.py`*

```python
from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world. You're at the polls index.")
```

This is the most basic view possible in Django. To access it in a browser, we
need to map it to a URL - and for this we need to define a URL configuration,
or «URLconf» for short. These URL configurations are defined inside each
Django app, and they are Python files named `urls.py`.

To define a URLconf for the `polls` app, create a file `polls/urls.py`
with the following content:

*`polls/urls.py`*

```python
from django.urls import path

from . import views

urlpatterns = [
    path("", views.index, name="index"),
]
```

Your app directory should now look like:

```text
polls/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    urls.py
    views.py
```

The next step is to configure the root URLconf in the `mysite` project to
include the URLconf defined in `polls.urls`. To do this, add an import for
`django.urls.include` in `mysite/urls.py` and insert an
[`include()`](/it/5.2/ref/urls/#django.urls.include) in the `urlpatterns` list, so you have:

*`mysite/urls.py`*

```python
from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path("polls/", include("polls.urls")),
    path("admin/", admin.site.urls),
]
```

The [`path()`](/it/5.2/ref/urls/#django.urls.path) function expects at least two arguments:
`route` and `view`.
The [`include()`](/it/5.2/ref/urls/#django.urls.include) function allows referencing other URLconfs.
Whenever Django encounters [`include()`](/it/5.2/ref/urls/#django.urls.include), it chops off whatever
part of the URL matched up to that point and sends the remaining string to the
included URLconf for further processing.

L’idea alla base di [`include()`](/it/5.2/ref/urls/#django.urls.include) è di semplificare il plug-and-play delle URL. Poiché i sondaggi si trovano nella propria URLconf (`polls/urls.py`), possono essere posizionati dentro «/polls/», o dentro «/fun\_polls/», o dentro «/content/polls/», o qualsiasi altro percorso e l’app continuerà a funzionare.

> **Quando usare  include()**
>
> You should always use `include()` when you include other URL patterns.
> The only exception is `admin.site.urls`, which is a pre-built URLconf
> provided by Django for the default admin site.

Ora hai collegato una vista `index` nella URLconf. Verifica che funzioni con il seguente comando:

```console
$ python manage.py runserver
```

*Windows*

```doscon
...\> py manage.py runserver
```

Nel tuo browser vai all’indirizzo <http://localhost:8000/polls/> , e dovresti vedere il testo «*Hello, world. You’re at the polls index.*», che hai definito nella view  `index`.

> **Non hai trovato la pagina?**
>
> Se ottieni una pagina di errore, controlla di stare andando su <http://localhost:8000/polls/> e non <http://localhost:8000/>.

Quando sei a tuo agio con il flusso base di richiesta e risposta, leggi [parte 2 di questo tutorial](/it/5.2/intro/tutorial02/)  per iniziare a lavorare con il database.