# Documentazione Django 6.0.7

# Django a prima vista

Dal momento che Django è stato sviluppato in un ambiente di redazione veloce, è stato progettato per rendere i task più comuni dello sviluppo web veloci e semplici. Ecco un sommario informale di come scrivere una applicazione web database-driven usando Django.

Il fine di questo documento è fornirti abbastanza specifiche tecniche da comprendere come funziona Django ma non vuole essere un tutorial o un manuale – ma abbiamo entrambi! Quando sei pronto ad iniziare un progetto, puoi iniziare con il tutorial o esplorare la documentazione più dettagliata.

## Progetta il tuo modello

Seppure puoi usare Django senza un database, esso viene fornito di un “object-relational mapper’_ nel quale descrivi lo schema del tuo database in codice Python.

La sintassi data-model offre molti ricchi modi di rappresentare i tuoi modelli – finora, ha risolto molti anni di problemi legati agli schemi dei database. Ecco un rapido esempio:

`news/models.py`

    from django.db import models

    class Reporter(models.Model):
        full_name = models.CharField(max_length=70)

        def __str__(self):
            return self.full_name

    class Article(models.Model):
        pub_date = models.DateField()
        headline = models.CharField(max_length=200)
        content = models.TextField()
        reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)

        def __str__(self):
            return self.headline

## Installalo

Passo successivo, utilizza Django da linea di comando per creare le tabelle nel database automaticamente:

/ 

    $ python manage.py makemigrations
    $ python manage.py migrate

    ...\> py manage.py makemigrations
    ...\> py manage.py migrate

Il comando `makemigrations` scorre tutti i modelli disponibili e crea migrazioni per tutte le tabelle che ancora non esistono. `migrate` lancia tutte le migrazioni e crea le tabelle nel tuo database, fornendo allo stesso tempo come opzione un controllo dello schema molto più ricco.

## Prova le API disponibili

With that, you’ve got a free, and rich, Python API to access your data. The API is created on the fly, no code generation necessary:

    # Import the models we created from our "news" app
    >>> from news.models import Article, Reporter

    # No reporters are in the system yet.
    >>> Reporter.objects.all()
    <QuerySet []>

    # Create a new Reporter.
    >>> r = Reporter(full_name="John Smith")

    # Save the object into the database. You have to call save() explicitly.
    >>> r.save()

    # Now it has an ID.
    >>> r.id
    1

    # Now the new reporter is in the database.
    >>> Reporter.objects.all()
    <QuerySet [<Reporter: John Smith>]>

    # Fields are represented as attributes on the Python object.
    >>> r.full_name
    'John Smith'

    # Django provides a rich database lookup API.
    >>> Reporter.objects.get(id=1)
    <Reporter: John Smith>
    >>> Reporter.objects.get(full_name__startswith="John")
    <Reporter: John Smith>
    >>> Reporter.objects.get(full_name__contains="mith")
    <Reporter: John Smith>
    >>> Reporter.objects.get(id=2)
    Traceback (most recent call last):
        ...
    DoesNotExist: Reporter matching query does not exist.

    # Create an article.
    >>> from datetime import date
    >>> a = Article(
    ...     pub_date=date.today(), headline="Django is cool", content="Yeah.", reporter=r
    ... )
    >>> a.save()

    # Now the article is in the database.
    >>> Article.objects.all()
    <QuerySet [<Article: Django is cool>]>

    # Article objects get API access to related Reporter objects.
    >>> r = a.reporter
    >>> r.full_name
    'John Smith'

    # And vice versa: Reporter objects get API access to Article objects.
    >>> r.article_set.all()
    <QuerySet [<Article: Django is cool>]>

    # The API follows relationships as far as you need, performing efficient
    # JOINs for you behind the scenes.
    # This finds all articles by a reporter whose name starts with "John".
    >>> Article.objects.filter(reporter__full_name__startswith="John")
    <QuerySet [<Article: Django is cool>]>

    # Change an object by altering its attributes and calling save().
    >>> r.full_name = "Billy Goat"
    >>> r.save()

    # Delete an object with delete().
    >>> r.delete()

## Un’interfaccia di amministrazione dinamica: non è solo impalcatura – è tutta la casa

Una volta che i modelli sono definiti, Django può creare una automaticamente una interfaccia amministrativa professionale e production-ready – un sito web che permette agli utenti autenticati di aggiungere, cambiare e cancellare oggetti. L’unico step richiesto è quello di registrare il tuo modello nel sito di amministrazione:

`news/models.py`

    from django.db import models

    class Article(models.Model):
        pub_date = models.DateField()
        headline = models.CharField(max_length=200)
        content = models.TextField()
        reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)

`news/admin.py`

    from django.contrib import admin

    from . import models

    admin.site.register(models.Article)

La filosofia qui è che il tuo sito viene modificato da uno staff, un cliente o magari proprio da te – e tu non vuoi dover avere a che fare con la creazione dell’interfaccia di backend solo per gestire il contenuto.

Un classico modus operandi nella creazione delle app Django è creare i modelli e avere il pannello di amministratore online il prima possibile, in modo che lo staff o i clienti possano iniziare a inserire i dati. Dopo di che è possibile iniziare a sviluppare come presentare quei dati agli utenti.

## Progetta le tue URL

Uno schema di URL pulito ed elegante è un dettaglio importante in una applicazione web di qualità elevata. Django incoraggia un design delle URL gradevole e non aggiunge parti non necessarie come `.php` o `.asp`.

Per pianificare le URL di un app, crea un modulo Python chiamato a URLconf. Una tabella di contenuti della tua app, contiene una corrispondenza tra il pattern URL e le funzioni di callback Python. URLconfs è utile anche per disaccoppiare le URL dal codice Python.

Ecco come dovrebbe essere un URLconf per l’esempio precedente `Reporter`/`Article`:

`news/urls.py`

    from django.urls import path

    from . import views

    urlpatterns = [
        path("articles/<int:year>/", views.year_archive),
        path("articles/<int:year>/<int:month>/", views.month_archive),
        path("articles/<int:year>/<int:month>/<int:pk>/", views.article_detail),
    ]

Il codice qui sopra mappa i percorsi URL a funzioni Python («views»). Le stringhe dei percorsi usano dei segnaposto per «catturare» valori dagli URL. Quando un utente visita una pagina, Django scorre tutti i percorsi, nell’ordine in cui sono definiti, e si ferma al primo che corrisponde al percorso richiesto. (Se nessuno di essi corrisponde, Django chiama una view «speciale» con un errore 404.) Questo procedimento è molto veloce, perché i percorsi sono compilati in espressioni regolari al momento del caricamento.

Una volta che c’è corrispondenza con il pattern della URL, Django chiama la view corrispondente, il quale è una funzione Python. A ogni view viene passato un oggetto request - che contiene i metadati della richiesta - e i valori catturati nel pattern URL.

Per esempio, se un utente richiedesse la URL «/articles/2005/05/39323/», Django chiamerebbe la funzione `news.views.article_detail(request, year=2005, month=5, pk=39323)`.

## Scrivi le tue viste

Ogni view è responsabile nel fare una di queste due cose: Ritornare un’istanza della classe `HttpResponse` che contiene il contenuto della pagina richiesta, o lancia un’eccezione come `Http404`. Il resto dipende da te.

Genericamente, una view riceve dati in base ai parametri passati, carica e renderizza il template con i dati ricevuti. Ecco una view di esempio per `year_archive` sopra citata:

`news/views.py`

    from django.shortcuts import render

    from .models import Article

    def year_archive(request, year):
        a_list = Article.objects.filter(pub_date__year=year)
        context = {"year": year, "article_list": a_list}
        return render(request, "news/year_archive.html", context)

Questo esempio usa Django’s template system, il quale ha una serie di potenti caratteristiche, ma prova a rimanere abbastanza semplice per un uso per i non-programmatori.

## Progetta i tuoi template

Il codice precedente carica il template `news/year_archive.html`.

Django ha un percorso di ricerca dei template, il quale ti permette di ridurre la ridondanza nei vari template. Nella tua configurazione di Django, specifica una lista di cartelle da controllare tramite la configurazione :setting:`DIRS per la ricerca dei template. Se un template non esiste nella prima cartella, controlla la seconda e così via.

Diciamo che `news/year_archive.html` sia stato trovato. Ecco come potrebbe essere:

`news/templates/news/year_archive.html`

    {% extends "base.html" %}

    {% block title %}Articles for {{ year }}{% endblock %}

    {% block content %}
    <h1>Articles for {{ year }}</h1>

    {% for article in article_list %}
        <p>{{ article.headline }}</p>
        <p>By {{ article.reporter.full_name }}</p>
        <p>Published {{ article.pub_date|date:"F j, Y" }}</p>
    {% endfor %}
    {% endblock %}

Le variabili sono delimitate da doppie parentesi graffe. `{{ article.headline }}` significa «Mostra il valore dell’attributo headline dell’articolo.» Ma i punti non sono usati sono per accedere a un attributo. Possono essere usati anche per accedere a una chiave di un dizionario, un indice o una chiamata a una funzione.

Nota che `{{ article.pub_date|date:"F j, Y" }}` usa una «pipe» (il carattere «|») in stile Unix . Questo è un filtro del template ed è un modo per filtrare il valore di una variabile. In questo caso, il filtro data formatta un oggetto Python di tipo datetime nel formato dato (come si trova nella funzione data di PHP).

Puoi concatenare tutti i filtri che desideri. Puoi scrivere filtri di template personalizzati. Puoi scrivere tag di template personalizzati, che eseguono codice Python personalizzato dietro le quinte.

Infine, Django usa il concetto di «template inheritance». Questo è ciò che fa `{% extends "base.html" %}`. Significa «Prima carica il template chiamato “base”, nel quale sono definiti un mucchio di blocchi, e riempi i blocchi con quelli seguenti.» In breve, questo permette di ridurre drasticamente la ridondanza nei template: ogni template deve definire solo ciò che è unico per quel template.

Ecco come dovrebbe essere il template «base.html», compreso l’uso di: static files:

`templates/base.html`

    {% load static %}
    <html lang="en">
    <head>
        <title>{% block title %}{% endblock %}</title>
    </head>
    <body>
        <img src="{% static 'images/sitelogo.png' %}" alt="Logo">
        {% block content %}{% endblock %}
    </body>
    </html>

Semplicemente, definisce la grafica generale del sito (con il logo), e fornisce dei «buchi» da riempire da parte dei template figli. Questo significa che il sito può essere ridisegnato modificando un unico file – il template di base.

Ti permette anche di creare versione multiple del sito, con template di base differenti mentre riutilizzi i template figlio. I creatori di Django hanno utilizzato questa tecnica per creare versioni per dispositivi mobile soprendentemente diversi giusto creando un nuovo base template.

Non sei costretto ad utilizzare il linguaggio di template di Django se ne preferisci un altro. Anche se il linguaggio di template di Django è particolarmente ben integrato con i modelli di Django, nessuno ti obbliga ad utilizzarlo. A questo proposito, non sei obbligato ad utilizzare nemmeno il Django database API. Puoi utilizzare qualsiasi livello di astrazione per i database, puoi leggere file XML, puoi leggere file sul disco, o qualsiasi cosa tu voglia. Qualsiasi pezzo di Django (models, views, templates) lavorano indipendentemente dagli altri pezzi.

## Questa è solo la superficie

Questa è stata solo una breve panoramica sulle funzionalità di Django. Maggiori funzionalità :

- Un framework per la cache che si integra con memcached o altri backend.

- Un framework per la syndication che ti permette di creare feed RSS e Atom scrivendo una piccola classe Python.

- Più attraenti funzionalità di amministrazione generate automaticamente – questa panoramica ha appena scalfito la superficie.

I prossimi passi per te sono scaricare Django, leggere the tutorial e unirti alla` comunità`_. Grazie per il tuo interesse!