Django è un potente framework web open-source basato su Python che semplifica il processo di creazione e gestione di siti e app web. Le applicazioni Django sono scalabili, ad alte prestazioni e sicure. Viene inoltre fornito con un'ottima documentazione su ogni singola parte del framework.
Nella nostra serie su Django, abbiamo esplorato Django implementando un sito web di esempio con funzionalità di blogging di base. In questa guida, vedremo i passaggi per creare una vista di esempio per la nostra app Django.
Prerequisiti
Per seguire questa guida, avrai bisogno dei seguenti componenti.
- Un server Ubuntu con configurazioni appropriate. Scopri di più su come configurare un server Ubuntu.
- Un ambiente di sviluppo Python configurato correttamente.
- Un database server, ad esempio, MySQL. Questa guida approfondisce l'installazione e la configurazione di MySQL su un server Ubuntu.
Questa guida è la continuazione della nostra serie su Django. Innanzitutto, sarà utile consultare le guide precedenti su come configurare Django, stabilire la connessione al database di Django, creare modelli, e abilitare l'interfaccia di amministrazione di Django.
In questa guida, mostreremo come creare viste Django che consentiranno all'app web di gestire correttamente le richieste web e restituire la risposta appropriata. Come descritto dalla documentazione ufficiale di Django, una risposta web può essere il contenuto HTML di una pagina web, un reindirizzamento o un errore HTTP. Non esiste un luogo fisso in cui memorizzare le funzioni di vista, purché si trovino all'interno dei percorsi Python. Tuttavia, esistono convenzioni popolari per la denominazione e il posizionamento dei file. Questa guida seguirà tali convenzioni.
Passo 1. Attivazione dell'ambiente virtuale
Django funziona al meglio all'interno di un ambiente virtuale Python. La nostra app Django sample_app è stabilita all'interno di un ambiente virtuale dedicato. Per prima cosa, attiva l'ambiente virtuale:
|
1 2 3 |
cd sample_app/ . sample_app_env/bin/activate |
Passo 2. Creazione delle funzioni di vista
Naviga nella nostra directory random_app che ospita i modelli per il nostro sito web di blog:
|
1 |
cd random_app/ |
Qui, il file views.py conterrà i codici necessari per creare le nostre viste. Aprilo in un editor di testo:
|
1 |
nano views.py |
Abbiamo bisogno della funzione render() della libreria django.shortcuts quindi la prima riga rimane la stessa. La funzione render() function aiuta a combinare sia un template che un contesto da restituire come oggetto HttpResponse appropriato.
La prima vista accoglierà gli utenti che arrivano sulla pagina index. Dovremo importare la funzione HttpResponse() dalla libreria Django http:
|
1 2 3 4 5 6 7 8 |
from django.shortcuts import render from django.http import HttpResponse def index(request): return HttpResponse(Sei arrivato sulla pagina di benvenuto') def individual_post(request): return HttpResponse('I singoli post will appariranno qui') |
Salva il file e chiudi l'editor.
Passo 3. Mappatura degli URL alle viste
Al momento, non c'è alcun URL designato per queste funzioni, quindi sono inaccessibili. Dobbiamo aggiungere un altro blocco urlpatterns all'interno del file di configurazione degli URL. In Python, viene chiamato file URLconf (configurazione URL).
Django deve determinare il modulo root URLconf da utilizzare. Successivamente, cercherà in urlpatterns che contiene tutti i pattern URL in una struttura a lista. Django quindi scorre il file finché non trova la prima corrispondenza. Una volta trovata, Django cercherà la vista associata. Questa funzione di vista riceverà i dati relativi al pattern URL e un oggetto HttpRequest . Un errore in qualsiasi punto di questo processo lo reindirizzerà a una vista di gestione degli errori.
Apri il file urls.py di random_app in un editor di testo:
|
1 |
nano urls.py |
Inserisci il seguente codice:
|
1 2 3 4 5 6 7 |
from django.urls import path from . import views urlpatterns = [ path('', views.index, name='index'), path('post/', views.individual_post, name='individual_post') ] |
Salva il file e chiudi l'editor.
Una volta fatto, dovremo anche includere il percorso del file URL sotto sample_app della directory URLconf. Altrimenti, la nostra app Django non lo riconoscerà. Questo perché il URLconf di sample_app è impostato come ROOT_URLCONF nel file delle impostazioni.
Naviga nella directory della nostra app sample_app:
|
1 |
cd sample_app/sample_app/sample_app/ |
Apri il file urls.py in un editor di testo:
|
1 |
nano urls.py |
Inserisci il seguente codice nel file:
|
1 2 3 4 5 6 7 |
from django.contrib import admin from django.urls import include, path urlpatterns = [ path('admin/', admin.site.urls), path('', include('random_app.urls')) ] |
Testiamo le nostre modifiche. Avvia il server dell'app Django su localhost:8000:
|
1 |
python manage.py runserver localhost:8000 |
Naviga all'URL:
|
1 |
localhost:8000 |
Controlla l'URL per il post:
|
1 |
localhost:8000/posts |
Passo 4. Creazione di un post del blog
Abbiamo stabilito i nostri pattern URL e analizzato i loro flussi di lavoro. È il momento di aggiungere un blog di esempio e vedere il risultato.
Dal pannello di amministrazione, naviga alla random_app pagina:
|
1 |
localhost:8000/admin/random_app/ |
Clicca sul link +Aggiungi dalla riga Posts :
Nella nuova pagina web, verrà presentato un modulo composto dai seguenti campi.
- Titolo: Il titolo del post del blog.
- Slug: Si riferisce alla parte dell'indirizzo web valido con parole chiave leggibili dall'uomo. Generalmente, gli slug vengono creati a partire dal titolo del post.
- Contenuto: Il corpo del post del blog.
- Autore: Il relativo nome utente.
Clicca su SALVA per inviare il post:
Passo 5. Visualizzazione dei dati nel database
Nella prossima sezione, lavoreremo con il nostro database. Accedi a MySQL come utente dedicato a Django:
|
1 |
mysql -u sample_app_user -p |
Verifichiamo se il nostro post è stato registrato con successo nel database:
|
1 |
USE sample_app_data; |
|
1 |
SELECT * FROM random_app_post; |
Voilà! Il post è stato registrato con successo! Ora puoi uscire dalla shell di MySQL.
Passo 6. Ulteriori modifiche alle viste
Ci sono ancora alcune cose che possiamo fare con le nostre viste. Apri il file in un editor di testo:
|
1 |
nano views.py |
Il codice dovrebbe apparire così:
|
1 2 3 4 5 6 7 8 9 10 |
from django.shortcuts import render from django.http import HttpResponse from .models import Post def index(request): return HttpResponse('Hello, welcome to the index page.') def individual_post(request): recent_post = Post.objects.get(id__exact=1) return HttpResponse(recent_post.title + ': ' + recent_post.content) |
Qui abbiamo aggiunto un'istruzione import aggiuntiva per Post. Anche la stringa tra virgolette da HttpResponse viene sostituita con i dati del nostro post del blog. Per fare riferimento ai dati, utilizziamo l'ID del post del blog con l'oggetto associato. L'ID viene memorizzato in una variabile recent_post. Ora possiamo estrarre campi specifici dell'oggetto aggiungendo il campo con un punto come separatore.
Una volta modificato, verifichiamo le modifiche. Avvia il server Django:
|
1 |
python manage.py runserver localhost:8000 |
Ora accedi alla Posts pagina:
|
1 |
localhost:8000/posts |
Dovrebbe mostrare il post del blog che abbiamo creato.
Passo 7. Uscita dal progetto
Per uscire dal server Django, premi Ctrl + C dal terminale. Per disattivare l'ambiente virtuale Python, esegui il seguente comando:
|
1 |
deactivate |
Considerazioni finali
In questa guida, abbiamo dimostrato con successo come creare viste, mappare pattern URL e visualizzare testi su una pagina web dal database di random_app in Django.Questi sono concetti fondamentali di Django che è necessario comprendere e padroneggiare.
Ecco ulteriori risorse per aiutarti a creare e gestire app Django:
- Creare un'app Django con connessione al database: un tutorial
- Creare un'applicazione Django e Gunicorn con Docker su Ubuntu
- Come proteggere e scalare un'applicazione Django con Docker, Nginx e Let’s Encrypt
Buona programmazione!
Commenti
Ancora nessun commento. Scrivi il primo.