Démystifier la magie de Django

Selon la documentation officielle,

Django est un framework Web Python de haut niveau qui encourage un développement rapide et une conception propre et pragmatique. Construit par des développeurs expérimentés, il prend en charge une grande partie des tracas du développement Web, vous pouvez donc vous concentrer sur l'écriture de votre application sans avoir à réinventer la roue. C'est gratuit et open source.

— DjangoProject.com

C'est l'un des frameworks populaires de Python pour la création d'applications Web et il est préféré pour son évolutivité dans la création d'un passe-partout avec des configurations et des fichiers définis. Cela résume tout l'objectif de Django pour les développeurs ;

"... créer une excellente application en peu de temps et moins de soucis pour les paramètres de base."

Il existe des configurations, des fichiers et des styles de base qui s'appliquent à toutes les applications Web, peu importe ce que vous construisez. Lorsque vous utilisez Django, ceux-ci sont générés automatiquement lorsque vous exécutez certaines commandes à différents moments du cycle de développement de votre application. Avec cela, vous aurez suffisamment de temps pour vous concentrer sur l'aspect central du développement de votre application pendant que Django s'occupe des autres pour vous.

Cela signifie qu'il se passe beaucoup de choses sous le capot. Pour quelqu'un qui ne maîtrise pas parfaitement les pièces mobiles, cela peut être écrasant. Dans cet article, nous allons apprendre ce qui suit :

• Installation de Django
• Les commandes startproject et startapp
• Les fichiers de configuration de Django qui incluent ;
• paramètres.py
• urls.py
• manage.py
• Disposition des modèles
• Routage

Nous apprendrons comment tout cela s'emboîte et le rôle qu'ils jouent. Il est important de savoir qu'il ne sera pas possible de regarder tout ce qui se passe à l'intérieur de Django. Pour les cas hors de la portée de ce tutoriel, il y aura des liens pour vous diriger vers des ressources qui vous aideront à cela.

À des fins d'apprentissage, nous allons construire une plate-forme de commerce électronique. Il ne s'agit pas d'un site de commerce électronique à part entière, notre application n'aura que deux fonctionnalités de base ; créer des produits et passer des commandes depuis la vue de l'administrateur.

Cet article vous guidera dans la compréhension des commandes, des fichiers et des bases prédéfinis de Django. Il est destiné aux développeurs qui ont utilisé Django ou ont l'intention de l'utiliser et qui veulent savoir ce qui se passe sous le capot. Bien qu'il ne soit pas obligatoire d'avoir utilisé Django, avoir une expérience des bases de Django avant de continuer avec cet article vous donnera un avantage. Vous devez avoir une connaissance pratique de Python pour bien comprendre ce qui sera couvert dans cet article.

Installer Django

Si Django n'est pas déjà installé, voici les étapes à suivre.

Tout d'abord, créez un environnement virtuel, nommé djangodev . Vous en avez besoin pour isoler votre espace de travail Django et ses packages dépendants.

 python3 -m venv ~/.virtualenvs/djangodev

Maintenant, pour accéder à votre environnement virtuel, vous devez l'activer ;

 source ~/.virtualenvs/djangodev/bin/activate

Si vous obtenez une erreur en cours d'exécution avec la source , vous pouvez utiliser cette commande alternative,

 . ~/.virtualenvs/djangodev/bin/activate

Pour les utilisateurs de Windows, utilisez-le à la place,

 ...\> %HOMEPATH%\.virtualenvs\djangodev\Scripts\activate.bat

Remarque : Vous devez activer l'environnement virtuel chaque fois que vous souhaitez utiliser Django.

Maintenant que vous êtes dans votre environnement virtuel, installez Django :

 python -m pip install Django

Pour vérifier si Django a été correctement installé, exécutez ;

 python -m django --version

Boum ! Maintenant que vous êtes prêt pour un peu de magie, préparez vos baguettes !

La méthode de création de fichiers et de dossiers lors de vos déplacements peut être simple et directe. Cependant, ce n'est pas idéal lorsque vous devez créer un projet moyen ou grand et un délai à battre. Nous avons toujours un délai à respecter, même pour des projets personnels.

En suivant cette méthode lors de la création d'un nouveau grand projet, vous devrez créer plusieurs fichiers et dossiers et effectuer plusieurs réglages, ce qui pourrait entraîner la création de bogues évitables et beaucoup de temps perdu. Les commandes startproject et startapp disponibles via Django visent à résoudre ce problème. Ces deux commandes créent des fichiers, des dossiers et effectuent de nombreuses configurations pour vous.

Commençons par générer une nouvelle application à l'aide de la commande startproject .

Échafaudage Une application

Nous allons générer notre application et examiner les fichiers générés, ainsi que quelques commandes que nous utiliserons. Exécutez cette commande dans votre terminal pour commencer ;

 django-admin startproject ecommerce_site

Lors de l'installation de Django, django-admin est ajouté à votre chemin pour lui permettre d'effectuer ses actions. C'est l'utilitaire de ligne de commande de Django pour les responsabilités administratives. En savoir plus django-admin ici ; c'est un peu au-delà de la portée de cet article.

startproject est une commande Django qui permet de générer le projet . Ici nous lui passons le nom de notre projet ecommerce_site . Il continue ensuite à créer le projet dans un répertoire appelé ecommerce_site . Le répertoire devrait ressembler à ceci,

Nous devrons naviguer dans le répertoire nouvellement créé et exécuter la commande pour générer l'application .

 cd ecommerce_site python manage.py startapp trading

startapp est une commande exécutée par manage.py dans le répertoire du projet, elle crée plusieurs fichiers et un dossier nommé en utilisant le nom spécifié dans la commande, dans ce cas, ce qui est spécifié est trading . Le dossier de l'application se compose de fichiers simples qui devraient être nécessaires pour créer des fonctionnalités d'une application. Maintenant, votre répertoire devrait ressembler à ceci :

Si vous vous demandez la différence entre un projet et une application. Un projet est une application web Django, il peut être composé d'une ou plusieurs applications. C'est le dossier contenant manage.py et l'autre module qui inclut settings.py et d'autres fichiers. Une application est un package python qui fait une certaine fonctionnalité, inclut des fichiers comme models.py , le répertoire de migration et plus encore. Vous pouvez consulter cette réponse sur Stack Overflow pour en savoir plus.

Le startproject créera le répertoire principal du projet, tandis que le startapp créera le répertoire de l'application. Les deux reçoivent également un nom à utiliser dans la génération. Le startproject est la première commande exécutée lors de la création d'un nouveau projet, tandis que le startapp est exécuté dans le nouveau répertoire du projet.

La mise en page actuelle est un excellent mappage que vous pouvez utiliser pour n'importe quelle application que vous construisez. Il est évolutif et se compose de fichiers dont vous aurez besoin. Il est possible de créer, renommer, modifier et déplacer des fichiers au sein du projet.

Configuration de Django

Django fournit différents paramètres et configurations pour vous, après avoir exécuté les deux commandes dans différents fichiers, parcourons les fichiers générés pour savoir ce que chacun fait.

settings.py

La plupart des applications Web nécessitent des configurations telles que ; authentification pour vérifier les utilisateurs, autorisations pour autoriser certains utilisateurs avec certaines capacités et définir des normes de sécurité. Tout cela est nécessaire pour offrir à vos utilisateurs la meilleure expérience dont ils ont besoin. En tant que développeur, il vous faudra beaucoup de temps pour commencer à déployer chacun d'entre eux par vous-même, pour chaque application sur laquelle vous travaillez.

Django vous fournit ces configurations nécessaires et plus encore - de sorte que vous pouvez choisir celles que vous voulez et les brancher. Celles-ci sont effectuées dans settings.py , il existe déjà des paramètres définis créés pour vous fournir des fonctionnalités de base.

Lorsque Django essaie d'exécuter un projet, il recherche certaines variables. Le settings.py est le fichier contenant ces variables qui mènent à d'autres fichiers ou informations. Django est dirigé vers ce fichier à partir du fichier manage.py et prend des informations ou charge d'autres fichiers vers lesquels il est dirigé à partir d'ici.

Ces configurations incluent :

• DEBUG
  La fonctionnalité DEBUG est définie sur True pour permettre la lecture des erreurs et le code de débogage en développement, elle doit être définie sur False pendant la production (c'est-à-dire lorsque vous déployez). Ce paramètre vous permet de mieux déboguer votre code avec l'aide de Django lorsqu'il essaie d'exécuter votre code.
• INSTALLED_APPS
  Ceci est une liste de toutes les applications exécutant une certaine fonctionnalité dans Django. Il est livré avec certaines applications par défaut telles que 'django.contrib.auth' qui est utilisée pour l'authentification des utilisateurs, django.contrib.admin' pour la fonctionnalité d'administration et 'django.contrib.messages' nécessaires à l'envoi de notifications ou d'informations aux utilisateurs. Toute autre application que vous créez à l'aide de la commande startapp devra être ici avant de pouvoir être exécutée par Django.
• MIDDLEWARE est un framework léger pour le traitement des entrées et sorties passant par les requêtes et réponses Django. Chaque middleware remplit une fonction spécifique avec une application, comme le 'django.contrib.auth.middleware.AuthenticationMiddleware' fonctionne avec le 'django.contrib.sessions' pour associer les utilisateurs aux requêtes. Vous devriez consulter d'autres fonctionnalités de chaque middleware sur la documentation.
• ROOT_URLCONF est une variable vers un chemin où Django recherche vos urlpatterns lorsqu'une requête est transmise à votre application Django. Chaque fois qu'une requête est faite dans une application Django, Django recherche cette variable et charge le fichier principal et parcourt la liste des urlpatterns à la recherche du chemin correspondant.
• TEMPLATES est un paramètre permettant le rendu de fichiers HTML pour représenter une vue. Il communique avec les applications de demande, d'authentification et de messages. La valeur 'BACKEND' et 'APP_DIRS' défini sur True permettent à Django de rechercher des fichiers HTML dans le dossier /templates . Les 'context_processors' dans les OPTIONS sont des callables , qui prennent la requête comme argument et la fusionnent avec le contexte lorsqu'un modèle est rendu, ces callables fonctionnent pour aider au débogage, à l'authentification et à la gestion des requêtes en général.
• WSGI_APPLICATION est un chemin menant à la variable d' application dans le fichier wsgi.py
• DATABASE est un dictionnaire qui contient l'accès à une base de données externe (ou interne comme dans le cas du sqlite par défaut) comme PostgresSQL, MySQL et MongoDB. Voici un exemple de base de données Postgres que j'utiliserai pour notre exemple :

 DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'db_name', 'USER': 'db_user', 'PASSWORD': 'db_password', 'HOST': 'localhost', 'PORT': '', } }

Vous pouvez décider d'utiliser la base de données sqlite par défaut, cela ne fonctionne pas très bien pour la production. Vous pouvez configurer une base de données Postgres comme ci-dessus, vous devrez d'abord créer la base de données et transmettre l'utilisateur, le mot de passe avec autorisation d'écriture à la base de données.

Remarque : Pour les besoins de ce didacticiel, vous pouvez déjà utiliser l'ensemble de bases de données sqlite par défaut. Ce qui précède est une démonstration sur la façon dont vous pouvez définir la connexion à la base de données SQL et NO-SQL dans Django.

• AUTH_PASSWORD_VALIDATORS ce sont des fonctions qui sont appelées pour les validations de mot de passe. Ils sont appelés lors de la création d'enregistrements d'utilisateurs (et d'administrateurs également), de réinitialisation et de modification des mots de passe. Vous pouvez en savoir plus à leur sujet dans la documentation officielle.

Vous trouverez plus de documentation sur les paramètres ici.

manage.py

La plupart des projets Web ont besoin d'un point d'entrée d'où partent les commandes. Un point d'entrée servant de passerelle vers l'application. Dans chaque projet Django, il s'agit généralement du fichier manage.py .

Ce fichier est nécessaire comme point de départ dans votre application. À partir de là, toutes les commandes sont exécutées et tout démarre ici.

manage.py fait la même fonction que django-admin. Il indique également à Django l'emplacement des configurations que vous avez dans votre application. Ceci est défini par défaut et n'a pas besoin d'être modifié.

Il utilise la fonction def main() pour gérer le module de paramètres par défaut de notre fichier settings.py . Il essaie d'importer la fonction d'exécution, et s'il rencontre une erreur, il lève le ImportError . Sinon, il prend n'importe quel argument passé par sys.argv à partir de la ligne de commande et s'exécute.

sys.argv est une liste qui contient la commande transmise via le terminal. Lorsque nous python manage.py runserver dans la ligne de commande, sys.argv est défini sur ["manage.py", "runserver"] et ceci est transmis à la fonction execute() .

Des arguments tels que python manage.py startapp trading ou python manage.py makemigrations sont définis sur [ "manage.py", "startapp", "trading"] et ["manage.py", "makemigrations"] respectivement pour l'exécution.

L'instruction if est définie pour s'exécuter si la commande donnée est définie sur manage.py .

En plus d'exécuter les fonctions django-admin , vous l'utiliserez pour exécuter le serveur, gérer les migrations et d'autres commandes que votre projet utilisera. Vous en aurez également besoin lors du déploiement, du test et du débogage de vos projets.

Disposition du modèle

Django vous propose une mise en page de modélisation simple. Vous configurez vos modèles dans le fichier models.py du répertoire de trading . Vos classes (ou modèles) sont des dispositions que vos tables de base de données suivront.

Vous définissez vos classes en fonction des types de données que vous souhaitez obtenir de l'utilisateur (ou de l'administrateur) pour chaque table. Nos modèles créent un fichier de migration qui fonctionne avec la variable DATABASE dans le settings.py .

Créons deux modèles dont nous aurons besoin, pour les produits et les commandes :

 from django.db import models class Product(models.Model): name = models.CharField(max_length=50) image = models.ImageField(upload_to='products', default='python.png') price = models.IntegerField() description = models.TextField() def __str__(self): return self.name class Order(models.Model): product = models.ForeignKey(Product, on_delete=models.CASCADE) quantity = models.IntegerField() date = models.DateField(auto_now_add=True) user = models.CharField(max_length=50) def __str__(self): return self.user

Le modèle de produit a un nom, un prix, une description et une image (qui, une fois enregistrée, sera téléchargée dans un dossier de products . Celle-ci est créée si ce dossier n'existe pas). La order a un product (lié à la table des products ), les colonnes quantité, date et utilisateur.

Avec ces informations, Django crée un schéma de base de données pour l'application. Crée également une API d'accès à la base de données Python pour accéder aux objets Product et Order. Django a un outil de migration intégré pour que vous n'ayez pas à utiliser de packages externes pour les migrations.

L'étape suivante consiste à exécuter la commande de migration et à migrer vers la base de données. Mais avant cela, nous devons enregistrer le trading en tant qu'application dans notre répertoire de projet.

Tout d'abord, nous devons configurer le répertoire de trading en tant qu'application dans Django. Django l'a fait pour vous dans le fichier app.py Ce fichier enregistre le trading en tant qu'application et sera ensuite utilisé dans le fichier settings.py .

Maintenant, dans settings.py ajoutez trading dans INSTALLED_APP . Ça devrait ressembler à ça:

 INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'trading.apps.TradingConf', ]

Sur le terminal, exécutez :

 $ python manage.py makemigrations trading $ python manage.py migrate

Remarque : Votre environnement virtuel doit être activé et vous devez vous trouver dans le répertoire du projet.

python manage.py makemigrations trading prend note des modifications apportées au module de trading et crée un fichier dans le dossier de migration des modifications dans models.py et python manage.py migrate puis met à jour les modifications.

Vous pouvez trouver le fichier de migration généré à partir de la commande python manage.py makemigrations trading dans le répertoire de migration nommé 0001_initial.py . Vous pouvez voir les classes et les colonnes comme des commandes de création à l'intérieur du fichier. Au fur et à mesure que des modifications sont apportées à models.py , davantage de fichiers seront générés ici.

Fonctionnalités d'administration

Dans notre application actuelle, nous aurons besoin de fonctionnalités d'administration pour gérer les produits et les commandes qui seront créés dans l'application. Django nous fournit une fonctionnalité d'administration intégrée déjà à notre disposition. L'application d'administration (fonctionnalité) a également été enregistrée dans notre liste INSTALLED_APP ; 'django.contrib.admin' .

De plus, l'URL de l'administrateur a également été enregistrée dans la liste urlpatterns de notre fichier de configuration d'URL urls.py ; path('admin/', admin.site.urls), . Le fichier admin.py vous permet d'enregistrer des modèles et les actions CRUD à effectuer sur les modèles.

Pour configurer l'administrateur, exécutez ceci sur le terminal :

 $ python manage.py createsuperuser

Vous serez invité à saisir un nom d'utilisateur, un e-mail et un mot de passe. Après cela, vous avez réussi à créer un administrateur. Pour commencer avec la fonctionnalité d'administration, exécutez le serveur :

 $ python manage.py runserver

La visite de https://127.0.0.1:8000/admin/ mènera à une session de connexion, lorsque vous vous connectez (avec le nom d'utilisateur et le mot de passe que vous avez créés), vous êtes dirigé vers le tableau de bord d'administration :

Les groupes et les utilisateurs sont des configurations par défaut qui permettent à l'administrateur d'accéder à la gestion et aux autorisations des utilisateurs. Maintenant, enregistrons nos modèles.

Dans le admin.py , ajoutez les lignes suivantes :

 from django.contrib import admin # Register your models here. from .models import Product, Order admin.site.register(Product) admin.site.register(Order)

from django.contrib import admin importe la fonctionnalité d'administration de Django, puis nous avons importé les deux classes de notre models.py et les avons enregistrées afin qu'un administrateur puisse effectuer des actions CRUD sur les produits et commander à partir du tableau de bord.

Après avoir enregistré les modèles, votre tableau de bord devrait ressembler à ceci :

Ajout de produits :

Passer des commandes à partir du tableau de bord d'administration :

Routage facile

Chaque site a besoin d'un itinéraire ou d'URL menant à des pages spécifiques contenant certaines informations pour l'utilisateur final. Des collections d'informations ou d'applications similaires sont accessibles dans un itinéraire particulier. Il est nécessaire de regrouper les itinéraires pour l'accessibilité et la communication au sein des fichiers. Django l'a fait pour vous dans le fichier urls.py

Le urls.py est un fichier partant de la variable ROOT_CONF dans le settings.py . C'est là que notre configuration d'URL principale est effectuée. Lorsque nous créons des vues dans différents fichiers ou dossiers, ou même dans le fichier urls.py , elles doivent être configurées dans la liste urlpatterns .

Django attend une liste nommée urlpatterns dans le fichier. Vous pouvez remplacer le fichier dans la variable ROOT_CONF par n'importe quel autre fichier que vous avez placé dans la liste des modèles d' urlpatterns .

 urlpatterns = [ path('admin/', admin.site.urls), ]

La liste se compose d'objets qui sont des instances de path ou re-path . Chaque instance a deux paramètres obligatoires, le modèle 'admin/' , et une vue ou un fichier URL, admin.site.urls .

Les instances peuvent également mener à un autre fichier avec plus de configurations d'URL. Ceci est fait pour la lisibilité.

views.py

Un besoin important pour une application backend est les vues auxquelles chaque route correspond. Dans Django, vous écrivez vos vues basées sur une fonction ou une classe pour une application dans le fichier views.py . Une vue est une classe ou une fonction qui traite une requête et renvoie une réponse à votre utilisateur.

Modifiez votre fichier views.py en ceci :

 from django.http import HttpResponse def home(request): return HttpResponse("This is a shopping site for products") def order(request): return HttpResponse("Hello, welcome to our store, browse to our products and order!")

Ici, nous avons importé HTTPResponse pour l'utiliser dans la définition de deux vues (vues de fonction) pour renvoyer la phrase lorsqu'elle est appelée. def home doit être appelé lorsque vous visitez l'adresse principale et def order lorsque vous accédez à l'URL de la commande.

Après avoir créé nos vues, nous devons les affecter à différentes routes (ou urlpatterns ). Cela peut être fait de plusieurs manières, nous pouvons créer une liste d' urlpatterns dans le même fichier, ou nous pouvons importer trading.views dans le fichier ecommerce_site.urls et créer le chemin.

La meilleure façon de le faire est de créer un fichier de configuration de sous-URL (inside trading ) et de l'inclure dans ecommerce_site.urls . Créez un fichier urls.py dans le répertoire de trading . Votre répertoire devrait ressembler à :

 trading/ __init__.py admin.py apps.py migrations/ __init__.py 0001_initial.py models.py tests.py urls.py views.py

Ajoutez le code suivant à votre nouveau fichier ( urls.py )

 from django.urls import path from . import views urlpatterns = [ path('', views.home, name='home'), path('order/', views.order, name='order'), ]

Enregistrons le fichier de configuration de l'URL de trading ( urls.py ) dans le fichier de configuration des URL du projet,

 from django.contrib import admin from django.urls import include, path urlpatterns = [ path('admin/', admin.site.urls), path('', include('trading.urls')) ]

Pour pouvoir accéder aux urlpatterns nous allons utiliser la classe include de django.urls en ligne 2. Ensuite choisir un pattern et joindre le fichier urls.py dans le répertoire de trading.

Ce que nous avons fait ici a été d'importer la classe path de django et le fichier views.py . Ensuite, notre liste se compose de deux instances de chemin pour chaque vue. Donc, def home est appelée sur https://127.0.0.1:8000/.

Et la def order est appelée sur https://127.0.0.1:8000/order/.

Remarque : Le processus d'exécution de startproject et startapp n'est pas obligatoire mais fortement encouragé par Django. Et vous pouvez créer/déplacer des fichiers et des dossiers après avoir exécuté chaque commande à votre convenance.

Arbre de dépendance

Voici le processus dans lequel Django traite les requêtes provenant des URL entrant :

1. Django recherche l'emplacement racine (chemin) de vos URL dans la variable ROOT_CONF .
2. Django charge le fichier python indiqué dans le chemin fourni. Et localise la variable urlpatterns , c'est une liste contenant toutes les instances de django.urls.path() et/ou django.urls.re_path() .
3. Dans la liste, Django va dans l'ordre et cherche une URL correspondante.
4. Python, importe et appelle la vue (vue basée sur les fonctions ou basée sur les classes). Ce qui est ensuite transmis avec la requête HTTP.
5. La vue traite la demande et les informations transmises et renvoie un message/modèle ou redirige vers une autre vue.
6. Si aucun modèle d'URL ne correspond, ou si une exception est déclenchée à n'importe quel moment de ce processus, Django invoque une vue de gestion des erreurs appropriée.

Conclusion

Nous avons appris la possibilité de créer des fichiers pour Django sans la ligne de commande. Nous avons également appris les avantages et les éléments constitutifs d'un projet Django. Django est un outil incroyable pour créer des projets backend dans le but de créer de la simplicité.

Vous pouvez consulter le code de ce tutoriel sur GitHub.

Ressources

• Gestion des mots de passe dans Django
• Django : prise en main
• Django : Paramètres
• Django léger par O'Reilly