Modelli (Models)
I modelli (models) in Django rappresentano la struttura dei dati dellâapplicazione. Ogni modello corrisponde a una tabella nel database e ogni attributo del modello diventa una colonna della tabella.
Definire un Modello
Un modello Django e una classe Python che eredita da models.Model:
# myapp/models.py
from django.db import models
class Articolo(models.Model):
titolo = models.CharField(max_length=200)
contenuto = models.TextField()
data_pubblicazione = models.DateTimeField(auto_now_add=True)
pubblicato = models.BooleanField(default=False)
visualizzazioni = models.PositiveIntegerField(default=0)
Ogni campo (CharField, TextField, ecc.) definisce il tipo di dato e le sue opzioni.
Il Metodo str
Il metodo __str__ definisce la rappresentazione testuale del modello, usata nellâadmin e nella shell:
class Articolo(models.Model):
titolo = models.CharField(max_length=200)
autore = models.CharField(max_length=100)
def __str__(self):
return f'{self.titolo} - {self.autore}'
Senza __str__, Django mostrerebbe qualcosa come Articolo object (1), poco utile per lâidentificazione.
La Classe Meta
La classe interna Meta permette di configurare il comportamento del modello:
class Articolo(models.Model):
titolo = models.CharField(max_length=200)
data_pubblicazione = models.DateTimeField()
class Meta:
ordering = ['-data_pubblicazione']
verbose_name = 'Articolo'
verbose_name_plural = 'Articoli'
db_table = 'blog_articoli'
unique_together = [['titolo', 'data_pubblicazione']]
indexes = [
models.Index(fields=['titolo']),
models.Index(fields=['-data_pubblicazione']),
]
- ordering: ordine predefinito delle query (il
-indica ordine decrescente). - verbose_name: nome leggibile del modello al singolare.
- verbose_name_plural: nome leggibile al plurale.
- db_table: nome personalizzato della tabella nel database.
- unique_together: vincolo di unicita su combinazioni di campi.
- indexes: indici del database per migliorare le prestazioni.
Metodi Personalizzati
Puoi aggiungere metodi personalizzati per incapsulare la logica di business:
from django.utils import timezone
class Articolo(models.Model):
titolo = models.CharField(max_length=200)
data_pubblicazione = models.DateTimeField()
pubblicato = models.BooleanField(default=False)
def e_recente(self):
return self.data_pubblicazione >= timezone.now() - timezone.timedelta(days=7)
def pubblica(self):
self.pubblicato = True
self.save()
def get_absolute_url(self):
return f'/articoli/{self.pk}/'
Modelli Astratti
I modelli astratti definiscono campi comuni senza creare una tabella nel database:
class TimestampModel(models.Model):
creato_il = models.DateTimeField(auto_now_add=True)
aggiornato_il = models.DateTimeField(auto_now=True)
class Meta:
abstract = True
class Articolo(TimestampModel):
titolo = models.CharField(max_length=200)
contenuto = models.TextField()
class Commento(TimestampModel):
testo = models.TextField()
autore = models.CharField(max_length=100)
Sia Articolo che Commento avranno automaticamente i campi creato_il e aggiornato_il, ma la tabella TimestampModel non esistera nel database.
Modelli Proxy
I modelli proxy aggiungono comportamento senza modificare la tabella del database:
class Articolo(models.Model):
titolo = models.CharField(max_length=200)
pubblicato = models.BooleanField(default=False)
class ArticoloPubblicato(Articolo):
class Meta:
proxy = True
ordering = ['-data_pubblicazione']
def __str__(self):
return f'[PUBBLICATO] {self.titolo}'
I modelli proxy condividono la stessa tabella del modello genitore ma possono avere manager, metodi e ordinamenti diversi.
Conclusione
I modelli sono il cuore di ogni applicazione Django. Con la classe Meta, i metodi personalizzati, i modelli astratti e i modelli proxy, hai tutti gli strumenti per definire una struttura dati pulita, organizzata e riutilizzabile. Una buona progettazione dei modelli e il fondamento di unâapplicazione robusta.