Padroneggiare i QuerySet di Django: una guida completa con esempi pratici

Quando si lavora con Django, comprendere i QuerySet è fondamentale per interagire in modo efficiente con il database. In questo tutorial, ti guiderò attraverso i dettagli dei QuerySet utilizzando un semplice modello Contact. Lungo il percorso, spiegherò cosa fa ogni comando, perché è utile e come puoi applicarlo a scenari del mondo reale. Se hai appena iniziato a usare Django o stai cercando di migliorare le tue competenze, sei nel posto giusto.

Impostazione della scena: il modello di contatto

Iniziamo creando un piccolo modello di Contatto. Immagina di creare una rubrica in cui ogni contatto ha un nome, un cognome e un indirizzo email. Ecco come appare in Django:

 from django.db import models class Contact(models.Model): first_name = models.CharField(max_length=50) last_name = models.CharField(max_length=50) email = models.EmailField(unique=True) def __str__(self): return f"{self.first_name} {self.last_name}"

Questo modello è piuttosto semplice. I campi first_name e last_name sono CharField con una lunghezza massima di 50 caratteri, mentre il campo email è univoco, assicurando che non ci siano indirizzi email duplicati. Il metodo __str__ restituisce una bella rappresentazione del contatto, perfetta per il debug o la visualizzazione dei dati.

Esegui le migrazioni per applicare questo modello al tuo database:

 python manage.py makemigrations python manage.py migrate

Con il modello pronto, approfondiamo l'argomento QuerySet.

Che cos'è un QuerySet?

Un QuerySet è essenzialmente una raccolta di query di database. Consideralo come un modo per recuperare, filtrare e manipolare i dati dal tuo database. La bellezza dei QuerySet è che sono pigri, ovvero non raggiungono il database finché non li valuti esplicitamente. Ciò li rende potenti ed efficienti.

Prima di esplorare i QuerySet, popoliamo il nostro database con alcuni dati di esempio.

Aggiunta di dati campione

Avvia la shell Django per creare alcuni contatti:

 python manage.py shell

All'interno del guscio:

 from app.models import Contact Contact.objects.create(first_name="Alice", last_name="Smith", email="alice@example.com") Contact.objects.create(first_name="Bob", last_name="Jones", email="bob@example.com") Contact.objects.create(first_name="Charlie", last_name="Brown", email="charlie@example.com") Contact.objects.create(first_name="Diana", last_name="Prince", email="diana@example.com")

Ora abbiamo alcuni dati con cui lavorare. Immergiamoci in QuerySets e vediamo cosa possiamo fare.

Recupero di tutti i record

Il QuerySet più semplice è Contact.objects.all(). Questo recupera tutti i record dalla tabella Contact.

 contacts = Contact.objects.all() print(contacts)

Noterai che non recupera immediatamente i dati, ma prepara solo la query. Questa è un'eccellente funzionalità di QuerySets perché evita accessi non necessari al database finché non hai bisogno dei dati.

Perché utilizzarlo?

Se vuoi vedere tutto nella tua tabella, all() è la tua scelta. È anche il punto di partenza per concatenare altri comandi, che tratteremo in seguito.

Conteggio dei record

Vuoi sapere quanti contatti hai? Usa .count().

 count = Contact.objects.all().count() print(f"Total Contacts: {count}")

In questo modo viene inviata una query SELECT COUNT(*) al database, operazione più rapida rispetto al caricamento di tutti gli oggetti e al loro conteggio in Python.

Perché utilizzarlo?

Quando hai bisogno di un rapido riepilogo dei tuoi dati, il conteggio dei record è di inestimabile valore.

Controllo dell'esistenza

Se vuoi semplicemente sapere se esistono record, .exists() è il tuo amico.

 exists = Contact.objects.all().exists() print(f"Contacts Exist: {exists}")

Questo metodo è molto più veloce rispetto al recupero di tutti i record, poiché interrompe la ricerca non appena trova la prima corrispondenza.

Perché utilizzarlo?

Perfetto per scenari come la logica condizionale: se ci sono dati, fai una cosa; altrimenti, fai qualcos'altro.

Recupero di record specifici

A volte sai esattamente cosa stai cercando. Usa .get() per recuperare un singolo record tramite una condizione specifica:

 alice = Contact.objects.get(email="alice@example.com") print(f"Found Contact: {alice}")

La cattura

Se nessun record corrisponde, viene generata un'eccezione DoesNotExist.
Se più record corrispondono, viene generato un'eccezione MultipleObjectsReturned.

Filtraggio dei dati

E se volessi tutti i contatti con un cognome specifico? Ecco dove entra in gioco .filter().

 smith_contacts = Contact.objects.filter(last_name="Smith") print(smith_contacts)

Questo crea un QuerySet di tutti i record corrispondenti. Puoi usare varie ricerche di campo per affinare la tua ricerca:

icontains : Ricerca senza distinzione tra maiuscole e minuscole.
startswith : Corrisponde all'inizio di una stringa.
esatto : corrisponde al valore esatto.

Per esempio:

 emails_with_example = Contact.objects.filter(email__icontains="example.com")

Perché utilizzarlo?

Il filtraggio è una delle operazioni più comuni in qualsiasi applicazione basata su database. Ti consente di concentrarti sui dati di cui hai bisogno.

Esclusione dei dati

Vuoi tutto tranne un set specifico di record? Usa .exclude():

 non_smith_contacts = Contact.objects.exclude(last_name="Smith") print(non_smith_contacts)

Ordinamento dei risultati

Ordinare i dati è semplice con .order_by().

 ordered_contacts = Contact.objects.all().order_by("first_name") print(ordered_contacts)

Per ordinare in ordine decrescente, anteporre al campo il simbolo - :

 descending_contacts = Contact.objects.all().order_by("-last_name")

Aggregazioni

Se lavori con dati numerici, Django ha funzioni di aggregazione integrate come Count , Sum , Avg , Max e Min . Contiamo quanti cognomi univoci abbiamo:

 from django.db.models import Count unique_last_names = Contact.objects.values("last_name").distinct().count() print(f"Unique Last Names: {unique_last_names}")

Annotazione dei QuerySet

Le annotazioni ti consentono di aggiungere campi calcolati al tuo QuerySet. Ad esempio, potresti voler creare un campo full_name dinamicamente:

 from django.db.models import Value from django.db.models.functions import Concat contacts = Contact.objects.annotate( full_name=Concat('first_name', Value(' '), 'last_name') ) for contact in contacts: print(contact.full_name)

Risultati di affettatura

Hai bisogno solo di un sottoinsieme dei tuoi dati? Utilizza lo slicing:

 top_two_contacts = Contact.objects.all()[:2]

SQL grezzo

Se sei curioso di sapere cosa sta facendo Django dietro le quinte, puoi esaminare il codice SQL grezzo:

 print(Contact.objects.all().query)

Conclusione

I QuerySet di Django sono incredibilmente potenti e padroneggiarli è un punto di svolta per lavorare con i dati nei tuoi progetti. Che tu stia filtrando record, contando righe o eseguendo query complesse, i QuerySet ti forniscono gli strumenti di cui hai bisogno per svolgere il lavoro in modo efficiente.

Comprendendo le basi e immergendoti in operazioni più avanzate, sarai in grado di scrivere codice pulito e ottimizzato che sfrutta appieno l'ORM di Django. Se hai trovato utile questa guida, sentiti libero di condividerla: potrebbe essere la risorsa che qualcun altro sta cercando!

HAYDN ELLEN