PyCharm
The only Python IDE you need.
Présentation des vues de Django
Les vues constituent un élément central de l’architecture de Django et il est important de bien comprendre comment les utiliser pour tout développeur travaillant avec ce framework. Que vous découvriez le développement d’applications web avec Django ou ayez simplement besoin de rafraîchir vos connaissances des vues, vous trouverez ce que vous cherchez.
Mieux comprendre les vues vous aidera à progresser plus rapidement dans votre projet Django. Qu’il s’agisse de travailler sur un backend d’API ou des flux d’interface utilisateur web, savoir comment utiliser les vues est essentiel.
Poursuivez la lecture pour découvrir ce que sont les vues Django, leurs différents types, les bonnes pratiques d’utilisation de ces dernières et les principaux cas d’utilisation.
Qu’est-ce que les vues dans Django ?
Les vues constituent un élément essentiel de l’architecture MTV (modèle-template-vue) de Django. Elles servent essentiellement d’intermédiaires entre les modèles et les templates, en traitant les demandes des utilisateurs et en renvoyant des réponses.
Vous avez sans doute déjà utilisé les vues dans le cadre du schéma MVC (modèle-vue-contrôleur). Toutefois, elles sont légèrement différentes des vues de Django et ne constituent pas des correspondances exactes. Les vues Django sont essentiellement des contrôleurs dans MVC, tandis que les templates Django correspondent à peu près aux vues de MVC. Cela rend la compréhension des nuances de Django vitale, même si vous connaissez les vues dans le contexte de MVC.
Les vues font partie de l’interface utilisateur dans Django, et elles traitent la logique et le traitement des données pour les requêtes web destinées aux applications et sites pilotés par Django. Elles effectuent le rendu de vos templates pour créer ce que l’utilisateur voit lorsqu’il ouvre votre page web. Chaque vue basée sur la classe ou la fonction prend une requête utilisateur, récupère les données de ses modèles, applique la logique métier ou le traitement des données, puis prépare et renvoie une réponse HTTP à un template.
Cette réponse peut être tout élément affichable par un navigateur web et est généralement une page web HTML. Cependant, les vues Django peuvent également renvoyer des images, des documents XML, des redirections, des pages d’erreur et bien plus encore.
Rendu et transfert des données aux templates
Django fournit le raccourci render() pour simplifier le rendu de templates à partir des vues. L’utilisation de render() évite d’avoir à charger le template et créer la réponse manuellement.
PyCharm inclut la saisie semi-automatique intelligente du code et suggère automatiquement la fonction render() à partir de django.shortcuts dès que vous commencez à la saisir dans vos vues. Il reconnaît également les noms de template et fournit la saisie semi-automatique des chemins de template, afin d’éviter les fautes de frappe et les erreurs.
L’utilisateur fournit la requête, le nom de template et un dictionnaire contextuel, qui apporte des données pour le template. Une fois les données nécessaires obtenues, la vue les transfère au template, où elles peuvent être rendues et présentées à l’utilisateur.
from django.shortcuts import render
def my_view(request):
# Some business logic to obtain data
data_to_pass = {'variable1': 'value1', 'variable2': 'value2'}
# Pass the data to the template
return render(request, 'my_template.html', context=data_to_pass)
Dans cet exemple, data_to_pass est un dictionnaire contenant les données à envoyer au template. La fonction render est ensuite utilisée pour rendre le template (my_template.html) à partir des données contextuelles fournies.
Désormais, votre template (my_template.html) permet d’accéder aux données et de les afficher.
{{ variable1 }}
{{ variable2 }}
Dans le template, utilisez des accolades doubles ({{ }}) pour indiquer les variables de template. Celles-ci seront remplacées par les valeurs des données contextuelles transférées par la vue.
PyCharm assure la saisie semi-automatique et la mise en évidence des éléments de syntaxe pour les balises de templates, les variables et les boucles de Django. Il fournit également un linting dans l’éditeur pour les erreurs communes. Cela vous permet de vous focaliser sur la création de vues et le traitement de la logique, au lieu de perdre du temps à remplir manuellement des éléments de template ou à déboguer des erreurs communes.
Vues basées sur les fonctions
Django a deux types de vues : les vues basées sur les fonctions et les vues basées sur les classes.
Les vues basées sur les fonctions sont créées en utilisant des fonctions Python et sont généralement divisées en quatre grandes catégories : créer, lire, mettre à jour et supprimer (CRUD – Create, Read, Update et Delete). C’est la fondation de tous les frameworks de développement. Elles prennent une requête HTTP et renvoient une réponse HTTP.
from django.http import HttpResponse
def my_view(request):
# View logic goes here
context = {"message": "Hello world"}
return HttpResponse(render(request, "mytemplate.html", context))
Cet extrait de code traite la logique de la vue, prépare un dictionnaire contextuel pour transférer les données au template qui est rendu, puis renvoie le code HTML final du template dans un objet de réponse.
Les vues basées sur les fonctions sont simples et directes. La logique est contenue dans une fonction Python unique au lieu d’être répartie entre les différentes méthodes d’une classe, ce qui les rend particulièrement bien adaptées aux cas d’utilisation demandant très peu de traitement.
PyCharm vous permet de générer automatiquement la structure def my_view(request) en utilisant les live templates. Les live templates sont des extraits de code prédéfinis qui peuvent être transformés en code réutilisable. Cette fonctionnalité permet de gagner du temps et garantit une structure cohérente pour vos définitions de vues.
Vous pouvez appeler les live templates simplement en appuyant sur ⌘J, en saisissant Listview et en appuyant sur la touche de tabulation.
De plus, PyCharm inclut la fenêtre d’outils Django Structure, où vous pouvez voir la liste de l’ensemble des vues de votre projet Django, classées par application. Cela permet de trouver rapidement les vues, de naviguer entre elles et de déterminer à quel fichier chacune des vues appartient.
Vues basées sur les classes
Django a introduit des vues basées sur les classes pour éviter aux utilisateurs d’écrire trop souvent le même code. Elles ne remplacent pas les vues basées sur les fonctions, mais ont des applications et des avantages qui leur sont propres, notamment lorsqu’une logique complexe est requise.
Les vues basées sur les classes dans Django fournissent des classes parent réutilisables qui implémentent les différents schémas et les différentes fonctionnalités généralement exigées par les applications web. Vous pouvez prendre vos vues à partir de ces classes parent pour réduire le code réutilisable
Les vues basées sur les classes offrent des classes parent génériques, telles que :
ListViewDetailViewCreateView- Et bien plus.
Vous trouverez ci-dessous deux extraits de code similaires démontrant une simple vue BookListView. Le premier affiche une implémentation basique utilisant les conventions basées sur les classes par défaut, tandis que le deuxième illustre comment personnaliser la vue en spécifiant des paramètres supplémentaires.
Implémentation de base :
from django.views.generic import ListView
from .models import Book
class BookListView(ListView):
model = Book
# The template_name is omitted because Django defaults to 'book_list.html'
# based on the convention of _list.html for ListView.
Lorsque BookListView est rendu, il interroge directement les enregistrements Book et les transmet sous la variable books lors du rendu de book_list.html. Cela signifie que vous pouvez rapidement créer une vue pour lister des objets sans avoir à réécrire la logique sous-jacente.
Implémentation personnalisée :
from django.views.generic import ListView
from .models import Book
class BookListView(ListView):
model = Book
# You can customize the view further by adding additional attributes or methods
def get_queryset(self):
# Example of customizing the queryset to filter books
return Book.objects.filter(is_available=True)
Dans le deuxième extrait de code, nous avons introduit une méthode get_queryset() personnalisée, afin de mieux filtrer les enregistrements affichés dans la vue. Cela illustre comment les vues basées sur les classes peuvent être étendues au-delà de leur fonctionnalité par défaut pour répondre aux besoins de votre application.
Les vues basées sur les classes définissent également les méthodes qui interviennent à des niveaux clés du cycle de vie de la requête et des réponses, comme :
get(): logique pour les requêtesGET.post(): logique pour les requêtesPOST.dispatch(): détermine quelle méthode appeler,get()oupost().
Ces types de vues fournissent une structure tout en offrant la personnalisation là où elle est nécessaire, ce qui les rend parfaitement adaptés pour les cas d’utilisation complexes.
PyCharm inclut des live templates pour les vues basées sur les classes, telles que ListView, DetailView et TemplateView, ce qui vous permet de générer intégralement des classes de vues en quelques secondes, avec des méthodes réutilisables et des docstrings.
Création de vues basées sur les classes personnalisées
Vous pouvez également créer vos propres classes de vues en ajoutant des sous-classes à partir des classes Django génériques, afin de les personnaliser en fonction de vos besoins.
Voici quelques cas d’utilisation où la création de vos propres classes peut être souhaitable :
- Ajout de logique métier, notamment pour les calculs complexes.
- Mélange de plusieurs parents génériques pour fusionner les fonctionnalités.
- Gestion des sessions ou des états au niveau de plusieurs requêtes.
- Optimisation de l’accès aux bases de données avec des requêtes personnalisées.
- Réutilisation de la logique de rendu commune entre différentes zones.
Une vue personnalisée basée sur les classes pourrait prendre la forme suivante :
from django.views.generic import View
from django.shortcuts import render
from . import models
class ProductSalesView(View):
def get(self, request):
# Custom data processing
sales = get_sales_data()
return render(request, "sales.html", {"sales": sales})
def post(self, request):
# Custom form handling
form = SalesSearchForm(request.POST)
if form.is_valid():
results = models.Sale.objects.filter(date__gte=form.cleaned_data['start_date'])
context = {"results": results}
return render(request, "search_results.html", context)
# Invalid form handling
errors = form.errors
return render(request, "sales.html", {"errors": errors})
Ici, les gestionnaires get et post personnalisés vous permettent d’étendre les vues existantes aux différentes requêtes.
Quand utiliser chaque type de vue
Les vues basées sur les fonctions et les vues basées sur les classes peuvent être utiles toutes les deux en fonction de la complexité et des besoins de la logique de la vue.
Les différences principales sont que les vues basées sur les classes :
- Incitent à la réutilisation via les sous-classes et le comportement d’héritage des parents.
- Sont idéales pour la gestion des états entre les requêtes.
- Renforcent la structure et la discipline.
Vous pouvez les utiliser en conjonction avec :
- Des pages de tableau de bord à logique de rendu complexe.
- Des pages destinées au public qui affichent les données dynamiques.
- Des portails d’administration pour la gestion des contenus.
- Des pages de liste ou de détails impliquant les modèles de base de données.
D’un autre côté, les vues basées sur les fonctions :
- Sont plus simples et nécessitent moins de code pour leur création.
- Peuvent être plus faciles à aborder pour les développeurs Python.
- Sont très flexibles et ont moins de contraintes.
Leurs cas d’utilisation incluent :
- Idées de prototypage.
- Vues CRUD ou de bases de données simples.
- Pages d’accueil ou marketing.
- Points de terminaison d’API pour servir les requêtes web.
En résumé, les vues basées sur les fonctions sont flexibles, simples et plus faciles à comprendre. Toutefois, pour les cas plus complexes, vous devez créer davantage de code qui n’est pas nécessairement réutilisable.
Les vues basées sur les classes de Django imposent une structure et sont réutilisables, mais elles peuvent être plus difficiles à comprendre, implémenter et déboguer.
Vues et URL
Comme nous l’avons établi, dans Django, les vues correspondent aux fonctions ou aux classes qui conditionnent le rendu d’un template. Chaque vue crée un lien avec un schéma d’URL, afin de guider les requêtes entrantes vers le bon endroit.
Comprendre la relation entre les vues et les URL est important pour gérer efficacement le flux de votre application.
Chaque vue correspond à un schéma d’URL défini dans le fichier urls.py de votre application Django. Ce mappage d’URL permet de s’assurer que lorsqu’un utilisateur navigue vers une adresse spécifique dans votre application, Django sait exactement quelle vue appeler.
Nous allons examiner une configuration d’URL simple :
from django.urls import path
from .views import BookListView
urlpatterns = [
path('books/', BookListView.as_view(), name='book-list'),
]
Dans cette configuration, lorsqu’un utilisateur accède à /books/, BookListView intervient pour assurer le rendu de la liste de books. En mappant clairement les URL avec les vues, vous rendez votre base de code plus simple à lire et mieux organisée.
Simplification de la gestion des URL avec PyCharm
La gestion et la visualisation des points de terminaison dans Django peuvent devenir de plus en plus difficiles au fur et à mesure que votre application se développe. Pour cette raison, PyCharm dispose de la fenêtre d’outils Endpoints, qui crée une vue centralisée de tous les schémas d’URL de votre application, des vues liées et des méthodes HTTP. Cette fonctionnalité permet d’afficher la liste des points de terminaison de votre projet, ce qui facilite le suivi des liens entre les vues et les URL.
Au lieu de chercher dans plusieurs fichiers urls.py, vous pouvez localiser instantanément les vues correspondantes et y accéder en un simple clic. Cela est particulièrement utile pour les projets Django de plus grande taille où les configurations d’URL recouvrent plusieurs fichiers ou pour les équipes où la détermination rapide du contexte est cruciale.
De plus, la fenêtre d’outils Endpoints vous permet de visualiser tous les points de terminaison dans une interface tabulaire. Chaque ligne affiche le chemin de l’URL, la méthode HTTP (GET, POST, etc.) et la fonction ou la classe de vue associée à ce point de terminaison.
Cette fonctionnalité non seulement renforce la productivité, mais améliore également la navigation du code, ce qui vous permet d’identifier facilement les schémas d’URL manquants ou dupliqués. Ce niveau de visibilité est précieux pour déboguer les problèmes de routage ou d’intégration des nouveaux développeurs dans un projet.
Regardez cette vidéo pour plus d’informations sur la fenêtre d’outils Endpoints et ses avantages.
Bonnes pratiques d’utilisation des vues Django
Voici quelques directives qui peuvent vous aider à créer des vues bien structurées et faciles à gérer.
Ne pas perdre de vue l’objectif des vues
Les vues doivent se focaliser sur le traitement des requêtes, la récupération des données, le transfert des données aux templates, ainsi que le contrôle des flux et des redirections. La logique métier compliquée et les traitements complexes doivent se faire ailleurs, comme dans les méthodes de modèle ou les classes de services dédiées.
Toutefois, vous devez veiller à ne pas surcharger vos modèles avec trop de logique, car cela risque de déboucher sur un schéma contre-productif, ou « fat model », dans Django. La documentation de Django sur les vues permet de mieux comprendre comment les structurer correctement.
Maintenir des vues et des templates légers
Il est préférable de veiller à maintenir des vues et des templates légers. Les vues doivent traiter les requêtes et la récupération des données, tandis que les templates portent essentiellement sur la présentation avec une logique minimale.
Le traitement complexe doit se faire en Python, en dehors des templates, pour améliorer la maintenance et les tests. Pour plus d’informations sur cela, consultez la documentation des templates Django.
Découplage des requêtes de base de données
L’extraction des requêtes de base de données dans des gestionnaires ou des référentiels au lieu de les placer directement dans des vues peut contribuer à réduire la duplication. Reportez-vous à la documentation des modèles Django pour des instructions de gestion efficace des interactions avec les bases de données.
Utiliser des vues basées sur les classes génériques lorsque cela est possible
Les vues génériques basées sur les classes de Django, telles que DetailView et ListView, assurent la réutilisation sans avoir à écrire beaucoup de code. Privilégiez ces vues pour ne pas avoir à réinventer la roue et mieux utiliser votre temps. La documentation des vues génériques est une excellente ressource pour comprendre ces fonctionnalités.
Les vues basées sur les fonctions suffisent pour les cas d’utilisation simples
Pour les vues de base, telles que servir des API, une fonction peut être plus efficace qu’une classe. Réservez les vues basées sur des classes complexes aux flux d’interface utilisateur compliqués. La page de documentation sur l’écriture des vues présente des exemples utiles.
Structure nette des routes et des URL
Organisez les routes et les gestionnaires de vues en les groupant dans des applications selon leurs fonctionnalités. Cela permet de naviguer jusqu’à la source plus facilement. Consultez la documentation du répartisseur d’URL de Django pour les bonnes pratiques de structuration des configurations d’URL.
Premiers pas
Maintenant que vous comprenez les bases des vues dans Django, vous allez devoir approfondir le framework et les étapes suivantes.
- Remettez à jour votre connaissance de Django avec notre article de blog Comment apprendre Django, qui est idéal pour les débutants ou tous ceux qui cherchent à actualiser leur expertise.
- Découvrez comment créer et exécuter votre premier projet Django dans PyCharm, avec notre tutoriel sur la création d’une application pratique de base, ou explorez notre liste complète d’idées de projet Django pour vous donner de l’inspiration.
- Explorez l’état de Django pour voir les dernières tendances de développement Django et faire le plein d’idées.
- Si vous hésitez toujours sur le framework Python à utiliser, nos guides de comparaison Django vs. Flask et Django vs. FastAPI peuvent vous aider.
Prise en charge de Django dans PyCharm
PyCharm Professional est le meilleur IDE de sa catégorie pour le développement Django. Il vous permet de coder plus rapidement grâce à une fonction d’assistance propre à Django, la navigation et refactorisation à l’échelle du projet et une prise en charge complète des templates Django. Vous pouvez vous connecter à votre base de données en un clic et travailler sur TypeScript, JavaScript et les frameworks frontend. PyCharm prend également d’emblée en charge Flask et FastAPI.
Créez de meilleures applications et simplifiez votre code. Prenez un bon départ avec PyCharm dès maintenant pour une expérience de développement Django sans effort.
Auteur de l’article original en anglais :
Subscribe to PyCharm Blog updates
