Tutorial Django: inizia con Django 2.0

Django è un framework web Python unico per tutti che è stato ispirato da Ruby on Rails e utilizza molte delle stesse metafore per rendere lo sviluppo web facile e veloce. Completamente caricato e flessibile, Django è diventato uno dei framework web più utilizzati di Python.

Django include praticamente tutto ciò di cui hai bisogno per creare un'applicazione web di qualsiasi dimensione e la sua popolarità rende facile trovare esempi e aiuto per vari scenari. Inoltre Django fornisce strumenti per consentire alla tua applicazione di evolversi e aggiungere funzionalità con garbo e per migrare il suo schema di dati (se ne ha uno).

Django ha anche la reputazione di essere complesso, con molti componenti e una buona dose di configurazione "sotto il cofano" richiesta. In verità, puoi far funzionare una semplice app in un ordine relativamente breve, quindi espandere le sue funzionalità da lì secondo necessità.

In questa guida illustreremo la creazione di un'app Django 2.0 rudimentale e toccheremo brevemente le funzionalità più importanti che fornisce agli sviluppatori web.

Aggiornamento da Django 1.x

Se hai esperienza con una precedente edizione 1.x di Django, queste sono le modifiche più importanti di cui essere consapevoli:

  • Django 2.0 supporta solo Python 3.4 e versioni successive. Python 2.x non sarà supportato nelle versioni future di Django.
  • Django 2 segue il modello di Python 3 di utilizzare stringhe Unicode native ove possibile. Alcune funzioni Django non accetteranno più bytestrings come input. 

Ci sono molte altre modifiche incompatibili con le versioni precedenti, ma queste sono due delle più significative, soprattutto quando si iniziano nuovi progetti.

Installazione delle librerie principali di Django

Per installare Django 2.0, avrai bisogno di Python 3.4 o superiore. Quindi il modo più semplice per installare Django è tramite l' piputilità di Python :

pip install django

Questo installa le librerie Django di base e l' django-adminutilità della riga di comando utilizzata per la gestione dei progetti Django.

Se vuoi lavorare con più versioni di Django fianco a fianco, crea un ambiente virtuale, installa lì la versione di Django che desideri e usala per il progetto Django in questione.

Tieni presente che non è necessario utilizzare ambienti virtuali per creare più progetti con una singola istanza di Django. Hai solo bisogno di loro per utilizzare diverse revisioni del punto del framework Django  con progetti diversi.

Creazione di un nuovo progetto Django

Le istanze di Django sono organizzate in due livelli: progetti e app .

  • Un progetto è un'istanza di Django con la propria configurazione di database, impostazioni e app. È meglio pensare a un progetto come a un luogo in cui archiviare tutte le configurazioni a livello di sito che utilizzerai.
  • Un app è una suddivisione di un progetto, con la sua logica percorso e il rendering. È possibile inserire più app in un singolo progetto Django. 

Per creare un nuovo progetto Django da zero, inserisci la directory in cui desideri memorizzare il progetto e digita:

django-admin startproject

dove è il nome sia del progetto che della sottodirectory in cui verrà archiviato il progetto. Assicurati di scegliere un nome che non possa entrare in conflitto con un nome usato internamente da Python o Django. Un nome come myprojfunzionerà perfettamente.

La directory risultante dovrebbe contenere un  manage.pyfile, che viene utilizzato per controllare il comportamento dell'app dalla riga di comando, e un'altra sottodirectory (anche con il nome del progetto) che contiene i seguenti file:

  • Un __init__.pyfile, che viene utilizzato da Python per designare una sottodirectory come modulo di codice.
  • settings.py, che contiene le impostazioni utilizzate per il progetto. Molte delle impostazioni più comuni saranno precompilate per te.
  • urls.py, che elenca le rotte o gli URL disponibili per il tuo progetto Django o per i quali il progetto restituirà risposte.
  • wsgi.py, che viene utilizzato dai server Web compatibili con WSGI, come Apache HTTP o Nginx, per servire le app del progetto.

Prima di ogni altra cosa, prova il progetto per assicurarti che funzioni. Dalla riga di comando nella directory contenente il manage.pyfile del progetto , esegui:

python manage.py runserver

Questo dovrebbe avviare un server web di sviluppo disponibile su //127.0.0.1:8000/. Visita quel link e dovresti vedere una semplice pagina di benvenuto che ti dice che l'installazione è stata eseguita correttamente.

Nota che il server web di sviluppo non dovrebbe essere usato per servire un progetto Django al pubblico. Non scalerà per gestire il traffico necessario.

Creazione di un'app Django

Successivamente dobbiamo creare un'app all'interno di questo progetto. Passa alla stessa directory manage.pye immetti questo comando:

python manage.py startapp myapp

Questo crea una sottodirectory per un'app denominata myapp che contiene quanto segue:

  • Una migrationsdirectory. Contiene il codice utilizzato per migrare il sito tra le versioni del suo schema di dati.
  • admin.py. Contiene gli oggetti utilizzati dagli strumenti di amministrazione incorporati di Django. Se la tua app ha un'interfaccia di amministrazione o utenti privilegiati, dovrai configurare gli oggetti correlati qui.
  • apps.py. Fornisce informazioni di configurazione sull'app al progetto in generale, tramite un AppConfigoggetto.
  • models.py. Contiene oggetti che definiscono le strutture di dati utilizzate dalla tua app per interfacciarsi con i database.
  • tests.py. Contiene eventuali test utilizzati per garantire che le funzioni e i moduli del tuo sito funzionino come previsto.
  • views.py. Contiene funzioni che eseguono il rendering e restituiscono risposte.

Per iniziare a lavorare con l'app, dobbiamo prima registrarla con il progetto. Per fare ciò, modifica myproj/settings.pye aggiungi una riga all'inizio INSTALLED_APPSdell'elenco:

INSTALLED_APPS = [ ‘myapp.apps.MyappConfig’, ‘django.contrib.admin’, ... 

Se guardi dentro myapp.apps, vedrai un oggetto pre-generato denominato MyappConfig, che è ciò a cui ci riferiamo qui.

Aggiunta di percorsi e visualizzazioni alla tua app Django

Le app Django seguono uno schema di base per l'elaborazione delle richieste:

  • Quando viene ricevuta una richiesta in arrivo, Django analizza l'URL per una route a cui applicarla.
  • Le rotte sono definite in urls.py, con ogni rotta collegata a una vista , ovvero una funzione che restituisce i dati da inviare al client. Le viste possono essere posizionate ovunque in un progetto Django, ma sono organizzate al meglio nei propri moduli.
  • Views can contain the results of a template, i.e. code that formats requested data according to a certain design.

To get an idea of how all these pieces fit together, let’s modify the default route of our sample app to return a custom message.

Routes are defined in urls.py in a list named urlpatterns. If you open the sample urls.py, you’ll see urlpatterns already predefined:

urlpatterns = [ path(‘admin/’, admin.site.urls), ] 

The path function—a Django built-in—takes a route and a view function as arguments and generates a reference to a URL path. By default, Django creates an admin path that is used for site administration, but we need to create our own routes.

Add another entry, so that the whole file looks like:

from django.contrib import admin from django.urls import include, path urlpatterns = [ path(‘admin/’, admin.site.urls), path(‘myapp/’, include(‘myapp.urls’)) ] 

The include function tells Django to look for more route pattern information in the file myapp.urls. All of the routes found in that file will be attached to the top-level route myapp (e.g., //127.0.0.1:8080/myapp).

Next, create a new urls.py in myapp and add the following:

from django.urls import path from . import views urlpatterns = [ path(‘’, views.index) ] 

Django prepends a slash to the beginning of each URL, so to specify the root of the site (/), we just supply a blank string as the URL.

Now edit the file myapp/views.py so it looks like this:

from django.http import HttpResponse def index(request): return HttpResponse(“Hello, world!”) 

django.http.HttpResponse is a Django built-in that generates an HTTP response from a supplied string. Note that request, which contains the information for an incoming HTTP request, must be passed as the first parameter to a view function.

Stop and restart the development server, and navigate to //127.0.0.1:8000/myapp/. You should see Hello, world! appear in the browser.

Adding routes with variables in Django

Django can accept routes that incorporate variables as part of their syntax. Let’s say you wanted to accept URLs that had the format year/. You could accomplish that by adding the following entry to urlpatterns:

path(‘year/’, views.year) 

The view function views.year would then be invoked through routes like year/1996, year/2010, and so on, with the variable year passed as a parameter to views.year.

To try this out for yourself, add the above urlpatterns entry to myapp/urls.py, then add this function to myapp/views.py:

def year(request, year): return HttpResponse(‘Year: {}’.format(year)) 

If you navigate to /myapp/year/2010 on your site, you should see Year: 2010 displayed in response. Note that routes like /myapp/year/rutabaga will yield an error, because the int: constraint on the variable year allows only an integer in that position. Many other formatting options are available for routes.

Earlier versions of Django had a more complex and difficult-to-parse syntax for routes. If you still need to add routes using the old syntax—for instance, for backward compatibility with an old Django project—you can do so by using the django.urls.re_path function.

Django templates

Django’s built-in template language can be used to generate web pages from data.

Templates used by Django apps are stored in a directory that is central to the project: /templates//. For our myapp project, the directory would be myapp/templates/myapp/. This directory structure may seem a little awkward, but Django can look for templates in multiple places, so this avoids name collisions between templates with the same names across multiple apps.

In your myapp/templates/myapp/ directory, create a file named year.html with the following content:

Year: {{year}} 

Any value within double curly braces in a template is treated as a variable. Everything else is treated literally.

Modify myapp/views.py to look like this:

from django.shortcuts import render from django.http import HttpResponse def index(request): return HttpResponse(“Hello, world!”) def year(request, year): data = {’year’:year} return render(request, ‘myapp/year.html’, data) 

The render function, a Django “shortcut” (a combination of multiple built-ins for convenience), takes the existing request object, looks for the template myapp/year.html in the list of available template locations, and passes the dictionary data to it as context for the template.

The amount of processing you can perform on data within Django templates is intentionally quite limited. Django’s philosophy is to enforce separation of presentation and business logic whenever possible. Thus you can loop through an iterable object, and you can perform if/then/else tests, but modifying the data within a template is frowned upon.

For instance, a simple “if” test can be encoded this way:

{% if year > 2000 %} 21st century year: {{year}} {% else %} Pre-21st century year: {{year}} {% endif %} 

The {% and %} markers delimit blocks of code that can be executed in Django’s template language.

If you want to use a more sophisticated template processing language, you can swap in others, such as Jinja2 or Mako. Django includes back-end integration for Jinja2, but any template language that returns a string can be used—for instance, by returning that string in a HttpResponse object as in the case of our ”Hello, world!” route.

Next steps with Django

What we’ve seen here covers only the most basic elements of a Django application. Django includes a great many other components that can be employed in a web project. All of these are worth discussing in detail separately, but I will leave you with a brief overview:

  • Databases and data models. Django’s built-in ORM can be used to define data structures and relationships between them for your app, as well as migration paths between versions of those structures.

  • Moduli . Django fornisce un modo coerente alle viste per fornire moduli di input a un utente, recuperare dati, normalizzare i risultati e fornire rapporti di errore coerenti.

  • Sicurezza e utilità . Django include molte funzioni integrate per la memorizzazione nella cache, la registrazione, la gestione delle sessioni, la gestione dei file statici e la normalizzazione degli URL. Comprende anche strumenti per esigenze di sicurezza comuni come l'utilizzo di certificati crittografici o la protezione contro la contraffazione tra siti o il clickjacking.