Creazione di modelli Django: un tutorial

Hark Labs2022-03-08 · 12 min read

Creazione di modelli Django: un tutorial

Django è un noto framework web per lo sviluppo rapido di siti e applicazioni web sicuri e facilmente manutenibili. Creato utilizzando Python, Django semplifica lo sviluppo web, consentendo di dedicare più tempo e attenzione alla scrittura di app senza dover reinventare la ruota ogni volta. Django è un progetto gratuito e open-source con una solida documentazione ufficiale, un ottimo supporto della community e un'ampia disponibilità di supporto gratuito e a pagamento.

In questa guida, vedremo in dettaglio come creare i modelli Django. In Django, un modello è la fonte principale di informazioni sui tuoi dati. I modelli descrivono i campi e il comportamento dei dati da memorizzare. Django utilizza il modello per generare le tabelle del database tramite ORM (Object Relational Mapping), anch'essi definiti modelli.

Prerequisiti

Lavoriamo su un sistema operativo basato su Unix, preferibilmente un cloud server Ubuntu 20.04 come sistema su cui abbiamo effettuato i test. Se desideri configurare Django in un ambiente simile, fai riferimento al nostro tutorial, “Come installare Django e configurare un ambiente di sviluppo su Ubuntu 20.04.”

Passo 1. Ambiente di sviluppo Python

Django è basato su Python. Pertanto, abbiamo bisogno di un ambiente di sviluppo Python robusto con tutti gli strumenti necessari per lavorare con le app Python. Ne abbiamo già parlato in una guida dedicata. Qui faremo una breve dimostrazione.

Per prima cosa, avvia un terminale ed esegui i seguenti comandi:

$ sudo apt update && sudo apt upgrade -y
$ sudo apt install python3 python-is-python3

1 2	$ sudo apt update && sudo apt upgrade -y $ sudo apt install python3 python-is-python3

Successivamente, installa pip – il gestore di pacchetti Python:

$ sudo apt install python3-pip

1	$ sudo apt install python3-pip

Quindi, installa alcuni pacchetti di sviluppo aggiuntivi:

$ sudo apt install build-essential libssl-dev libffi-dev python3-dev

1	$ sudo apt install build-essential libssl-dev libffi-dev python3-dev

Per creare un ambiente virtuale, abbiamo anche bisogno del modulo Python venv :

$ sudo apt install python3-venv

1	$ sudo apt install python3-venv

Passo 2. Installazione di MySQL Server

MySQL è un popolare sistema di gestione di database relazionali. È open-source, stabile e ricco di funzionalità. Utilizzeremo MySQL come database server per la nostra app Django. Installa MySQL usando APT:

$ sudo apt install mysql-server

1	$ sudo apt install mysql-server

Successivamente, verifica l'installazione:

$ systemctl status mysql

1	$ systemctl status mysql

Si tratta solo di una configurazione di base di MySQL con le opzioni predefinite. Consulta la guida più approfondita su installazione e configurazione di MySQL.

Passo 3. Configurazione dell'app Django

Siamo ora pronti per creare la nostra app Django. Se sei interessato a una dimostrazione più approfondita di Django, fai riferimento al nostro tutorial, “Installare il framework web Django su Ubuntu 20.04.”

Successivamente, crea una directory dedicata per l'app. Il nome della directory dovrebbe riflettere il nome del progetto:

$ mkdir -pv <project_dir>

1	$ mkdir -pv <project_dir>

All'interno della directory del progetto, crea un ambiente virtuale Python utilizzando il modulo venv :

$ python3 -m venv <virtual_env_name>

1	$ python3 -m venv <virtual_env_name>

Attiva l'ambiente virtuale:

$ . sample_app_env/bin/activate

1	$ . sample_app_env/bin/activate

Installa Django usando pip:

$ pip install django

1	$ pip install django

Successivamente, crea un nuovo progetto Django utilizzando il comando django-admin :

$ django-admin startproject sample_app

1	$ django-admin startproject sample_app

Passo 4. Configurazione dell'app Django

L'app Django contiene tutte le configurazioni predefinite. Per il nostro scopo, dobbiamo apportare alcune modifiche.

Inizia modificando il file di configurazione settings.py:

$ nano sample_app/sample_app/sample_app/settings.py

1	$ nano sample_app/sample_app/sample_app/settings.py

Quindi, modifica il fuso orario:

$ TIME_ZONE = '<time_zone>'

1	$ TIME_ZONE = '<time_zone>'

Aggiungi le macchine autorizzate ad accedere al server dell'app Django:

$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

1	$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

Dopodiché, applica le modifiche:

$ python manage.py migrate

1	$ python manage.py migrate

Infine, crea un superuser per la nostra app web Django:

$ python manage.py createsuperuser

1	$ python manage.py createsuperuser

Passaggio 5. Connessione dell'app Django a MySQL

Per connetterci a MySQL, abbiamo bisogno di una libreria di connettori Python aggiuntiva compatibile con Django. Utilizzeremo mysqlclient.

Innanzitutto, assicurati di aver installato i pacchetti necessari:

$ sudo apt install python3-dev libmysqlclient-dev default-libmysqlclient-dev

1	$ sudo apt install python3-dev libmysqlclient-dev default-libmysqlclient-dev

Successivamente, installa mysqlclient:

$ pip install mysqlclient

1	$ pip install mysqlclient

Creazione di un database dedicato

Per la nostra app, dobbiamo creare un database dedicato e un utente del database. Avvia la shell MySQL come root:

$ sudo mysql -u root

1	$ sudo mysql -u root

Crea un database dedicato per la nostra app Django:

$ CREATE DATABASE <dedicated_database>;

1	$ CREATE DATABASE <dedicated_database>;

Quindi, crea un utente di database dedicato per l'app Django:

$ CREATE USER '<username>'@'%' IDENTIFIED WITH mysql_native_password BY '<user_password>';

1	$ CREATE USER '<username>'@'%' IDENTIFIED WITH mysql_native_password BY '<user_password>';

Infine, concedi all'utente dedicato i permessi completi sul database dedicato:

$ GRANT ALL ON <database>.* TO '<username'@'%';

1	$ GRANT ALL ON <database>.* TO '<username'@'%';

Modifica della configurazione di Django per utilizzare MySQL

Ora dobbiamo modificare alcune configurazioni di Django in modo che possa utilizzare MySQL come server di database. Apri settings.py in un editor di testo:

$ nano settings.py

1	$ nano settings.py

Scorri verso il basso fino alla sezione DATABASES e incolla il seguente codice:

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'OPTIONS': {
'read_default_file': '/etc/mysql/my.cnf',
},
}
}

DATABASES = {

'default': {

'ENGINE': 'django.db.backends.mysql',

'OPTIONS': {

'read_default_file': '/etc/mysql/my.cnf',

}

Successivamente, modifica il file di configurazione di MySQL in modo che contenga le credenziali del database necessarie:

$ sudo nano /etc/mysql/my.cnf

1	$ sudo nano /etc/mysql/my.cnf

Aggiungi il seguente blocco alla fine del file:

[client]
database = <dedicated_database>
user = <dedicated_user>
password = <user_password>
default-character-set = utf8

[client]

database = <dedicated_database>

user = <dedicated_user>

password = <user_password>

default-character-set = utf8

Riavvia MySQL per rendere effettive le modifiche:

$ sudo systemctl daemon-reload
$ sudo systemctl restart mysql

1 2	$ sudo systemctl daemon-reload $ sudo systemctl restart mysql

Passaggio 6. Creazione di un modello Django

Siamo ora pronti per creare un nuovo modello all'interno del nostro progetto Django. Attiva l'ambiente virtuale:

$ cd sample_app/
$ . sample_app_env/bin/activate
$ cd sample_app/

$ cd sample_app/

$ . sample_app_env/bin/activate

$ cd sample_app/

In questa posizione, indica a Django di creare una nuova app:

$ python manage.py startapp <new_app>

1	$ python manage.py startapp <new_app>

Dopo la creazione, l'albero dei file dovrebbe apparire simile a questo. Qui, il file models.py conterrà i codici per il nostro modello Django personalizzato:

Controlla il contenuto corrente del file:

$ cat models.py

1	$ cat models.py

A scopo dimostrativo, creeremo un modello per i post del blog chiamato Post. Conterrà i seguenti campi:

title: Titolo del post del blog.
slug: Memorizza e genera URL validi per le pagine web.
content: Il testo del post del blog.
created_on: Data di creazione del post.
author: L'utente che ha creato il post.

Apri il file models.py in un editor di testo:

$ nano models.py

1	$ nano models.py

Importiamo alcune API necessarie per il nostro modello. Per impostazione predefinita, importa l'API dei modelli. Avremo anche bisogno dell'API slugify per la generazione degli slug, User per l'autenticazione e reverse per una creazione degli URL migliore e più flessibile:

from django.db import models
from django.template.defaultfilters import slugify
from django.contrib.auth.models import User
from django.urls import reverse

from django.db import models

from django.template.defaultfilters import slugify

from django.contrib.auth.models import User

from django.urls import reverse

Successivamente, aggiungi il metodo di classe chiamato Post. Conterrà i campi di database necessari come title, slug, content, created_on, e author:

class Post(models.Model):
   title = models.CharField(max_length=255)
   slug = models.SlugField(unique=True, max_length=255)
   content = models.TextField()
   created_on = models.DateTimeField(auto_now_add=True)
   author = models.TextField()

class Post(models.Model):

title = models.CharField(max_length=255)

slug = models.SlugField(unique=True, max_length=255)

content = models.TextField()

created_on = models.DateTimeField(auto_now_add=True)

author = models.TextField()

Abbiamo bisogno della funzionalità per la generazione degli URL e il salvataggio del post. È importante perché genera link univoci corrispondenti a post univoci:

def get_absolute_url(self):
   return reverse('blog_post_detail', args=[self.slug])

def save(self, *args, **kwargs):
   if not self.slug:
      self.slug = slugify(self.title)
      super(Post, self).save(*args, **kwargs)

def get_absolute_url(self):

return reverse('blog_post_detail', args=[self.slug])

def save(self, *args, **kwargs):

if not self.slug:

self.slug = slugify(self.title)

super(Post, self).save(*args, **kwargs)

La sezione successiva indicherà al modello come ordinare i post e visualizzarli sulla pagina web. Codificheremo la logica utilizzando una classe interna, Meta. Conterrà logica di modello aggiuntiva che non riguarda la definizione dei campi del database:

class Meta:
   ordering = ['created_on']

def __unicode__(self):
   return self.title

class Meta:

ordering = ['created_on']

def __unicode__(self):

return self.title

Infine, avremo la funzionalità del modello Comment in questo file. Richiede l'aggiunta di un'altra classe Comment utilizzando models.Model come firma. Conterrà i seguenti campi del database:

name: Nome del commentatore.
email: Indirizzo email del commentatore.
text: Contenuto del commento stesso.
post: Il post su cui è stato inserito il commento.
created_on: Data e ora di creazione del commento.

Il codice sarà simile a questo:

class Comment(models.Model): 
   name = models.CharField(max_length=42) 
   email = models.EmailField(max_length=75) 
   website = models.URLField(max_length=200, null=True, blank=True) 
   content = models.TextField() 
   post = models.ForeignKey(Post, on_delete=models.CASCADE) 
   created_on = models.DateTimeField(auto_now_add=True)

class Comment(models.Model):

name = models.CharField(max_length=42)

email = models.EmailField(max_length=75)

website = models.URLField(max_length=200, null=True, blank=True)

content = models.TextField()

post = models.ForeignKey(Post, on_delete=models.CASCADE)

created_on = models.DateTimeField(auto_now_add=True)

A questo punto, il nostro file models.py avrà questo aspetto:

Infine, salva il file e chiudi l'editor.

Passo 7. Aggiornamento delle impostazioni di Django

Il modello è stato creato. Tuttavia, dobbiamo modificare alcuni file di configurazione per mettere in funzione il modello. All'interno di settings.py, dobbiamo aggiungere il nostro modello sotto INSTALLED_APPS.

Apri settings.py in un editor di testo:

$ nano settings.py

1	$ nano settings.py

Registra il nuovo modulo sotto la sezione INSTALLED_APPS:

Salva il file e chiudi l'editor.

Passo 8. Migrazione delle modifiche

Ora che abbiamo aggiunto tutti i modelli desiderati, il passo successivo consiste nell'applicare queste modifiche. Django applicherà questi schemi al nostro database MySQL.

Il seguente comando genererà tutti i file di migrazione necessari. L'output mostrerà le posizioni di tutti questi file all'interno della directory del progetto:

$ python manage.py makemigrations

1	$ python manage.py makemigrations

Il seguente comando elencherà tutte le migrazioni esistenti:

$ python manage.py showmigrations

1	$ python manage.py showmigrations

Nota che tutte le migrazioni sono contrassegnate ad eccezione di 0001_initial che è stata creata come parte dei modelli Post e Comment.

Il seguente comando mostrerà quale query SQL eseguirà Django per effettuare le migrazioni:

$ python manage.py sqlmigrate random_app 0001_initial

1	$ python manage.py sqlmigrate random_app 0001_initial

Tutto ciò di cui abbiamo bisogno ora è applicare le migrazioni. Queste migrazioni scriveranno le modifiche nel database:

$ python manage.py migrate

1	$ python manage.py migrate

Passo 9. Verifica delle modifiche

Per verificare le modifiche, diamo un'occhiata al nostro database MySQL. Avvia la shell MySQL come utente Django:

$ mysql sample_app_data -u sample_app_user

1	$ mysql sample_app_data -u sample_app_user

Successivamente, cambia il database attivo corrente con il database dell'app Django:

$ USE <django_dedicated_database>;

1	$ USE <django_dedicated_database>;

Elenca tutte le tabelle del database:

$ SHOW TABLES;

1	$ SHOW TABLES;

Infine, per vedere il contenuto di una qualsiasi delle tabelle, usa la DESCRIBE query:

$ DESCRIBE random_app_comment;
$ DESCRIBE random_app_post;

1 2	$ DESCRIBE random_app_comment; $ DESCRIBE random_app_post;

Limitazioni di Django con MySQL

Quando si usa MySQL come server di database per l'app Django, ci sono alcune cose da tenere a mente:

Non c'è molto supporto per le transazioni relative ai processi di modifica dello schema. Ciò significa che, se una migrazione fallisce, è necessario annullare manualmente tutte le modifiche prima di tentare un'altra migrazione. Non c'è modo di ripristinare uno stato precedente in cui la migrazione fallita non era avvenuta.
Per la maggior parte dei processi di modifica dello schema, MySQL riscrive completamente le tabelle. In certe situazioni, questo può richiedere molto tempo. Nel peggiore dei casi, la complessità temporale sarà proporzionale al numero di righe da aggiungere o di colonne da rimuovere. Secondo la documentazione ufficiale di Django, potrebbe essere necessario un minuto per milione di righe.
MySQL impone un limite di caratteri per la lunghezza dei nomi di colonne, tabelle e indici. C'è anche un limite alla dimensione totale di tutte le colonne e delle coperture degli indici. Django può superare questo limite. Alcuni backend diversi da MySQL sono in grado di gestire il limite più elevato di Django.

Ecco perché si raccomanda vivamente di valutare le opzioni e scegliere quella più appropriata.

Considerazioni finali

Questa guida dimostra con successo come aggiungere moduli a un'app Django esistente. Abbiamo utilizzato MySQL come backend per l'app. Mostra inoltre alcuni concetti chiave di Django come i modelli, il funzionamento delle migrazioni e il modo in cui Django traduce i modelli in tabelle di database MySQL.

Buona programmazione!

Hark Labs

Autore · CloudSigma

Preslav Dobrev è un designer creativo presso CloudSigma, con un focus su un'identità aziendale coerente attraverso l'uso di canali di marketing tradizionali e innovativi. È abile nel fondere la visione artistica con il marketing strategico per creare narrazioni di brand di grande impatto.