Sviluppo web in Django con Python

Django è un framework per lo sviluppo web gratuito, open-source e di alto livello, ampiamente utilizzato. Offre molte funzionalità agli sviluppatori "pronte all'uso", così lo sviluppo può essere rapido. Allo stesso tempo, i siti realizzati con Django sono sicuri, scalabili e manutenibili.

Obiettivo

L'obiettivo di questo tutorial è creare un'applicazione blog in cui i contenuti possano essere creati e aggiornati tramite un pannello di amministrazione. I contenuti del blog vengono mostrati nella pagina e possono essere eliminati se necessario. L'applicazione nel suo complesso fornisce funzionalità CRUD (Create, Read, Update, Delete).

Questo tutorial non usa tecnologie FrontEnd come JavaScript, CSS, ecc., ma si concentra sui concetti di base, essenziali in ogni sviluppo web con Django.

Configurazione richiesta

1. Git Bash: Può essere usato su tutti i sistemi operativi. Tutti i comandi relativi a Django e quelli Unix vengono eseguiti qui. Per scaricare Git Bash: Clicca qui.
2. Editor di testo: Puoi usare qualsiasi editor, come Sublime Text o Visual Studio Code. Per questo progetto, viene usato Sublime Text.
3. Python 3: Puoi scaricare l'ultima versione di Python da Download Python.

Nota: Seguire questo tutorial è semplice se conosci le basi di Python e sai cosa sono cicli, funzioni, classi, ecc., e hai un po' di dimestichezza con bash o la riga di comando.

Ambiente virtuale

Un ambiente virtuale gestisce le dipendenze dei progetti in Python. Funziona come un contenitore autonomo o un ambiente isolato in cui sono installati tutti i pacchetti Python e le versioni richieste per uno specifico progetto. Poiché escono nuove versioni di Python, Django o altri pacchetti, grazie a un ambiente virtuale puoi lavorare con versioni precedenti specifiche del tuo progetto. In sintesi, puoi avviare un progetto indipendente con Django versione 2.0, mentre su lo stesso computer puoi iniziarne un altro indipendente con Django versione 3.0.

Nota: Esistono molti modi per creare un ambiente virtuale, ma qui ne mostriamo uno solo.

Passaggi per creare un ambiente virtuale

1. Puoi creare una nuova directory chiamata 'project-blog' usando il comando 'mkdir' sul Desktop.

2. Cambia directory in 'project-blog' usando il comando 'cd'.
   

3. L'ambiente virtuale si crea usando 'python -m venv env', dove env è il nostro ambiente virtuale, visibile con il comando 'ls'.
   

4. Per attivare l'ambiente virtuale: L'ambiente virtuale si attiva usando il comando 'source', abilitando la cartella 'Scripts'.
   
   Se hai attivato correttamente l'ambiente, vedrai 'env' tra parentesi.
   
   

5. Installare Django: Puoi usare 'pip install django' per installare Django nel tuo ambiente virtuale.
   

Nota: Gli utenti Linux e Mac devono usare specificamente 'python3' nel comando perché la versione 2 di Python è già preinstallata sul computer. Inoltre, è preferibile usare la versione 3, dato che Python non supporta più la versione 2 dal 2020.

Creare un progetto Django

1. Il primo passo è creare il progetto usando il comando 'django-admin startproject project_name', dove 'project_name' nel tuo caso è 'django_blog'. Inoltre, verranno generati molti file all'interno del nuovo progetto: puoi approfondirli nella documentazione di Django se necessario.
   
2. Cambia directory nel progetto appena creato usando 'cd' e visualizza i file creati con 'ls'.
   
3. Puoi avviare il progetto con 'python manage.py runserver'.
   
4. Visualizza il progetto nel tuo browser preferito (Google Chrome, Mozilla Firefox, ecc.). Vai nel browser e digita 'localhost:8000' o '127.0.0.1:8000' nella barra degli indirizzi, come mostrato sotto.
   
   Nota: Per vedere la stessa pagina mostrata qui sopra, il server nel bash deve essere in esecuzione in background. Puoi fermarlo manualmente quando vuoi con 'Ctr+C' su Windows/Linux e 'Cmd+C' su Mac.

Avviare il nuovo progetto Django

Per creare un nuovo progetto in Django, il processo è sempre in due passaggi, come mostrato sotto.

1. Per prima cosa crea un'app usando il comando 'python manage.py startapp app_name', dove app_name nel tuo caso è 'blog'. In Django un singolo progetto può avere molte app, e ogni app fornisce una singola funzionalità specifica al progetto.
   
2. Il secondo passo è far sapere al progetto della nuova app creando una modifica alla sezione INSTALLED_APP in 'django_blog/settings.py'.
   

Modifiche ai nostri Model

Django usa 'SQLite' come database predefinito: è leggero e adatto a progetti piccoli, quindi va bene per questo tutorial. Usa un 'Object Relational Mapper (ORM)' che rende molto semplice lavorare con il database. Non scrivi il codice SQL direttamente: le tabelle vengono create con l'aiuto della parola chiave 'class' in 'models.py'.

Dentro 'blog/models.py' devi creare un nuovo model chiamato 'Post'. È una classe che diventerà poi una tabella nel database, e al momento eredita da 'models.Model'. Come in un blog standard, un certo 'Post' contiene un titolo, che sarà un campo CharField. È una colonna testuale e accetta l'argomento obbligatorio 'max_length', che nel tuo caso è 50. C'è anche un altro campo chiamato 'content', di tipo TextField, che contiene il testo dettagliato del 'Post', come in un blog standard. È definito il metodo con doppio underscore ('str') che sovrascrive il campo 'title' e restituisce il valore effettivo di 'title' invece di un oggetto.

Creare le migrazioni

'python manage.py makemigrations' è il primo passo: legge 'models.py' dopo la sua creazione. Crea una nuova cartella chiamata 'migrations' in cui c'è un file '0001_initial.py', portabile tra database.

Applicare le migrazioni al database

Questo è il secondo passo, in cui 'python manage.py migrate' legge la cartella 'migrations' appena creata e crea il database; inoltre, lo aggiorna quando c'è un cambiamento nel model.

Registrare nel pannello di amministrazione

Vai su 'blog/admin.py' e importa il model chiamato 'Post' usando 'from .models import Post'. Per registrare i model nell'admin, usa il comando 'admin.site.register(Post)'.

Creare un SuperUser e visualizzare nel pannello di amministrazione

Devi creare un SuperUser prima di accedere al pannello 'admin'. Per farlo, usa 'winpty python manage.py createsuperuser'.

Nota: winpty è un comando specifico di bash usato per comunicare con i programmi della console di Windows.

Esegui il server in background in bash con il comando python manage.py runserver. Vai nel browser e digita quanto segue nella barra degli indirizzi.

Compila poi i tuoi dati, cioè nome utente e password creati in precedenza:

Visualizza quindi il pannello admin con il nostro model 'Post' appena creato.

Modifica il contenuto del 'Post' facendo clic sul pulsante 'Add'. Compila le informazioni e fai clic su 'Save'.

Modifiche a views e URL

Vai su 'blog/views.py' e applica le modifiche mostrate sotto. Aggiungi la funzione 'blog_list', che accetta la richiesta. Viene eseguita una query che recupera tutti gli oggetti creati con 'Post.objects.all()' e li salva in post. Viene creato un nuovo dizionario 'context' dove l'oggetto può essere passato come chiave e recuperato nel template 'blog-list.html', il tutto restituendo la risposta con render.

Crea un nuovo file chiamato 'urls.py' in 'django_blog/blog' e aggiungi le seguenti modifiche. C'è un import relativo della view 'blog_list' e anche 'urlpatterns', che è un elenco di percorsi a pagine specifiche del sito. Al momento, il b'path contiene la stringa vuota e il nome della view.

Spostati su 'django_blog/urls.py', importa include e modifica 'urlpatterns'. Poi aggiungi il percorso agli URL della tua app tramite include. Inoltre, quando gli utenti vanno su 'posts/', vengono indirizzati ai nostri 'blog.urls'.

Creare e modificare i template

Creiamo una cartella templates, che in genere contiene i file 'HTML' e usa un proprio linguaggio di templating chiamato 'Jinja2'. La cartella deve chiamarsi 'templates/blog/blog_list.html', secondo la convenzione.

Qui sotto vedi la sintassi relativa all''HyperText Markup Language (HTML), con 'h1' per il titolo grande e una lista non ordinata (ul) con elementi li. Inoltre, è usata la sintassi del ciclo 'for' relativa a 'Jinja 2', dove l'oggetto 'blog_list' passato come chiave da 'blog/views.py' viene iterato con ciascun elemento chiamato 'list'.

Visualizza il 'title' chiamato 'First Post' nella pagina web.

Aggiungiamo un'altra informazione dal pannello admin come sopra e chiamiamo il titolo del secondo post title 'Second Post'.

Dopo aver aggiunto l'informazione e ricaricato la homepage, i dati verranno aggiornati.

Dettagli per ogni singolo post

Creerai una pagina per ogni post che contenga il titolo e il suo contenuto. L'URL sarà "localhost:8000/posts/'id'", dove id indica il numero univoco o la chiave primaria associata a ciascun 'Post', assegnata da Django.
Creiamo una funzione 'blog_detail' in 'blog/view.py' , che accetta id come parametro. Viene inoltre eseguita una query per ottenere solo lo specifico id e salvarlo in 'each_post'. Come sopra, le informazioni necessarie vengono passate come context a 'blog_detail.html'.

L'URL in 'blog/urls.py' è modificato: il path contiene '<id>', che accetta l'id univoco in forma intera. Supponiamo che l'utente arrivi su 'posts/' e veda tutti i post; se va su 'posts/1', vede solo le informazioni relative al primo post creato.

Creiamo un nuovo file, 'blog/blog_detail.html', e apportiamo le seguenti modifiche. Poiché blog_detail è passato come context, 'title' e 'content' sono accessibili con la notazione a punti.

Vai all'URL nel tuo browser e digita quanto sopra per ottenere i singoli post. Poiché l'id per la prima informazione creata è '1', la seconda sarà '2' e così via per le nuove informazioni.

Eliminare il post

Definiamo blog_delete, che accetta la richiesta e l'id. Viene anche eseguita una query in cui 'Post.objects.get(id=id)' ottiene l'oggetto con id univoco e lo salva in each_post. Subito dopo viene chiamato 'each_post.delete()' per eliminare il 'Post'. Infine si importa HttpResponseRedirect dal modulo 'django.http' per reindirizzare la pagina a '/posts/'.

. In 'urls.py' importa 'blog_delete' e imposta il path su '<id>/delete', dove l'id seguito da delete alla fine rimuoverà quell'oggetto o informazione specifica.

Eliminiamo il nostro post digitando quanto segue in 'urls.py'.

Infine, la pagina viene reindirizzata a '/posts' quando viene chiamato 'posts/1/delete/', considerando che in homepage esiste un solo post.

Conclusione

Congratulazioni per aver terminato il tutorial! Hai imparato le basi dello sviluppo web con Django e la funzionalità CRUD. Per maggiori dettagli su un argomento specifico, vai alla documentazione di Django.

Riferimenti:

• Just Django
• Introduzione a Django su Mozilla