Un QuerySet représente une collection de lignes de base de données en tant qu'objet Python que vous pouvez filtrer, ordonner et chaîner. Sa caractéristique définissante est la paresse — un QuerySet ne frappe pas la base de données lors de sa création ; il n'exécute la requête que lorsque les données sont réellement nécessaires (évaluées). Comprendre ceci est essentiel pour écrire du code Django efficace.
Les QuerySets sont paresseux — aucun accès à la base de données jusqu'à l'évaluation
# NONE of these touch the database — they just build up the query
qs = Article.objects.all() # no query yet
qs = qs.filter(published=True) # still no query — chaining is lazy
qs = qs.exclude(views=0).order_by("-created_at") # still no query
# the database is hit ONLY when the QuerySet is EVALUATED:
for article in qs: # ← NOW the query runs
print(article.title)
Construire et chaîner un QuerySet ne coûte rien — Django assemble le SQL mais diffère l'exécution jusqu'à ce que vous ayez réellement besoin des résultats. Cela vous permet de composer des requêtes complexes efficacement en un seul voyage à la base de données.
✓ Iterating: for x in qs
✓ Slicing with step: qs[::2] (plain slicing qs[:10] stays lazy, adds LIMIT)
✓ len(qs), list(qs), bool(qs)
✓ Calling a non-QuerySet method: .count(), .exists(), .first(), .get(), .aggregate()
# build a query conditionally WITHOUT extra database trips
qs = Article.objects.all()
if search:
qs = qs.filter(title__icontains=search) # no DB hit
if category:
qs = qs.filter(category=category) # no DB hit
articles = qs[:20] # ONE query runs here, with LIMIT 20
La paresse vous permet de composer conditionnellement une requête sur plusieurs lignes, puis de l'exécuter une seule fois — efficace et propre.
qs = Article.objects.filter(published=True)
list(qs) # query runs, results CACHED on the QuerySet
list(qs) # uses the CACHE — no second query
# BUT a NEW queryset re-queries:
Article.objects.filter(published=True) # a fresh queryset → new query
Une fois évalué, un QuerySet met en cache ses résultats, donc réitérer le même QuerySet ne relance pas la requête.
# ⚠️ calling .count() then iterating runs TWO queries
if Article.objects.filter(published=True).count() > 0: # query 1
for a in Article.objects.filter(published=True): # query 2 (new queryset!)
...
# ✅ better — evaluate once, reuse
qs = list(Article.objects.filter(published=True))
if qs: ...
Comprendre les QuerySets et leur paresse est fondamental pour écrire du code Django de base de données efficace et correct — cela affecte directement la performance et explique les comportements qui confondent les nouveaux venus.
La clé est que les QuerySets ne frappent pas la base de données jusqu'à l'évaluation, ce qui est puissant : vous pouvez construire, filtrer, chaîner et composer conditionnellement des requêtes complexes sur plusieurs lignes de code sans aucun coût de base de données, puis exécuter le tout en un seul voyage lorsque vous avez réellement besoin des résultats.
Cela permet une construction de requête propre et efficace (par ex. ajouter conditionnellement des filtres selon l'entrée utilisateur, puis exécuter une seule requête) qui autrement nécessiterait une construction de chaîne SQL maladroite.
Savoir précisément ce qui déclenche l'évaluation (itération, len(), list(), .count(), .exists(), etc.) et que les résultats sont mis en cache sur un QuerySet évalué est essentiel pour éviter les pièges de performance courants — notamment l'exécution accidentelle de la même requête plusieurs fois (par ex. appeler .count() puis itérer un QuerySet frais, frappant la base de données deux fois).
La paresse est l'un des concepts les plus importants pour utiliser bien l'ORM Django, séparant les développeurs qui écrivent du code de base de données efficace de ceux qui déclenchent involontairement des requêtes redondantes, ce qui en fait une connaissance fondamentale qui sous-tend tout l'usage efficace de l'ORM et l'optimisation des performances dans Django.