Django est un framework web puissant, open-source et basé sur Python qui simplifie le processus de création et de gestion de sites et d'applications web. Les applications Django sont évolutives, performantes et sécurisées. Il est également fourni avec une très bonne documentation sur chaque partie du framework.
Dans notre série sur Django, nous avons exploré Django en implémentant un exemple de site web avec des fonctionnalités de blog de base. Dans ce guide, nous allons passer en revue les étapes de création d'une vue d'exemple pour notre application Django.
Prérequis
Pour suivre ce guide, vous aurez besoin des composants suivants.
- Un Ubuntu serveur avec les configurations appropriées. En savoir plus sur la configuration d'un serveur Ubuntu.
- Un environnement de développement Python correctement configuré.
- Un serveur de base de données, par exemple, MySQL. Ce guide détaille l'installation et la configuration de MySQL sur un serveur Ubuntu.
Ce guide est la suite de notre série sur Django. Tout d'abord, il sera utile de consulter les guides précédents sur la configuration de Django, l'établissement de la connexion à la base de données Django, la création de modèles, et l'activation de l'interface d'administration de Django.
Dans ce guide, nous allons montrer comment créer des vues Django qui permettront à l'application web de gérer correctement les requêtes web et de renvoyer la réponse appropriée. Comme décrit par la documentation officielle de Django, une réponse web peut être le contenu HTML d'une page web, une redirection ou une erreur HTTP. Il n'y a pas d'emplacement fixe pour stocker les fonctions de vue tant qu'elles se trouvent dans les chemins Python. Cependant, il existe des conventions populaires pour nommer et placer les fichiers. Ce guide suivra ces conventions.
Étape 1. Activation de l'environnement virtuel
Il est préférable d'utiliser Django au sein d'un environnement virtuel Python. Notre application Django sample_app est établie dans un environnement virtuel dédié. Tout d'abord, activez l'environnement virtuel :
|
1 2 3 |
cd sample_app/ . sample_app_env/bin/activate |
Étape 2. Création des fonctions de vue
Naviguez vers notre répertoire random_app qui héberge les modèles pour notre site web de blog :
|
1 |
cd random_app/ |
Ici, le fichier views.py contiendra le code nécessaire à la création de nos vues. Ouvrez-le dans un éditeur de texte :
|
1 |
nano views.py |
Nous avons besoin de la fonction render() de la bibliothèque django.shortcuts ; la première ligne reste donc la même. La fonction render() fonction aide à combiner à la fois un modèle et un contexte pour renvoyer l'objet HttpResponse approprié.
La première vue accueillera les utilisateurs arrivant sur la page d'index. Nous devrons importer la fonction HttpResponse() depuis la bibliothèque Django http:
|
1 2 3 4 5 6 7 8 |
from django.shortcuts import render from django.http import HttpResponse def index(request): return HttpResponse(Vous êtes arrivé sur la page d'accueil') def individual_post(request): return HttpResponse('Les articles individuels apparaîtront ici') |
Enregistrez le fichier et fermez l'éditeur.
Étape 3. Mappage des URL aux vues
Pour l'instant, aucune URL n'est attribuée à ces fonctions, elles sont donc inaccessibles. Nous devons ajouter un autre bloc urlpatterns dans le fichier de configuration des URL. En Python, on l'appelle le fichier URLconf (configuration d'URL).
Django doit déterminer le module root URLconf à utiliser. Ensuite, il cherchera dans urlpatterns qui contient tous les motifs d'URL sous forme de liste. Django parcourt ensuite le fichier jusqu'à ce qu'il trouve la première correspondance. Une fois qu'il a trouvé une correspondance, Django recherche la vue associée. Cette fonction de vue recevra les données liées au motif d'URL et un objet HttpRequest . Une erreur à n'importe quelle étape de ce processus redirigera vers une vue de gestion des erreurs.
Ouvrez le fichier urls.py de random_app dans un éditeur de texte :
|
1 |
nano urls.py |
Saisissez le code suivant :
|
1 2 3 4 5 6 7 |
from django.urls import path from . import views urlpatterns = [ path('', views.index, name='index'), path('post/', views.individual_post, name='individual_post') ] |
Enregistrez le fichier et fermez l'éditeur.
Une fois cela fait, nous devrons également inclure le chemin du fichier URL sous sample_app du répertoire URLconf. Sinon, notre application Django ne la reconnaîtra pas. C'est parce que le URLconf de sample_app est défini comme le ROOT_URLCONF dans le fichier settings.
Accédez au répertoire de notre application sample_app:
|
1 |
cd sample_app/sample_app/sample_app/ |
Ouvrez le fichier urls.py dans un éditeur de texte :
|
1 |
nano urls.py |
Saisissez le code suivant dans le fichier :
|
1 2 3 4 5 6 7 |
from django.contrib import admin from django.urls import include, path urlpatterns = [ path('admin/', admin.site.urls), path('', include('random_app.urls')) ] |
Testons nos modifications. Lancez le serveur de l'application Django sur localhost:8000:
|
1 |
python manage.py runserver localhost:8000 |
Accédez à l'URL :
|
1 |
localhost:8000 |
Vérifiez l'URL pour le post :
|
1 |
localhost:8000/posts |
Étape 4. Création d'un post de blog
Nous avons établi nos modèles d'URL et examiné leurs flux de travail. Il est temps d'ajouter un exemple de blog et de voir le résultat.
Depuis le panneau d'administration, accédez à la page random_app :
|
1 |
localhost:8000/admin/random_app/ |
Cliquez sur le lien +Ajouter depuis la ligne Posts :
Sur la nouvelle page web, un formulaire composé des champs suivants s'affichera.
- Titre : Le titre du post de blog.
- Slug : Il fait référence à la partie de l'adresse web valide contenant des mots-clés lisibles par l'homme. Généralement, les slugs sont créés à partir du titre du post.
- Contenu : Le corps du post de blog.
- Auteur : Le nom d'utilisateur correspondant.
Cliquez sur SAVE pour soumettre le post :
Étape 5. Affichage des données dans la base de données
Dans cette section suivante, nous allons travailler avec notre base de données. Connectez-vous à MySQL en tant qu'utilisateur dédié à Django :
|
1 |
mysql -u sample_app_user -p |
Vérifions si notre post a été enregistré avec succès dans la base de données :
|
1 |
USE sample_app_data; |
|
1 |
SELECT * FROM random_app_post; |
Voilà ! Le post a été enregistré avec succès ! Vous pouvez maintenant quitter le shell MySQL.
Étape 6. Ajustements supplémentaires des vues
Il y a encore quelques petites choses que nous pouvons faire avec nos vues. Ouvrez le fichier dans un éditeur de texte :
|
1 |
nano views.py |
Le code devrait ressembler à ceci :
|
1 2 3 4 5 6 7 8 9 10 |
from django.shortcuts import render from django.http import HttpResponse from .models import Post def index(request): return HttpResponse('Hello, welcome to the index page.') def individual_post(request): recent_post = Post.objects.get(id__exact=1) return HttpResponse(recent_post.title + ': ' + recent_post.content) |
Ici, nous avons ajouté une instruction import supplémentaire pour Post. La chaîne entre guillemets de HttpResponse est également remplacée par les données de notre post de blog. Pour référencer les données, nous utilisons l'ID du post de blog avec l'objet associé. L'ID est stocké dans une variable recent_post. Maintenant, nous pouvons extraire des champs spécifiques de l'objet en ajoutant le champ avec un point comme séparateur.
Une fois modifié, vérifions les changements. Lancez le serveur Django :
|
1 |
python manage.py runserver localhost:8000 |
Maintenant, accédez à la page Posts :
|
1 |
localhost:8000/posts |
Il devrait afficher le post de blog que nous avons créé.
Étape 7. Quitter le projet
Pour quitter le serveur Django, appuyez sur Ctrl + C depuis le terminal. Pour désactiver l'environnement virtuel Python, exécutez la commande suivante :
|
1 |
deactivate |
Dernières réflexions
Dans ce guide, nous avons démontré avec succès la création de vues, le mappage de modèles d'URL et l'affichage de textes sur une page web à partir de la base de données de random_app dans Django.Ce sont des concepts fondamentaux de Django qu'il est nécessaire de comprendre et de maîtriser.
Voici d'autres ressources pour vous aider à créer et gérer des applications Django :
- Créer une application Django avec connexion à une base de données : un tutoriel
- Créer une application Django et Gunicorn avec Docker sur Ubuntu
- Comment sécuriser et mettre à l'échelle une application Django avec Docker, Nginx et Let’s Encrypt
Bon développement !
Commentaires
Aucun commentaire pour l'instant. Soyez le premier.