Demistificare la magia di Django

Secondo la documentazione ufficiale,

Django è un framework Web Python di alto livello che incoraggia uno sviluppo rapido e un design pulito e pragmatico. Creato da sviluppatori esperti, si occupa di gran parte del problema dello sviluppo Web, così puoi concentrarti sulla scrittura della tua app senza dover reinventare la ruota. È gratuito e open source.

— DjangoProject.com

È uno dei framework popolari di Python per la creazione di applicazioni Web ed è preferito per la sua scalabilità nella creazione di un boilerplate con configurazioni e file stabiliti. Questo conclude l'intero obiettivo di Django per gli sviluppatori;

"...creare un'ottima applicazione in poco tempo e meno preoccupazioni per le impostazioni di base."

Esistono configurazioni di base, file e stili che attraversano tutte le applicazioni Web, indipendentemente da ciò che stai creando. Quando utilizzi Django, questi vengono generati automaticamente quando esegui determinati comandi in diversi punti del ciclo di sviluppo della tua applicazione. Con questo, avrai abbastanza tempo per concentrarti sull'aspetto centrale dello sviluppo della tua applicazione mentre Django gestisce gli altri per te.

Significa che ci sono molte cose che accadono sotto il cofano. Per qualcuno che non ha una piena comprensione delle parti mobili, questo può essere opprimente. In questo articolo impareremo quanto segue:

• Installazione di Django
• I comandi startproject e startapp
• File di configurazione di Django che includono;
• impostazioni.py
• urls.py
• gestire.py
• Disposizione dei modelli
• Instradamento

Impareremo come si adattano tutti insieme e il ruolo che svolgono. È importante sapere che non sarà possibile dare un'occhiata a tutto ciò che accade all'interno di Django. Per i casi al di fuori dell'ambito di questo tutorial, ci saranno collegamenti per indirizzarti a risorse che ti aiuteranno in questo.

A scopo didattico, costruiremo una piattaforma di e-commerce. Questo non è un sito di e-commerce in piena regola, la nostra applicazione avrà solo due funzionalità di base; creare prodotti ed effettuare ordini dalla vista dell'amministratore.

Questo articolo ti guiderà nella comprensione dei comandi, dei file e delle nozioni di base predefiniti di Django. È rivolto agli sviluppatori che hanno utilizzato Django o intendono usarlo e vogliono sapere cosa succede sotto il cofano. Anche se non è obbligatorio aver utilizzato Django, avere esperienza con le basi di Django prima di continuare con questo articolo ti darà un vantaggio. È necessario avere una conoscenza pratica di Python per comprendere appieno ciò che verrà trattato in questo pezzo.

Installazione di Django

Se non hai già installato Django, ecco i passaggi per farlo.

Innanzitutto, crea un ambiente virtuale, chiamato djangodev . Ne hai bisogno per isolare il tuo spazio di lavoro Django e i suoi pacchetti dipendenti.

 python3 -m venv ~/.virtualenvs/djangodev

Ora per entrare nel tuo ambiente virtuale, devi attivarlo;

 source ~/.virtualenvs/djangodev/bin/activate

Se si verifica un errore in esecuzione con source , è possibile utilizzare questo comando alternativo,

 . ~/.virtualenvs/djangodev/bin/activate

Per gli utenti Windows, usa invece questo,

 ...\> %HOMEPATH%\.virtualenvs\djangodev\Scripts\activate.bat

Nota: è necessario attivare l'ambiente virtuale ogni volta che si desidera utilizzare Django.

Ora che sei nel tuo ambiente virtuale, installa Django:

 python -m pip install Django

Per verificare se Django è stato installato correttamente, esegui;

 python -m django --version

Shakaboom! Ora sei pronto per un po' di magia, prepara le bacchette!

Il metodo per creare file e cartelle in movimento potrebbe essere semplice e diretto. Tuttavia, non è l'ideale quando devi creare un progetto medio o grande e una scadenza da rispettare. Abbiamo sempre una scadenza da rispettare, anche per i progetti personali.

Seguendo questo metodo durante la creazione di un nuovo progetto di grandi dimensioni, dovrai creare più file e cartelle ed eseguire più impostazioni, il che potrebbe portare alla creazione di bug evitabili e molto tempo perso. I comandi startproject e startapp a nostra disposizione tramite Django mirano a risolvere questo problema. Questi due comandi creano file, cartelle ed eseguono molte configurazioni per te.

Iniziamo generando una nuova applicazione utilizzando il comando startproject .

Ponteggi Un'applicazione

Genereremo la nostra applicazione e daremo un'occhiata ai file che vengono generati, oltre ai pochi comandi che utilizzeremo. Esegui questo comando nel tuo terminale per iniziare;

 django-admin startproject ecommerce_site

Durante l'installazione di Django, django-admin viene aggiunto al tuo percorso per dargli accesso per eseguire le sue azioni. È l'utilità della riga di comando di Django per le responsabilità amministrative. Ulteriori informazioni sugli usi django-admin qui; è un po' oltre lo scopo di questo articolo.

startproject è un comando Django che aiuta a generare il progetto . Qui gli passiamo il nome del nostro progetto ecommerce_site . Quindi va a creare il progetto in una directory chiamata ecommerce_site . La directory dovrebbe assomigliare a questa,

Dovremo navigare nella directory appena creata ed eseguire il comando per generare l'app .

 cd ecommerce_site python manage.py startapp trading

startapp è un comando eseguito da manage.py nella directory del progetto, crea più file e una cartella denominata utilizzando il nome specificato nel comando, in questo caso ciò che viene specificato è trading . La cartella dell'app è composta da semplici file che dovrebbero essere necessari per creare le funzionalità di un'applicazione. Ora la tua directory dovrebbe apparire così:

Se ti stai chiedendo la differenza tra un progetto e un'app. Un progetto è un'applicazione web Django, può essere costituita da una o più app. È la cartella che manage.py e l'altro modulo che include settings.py e altri file. Un'app è un pacchetto Python che esegue una determinata funzionalità, include file come models.py , la directory di migrazione e altro ancora. Puoi dare un'occhiata a questa risposta su Stack Overflow per ulteriori informazioni.

startproject creerà la directory principale del progetto, mentre startapp creerà la directory dell'app. Ad entrambi è stato anche passato un nome da utilizzare nella generazione. startproject è il primo comando eseguito durante la creazione di un nuovo progetto, mentre startapp viene eseguito all'interno della nuova directory del progetto.

Il layout attuale è un'ottima mappatura che puoi utilizzare per qualsiasi applicazione che stai creando. È scalabile e consiste di file di cui avrai bisogno. C'è la possibilità di creare, rinominare, modificare e spostare file all'interno del progetto.

La configurazione di Django

Django fornisce diverse impostazioni e configurazioni per te, dopo aver eseguito i due comandi in file diversi, esaminiamo i file generati per scoprire cosa fa ciascuno.

settings.py

La maggior parte delle applicazioni web necessita di configurazioni come; autenticazione per verificare utenti, autorizzazioni per consentire a determinati utenti con determinate capacità e impostare standard di sicurezza. Tutti questi sono necessari per offrire ai tuoi utenti la migliore esperienza necessaria. Ci vorrà molto tempo per te come sviluppatore per iniziare a eseguire ciascuno di questi da solo, per ogni applicazione su cui lavori.

Django ti fornisce queste configurazioni necessarie e altro, in modo che tu possa optare per quelle che desideri e collegarle. Queste sono fatte in settings.py , ci sono già impostazioni create per fornirti funzionalità di base.

Quando Django tenta di eseguire un progetto, ci sono alcune variabili che cerca. settings.py è il file che contiene quelle variabili che portano ad altri file o informazioni. Django viene indirizzato a questo file dal file manage.py e prende informazioni o carica altri file a cui è condotto da qui.

Queste configurazioni includono:

• DEBUG
  La funzionalità DEBUG è impostata su True per consentire la lettura degli errori e il debug del codice in fase di sviluppo, dovrebbe essere impostata su False durante la produzione (ovvero durante la distribuzione). Questa impostazione ti consente di eseguire meglio il debug del tuo codice con l'aiuto di Django quando prova a eseguire il tuo codice.
• INSTALLED_APPS
  Questo è un elenco di tutte le app che eseguono una determinata funzionalità in Django. Viene fornito con alcune app predefinite come 'django.contrib.auth' che viene utilizzato per l'autenticazione dell'utente, django.contrib.admin' per la funzionalità di amministrazione e 'django.contrib.messages' necessario per inviare notifiche o informazioni agli utenti. Qualsiasi altra app creata utilizzando il comando startapp dovrà essere qui prima che possa essere eseguita da Django.
• MIDDLEWARE è un framework leggero per l'elaborazione di input e output attraverso richieste e risposte Django. Ogni middleware svolge una funzione specifica con un'app, ad esempio 'django.contrib.auth.middleware.AuthenticationMiddleware' funziona con 'django.contrib.sessions' per associare gli utenti alle richieste. Dovresti controllare ulteriori funzionalità di ciascun middleware nei documenti.
• ROOT_URLCONF è una variabile per un percorso in cui Django cerca i tuoi urlpatterns quando una richiesta viene passata alla tua applicazione Django. Ogni volta che viene effettuata una richiesta in un'applicazione Django, Django ricerca questa variabile e carica il file iniziale e scorre l'elenco di urlpatterns alla ricerca del percorso corrispondente.
• TEMPLATES è un'impostazione per consentire il rendering di file HTML per rappresentare una vista. Comunica con le app di richiesta, autenticazione e messaggi. Il valore 'BACKEND' e 'APP_DIRS' impostati su True consentono a Django di cercare file HTML all'interno della cartella /templates . I 'context_processors' nelle OPTIONS sono callable , che accettano la richiesta come argomento e la uniscono al contesto quando viene eseguito il rendering di un modello, questi callable funzionano per aiutare con il debug, l'autenticazione e la gestione delle richieste in generale.
• WSGI_APPLICATION è un percorso che porta alla variabile application nel file wsgi.py
• DATABASE è un dizionario che contiene l'accesso a un database esterno (o interno come nel caso dello sqlite predefinito) come PostgresSQL, MySQL e MongoDB. Ecco un esempio di un database Postgres che userò per il nostro esempio:

 DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'db_name', 'USER': 'db_user', 'PASSWORD': 'db_password', 'HOST': 'localhost', 'PORT': '', } }

Puoi decidere di utilizzare il database sqlite predefinito, questo non funziona benissimo per la produzione. Puoi impostare un database Postgres come sopra, dovrai prima creare il database e passare l'utente, la password con il permesso di scrittura al database.

Nota : ai fini di questo tutorial puoi già utilizzare il set di database sqlite predefinito. Quanto sopra è una dimostrazione su come impostare la connessione al database SQL e NO-SQL in Django.

• AUTH_PASSWORD_VALIDATORS queste sono funzioni che vengono chiamate per la convalida delle password. Vengono chiamati durante la creazione di record di utenti (e anche amministratori), reimpostazione e modifica delle password. Puoi saperne di più su di loro dalla documentazione ufficiale.

Ulteriori documentazione sulle impostazioni è disponibile qui.

manage.py

La maggior parte dei progetti Web necessita di un punto di ingresso da cui iniziano i comandi. Un punto di ingresso che funge da gateway nell'applicazione. In ogni progetto Django, di solito è il file manage.py .

Questo file è necessario come punto di partenza nell'applicazione. Da qui, tutti i comandi vengono eseguiti e tutto si avvia qui.

manage.py svolge la stessa funzione di django-admin. Dice anche a Django la posizione per le configurazioni che hai nella tua applicazione. Questo è impostato per impostazione predefinita e non deve essere modificato.

Utilizza la funzione def main() per gestire il modulo delle impostazioni predefinite nel nostro file settings.py . Tenta di importare la funzione di esecuzione e, se si verifica un errore, genera ImportError . In caso contrario, prende qualsiasi argomento passato da sys.argv dalla riga di comando ed è eseguito.

sys.argv è un elenco che contiene il comando passato tramite il terminale. Quando eseguiamo python manage.py runserver nella riga di comando, sys.argv viene impostato su ["manage.py", "runserver"] e questo viene passato alla funzione execute() .

Argomenti come python manage.py startapp trading o python manage.py makemigrations sono impostati rispettivamente su [ "manage.py", "startapp", "trading"] e ["manage.py", "makemigrations"] per l'esecuzione.

L'istruzione if è impostata per essere eseguita se il comando fornito è impostato su manage.py .

Oltre a eseguire le funzioni django-admin , lo utilizzerai nel server in esecuzione, gestirai le migrazioni e altri comandi che utilizzerà il tuo progetto. Ne avrai bisogno anche durante la distribuzione, il test e il debug dei tuoi progetti.

Disposizione del modello

Django fornisce un layout di modellazione semplice per te. Configura i tuoi modelli nel file models.py nella directory di trading . Le tue classi (o modelli) sono layout seguiti dalle tabelle del database.

Definisci le tue classi in base ai tipi di dati che desideri ottenere dall'utente (o dall'amministratore) per ogni tabella. I nostri modelli creano un file di migrazione che funziona con la variabile DATABASE in settings.py .

Creiamo due modelli di cui avremo bisogno, per prodotti e ordini:

 from django.db import models class Product(models.Model): name = models.CharField(max_length=50) image = models.ImageField(upload_to='products', default='python.png') price = models.IntegerField() description = models.TextField() def __str__(self): return self.name class Order(models.Model): product = models.ForeignKey(Product, on_delete=models.CASCADE) quantity = models.IntegerField() date = models.DateField(auto_now_add=True) user = models.CharField(max_length=50) def __str__(self): return self.user

Il modello del prodotto ha un nome, un prezzo, una descrizione e un'immagine (che una volta salvata verrà caricata in una cartella products . Viene creata se la cartella non esiste). L' order ha un product (collegato alla tabella products ), la quantità, la data e le colonne utente.

Con queste informazioni, Django crea uno schema di database per l'app. Inoltre, crea un'API di accesso al database Python per accedere agli oggetti Prodotto e Ordine. Django ha uno strumento di migrazione integrato in modo da non dover utilizzare pacchetti esterni per le migrazioni.

Il passaggio successivo consiste nell'eseguire il comando di migrazione e migrare al database. Ma prima di farlo, dobbiamo registrare il trading come app nella nostra directory dei progetti.

Prima di tutto, dobbiamo configurare la directory di trading come app in Django. Django lo ha fatto per te nel file app.py Questo file registra il trading come app e verrà ulteriormente utilizzato nel file settings.py .

Ora, in settings.py aggiungi trading in INSTALLED_APP . Dovrebbe sembrare come questo:

 INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'trading.apps.TradingConf', ]

Sul terminale, esegui:

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

Nota: il tuo ambiente virtuale deve essere attivato e dovresti trovarti all'interno della directory del progetto.

python manage.py makemigrations trading prende nota delle modifiche apportate nel modulo di trading e crea un file nella cartella di migration delle modifiche in models.py e python manage.py migrate quindi aggiorna le modifiche.

Puoi trovare il file di migrazione generato dal comando python manage.py makemigrations trading nella directory di migration denominata 0001_initial.py . Puoi vedere le classi e le colonne come comandi per la creazione all'interno del file. Man mano che vengono apportate più modifiche a models.py , qui verranno generati più file.

Funzionalità di amministrazione

Nella nostra attuale applicazione, avremo bisogno di funzioni di amministrazione per gestire i prodotti e gli ordini che verranno creati nell'applicazione. Django ci fornisce una funzionalità di amministrazione integrata già a nostra disposizione. Anche l'app (funzione) di amministrazione è stata registrata nel nostro elenco INSTALLED_APP ; 'django.contrib.admin' .

Inoltre, l'URL per l'amministratore è stato registrato anche nell'elenco urlpatterns del nostro file di configurazione dell'URL urls.py ; path('admin/', admin.site.urls), . Il file admin.py consente di registrare i modelli e le azioni CRUD da eseguire sui modelli.

Per configurare l'amministratore, esegui questo sul terminale:

 $ python manage.py createsuperuser

Ti verrà chiesto di inserire un nome utente, e-mail e password. Dopodiché, hai creato correttamente un amministratore. Per iniziare con la funzionalità di amministrazione, esegui il server:

 $ python manage.py runserver

La visita di https://127.0.0.1:8000/admin/ porterà a una sessione di accesso, quando accedi (con nome utente e password che hai creato) vieni indirizzato alla dashboard di amministrazione:

I gruppi e gli utenti sono configurazioni predefinite che consentono all'amministratore di accedere alla gestione e alle autorizzazioni degli utenti. Ora registriamo i nostri modelli.

In admin.py , aggiungi le seguenti righe:

 from django.contrib import admin # Register your models here. from .models import Product, Order admin.site.register(Product) admin.site.register(Order)

from django.contrib import admin importa la funzionalità di amministrazione da Django, quindi abbiamo importato le due classi dal nostro models.py e le abbiamo registrate in modo che un amministratore possa eseguire azioni CRUD sui prodotti e ordinare dalla dashboard.

Dopo aver registrato i modelli, la tua dashboard dovrebbe apparire così:

Aggiunta di prodotti:

Effettuare ordini dalla dashboard di amministrazione:

Percorso facile

Ogni sito ha bisogno di route o URL che conducano a pagine specifiche con determinate informazioni per l'utente finale. È possibile accedere a raccolte di informazioni o applicazioni simili in un percorso particolare. È necessario raggruppare i percorsi insieme per l'accessibilità e la comunicazione all'interno dei file. Django lo ha fatto per te nel file urls.py

urls.py è un file che parte dalla variabile ROOT_CONF in settings.py . È qui che viene eseguita la nostra configurazione dell'URL principale. Quando creiamo viste in diversi file o cartelle, o anche nel file urls.py , devono essere configurate nell'elenco urlpatterns .

Django si aspetta un elenco chiamato urlpatterns nel file. Puoi cambiare il file nella variabile ROOT_CONF in qualsiasi altro file che hai inserito nell'elenco urlpatterns .

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

L'elenco è costituito da oggetti che sono istanze di path o re-path . Ogni istanza ha due parametri obbligatori, il pattern 'admin/' e un file di visualizzazione o URL, admin.site.urls .

Le istanze potrebbero anche portare a un altro file con più configurazioni di URL. Questo è fatto per la leggibilità.

views.py

Un'esigenza importante per un'applicazione di back-end sono le viste a cui viene mappato ogni percorso. In Django, scrivi la tua funzione o le viste basate sulla classe per un'app nel file views.py . Una vista è una classe o una funzione che elabora una richiesta e restituisce una risposta all'utente.

Modifica il tuo file views.py in questo modo:

 from django.http import HttpResponse def home(request): return HttpResponse("This is a shopping site for products") def order(request): return HttpResponse("Hello, welcome to our store, browse to our products and order!")

Qui abbiamo importato HTTPResponse per usarlo nella definizione di due viste (viste di funzione) per restituire una frase quando chiamato. def home dovrebbe essere chiamato quando visiti l'indirizzo principale e def order quando accedi all'URL dell'ordine.

Dopo aver creato le nostre viste, dobbiamo assegnarle a diversi percorsi (o urlpatterns ). Ciò può essere fatto in diversi modi, possiamo creare un elenco di urlpatterns nello stesso file, oppure possiamo importare trading.views nel file ecommerce_site.urls e creare il percorso.

Il modo migliore per farlo è creare un file di configurazione dell'URL secondario (all'interno trading ) e includerlo in ecommerce_site.urls . Crea un file urls.py nella directory di trading . La tua directory dovrebbe assomigliare a:

 trading/ __init__.py admin.py apps.py migrations/ __init__.py 0001_initial.py models.py tests.py urls.py views.py

Aggiungi il seguente codice al tuo nuovo file ( urls.py )

 from django.urls import path from . import views urlpatterns = [ path('', views.home, name='home'), path('order/', views.order, name='order'), ]

Registriamo il file di configurazione dell'URL di trading ( urls.py ) nel file di configurazione degli URL del progetto,

 from django.contrib import admin from django.urls import include, path urlpatterns = [ path('admin/', admin.site.urls), path('', include('trading.urls')) ]

Per poter accedere agli urlpatterns useremo la classe include da django.urls nella riga 2. Quindi scegliamo un pattern e alleghiamo il file urls.py nella directory di trading.

Quello che abbiamo fatto qui è stato importare la classe path da django e il file views.py . Quindi il nostro elenco consiste in due istanze di percorso per ciascuna vista. Quindi def home viene chiamato su https://127.0.0.1:8000/.

E def order viene chiamato su https://127.0.0.1:8000/order/.

Nota: il processo di esecuzione di startproject e startapp non è obbligatorio ma altamente incoraggiato da Django. E puoi creare/spostare file e cartelle dopo aver eseguito ogni comando per la tua comodità di lavoro.

Albero delle dipendenze

Ecco il processo in cui Django elabora le richieste dagli URL in arrivo:

1. Django cerca la posizione principale (percorso) per i tuoi URL nella variabile ROOT_CONF .
2. Django carica il file python fornito nel percorso fornito. E individua la variabile urlpatterns , questa è una lista contenente tutte le istanze di django.urls.path() e/o django.urls.re_path() .
3. Nell'elenco, Django va in ordine e cerca un URL corrispondente.
4. Python, importa e chiama la vista (vista basata su funzioni o basata su classi). Che viene ulteriormente passato con la richiesta HTTP.
5. La vista elabora la richiesta e le informazioni passate e restituisce un messaggio/modello o reindirizza a un'altra vista.
6. Se nessun pattern URL corrisponde, o se viene sollevata un'eccezione durante qualsiasi punto di questo processo, Django invoca una vista di gestione degli errori appropriata.

Conclusione

Abbiamo appreso della possibilità di creare file per Django senza la riga di comando. Inoltre abbiamo appreso i vantaggi e gli elementi costitutivi di un progetto Django. Django è uno strumento straordinario per creare progetti di back-end con l'obiettivo di creare semplicità.

Puoi controllare il codice per questo tutorial su GitHub.

Risorse

• Gestione delle password in Django
• Django: Come iniziare
• Django: Impostazioni
• Django leggero di O'Reilly