Con questo articolo vedremo insieme una panoramica molto generale e superficiale della tecnologia, per poi approfondire i singoli moduli in futuri articoli. Nell'introduzione vedremo in particolare come installare il framework e come impostare il nostro progetto per creare una semplice applicazione blog.
Fondamenti di Django
Django si basa sul paradigma MTV Model-Template-View, il quale si discosta leggermente dal più noto MVC Model-View-Controller. Per una spiegazione più approfondita, vi rimando alle fonti citate a fine articolo.
- Model: è il livello del framework che rappresenta i dati, come accedervi, le loro validazioni e le relazioni tra entità differenti. E' una interfaccia che astrae sul contenuto delle tabelle del database della web application.
- Template: è il livello di presentazione, definisce come i dati devono essere mostrati nelle pagine web.
- View: è il livello che contiene la business logic, il ponte tra modello e template. Lo scopo di una view è ricevere richieste HTTP e restituire risposte.
Installazione e uso di virtualenv
Dall'esperienza personale e imparando da diverse guide e blog su internet, è consigliabile creare la propria applicazione web all'interno di un ambiente separato rispetto a quello globale della vostra macchina. Ciò garantisce l'isolamento e la replicabilità dell'applicazione che state creando.
Per Python esiste il tool virtualenv in grado di creare ambienti virtuali a sé stanti. Per l'installazione è sufficiente utilizzare il comando:
pip install virtualenv
Adesso, spostiamoci nella cartella del nostro progetto e creiamo l'ambiente virtuale con il comando:
virtualenv NOME_ENV
Nella cartelle del progetto vedrete creata una nuova cartella col nome NOME_ENV. Al suo interno troverete tutto il necessario per avviare l'ambiente di sviluppo virtuale.
Se avete installato differenti versioni di Python sulla vostra macchina e volete specificare quale usare per l'ambiente virtuale, vi basterà aggiungere al comando la seguente specifica:
virtualenv -p /usr/bin/python2.7 NOME_ENV
Per attivare l'ambiente virtuale, spostatevi nella cartella /NOME_ENV/bin/ e digitate il comando:
source ./activate
noterete nella vostra shell il nome dell'ambiente virtuale scritto tra parentesi accanto al vostro nome utente.
Quando vorrete poi chiudere l'ambiente virtuale, usate analogamente il comando deactivate.
Isolamento
Il gestore di ambienti virtuali virtualenv è utilizzato principalmente per creare un ambiente di sviluppo separato, in cui installare solo ed esclusivamente le librerie e i moduli necessari alla vostra applicazione, nelle versioni richieste.
Per fare ciò, è consigliabile creare un file di testo con l'elenco delle librerie richieste. Tale file generalmente è chiamato requirements.txt ma non si tratta di un nome obbligatorio per virtualenv.
Per ora, l'unica libreria che ci serve è proprio Django, nella sua ultima versione, che al momento della redazione dell'articolo è la 1.10.6.
Creiamo perciò il file requirements.txt ed incolliamoci dentro la seguente riga:
'Django==1.10.6'
Digitiamo adesso il comando
pip install -U -r requirements.txt
Così facendo avremo installato tutti i moduli elencati nel file requirements.txt - in questo caso, solo Django.
Scaffolding
Ora che abbiamo installato Django, passiamo alla creazione delle fondamenta della nostra applicazione web. Il framework mette a disposizione una serie di comandi per la creazione automatica della struttura base della nostra applicazione.
Spostiamoci nella cartella del progetto e digitiamo da linea di comando:
django-admin.py startproject usualblog .
All'interno della cartella appena creata troverete i seguenti file:
manage.py: contiene l'interfaccia per utilizzare i comandi messi a disposizione da Django per gestire il vostro sito. Punta automaticamente al progetto in questione e alle sue impostazioni.settings.py: contiene tutte le configurazioni per il vostro sito. Nel seguito vedremo alcune delle sue entry. Il contenuto completo sarà analizzato in un prossimo articolourls.py: contiene le URL alle viste del sito.wsgi.py: (Web Server Gateway Interface) contiene le configurazioni per i deploy dell'applicazione.
Model - Template - View
Ora che abbiamo creato la cartella principale del progetto, procediamo alla creazione della app.
Come detto all'inizio dell'articolo, ipotizziamo di creare un semplice blog. Procediamo quindi alla costruzione di tutto il necessario per gestire gli articoli.
Digitando il comando:
python ./manage.py startapp posts
sarà automaticamente creata una cartella posts contenente i seguenti file:
models.py: contiene la definizione del modello per la app.views.py: contiene la definizione della vista.tests.py: contiene i test per la app.
Model
Come la maggior parte dei framework per la creazione di web application, anche Django utilizza la tecnica ORM, Object-relational mapping, per interfacciare la programmazione orientata agli oggetti con la gestione dei database. Tutto si basa sul fatto che esista una relazione uno-a-uno tra le classi Python definite all'interno dei modelli e le tabelle create nel database al quale si collega l'applicazione.
Sarà perciò necessario definire una classe modello per gli articoli (post) all'interno del file posts/models.py ed una tabella posts nel database.
|
1 2 3 4 5 6 7 8 9 10 |
from __future__ import unicode_literals from django.db import models class Post(models.Model): title = models.CharField( max_length=255, ) text = models.TextField() |
Il modulo models di Django fornisce una serie di classi e oggetti costruiti per gestire le differenti tipologie di attributi definiti per il modello studiato. Per il nostro esempio sui post, ipotizziamo per ora di voler aggiungere assegnare ad ogni post un titolo ed un testo. Il titolo sarà in generale una stringa di testo di lunghezza relativamente inferiore rispetto al corpo del post. Per questo motivo si utilizza la classe di utility CharField del modulo models.py, impostando una lunghezza massima fissa. Viceversa, per il corpo del post è utilizzata la classe di utility TextField, più adatta a gestire testi lunghi.
Le classi di utilità di models.py contengono già una serie di vincoli di integrità dipendenti dal tipo di dato che deve essere salvato per quell'attributo: per esempio, se dobbiamo salvare una e-mail come attributo di un modello, possiamo utilizzare la classe EmailField, per la quale è già definito il controllo sulla validità come indirizzo di posta elettronica per la stringa inserita.
Configurazione Database
Definita la classe modello Post, procediamo alla configurazione del database.
Per semplicità, utilizzeremo il DBMS SQLite che ci permette di creare il database come fosse un solo file all'interno della nostra applicazione. Per progetti più ampi è ovviamente consigliabile l'utilizzo di DBMS più potenti ed espressivi.
Modifichiamo la entry usualblog/settings.py nel seguente modo:
|
1 2 3 4 5 6 7 8 9 10 |
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': 'usualblog.db', 'USER': '', 'PASSWORD': '', 'HOST': '', 'PORT': '', } } |
Utente, password, indirizzo e porta non sono necessari per questo esempio. Viceversa, se utilizzate un DBMS diverso da SQLite, dovete indicare l'indirizzo e le credenziali di accesso al vostro database.
Sempre all'interno di usualblog/settings.py è necessario modificare la entry INSTALLED_APPS aggiungendo l'applicazione posts creata in precedenza:
|
1 2 3 4 5 6 7 8 9 |
INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'posts', ] |
Per creare effettivamente il nostro nuovo database in SQLite, si utilizza il comando makemigrations di Djago.
python ./manage.py makemigrations
Per rendere effettiva la migrazione creata, digitiamo:
python ./manage.py migrate
Possiamo utilizzare la dbshell di Django per navigare il nostro database
python ./manage.py dbshell
Con i comandi .databases e .tables possiamo verificare il contenuto dei database collegati alla nostra applicazione. Tra le tabelle dovreste trovare posts_post relativa al modello dei Post. Per un elenco completo delle funzioni della dbshell, digitate .help.
Shell di Django
La dbshell non è l'unica shell messa a disposizione da Django. Così come è possibile gestire le istanze dei modelli della nostra applicazione lato database, è possibile gestirle direttamente come oggetti Python grazie alla shell interattiva di Django raggiungibile tramite il comando:
python ./manage.py shell
Se volessimo per esempio avere la lista completa dei post aggiunti alla nostra applicazione basterà importare la classe Post del modulo posts/models.py e utilizzare il metodo objects.all() messo a disposizione dalla classe Model.
Altri metodi utili per la gestione delle istanze sono:
get(): metodo che restituisce quella specifica istanza ricercata; il parametro in ingresso rappresenta le condizioni di query per la ricerca.create(): metodo per creare una nuova istanza passando direttamente gli attributi valorizzati.save(): metodo per creare una nuova istanza utilizzando un oggetto inizializzato.update(): metodo per aggiornare una istanza con i nuovi valori assegnati agli attributi.delete(): metodo per eliminare una istanza dalla tabella.
Tutti i metodi elencati (e gli altri messi a disposizione da Django) sono interfacce delle classiche istruzioni SQL per la gestione dei database.
Nell'immagine sottostante è presentata la creazione di un nuovo post tramite shell interattiva.
In un tutorial successivo vedremo come crearlo in modo più "user friendly" tramite le viste della nostra applicazione.
View e Template
Per chiudere il cerchio di questa breve presentazione a Django, vediamo come creare la nostra prima vista per caricare l'elenco dei post inseriti nel blog. Mostreremo il risultato in un template rappresentato da una semplice pagina html.
All'interno del file posts/views.py definiamo la classe ListPostView nel seguente modo:
|
1 2 3 4 5 6 7 |
from django.views.generic import ListView from posts.models import Post class ListPostView(ListView): model = Post template_name = 'post_list.html' |
La classe ListView di Django definisce i metodi e gli attributi per le viste del tipo "lista". E' ovviamente consigliabile utilizzare le classi View definite in Django come punto di partenza per le proprie viste.
Aggiungiamo al file usualblog/urls.py il seguente codice per far puntare la homepage del nostro sito alla vista appena creata:
|
1 2 3 4 5 |
from django.conf.urls import url from posts.views import ListPostView urlpatterns = [url(r'^$', ListPostView.as_view(), name='posts-list'),] |
Infine, creiamo la cartella templates all'interno di posts e costruiamo il template post_list.html nel seguente modo:
|
1 2 3 4 5 6 |
<h1>Elenco dei Post</h1> <ul> {% for post in object_list %} <li class="post">{{ post.title }} - {{ post.text }}</li> {% endfor %} </ul> |
All'interno della pagina html è iniettato codice Python utilizzando i tag {{ }}.
L'oggettp object_list è definito all'interno della classe ListView dalla quale deriva la vista ListPostView.
Adesso siamo pronti a testare la nostra applicazione. Eseguiamo il comando:
python manage.py runserver
e spostiamoci all'indirizzo locale http://127.0.0.1:8000/.
Il risultato sarà l'elenco dei post presenti nella tabella posts_post del nostro database.
Concludiamo così questa velocissima panoramica del framework Django. Nei prossimi tutorial vedremo in maniera più approfondita:
Potete trovare il codice completo dell'applicazione di esempio che andremo a costruire sul nostro repository github.
Come sempre vi invito a lasciare domande e commenti (e offese, vista la velocità con la quale è stato presentato l'argomento).
Fonti
